From 29bd174adf62df57f7dd73014eb153101890a1d5 Mon Sep 17 00:00:00 2001 From: Simon Hamp Date: Sat, 14 Nov 2026 19:18:30 +0000 Subject: [PATCH 1/2] Build a region's attribute bags once, when its fragment arrives A held fragment used to be the nested tree that came off the wire, and every frame walked it, normalized each node's children and rebuilt each attribute bag with attrsFor(). Nothing in that changes between frames. applyFragment() now holds the fragment prepared: three flat lists in pre-order (type, child count, attribute bag). emit() walks those lists and calls the collector's open(), leaf() and close() as before, so the collected tree is the same. paint() prepares its nodes the same way. In the binary-wire experiment this took a 1,202-node list from about 8.9 ms to 8.0 ms per frame, and moved about 1.7 ms onto receipt. Most of what is left is the collector itself. Co-Authored-By: Claude Opus 5.5 --- src/Asgard/ServerRegion.php | 67 +++++++++++++++++++++++++------ tests/Asgard/ServerRegionTest.php | 47 ++++++++++++++++++++++ 2 files changed, 102 insertions(+), 12 deletions(-) diff --git a/src/Asgard/ServerRegion.php b/src/Asgard/ServerRegion.php index fbf98ce..a1cec58 100644 --- a/src/Asgard/ServerRegion.php +++ b/src/Asgard/ServerRegion.php @@ -138,6 +138,9 @@ class ServerRegion * state, and the server rendered each fragment for one state. A * WeakMap also lets a fragment go when its component does. * + * Each fragment is held prepared (see prepare()), not as the tree + * that arrived. + * * @var \WeakMap>|null */ protected static ?\WeakMap $fragments = null; @@ -388,14 +391,14 @@ public static function applyFragment(string $region, array|string $tree, ?Native return false; } - $nodes = static::checkCallbacks($nodes, $region); + $prepared = static::prepare(static::checkCallbacks($nodes, $region)); if ($owner === null) { - static::$detached[$region] = $nodes; + static::$detached[$region] = $prepared; unset(static::$registries[$region]); } else { $held = static::fragments()[$owner] ?? []; - $held[$region] = $nodes; + $held[$region] = $prepared; static::fragments()[$owner] = $held; static::dropRegistry($region, $owner); @@ -1554,7 +1557,7 @@ public static function checkContent(mixed $tree, ?string &$reason = null): ?arra */ public static function paint(array $nodes): void { - static::emit($nodes); + static::emit(static::prepare($nodes)); } /** @@ -1898,25 +1901,65 @@ protected static function keyPath(string $name): string } /** - * Emit a normalized node list through the collector's public + * Turn a checked node list into the form a region holds: three lists + * in pre-order, index for index. `types` and `counts` give each + * node's type and how many children follow it, and `attrs` its + * collector attribute bag. + * + * A fragment is applied once and painted on every frame, so the bags + * are built here rather than in emit(). + * + * @return array{roots: int, types: list, counts: list, attrs: list} + */ + protected static function prepare(array $nodes): array + { + $prepared = ['roots' => count($nodes), 'types' => [], 'counts' => [], 'attrs' => []]; + + $walk = function (array $nodes) use (&$walk, &$prepared): void { + foreach ($nodes as $node) { + $children = static::normalize($node['children'] ?? []); + + $prepared['types'][] = (string) $node['type']; + $prepared['counts'][] = count($children); + $prepared['attrs'][] = static::attrsFor($node); + + $walk($children); + } + }; + + $walk($nodes); + + return $prepared; + } + + /** + * Emit a prepared fragment through the collector's public * open()/leaf()/close(), which is what makes a fragment work * identically in the Element-tree and streaming paths. */ - protected static function emit(array $nodes): void + protected static function emit(array $prepared): void { - foreach ($nodes as $node) { - $type = (string) $node['type']; - $attrs = static::attrsFor($node); - $children = static::normalize($node['children'] ?? []); + $i = 0; + static::emitSiblings($prepared, $prepared['roots'], $i); + } + + /** Emit `$count` siblings starting at node `$i`, and their subtrees. */ + protected static function emitSiblings(array $prepared, int $count, int &$i): void + { + for ($n = 0; $n < $count; $n++) { + $type = $prepared['types'][$i]; + $children = $prepared['counts'][$i]; + $attrs = $prepared['attrs'][$i]; + $i++; - if ($children === []) { + if ($children === 0) { NativeElementCollector::leaf($type, $attrs); continue; } NativeElementCollector::open($type, $attrs); - static::emit($children); + static::emitSiblings($prepared, $children, $i); NativeElementCollector::close(); } } diff --git a/tests/Asgard/ServerRegionTest.php b/tests/Asgard/ServerRegionTest.php index 0bff8a9..df7aa07 100644 --- a/tests/Asgard/ServerRegionTest.php +++ b/tests/Asgard/ServerRegionTest.php @@ -116,6 +116,53 @@ function renderNativeView(string $name, string $template): Element expect(json_encode($region))->not->toContain('Loading sales'); }); +it('keeps the shape of a fragment with several roots, siblings and depths', function () { + $template = <<<'BLADE' + + @server('feed') + Loading… + @endserver + + BLADE; + + // Held prepared (flat, in pre-order), so this checks the child counts + // put every node back under the right parent. + ServerRegion::applyFragment('feed', [ + ['type' => 'column', 'key' => 'a', 'children' => [ + ['type' => 'text', 'key' => 'a1', 'props' => ['text' => 'a1']], + ['type' => 'row', 'key' => 'a2', 'children' => [ + ['type' => 'text', 'key' => 'a2x', 'props' => ['text' => 'a2x']], + ['type' => 'text', 'key' => 'a2y', 'props' => ['text' => 'a2y']], + ]], + ['type' => 'text', 'key' => 'a3', 'props' => ['text' => 'a3']], + ]], + ['type' => 'spacer', 'key' => 'b'], + ['type' => 'text', 'key' => 'c', 'props' => ['text' => 'c']], + ]); + + $shape = function (array $node) use (&$shape): array { + return [$node['type'], $node['props']['text'] ?? null, array_map($shape, $node['children'] ?? [])]; + }; + + $first = renderNativeView('asgard-shape', $template)->toArray(new CallbackRegistry); + + expect(array_map($shape, $first['children'][0]['children']))->toBe([ + ['column', null, [ + ['text', 'a1', []], + ['row', null, [['text', 'a2x', []], ['text', 'a2y', []]]], + ['text', 'a3', []], + ]], + ['spacer', null, []], + ['text', 'c', []], + ]); + + expect($first['children'][0]['children'][0]['children'][1]['children'][1]['id']) + ->toBe(Element::fnv1a32('/feed/a/a2/a2y')); + + // A held fragment paints the same on every frame. + expect(renderNativeView('asgard-shape', $template)->toArray(new CallbackRegistry))->toBe($first); +}); + it('derives fragment node ids inside the region key path, not at the root', function () { ServerRegion::applyFragment('sales-summary', [ 'type' => 'column', From 575dcb2386bf027c08e17d694df727f20edcbd1e Mon Sep 17 00:00:00 2001 From: Simon Hamp Date: Sat, 14 Nov 2026 20:07:57 +0000 Subject: [PATCH 2/2] Run the tests and Pint on GitHub Actions Tests run on PHP 8.3 and 8.4 for every pull request and for pushes to main. composer.lock is ignored, so the install resolves fresh each time. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/tests.yml | 59 +++++++++++++++++++++++++++++++++++++ 1 file changed, 59 insertions(+) create mode 100644 .github/workflows/tests.yml diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml new file mode 100644 index 0000000..55657fe --- /dev/null +++ b/.github/workflows/tests.yml @@ -0,0 +1,59 @@ +name: Tests + +on: + push: + branches: [main] + pull_request: + +jobs: + tests: + runs-on: ubuntu-latest + + strategy: + fail-fast: false + matrix: + # 8.3 is the minimum composer.json allows. + php: [8.3, 8.4] + + name: Tests - PHP ${{ matrix.php }} + + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Setup PHP + uses: shivammathur/setup-php@v2 + with: + php-version: ${{ matrix.php }} + extensions: dom, simplexml, mbstring, openssl, sodium + coverage: none + + # composer.lock is not committed, so this resolves fresh each run, + # including nativephp/mobile from mobile-air's idea/asgard branch. + - name: Install dependencies + run: composer update --no-interaction --prefer-dist + + - name: Run tests + run: vendor/bin/pest + + code-style: + runs-on: ubuntu-latest + + name: Code Style + + steps: + - name: Checkout code + uses: actions/checkout@v4 + + - name: Setup PHP + uses: shivammathur/setup-php@v2 + with: + php-version: 8.4 + extensions: dom, simplexml, mbstring + coverage: none + + - name: Install dependencies + run: composer update --no-interaction --prefer-dist + + - name: Run Pint + run: vendor/bin/pint --test