@kudzujs/core 0.8.34 → 0.8.36

package/MIGRATION_ROADMAP.md

@@ -2,7 +2,7 @@
 
 This document is the source of truth for Kudzu's product direction, architecture invariants, and future development order. Read it before extending React-shaped syntax or browser capabilities.
 
-The executable post-`0.8.34` compiler and large-application sequence is maintained in [`docs/next-architecture/large-application-ai-native-roadmap.md`](./docs/next-architecture/large-application-ai-native-roadmap.md). Follow its PR dependencies for implementation work; this document remains authoritative when selecting or accepting a migration capability.
+The executable post-`0.8.36` compiler and large-application sequence is maintained in [`docs/next-architecture/large-application-ai-native-roadmap.md`](./docs/next-architecture/large-application-ai-native-roadmap.md). Follow its PR dependencies for implementation work; this document remains authoritative when selecting or accepting a migration capability.
 
 [`GOAL_A.md`](./GOAL_A.md) and [`GOAL_B.md`](./GOAL_B.md) are completed capability-validation records. Their commerce and realtime dashboard fixtures prove general lifecycle, navigation, async-workflow, and Worker capabilities; they are not separate product verticals or future priority lists.
 
@@ -314,6 +314,13 @@ This queue orders the next investigations by general migration value. Start only
 - Read-only graph consumers share a canonical AST while importer normalization deep-clones every node and repairs independent parent links before transformation.
 - A 100-importer fixture proves bounded parse/summary work and identical source results without changing accepted migration syntax or browser output.
 
+### Completed In 0.8.35
+
+- Cross-module declarations resolve through stable project-relative ModuleSymbol records rather than transformed AST identity or readable names.
+- Source-local SiteIds identify imports, re-exports, component calls, hooks, keyed lists, effects, and ownership records across private transformer clones.
+- Default/named exports, aliases, barrel chains, `export *`, cycles, ambiguity, repeated compilation, and source-dependent cache invalidation are covered without changing migration syntax or browser runtime behavior.
+- The 100-importer fixture reduces private clones from 200 to 100 and records a small directional build improvement; current React/Vue/Svelte/Astro whole-build and artifact context is retained in `PERFORMANCE.md`.
+
 ## Cross-Cutting Performance Gates
 
 Every migration feature must preserve:

package/PERFORMANCE.md

@@ -2,6 +2,62 @@
 
 Reproducibility classes: `npm run benchmark`, `npm run benchmark:keyed`, `npm run benchmark:native`, and `npm run benchmark:module-cache` are maintained in this repository; `npm run benchmark:commerce` is a maintained paired runner over the public external storefront; older excluded-workspace sections are historical provenance only and are not current framework rankings.
 
+## P0.9 Semantic State Operations
+
+Measured UTC 2026-08-11 on the Intel Core i5-9500 Linux x64 host with Node 24.14.0. The baseline was clean tag `v0.8.35` at `f25700d9d2b247c01db19f0e8c95f16cb1fa81a5`. The compiler and focused-check patch had SHA-256 `4c3c8a3de18b1e792ea84cf7608a89971850195036a58f37dd76e359bfc8a58d`, produced by:
+
+```bash
+git diff --binary v0.8.35 -- framework/compiler/optimize/command-specialization.mjs framework/compiler/descriptor-session.mjs test/compiler-passes.test.mjs test/fixtures/effect-isolation/src/pages/command.tsx test/framework.test.mjs | sha256sum
+```
+
+The maintained 100-importer fixture used three warm-ups and 21 alternating fresh-process samples. P0.9 keeps the existing direct command fast path first and invokes whole-handler semantic analysis only after direct specialization fails. Baseline and candidate produced the same normalized 382,603-byte graph, SHA-256 `8c35b3f6d2c571306bd97c4d51d4af76ca244badd36c57363bf579ef961f41aa`, 395,346-byte source result, and 103 / 103 / 100 parse, summary, and clone counts.
+
+| Target | Compiler median | Range | Peak RSS median | Source-result bytes |
+|---|---:|---:|---:|---:|
+| `v0.8.35` | 947.100 ms | 839.270-1,064.444 ms | 258.0 MiB | 395,346 B |
+| P0.9 candidate | 942.596 ms | 849.656-1,215.997 ms | 258.1 MiB | 395,346 B |
+
+The candidate's unpaired median is 0.48% lower. Round-paired candidate-minus-baseline differences had a +1.754 ms median with the candidate faster in 10/21 pairs and the baseline faster in 11/21. Timing and peak-RSS ranges overlap, so no material improvement or regression is claimed. An initial implementation that routed every direct handler through whole-handler analysis measured a +12.584 ms paired median and 10.6 MiB higher RSS median; restoring the direct fast path and narrowing the analyzer removed that regression before this final record.
+
+```text
+v0.8.35: [955.382,927.389,935.312,852.622,839.270,918.424,943.013,1026.033,936.514,1019.725,921.591,1064.444,949.671,975.729,933.380,896.773,949.751,951.418,947.100,998.950,1041.266]
+candidate: [942.596,1215.997,965.312,849.656,877.468,928.334,971.812,966.482,938.268,1016.268,932.327,939.217,928.284,1082.782,1086.319,976.534,881.665,915.266,962.642,905.596,1000.939]
+paired candidate-baseline: [-12.786,288.608,30.000,-2.966,38.198,9.910,28.799,-59.551,1.754,-3.457,10.736,-125.227,-21.387,107.053,152.939,79.761,-68.086,-36.152,15.542,-93.354,-40.327]
+```
+
+The four required source forms lower to the same existing command HandlerIR and command-only browser path. Alias/helper forms therefore avoid the native handler module and native runtime they previously required; no command ABI, state batching, ownership, runtime source, or unaffected route artifact changes.
+
+## P0.8 Stable ModuleSymbol And SiteId
+
+Measured UTC 2026-08-11 on the same Intel Core i5-9500 Linux x64 host with Node 24.14.0. The baseline was clean tag `v0.8.34` at `007fcb6e23c7d5bc742fa37c28388d070da9f598`. The compiler and maintained-check patch had SHA-256 `10ed6beb448b9e86961afab0b798f010932b8a29f98475d41f7bd8cfad04a872`, produced by:
+
+```bash
+git diff --binary v0.8.34 -- framework/compiler/project-session.mjs framework/compiler/source-compiler.mjs framework/compiler/analysis/component-analysis.mjs test/compiler-passes.test.mjs test/module-cache-performance.mjs | sha256sum
+```
+
+The maintained 100-importer fixture used three warm-ups and 21 alternating fresh-process samples. Because P0.8 intentionally adds source-local `site` metadata, the runner removes only `site` keys for output-equivalence hashing and reports the unmodified source-result size separately. The normalized 382,603-byte graph retained SHA-256 `8c35b3f6d2c571306bd97c4d51d4af76ca244badd36c57363bf579ef961f41aa`; parse and summary misses remained 103 each. Stable symbol traversal removed unnecessary normalization of intermediate barrel modules, reducing importer-local clones from 200 to 100.
+
+| Target | Compiler median | Range | Peak RSS median | Source-result bytes | Parse / summary / clone misses |
+|---|---:|---:|---:|---:|---:|
+| `v0.8.34` | 760.967 ms | 696.626-796.908 ms | 256.9 MiB | 382,603 B | not instrumented |
+| `0.8.35` | 755.595 ms | 692.365-804.376 ms | 257.8 MiB | 395,346 B | 103 / 103 / 100 |
+
+The candidate's unpaired median is 0.71% lower. Round-paired candidate-minus-baseline differences had a -2.971 ms median with the candidate faster in 13/21 pairs and the baseline faster in 8/21. This is a small directional improvement, not a material speedup claim. Peak RSS differs by 0.9 MiB and ranges overlap. The 12,743-byte source-result increase is deterministic SiteId metadata in build scratch, not deployed browser JavaScript.
+
+Two measurements before removing intermediate barrel clones showed paired medians of +12.142 ms and +21.954 ms and RSS medians 11.7-12.3 MiB above baseline. Removing those clones reduced the paired median to +4.951 ms; caching repeated ModuleSymbol resolutions produced the final -2.971 ms result. The earlier measurements are not the final candidate record.
+
+```text
+v0.8.34: [791.247,780.543,796.908,783.896,786.968,790.739,784.589,753.377,697.477,696.626,701.336,718.764,709.913,743.865,749.294,791.943,743.784,758.566,783.665,763.691,760.967]
+candidate: [783.482,799.855,760.681,768.299,804.376,802.390,783.124,799.484,692.365,720.229,708.652,707.073,712.554,708.853,750.750,756.400,742.668,755.595,776.556,747.370,751.392]
+paired candidate-baseline: [-7.765,19.312,-36.227,-15.597,17.408,11.651,-1.465,46.107,-5.112,23.603,7.316,-11.691,2.641,-35.012,1.456,-35.543,-1.116,-2.971,-7.109,-16.321,-9.575]
+```
+
+```bash
+git worktree add --detach /tmp/opencode/kudzu-v0.8.34 v0.8.34
+ln -s "$PWD/node_modules" /tmp/opencode/kudzu-v0.8.34/node_modules
+BASELINE_ROOT=/tmp/opencode/kudzu-v0.8.34 CANDIDATE_ROOT="$PWD" WARMUPS=3 RUNS=21 npm run benchmark:module-cache
+```
+
 ## P0.7 Parsed Module And Export Summary Cache
 
 Measured UTC 2026-08-11 on an Intel Core i5-9500 with 6 physical/logical cores, 31.2 GiB RAM, Linux 6.17.0-19-generic x64, Node 24.14.0, and npm 11.9.0. The baseline was clean tag `v0.8.33` at `65c96b13802c73e9c9a109cebbaac88bae7704a7`; both targets used the same installed dependencies. The implementation and maintained benchmark patch had SHA-256 `bca61b37f14c77488c4a35b62856faa6b471dd01081abcb69c47027b3b4615d9`, produced by:
@@ -33,25 +89,32 @@ BASELINE_ROOT=/tmp/opencode/kudzu-v0.8.33 CANDIDATE_ROOT="$PWD" WARMUPS=3 RUNS=2
 
 ### Current Cross-Framework Whole-Build Context
 
-This separate local check is not a parsed-module-cache comparison or maintained ranking. The external `/tmp/opencode/kudzu-dependency-benchmark` workspace is not Git-provenanced. It used Kudzu's current candidate, React 19.2.7, Vue 3.5.40, Svelte 5.56.6, Astro 7.1.1, and Vite 7.3.6. Every target emitted matched initial device content, and headless Chrome passed detail fetch, list filters, empty state, superseded async command, stale-result rejection, and HTTP error behavior. React, Vue, and Svelte perform separate client, SSR, and prerender builds; Astro uses its native build; Kudzu runs one static compiler build, so build stages and artifact architectures differ.
+Measured again after the P0.8 optimization on 2026-08-11. This separate local check is not a parsed-module-cache comparison or maintained ranking. The external `/tmp/opencode/kudzu-dependency-benchmark` workspace is not Git-provenanced. It used Kudzu 0.8.35, React 19.2.7, Vue 3.5.40, Svelte 5.56.6, Astro 7.1.1, and Vite 7.3.6. Every target emitted matched initial device content, and fresh headless Chrome runs passed detail fetch, list filters, empty state, superseded async command, stale-result rejection, and HTTP error behavior. One warm-up preceded seven rotated clean builds. React, Vue, and Svelte perform separate client, SSR, and prerender builds; Astro uses its native build and an application-specific imperative script; Kudzu runs one static compiler build, so build stages and artifact architectures differ.
 
 | Target | Build median | HTML raw / gzip | JavaScript raw / gzip | Total output |
 |---|---:|---:|---:|---:|
-| Kudzu | 856.2 ms | 5,647 B / 1,324 B | 30,712 B / 12,233 B | 36,359 B |
-| React SSR | 2,802.0 ms | 1,338 B / 562 B | 195,864 B / 61,488 B | 197,202 B |
-| Vue SSR | 2,295.3 ms | 1,348 B / 567 B | 69,643 B / 27,756 B | 70,991 B |
-| Svelte SSR | 2,972.9 ms | 1,399 B / 582 B | 40,781 B / 15,898 B | 42,180 B |
-| Astro native | 1,482.9 ms | 3,307 B / 1,229 B | 2,201 B / 883 B | 3,307 B |
+| Kudzu | 495.4 ms | 5,647 B / 1,324 B | 30,712 B / 12,233 B | 36,359 B |
+| React SSR | 1,639.5 ms | 1,338 B / 562 B | 195,864 B / 61,488 B | 197,202 B |
+| Vue SSR | 1,477.3 ms | 1,348 B / 567 B | 69,643 B / 27,756 B | 70,991 B |
+| Svelte SSR | 2,033.1 ms | 1,399 B / 582 B | 40,781 B / 15,898 B | 42,180 B |
+| Astro native | 974.5 ms | 3,307 B / 1,229 B | 2,201 B / 883 B | 3,307 B |
 
 ```text
-Kudzu: [672.2,697.5,796.0,856.2,884.2,937.9,985.9]
-React SSR: [2238.5,2345.7,2598.5,2802.0,2843.9,2848.5,3253.6]
-Vue SSR: [1968.1,2068.9,2150.7,2295.3,2494.6,2617.1,3380.0]
-Svelte SSR: [2615.6,2922.0,2926.6,2972.9,3020.5,3168.3,3739.9]
-Astro native: [1444.9,1445.7,1451.2,1482.9,1732.5,1744.0,2236.9]
+Kudzu: [474.3,482.6,493.4,495.4,498.0,503.5,504.9]
+React SSR: [1589.6,1617.1,1638.4,1639.5,1640.7,1662.7,1667.5]
+Vue SSR: [1433.8,1448.2,1450.0,1477.3,1486.0,1498.2,1500.5]
+Svelte SSR: [1956.3,1993.7,2025.4,2033.1,2036.9,2060.2,2072.8]
+Astro native: [943.3,945.9,964.7,974.5,988.8,996.4,999.5]
 ```
 
-The cross-framework result provides current whole-build context only. It does not show that Kudzu's module cache is faster than another framework's cache: this fixture has one application module per target and exposes no equivalent parser/cache counters. A cache-specific cross-framework claim would require matched 100-importer module graphs, equivalent output, equal cold/warm policy, and framework-specific cache instrumentation.
+```bash
+node /tmp/opencode/kudzu-dependency-benchmark/device-run.mjs
+node /tmp/opencode/kudzu-dependency-benchmark/device-verify.mjs
+```
+
+Kudzu's build median was 69.8% lower than React SSR, 66.5% lower than Vue SSR, 75.6% lower than Svelte SSR, and 49.2% lower than Astro native in this protocol. Kudzu shipped 80.1%, 55.9%, and 23.1% less JavaScript gzip than React, Vue, and Svelte respectively. Astro shipped only 883 B JavaScript gzip and a 3,307 B single-file output, so Kudzu's JavaScript gzip was 13.9 times and total output 11.0 times larger than Astro's direct imperative implementation. Kudzu's larger HTML carries static content and capability descriptors; its 1,324 B gzip was close to Astro's 1,229 B but larger than the hydrated SSR controls' 562-582 B HTML.
+
+The cross-framework result provides current whole-build and deploy-artifact context only. It does not show that Kudzu's ModuleSymbol cache is faster than another framework's module cache: this fixture has one application module per target and exposes no equivalent parser/cache counters. A cache-specific cross-framework claim would require matched 100-importer module graphs, equivalent output, equal cold/warm policy, and framework-specific cache instrumentation. The browser run verifies behavior rather than interaction latency; the maintained larger keyed benchmarks below remain the runtime-performance evidence.
 
 ## 2026-08-11 React, Vue, And Svelte Check
 

package/README.md

@@ -14,7 +14,7 @@ Kudzu compiles ordinary React-shaped TypeScript and TSX into complete static HTM
 
 > Experimental `0.8.x`: the compiler API and supported TSX surface may change.
 
-**Latest release: 0.8.34 - Session-local module cache.** Each unchanged source module is parsed and export-summarized once per ProjectSession, while every transformer receives an independent deep clone so mutable TypeScript AST state cannot leak across importers or projects. Read the [release notes](./RELEASES.md#0834---session-local-module-cache), open the [release page](https://github.com/kudzujs/kudzu/releases/tag/v0.8.34), or follow the [architecture packet](./docs/next-architecture/README.md).
+**Latest release: 0.8.36 - Semantic state operations.** Equivalent direct, aliased, and local-helper state updates now lower to the same command IR without adding handler JavaScript. Read the [release notes](./RELEASES.md#0836---semantic-state-operations), open the [release page](https://github.com/kudzujs/kudzu/releases/tag/v0.8.36), or follow the [architecture packet](./docs/next-architecture/README.md).
 
 - [Documentation](https://kudzujs.cloud/docs)
 - [Installation guide](https://kudzujs.cloud/docs#install)
@@ -32,6 +32,7 @@ Kudzu requires Node.js 22 or newer.
 ```bash
 npm create kudzu@latest my-app
 cd my-app
+npm install
 npm run dev
 ```
 

package/RELEASES.md

@@ -1,5 +1,70 @@
 # Kudzu Releases
 
+## 0.8.36 - Semantic state operations
+
+Kudzu 0.8.36 completes P0.9 by proving equivalent direct, aliased, and local-helper state updates and lowering them through the existing command HandlerIR path.
+
+### Changed in 0.8.36
+
+- Direct `setCount(count + 1)`, an immutable result alias, a zero-argument arrow helper, and a one-parameter function helper emit the same structured `add` command.
+- Binding identity proves state, setter, helper, and parameter ownership before specialization.
+- Recursion, helper or alias escape, mutation, optional calls, and object-based dynamic dispatch fail at authored source locations.
+- The existing direct command fast path remains first; whole-handler analysis runs only when direct specialization fails.
+- Quick Start instructions now include an explicit `npm install`, and `create-kudzu@0.1.102` reports install-aware next steps and includes the install command in generated READMEs.
+
+### Performance
+
+- The maintained 100-importer fixture preserves the same normalized graph, source-result bytes, digest, and 103 / 103 / 100 parse, summary, and clone counts.
+- Twenty-one alternating `v0.8.35`/candidate samples measured compiler medians of 947.100 ms and 942.596 ms. The +1.754 ms paired candidate-minus-baseline median and overlapping RSS ranges establish no material improvement or regression.
+- Alias and helper forms avoid native handler ESM and reuse the existing command runtime; direct command artifacts remain unchanged.
+
+### Validation
+
+- `npm run check`, `npm test`, and `npm run test:package` pass with all 197 tests and 151 generated pages.
+- Focused coverage proves identical JSON-safe command IR, signal ownership, build-module behavior calls, RouteIR commands, and zero native-handler artifacts for all four source forms.
+- Existing command ABI, synchronous batching, ownership, browser runtime, and unrelated native handlers remain unchanged.
+- P0.10 ModuleIR reference unification is next.
+
+### Upgrade
+
+```bash
+npm install @kudzujs/core@^0.8.36
+```
+
+## 0.8.35 - Stable module identity
+
+Kudzu 0.8.35 completes P0.8 by giving cross-module declarations and authored compiler sites stable identities that do not depend on transformed TypeScript AST objects or readable names.
+
+### Changed in 0.8.35
+
+- ProjectSession summarizes declaration, import, named re-export, and `export *` sites as source-local SiteId records.
+- ModuleSymbol identity combines a project-relative module path with the authored declaration SiteId; readable names remain diagnostic metadata.
+- Default and named exports, local aliases, barrel chains, `export *`, cycles, and ambiguous star exports resolve through one cycle-safe symbol graph.
+- Imported semantic consumers resolve ModuleSymbols first, then locate the authored SiteId in their private normalized AST clone instead of rescanning by declaration name.
+- Component owners, component calls, hooks, keyed lists, effects, states, refs, and IDs expose deterministic source-local SiteIds in compiler analysis records.
+- Repeated symbol resolutions are cached against their source dependencies and invalidate when any dependency source changes.
+
+### Performance
+
+- The 100-importer fixture retains 103 parse and 103 summary misses while removing 100 unnecessary intermediate barrel clones, reducing importer-local clones from 200 to 100.
+- Twenty-one alternating `v0.8.34`/candidate samples measured compiler medians of 760.967 ms and 755.595 ms. The paired candidate-minus-baseline median was -2.971 ms, with the candidate faster in 13/21 pairs; this is a small directional improvement, not a material speedup claim.
+- Peak RSS medians were 256.9 MiB and 257.8 MiB. The 12,743-byte source-result increase is deterministic SiteId metadata in build scratch, not deployed JavaScript.
+- A matched whole-build check measured Kudzu at 495.4 ms, Astro at 974.5 ms, Vue SSR at 1,477.3 ms, React SSR at 1,639.5 ms, and Svelte SSR at 2,033.1 ms. Kudzu shipped less JavaScript gzip than React, Vue, and Svelte; Astro's direct imperative implementation remained much smaller.
+
+### Validation
+
+- `npm run check`, `npm test`, `npm run test:package`, and all 195 tests pass.
+- Focused coverage verifies default/named exports, aliases, barrel chains, `export *`, ambiguity, cycles, repeated-session IDs, repeated-compilation IDs, resolution-cache invalidation, and clone-local declaration lookup.
+- All five cross-framework device targets pass the same Chrome checks for initial HTML, filtering, empty state, detail fetch, superseded commands, stale-result rejection, and HTTP failures.
+- Existing browser runtime code, route capabilities, source syntax, and deployed JavaScript remain unchanged; the repository build emits 150 pages.
+- P0.9 semantic state operations is next.
+
+### Upgrade
+
+```bash
+npm install @kudzujs/core@^0.8.35
+```
+
 ## 0.8.34 - Session-local module cache
 
 Kudzu 0.8.34 completes P0.7 by making source parsing and supported-export summarization proportional to unique modules within one ProjectSession instead of repeated importer edges.

package/docs/next-architecture/README.md

@@ -11,7 +11,7 @@ The top-level [`GOAL_A.md`](../../GOAL_A.md) and [`GOAL_B.md`](../../GOAL_B.md)
 | C: state/resource model | Research only | Reduced fixtures expose a limitation |
 | D: routing compatibility | Current behavior preserved | Revisit only with migration evidence and invariant review |
 
-The active post-`0.8.34` implementation sequence is [`large-application-ai-native-roadmap.md`](./large-application-ai-native-roadmap.md). P0.7 parsed module and export summary caching is complete; P0.8 stable ModuleSymbol and SiteId is next. The plan orders compiler semantic generalization, large-application foundations, compatibility boundaries, AI tooling, and production validation without changing the invariants below.
+The active post-`0.8.36` implementation sequence is [`large-application-ai-native-roadmap.md`](./large-application-ai-native-roadmap.md). P0.9 semantic state operations is complete; P0.10 ModuleIR reference unification is next. The plan orders compiler semantic generalization, large-application foundations, compatibility boundaries, AI tooling, and production validation without changing the invariants below.
 
 ## Required Invariants
 

package/docs/next-architecture/compiler-current-architecture.md

@@ -1,6 +1,6 @@
 # Current Compiler Architecture
 
-This maps the current `0.8.34` architecture, built on the completed `0.8.23` Goal A compiler foundation. File and function names are the stable references; line numbers are intentionally omitted because later work may still move code.
+This maps the current `0.8.36` architecture, built on the completed `0.8.23` Goal A compiler foundation. File and function names are the stable references; line numbers are intentionally omitted because later work may still move code.
 
 ## Responsibility Map
 
@@ -8,7 +8,7 @@ This maps the current `0.8.34` architecture, built on the completed `0.8.23` Goa
 |---|---|---|
 | CLI entry | [`bin/kudzu.mjs`](../../bin/kudzu.mjs) | Dispatches build and development commands. |
 | Project session | [`framework/compiler/project-session.mjs`](../../framework/compiler/project-session.mjs), `createProjectSession()` | Owns one absolute root, standard project paths, source records, bound graph operations, and Worker compiler for a build. Omitted roots resolve from call-time CWD. |
-| Parsed module cache | [`framework/compiler/project-session.mjs`](../../framework/compiler/project-session.mjs) | Parses each unchanged source module and summarizes its supported exports once per ProjectSession. Read-only graph/export/style/Worker consumers share the canonical tree; normalization receives a fresh deep clone with independent parent links. |
+| Parsed module cache and symbols | [`framework/compiler/project-session.mjs`](../../framework/compiler/project-session.mjs) | Parses each unchanged source module once per ProjectSession and records source-local declaration/import/re-export sites. Stable ModuleSymbol records resolve direct, aliased, barrel, and `export *` exports with cycle and ambiguity checks; repeated resolutions are cached against their source dependencies, and normalization consumers locate the resolved SiteId in a fresh clone with independent parent links. |
 | Build orchestration | [`framework/build.mjs`](../../framework/build.mjs), `build()` | Coordinates config, discovery, source compilation, RouteIR rendering, CapabilityIR projection, generator invocation, artifact emission, and `afterBuild`. |
 | Reachability/import resolution | [`framework/compiler/source-compiler.mjs`](../../framework/compiler/source-compiler.mjs), `reachableSourceFiles()`; [`framework/compiler/source-graph.mjs`](../../framework/compiler/source-graph.mjs), `ordinaryRuntimeDependencies()`, `resolveSourceImport()` | Starts from page entries, follows relative runtime imports/re-exports and validated Worker references, excludes unreachable migration source, and fails unresolved ordinary edges or dynamic imports at the importer source location before code generation. |
 | Ordered normalization | [`framework/compiler/normalization-pipeline.mjs`](../../framework/compiler/normalization-pipeline.mjs), `applyNormalizationPasses()`; [`framework/compiler/source-compiler.mjs`](../../framework/compiler/source-compiler.mjs), `normalizeCompilerSource()` | Applies migration/resource passes in order and repairs TypeScript parent pointers after every structural change. Imported source uses the same pipeline. |
@@ -17,9 +17,9 @@ This maps the current `0.8.34` architecture, built on the completed `0.8.23` Goa
 | Source-local binding index | [`framework/compiler/analysis/binding-index.mjs`](../../framework/compiler/analysis/binding-index.mjs) | After normalization, assigns deterministic lexical slots and classifies local, parameter, import, capture, global, and unresolved references. Native handler, effect, binding, list evaluator, optimized-command, and effect-resource consumers use complete index-owned AST; synthesized expressions retain the existing fallback. |
 | Pure collection language | [`framework/compiler/collection-analysis.mjs`](../../framework/compiler/collection-analysis.mjs) | Analyzes collection roots/selectors and serializes the allowed pure expression language used by lists and derived dependencies. |
 | Main semantic analysis | [`framework/compiler/source-compiler.mjs`](../../framework/compiler/source-compiler.mjs), `createKudzuTransformer()` | Produces transformed source plus explicit component, handler, binding, derived, keyed, and effect ownership results. |
-| Component ownership analysis | [`framework/compiler/analysis/component-analysis.mjs`](../../framework/compiler/analysis/component-analysis.mjs) | Retains ordered JSON-safe owner and specialization records for state, setters, props, refs, IDs, direct signal links, and source provenance; AST identity remains private to its source-local session. |
+| Component ownership analysis | [`framework/compiler/analysis/component-analysis.mjs`](../../framework/compiler/analysis/component-analysis.mjs) | Retains ordered JSON-safe owner and specialization records for state, setters, props, refs, IDs, direct signal links, source-local SiteIds, and source provenance; AST identity remains private to its source-local session. |
 | Per-source descriptor registration | [`framework/compiler/descriptor-session.mjs`](../../framework/compiler/descriptor-session.mjs), `createSemanticArtifact()`, `createDescriptorSession()` | Keeps AST descriptors private during analysis, then finalizes deterministic JSON-safe HandlerIR, BindingIR, DerivedIR, KeyedBlockIR, EffectIR, imports, and client roots into ModuleIR and validates every local slot reference. |
-| Command IR and codegen | [`framework/compiler/optimize/command-specialization.mjs`](../../framework/compiler/optimize/command-specialization.mjs), [`framework/compiler/ir/module-ir.mjs`](../../framework/compiler/ir/module-ir.mjs), [`framework/compiler/codegen/command-codegen.mjs`](../../framework/compiler/codegen/command-codegen.mjs) | Supported command handlers specialize to JSON-safe ModuleIR, then emit the existing `__kBehavior` AST without changing route plans. |
+| Command IR and codegen | [`framework/compiler/optimize/command-specialization.mjs`](../../framework/compiler/optimize/command-specialization.mjs), [`framework/compiler/ir/module-ir.mjs`](../../framework/compiler/ir/module-ir.mjs), [`framework/compiler/codegen/command-codegen.mjs`](../../framework/compiler/codegen/command-codegen.mjs) | Direct commands use the existing fast path; proven immutable state aliases and one-call local helpers specialize to the same JSON-safe command ModuleIR. Recursion, escape, mutation, and dynamic helper dispatch fail explicitly, while unrelated handlers retain native ESM. Codegen emits the existing `__kBehavior` AST and command ABI. |
 | Source compilation | [`framework/compiler/source-compiler.mjs`](../../framework/compiler/source-compiler.mjs), `compileSource()` | Runs TypeScript with the Kudzu transformer, rejects surviving React/Router references, and returns a JSON-safe project-relative build module, component analysis, ModuleIR, optional handler module, and imported assets without filesystem writes. |
 | Handler/evaluator lowering | [`framework/compiler/handler-lowering.mjs`](../../framework/compiler/handler-lowering.mjs) | Completes source-local callback/binding/list AST rewriting and diagnostics before the JSON-safe IR boundary. |
 | Handler module codegen | [`framework/compiler/handler-codegen.mjs`](../../framework/compiler/handler-codegen.mjs) | Renders finalized ordered imports and concatenates generated module-export source without TypeScript AST or semantic discovery. |
@@ -39,7 +39,7 @@ This maps the current `0.8.34` architecture, built on the completed `0.8.23` Goa
 
 ```text
 src/pages entries + config
-  -> ProjectSession(root) with project paths, source records, parsed/export caches, graph, and Worker compiler
+  -> ProjectSession(root) with project paths, source records, parsed/symbol caches, graph, and Worker compiler
   -> project discovery and reachable relative graph
   -> compileSource()
        -> ordered normalization and parent repair
@@ -71,8 +71,8 @@ The browser consumes static HTML first. State seeds and descriptors in that HTML
 - Transient component rewrite indexes remain source-local AST indexes; handler, binding, derived, keyed, effect, and component ownership now have explicit JSON-safe source results.
 - `build()` still owns explicit artifact selection and filesystem writes after generator results are produced.
 - Runtime generators intentionally specialize readable authored sources through exact anchors; every required anchor fails closed, but a future generator format may remove this transitional dependency.
-- Source reachability and source compilation remain in one session-bound compiler factory because both consume the same normalization and import graph contracts. Export summaries deliberately preserve the existing narrow forms; stable ModuleSymbol and SiteId identity remains P0.8 work.
-- Imported, specialized, and compiler-synthesized trees still use conservative name/scope fallback where the source-local binding index does not own the complete AST; cross-module semantics remain deferred to stable ModuleSymbol and SiteId work.
+- Source reachability and source compilation remain in one session-bound compiler factory because both consume the same normalization and import graph contracts. ModuleSymbol resolution is stable across canonical and cloned trees; unsupported export syntax remains intentionally narrow.
+- Imported declarations resolve by ModuleSymbol and source-local SiteId. Specialized and compiler-synthesized trees still use conservative name/scope fallback where the source-local binding index does not own the complete AST.
 
 These are future simplification opportunities, not incomplete Goal A contracts. Goal A changed no source support, browser output semantics, or browser architecture.
 

package/docs/next-architecture/large-application-ai-native-roadmap.md

@@ -2,7 +2,7 @@
 
 ## Status
 
-Active execution plan after `0.8.34`. This document turns the current compiler audit into an ordered implementation program. It does not mark any planned capability as supported and does not authorize a React runtime, VDOM, hydration, retained browser component tree, generic rerenderer, public store/query/resource API, SPA router, or islands.
+Active execution plan after `0.8.35`. This document turns the current compiler audit into an ordered implementation program. It does not mark any planned capability as supported and does not authorize a React runtime, VDOM, hydration, retained browser component tree, generic rerenderer, public store/query/resource API, SPA router, or islands.
 
 [`MIGRATION_ROADMAP.md`](../../MIGRATION_ROADMAP.md) remains authoritative for product invariants and fixture-driven feature selection. This plan is authoritative for the order and completion evidence of compiler generalization, large-application foundations, compatibility boundaries, AI tooling, and scale validation. If implementation evidence changes a boundary, update this document before broadening a patch.
 
@@ -136,7 +136,8 @@ This is an incremental evolution of the current repository:
 - [x] P0.5 Staged and collision-safe output is complete in `0.8.32`. Production output completes in one project-local staging tree, public files are compared against generated route/runtime/handler/chunk/Worker/CSS paths while copying, `afterBuild` runs before rollback-safe promotion, and ordinary failures preserve the prior `dist`. Same-root overlap and stale locks fail closed; after stale-lock removal, an interrupted promotion backup recovers on the next admitted build. Focused collision/replacement/dev checks pass with equivalent `v0.8.31` commerce deploy output; `.kudzu` remains compiler scratch for P0.6.
 - [x] P0.6 Explicit ProjectSession is complete in `0.8.33`. Each build owns an absolute root, project paths, source records, bound graph operations, and Worker compiler. Explicit-root build/dev entry points preserve omitted-root CLI CWD behavior. One imported build function compiles two same-shaped roots with isolated config, HTML, `.kudzu`, source results, and Worker bundles; all 191 tests and package checks pass without browser or source-syntax changes.
 - [x] P0.7 Parsed module and export summary caching is complete in `0.8.34`. Canonical read-only source trees and narrow export summaries are invalidated together by source text and remain ProjectSession-local; every normalization context receives a deep clone with independent parent links. A 100-importer fixture parses and summarizes 103 unique page/barrel/component/helper modules exactly once and creates 200 importer-local clones. The maintained paired benchmark preserves the complete source-result digest and establishes no material timing or peak-RSS conclusion; all 193 tests and package checks pass without broadening exports, source syntax, or browser output.
-- [ ] P0.8 Stable ModuleSymbol and SiteId is next. Cross-module declarations, aliases, re-exports, owners, and call sites must stop depending on transient AST identity outside one pass.
+- [x] P0.8 Stable ModuleSymbol and SiteId is complete in `0.8.35`. ProjectSession records source-local declaration, import, and re-export sites and resolves stable ModuleSymbol records through default/named exports, aliases, barrel chains, `export *`, ambiguity, and cycles. Cross-module compiler consumers locate resolved declarations by SiteId in their private normalized clones, while component calls, hooks, keyed blocks, effects, and ownership records expose deterministic source-local SiteIds. Repeated sessions and compilations preserve IDs, and symbol-only barrel traversal avoids cloning intermediate modules without changing browser artifacts or source syntax.
+- [x] P0.9 Semantic State Operations is complete in `0.8.36`. Direct setters, one immutable state-value alias, one synchronous zero-argument arrow helper, and one synchronous one-parameter function helper lower to identical existing command HandlerIR. Binding identity proves state/setter/helper/parameter ownership; recursion, escape, mutation, and dynamic helper dispatch fail at authored source locations. Existing direct command specialization remains first, unrelated safe handlers retain native ESM, and no command ABI, runtime, JavaScript VM, or general expression IR is added.
 
 ### P0: Semantic Correctness And Compiler Foundation
 
@@ -320,6 +321,8 @@ Every result carries a stable source-local binding slot, debug name, declaration
 
 **Done condition:** cross-module semantic consumers use ModuleSymbol records and source-local SiteId values; readable names remain diagnostic metadata.
 
+**Completed in `0.8.35`:** ProjectSession export summaries now include stable declaration/import/re-export records. ModuleSymbol identity is project-relative module path plus declaration SiteId and excludes readable names; cycle-safe resolution supports direct/default/named/aliased/barrel/`export *` paths and rejects ambiguity. Imported semantic consumers resolve symbols first, then find the authored SiteId in an importer-private normalized clone. Component analysis and ModuleIR ownership records carry deterministic owner, component-call, hook, keyed-list, and effect SiteIds. Focused fixtures verify default/named aliases, barrels, `export *`, cycles, ambiguity, repeated-session determinism, repeated-compilation determinism, and source-dependent resolution-cache invalidation. The 100-importer fixture retains 103 parse and summary misses while removing 100 intermediate barrel clones.
+
 ### PR 9: Semantic State Operations
 
 **Objective:** lower semantically equivalent state updates to the existing structured HandlerIR path.
@@ -337,6 +340,8 @@ function increment(value) { setCount(value + 1) }; increment(count)
 
 **Done condition:** the equivalent forms produce the same StateWrite semantics, browser result, ownership references, and zero-unused-runtime behavior; recursion, escape, mutation, and dynamic dispatch fail with explicit diagnostics.
 
+**Completed in `0.8.36`:** The command specializer now performs narrow whole-handler analysis only when the existing direct fast path fails. The four required forms emit the same `add` command, signal slot, owner, build-module behavior call, RouteIR command, and browser command runtime; alias/helper forms emit no native handler module. Focused compiler and command-only fixture coverage proves JSON-safe IR equivalence, source diagnostics, no native behavior artifacts, and unchanged batching/runtime ABI. The maintained 100-importer benchmark retains identical output and cache counts with no material timing or peak-RSS conclusion.
+
 ### PR 10: ModuleIR Reference Unification
 
 **Objective:** replace mixed state names, export strings, formatted owner strings, and slots with validated source-local slots and SymbolRef records.
@@ -466,4 +471,4 @@ The first comparison is Kudzu versus React + Vite using the same agent, model, t
 
 ## Immediate Decision
 
-PR 1 through PR 7 are complete. The next PR is **PR 8: Stable ModuleSymbol And SiteId**. Do not skip directly to a store, resource, router, virtualization, or ecosystem package feature.
+PR 1 through PR 9 are complete. The next PR is **PR 10: ModuleIR Reference Unification**. Do not skip directly to a store, resource, router, virtualization, or ecosystem package feature.

package/docs/next-architecture/versioning.md

@@ -1,6 +1,6 @@
 # Planned Version Sequence
 
-This is an execution sequence, not release history. `0.8.16` through `0.8.34` are completed scopes represented by package/release records.
+This is an execution sequence, not release history. `0.8.16` through `0.8.36` are completed scopes represented by package/release records.
 
 Keep each patch behavior-preserving and independently reviewable. If a boundary proves inseparable, revise this plan before combining releases; do not silently broaden a patch.
 
@@ -25,6 +25,8 @@ Keep each patch behavior-preserving and independently reviewable. If a boundary
 | `0.8.32` | Stage and validate production output before rollback-safe promotion, reject same-root overlap, and tighten keyed browser paths. | Build/hook failures preserve the prior output, stale locks fail closed, interrupted backups recover on the next admitted build after lock removal, public/generated collisions fail, and deploy output remains equivalent. |
 | `0.8.33` | Move root, graph, source records, compiler paths, and Worker ownership into an explicit build-scoped ProjectSession. | Two independent roots compile through one imported build entry without config, source, `.kudzu`, Worker, or output leakage; CLI CWD behavior remains unchanged. |
 | `0.8.34` | Cache canonical parsed modules and narrow export summaries within one ProjectSession while cloning transformer input. | A 100-importer fixture parses and summarizes 103 unique modules once, creates independent normalization trees, preserves the complete source-result digest, and leaks no cache state across projects. |
+| `0.8.35` | Resolve cross-module declarations through stable ModuleSymbol and source-local SiteId records. | Default/named exports, aliases, barrel chains, `export *`, cycles, ambiguity, repeated compilation, source invalidation, private clones, and measured build behavior remain deterministic. |
+| `0.8.36` | Lower equivalent direct, aliased, and local-helper state updates through existing command HandlerIR. | The four required forms emit identical commands and no native handler module; recursion, escape, mutation, and dynamic dispatch fail at authored source locations. |
 
 ## Sequence Rules
 
@@ -37,7 +39,7 @@ Keep each patch behavior-preserving and independently reviewable. If a boundary
 
 ## Generator Versions
 
-Keep `create-kudzu@0.1.101` while its template remains unchanged. Its `@kudzujs/core` range `^0.8.15` already accepts every planned Goal A patch. Publish `0.1.102` only when the template or minimum core range changes; a future `0.9.0` template must use `^0.9.0`.
+`create-kudzu@0.1.102` adds an explicit install step to the generated README and clearer completion output. Its `@kudzujs/core` range `^0.8.15` accepts every current `0.8.x` patch; a future `0.9.0` template must use `^0.9.0`.
 
 ## Release Boundary
 

package/framework/compiler/analysis/component-analysis.mjs

@@ -8,7 +8,7 @@ export function createComponentAnalysisSession(analysis) {
   function registerOwner(identity, descriptor = {}) {
     let owner = owners.get(identity)
     if (!owner) {
-      owner = { slot: analysis.owners.length, kind: descriptor.kind ?? "component", name: descriptor.name ?? "anonymous", props: descriptor.props ?? [], states: [], setters: [], refs: [], ids: [], ...(descriptor.source ? { source: descriptor.source } : {}) }
+      owner = { slot: analysis.owners.length, kind: descriptor.kind ?? "component", name: descriptor.name ?? "anonymous", props: descriptor.props ?? [], states: [], setters: [], refs: [], ids: [], ...(descriptor.site ? { site: descriptor.site } : {}), ...(descriptor.source ? { source: descriptor.source } : {}) }
       owners.set(identity, owner)
       analysis.owners.push(owner)
     }
@@ -20,7 +20,7 @@ export function createComponentAnalysisSession(analysis) {
     if (!owner) throw new Error("Component owner must be registered before its state")
     let state = owner.states.find(entry => entry.name === descriptor.name && entry.owner === descriptor.owner)
     if (!state) {
-      state = { slot: owner.states.length, name: descriptor.name, kind: descriptor.kind, ...(descriptor.owner ? { owner: descriptor.owner } : {}), ...(descriptor.source ? { source: descriptor.source } : {}) }
+      state = { slot: owner.states.length, name: descriptor.name, kind: descriptor.kind, ...(descriptor.owner ? { owner: descriptor.owner } : {}), ...(descriptor.site ? { site: descriptor.site } : {}), ...(descriptor.source ? { source: descriptor.source } : {}) }
       owner.states.push(state)
     }
     if (descriptor.setter && !owner.setters.some(entry => entry.name === descriptor.setter)) owner.setters.push({ name: descriptor.setter, signal: state.slot, kind: descriptor.kind })

package/framework/compiler/descriptor-session.mjs

@@ -149,8 +149,9 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
 
   function compileOptimizedEvent(expression, setters, stateOwners, owner, keyedBlock) {
     const statements = ts.isBlock(expression.body) ? expression.body.statements : [factory.createExpressionStatement(expression.body)]
-    const commands = statements.map(statement => ts.isExpressionStatement(statement) && canSpecializeCommand(statement.expression, expression, setters) ? compileEventCommand(statement.expression, setters) : undefined)
-    if (!commands.length || commands.some(command => !command)) return undefined
+    let commands = statements.map(statement => ts.isExpressionStatement(statement) && canSpecializeCommand(statement.expression, expression, setters) ? compileEventCommand(statement.expression, setters) : undefined)
+    if ((!commands.length || commands.some(command => !command)) && compileEventCommand.handler) commands = compileEventCommand.handler(expression, setters, bindingIndex)
+    if (!commands?.length || commands.some(command => !command)) return undefined
     const original = ts.getOriginalNode(expression)
     const source = original.pos >= 0 && original.end >= 0 ? { file: sourceName(original.getSourceFile()), start: original.getStart(), end: original.end } : undefined
     const handler = registerCommandHandler(moduleIR, commands.map(command => ({ ...command, owner: stateOwners.get(command.state) ?? owner })), source, owner)

package/framework/compiler/optimize/command-specialization.mjs

@@ -1,32 +1,203 @@
 import ts from "typescript"
+import { sourceNodeError } from "../ast-helpers.mjs"
 
 export function createCommandSpecializer({ isPrimitiveLiteral }) {
-  return function specializeCommand(expression, setters) {
+  const specialize = (expression, setters) => {
     if (ts.isCallExpression(expression) && ts.isPropertyAccessExpression(expression.expression) && ts.isIdentifier(expression.expression.expression) && expression.expression.expression.text === "console" && expression.expression.name.text === "log" && expression.arguments.length === 2 && ts.isStringLiteral(expression.arguments[0]) && ts.isIdentifier(expression.arguments[1]) && [...setters.values()].includes(expression.arguments[1].text)) {
       return { operation: "log", state: expression.arguments[1].text, value: expression.arguments[0].text }
     }
-
     if (!ts.isCallExpression(expression) || !ts.isIdentifier(expression.expression) || expression.arguments.length !== 1) return undefined
     const state = setters.get(expression.expression.text)
     if (!state) return undefined
-
     const value = expression.arguments[0]
-    if (ts.isBinaryExpression(value) && ts.isIdentifier(value.left) && value.left.text === state && ts.isNumericLiteral(value.right)) {
-      if (value.operatorToken.kind !== ts.SyntaxKind.PlusToken && value.operatorToken.kind !== ts.SyntaxKind.MinusToken) return undefined
-      const operand = signedNumber(value.right, value.operatorToken.kind === ts.SyntaxKind.MinusToken ? "negative" : undefined)
-      return operand ? { operation: "add", state, ...operand } : undefined
-    }
-    if (ts.isArrowFunction(value) && value.parameters.length === 1 && ts.isIdentifier(value.parameters[0].name) && ts.isBinaryExpression(value.body) && ts.isIdentifier(value.body.left) && value.body.left.text === value.parameters[0].name.text && ts.isNumericLiteral(value.body.right)) {
-      if (value.body.operatorToken.kind !== ts.SyntaxKind.PlusToken && value.body.operatorToken.kind !== ts.SyntaxKind.MinusToken) return undefined
-      const operand = signedNumber(value.body.right, value.body.operatorToken.kind === ts.SyntaxKind.MinusToken ? "negative" : undefined)
-      return operand ? { operation: "add", state, ...operand } : undefined
-    }
+    if (ts.isBinaryExpression(value) && ts.isIdentifier(value.left) && value.left.text === state) return addCommand(state, value)
+    if (ts.isArrowFunction(value) && value.parameters.length === 1 && ts.isIdentifier(value.parameters[0].name) && ts.isBinaryExpression(value.body) && ts.isIdentifier(value.body.left) && value.body.left.text === value.parameters[0].name.text) return addCommand(state, value.body)
     if (isPrimitiveLiteral(value)) {
       const literal = primitiveValue(value)
       return literal ? { operation: "set", state, ...literal } : undefined
     }
-    return undefined
   }
+  specialize.handler = (handler, setters, bindingIndex) => specializeHandler(handler, setters, bindingIndex, specialize)
+  return specialize
+}
+
+function specializeHandler(handler, setters, bindingIndex, specialize) {
+  const statements = ts.isBlock(handler.body) ? handler.body.statements.filter(statement => !ts.isEmptyStatement(statement)) : []
+  if (statements.length === 2) {
+    const command = aliasCommand(statements, handler, setters, bindingIndex) ?? helperCommand(statements, handler, setters, bindingIndex, specialize)
+    if (command) return [command]
+  }
+  rejectUnsafe(statements, handler, setters, bindingIndex)
+}
+
+function aliasCommand([first, second], boundary, setters, bindingIndex) {
+  const declaration = oneDeclaration(first)
+  if (!declaration || !(first.declarationList.flags & ts.NodeFlags.Const) || !declaration.initializer || !ts.isExpressionStatement(second)) return undefined
+  const value = stateAdd(declaration.initializer, boundary, setters, bindingIndex)
+  const call = second.expression
+  if (!value || !directCall(call) || call.arguments.length !== 1 || !ts.isIdentifier(call.arguments[0])) return undefined
+  const state = setters.get(call.expression.text)
+  if (state !== value.state || !captured(call.expression, boundary, call.expression.text, bindingIndex) || !declaredBy(call.arguments[0], declaration.name, boundary, bindingIndex) || refs(boundary, declaration.name, boundary, bindingIndex).length !== 1) return undefined
+  return { operation: "add", state, ...value.operand }
+}
+
+function helperCommand([first, second], boundary, setters, bindingIndex, specialize) {
+  if (!ts.isExpressionStatement(second) || !directCall(second.expression)) return undefined
+  const call = second.expression
+  let name
+  let command
+  const declaration = oneDeclaration(first)
+  if (declaration && first.declarationList.flags & ts.NodeFlags.Const && declaration.initializer && ts.isArrowFunction(declaration.initializer) && !declaration.initializer.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword) && !declaration.initializer.parameters.length && !ts.isBlock(declaration.initializer.body) && !call.arguments.length) {
+    name = declaration.name
+    command = safeDirect(declaration.initializer.body, boundary, setters, bindingIndex, specialize)
+  } else if (ts.isFunctionDeclaration(first) && first.name && first.body && !first.asteriskToken && !first.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword) && first.parameters.length === 1 && first.body.statements.length === 1 && ts.isExpressionStatement(first.body.statements[0]) && call.arguments.length === 1 && ts.isIdentifier(call.arguments[0])) {
+    const parameter = first.parameters[0]
+    if (!ts.isIdentifier(parameter.name) || parameter.initializer || parameter.dotDotDotToken) return undefined
+    name = first.name
+    command = parameterCommand(first.body.statements[0].expression, parameter.name, first, call.arguments[0], boundary, setters, bindingIndex)
+  }
+  if (!name || !command || call.expression.text !== name.text || !declaredBy(call.expression, name, boundary, bindingIndex) || refs(boundary, name, boundary, bindingIndex).length !== 1) return undefined
+  return command
+}
+
+function safeDirect(expression, boundary, setters, bindingIndex, specialize) {
+  const command = specialize(expression, setters)
+  if (!command || command.operation === "log") return undefined
+  if (!captured(expression.expression, boundary, expression.expression.text, bindingIndex)) return undefined
+  const value = expression.arguments[0]
+  return !ts.isBinaryExpression(value) || captured(value.left, boundary, command.state, bindingIndex) ? command : undefined
+}
+
+function parameterCommand(expression, parameter, helper, argument, boundary, setters, bindingIndex) {
+  if (!directCall(expression) || expression.arguments.length !== 1 || !ts.isBinaryExpression(expression.arguments[0])) return undefined
+  const state = setters.get(expression.expression.text)
+  const value = expression.arguments[0]
+  if (!state || !captured(expression.expression, boundary, expression.expression.text, bindingIndex) || !ts.isIdentifier(value.left) || !declaredBy(value.left, parameter, helper, bindingIndex) || !captured(argument, boundary, state, bindingIndex)) return undefined
+  const operand = addOperand(value)
+  return operand ? { operation: "add", state, ...operand } : undefined
+}
+
+function rejectUnsafe(statements, boundary, setters, bindingIndex) {
+  if (!bindingIndex) return
+  for (const statement of statements) {
+    const declaration = oneDeclaration(statement)
+    if (declaration?.initializer && ts.isObjectLiteralExpression(declaration.initializer) && containsSetter(declaration.initializer, boundary, setters, bindingIndex)) {
+      const use = refs(boundary, declaration.name, boundary, bindingIndex).find(dynamic)
+      if (use) fail(use, "Semantic state helpers do not support dynamic dispatch")
+    }
+    if (declaration?.initializer && stateAdd(declaration.initializer, boundary, setters, bindingIndex)) {
+      const use = setterAliasUse(boundary, declaration.name, setters, bindingIndex)
+      if (!use) continue
+      const uses = refs(boundary, declaration.name, boundary, bindingIndex)
+      if (!(statement.declarationList.flags & ts.NodeFlags.Const) || uses.some(mutated)) fail(declaration.name, "Semantic state aliases must remain immutable")
+      fail(uses.find(reference => reference !== use) ?? use, "Semantic state aliases must be passed directly to one setter and cannot escape")
+    }
+    const helper = helperDeclaration(statement, boundary, setters, bindingIndex)
+    if (!helper) continue
+    const uses = refs(boundary, helper.name, boundary, bindingIndex)
+    if (uses.some(reference => inside(reference, helper.body))) fail(helper.name, "Semantic state helpers cannot be recursive")
+    if (helper.mutable || uses.some(mutated)) fail(helper.name, "Semantic state helpers must remain immutable")
+    if (uses.some(dynamic)) fail(uses.find(dynamic), "Semantic state helpers do not support dynamic dispatch")
+    if (uses.length !== 1 || !directIdentifierCall(uses[0])) fail(uses.find(reference => !directIdentifierCall(reference)) ?? helper.name, "Semantic state helpers must be called exactly once and cannot escape")
+    fail(helper.body, "Semantic state helpers must contain one synchronous state operation")
+  }
+}
+
+function helperDeclaration(statement, boundary, setters, bindingIndex) {
+  const declaration = oneDeclaration(statement)
+  if (declaration?.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer)) && containsSetter(declaration.initializer, boundary, setters, bindingIndex)) return { name: declaration.name, body: declaration.initializer, mutable: !(statement.declarationList.flags & ts.NodeFlags.Const) }
+  if (ts.isFunctionDeclaration(statement) && statement.name && statement.body && containsSetter(statement.body, boundary, setters, bindingIndex)) return { name: statement.name, body: statement.body, mutable: false }
+}
+
+function stateAdd(expression, boundary, setters, bindingIndex) {
+  if (!ts.isBinaryExpression(expression) || !ts.isIdentifier(expression.left) || ![...setters.values()].includes(expression.left.text) || !captured(expression.left, boundary, expression.left.text, bindingIndex)) return undefined
+  const operand = addOperand(expression)
+  return operand ? { state: expression.left.text, operand } : undefined
+}
+
+function addCommand(state, expression) {
+  const operand = addOperand(expression)
+  return operand ? { operation: "add", state, ...operand } : undefined
+}
+
+function addOperand(expression) {
+  if (!ts.isBinaryExpression(expression) || !ts.isNumericLiteral(expression.right) || ![ts.SyntaxKind.PlusToken, ts.SyntaxKind.MinusToken].includes(expression.operatorToken.kind)) return undefined
+  return signedNumber(expression.right, expression.operatorToken.kind === ts.SyntaxKind.MinusToken ? "negative" : undefined)
+}
+
+function oneDeclaration(statement) {
+  if (!ts.isVariableStatement(statement) || statement.declarationList.declarations.length !== 1) return undefined
+  const declaration = statement.declarationList.declarations[0]
+  return ts.isIdentifier(declaration.name) ? declaration : undefined
+}
+
+function directCall(node) {
+  return ts.isCallExpression(node) && !node.questionDotToken && ts.isIdentifier(node.expression)
+}
+
+function captured(identifier, boundary, name, bindingIndex) {
+  if (!ts.isIdentifier(identifier)) return false
+  const resolution = bindingIndex?.resolveReference(identifier, boundary)
+  return !resolution ? identifier.text === name : resolution.debugName === name && ["capture", "unresolved"].includes(resolution.kind)
+}
+
+function declaredBy(identifier, declaration, boundary, bindingIndex) {
+  const resolution = bindingIndex?.resolveReference(identifier, boundary)
+  return bindingIndex ? resolution?.declaration === declaration : identifier.text === declaration.text
+}
+
+function refs(root, declaration, boundary, bindingIndex) {
+  const found = []
+  const visit = node => {
+    if (ts.isIdentifier(node) && declaredBy(node, declaration, boundary, bindingIndex)) found.push(node)
+    ts.forEachChild(node, visit)
+  }
+  visit(root)
+  return found
+}
+
+function containsSetter(root, boundary, setters, bindingIndex) {
+  let found = false
+  const visit = node => {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && setters.has(node.expression.text) && captured(node.expression, boundary, node.expression.text, bindingIndex)) found = true
+    if (!found) ts.forEachChild(node, visit)
+  }
+  visit(root)
+  return found
+}
+
+function setterAliasUse(root, declaration, setters, bindingIndex) {
+  let found
+  const visit = node => {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && setters.has(node.expression.text) && ts.isIdentifier(node.arguments[0]) && declaredBy(node.arguments[0], declaration, root, bindingIndex)) found = node.arguments[0]
+    if (!found) ts.forEachChild(node, visit)
+  }
+  visit(root)
+  return found
+}
+
+function directIdentifierCall(identifier) {
+  return ts.isCallExpression(identifier.parent) && identifier.parent.expression === identifier && !identifier.parent.questionDotToken
+}
+
+function dynamic(identifier) {
+  if (ts.isCallExpression(identifier.parent) && identifier.parent.expression === identifier) return Boolean(identifier.parent.questionDotToken)
+  for (let current = identifier.parent; current && !ts.isStatement(current); current = current.parent) if (ts.isCallExpression(current)) return true
+  return false
+}
+
+function mutated(identifier) {
+  const parent = identifier.parent
+  return ts.isPrefixUnaryExpression(parent) && [ts.SyntaxKind.PlusPlusToken, ts.SyntaxKind.MinusMinusToken].includes(parent.operator) || ts.isPostfixUnaryExpression(parent) || ts.isBinaryExpression(parent) && parent.left === identifier && parent.operatorToken.kind >= ts.SyntaxKind.FirstAssignment && parent.operatorToken.kind <= ts.SyntaxKind.LastAssignment
+}
+
+function inside(node, root) {
+  for (let current = node; current; current = current.parent) if (current === root) return true
+  return false
+}
+
+function fail(node, message) {
+  throw sourceNodeError(node, node.getSourceFile(), message)
 }
 
 function primitiveValue(node) {

package/framework/compiler/project-session.mjs

@@ -1,5 +1,6 @@
-import { join, resolve } from "node:path"
+import { join, relative, resolve, sep } from "node:path"
 import ts from "typescript"
+import { sourceNodeError } from "./ast-helpers.mjs"
 import { assetPath } from "./path-helpers.mjs"
 import { createSourceGraph } from "./source-graph.mjs"
 import { createWorkerCompiler } from "./worker-compiler.mjs"
@@ -8,7 +9,7 @@ export function createProjectSession(projectRoot = process.cwd(), { counters, so
   const root = resolve(projectRoot)
   const sourceDirectory = join(root, "src")
   const graph = createSourceGraph(root)
-  const modules = createModuleCache(sourceIndex, graph.parseSourceFile, counters)
+  const modules = createModuleCache(root, sourceIndex, graph, counters)
   return {
     root,
     sourceDirectory,
@@ -23,8 +24,19 @@ export function createProjectSession(projectRoot = process.cwd(), { counters, so
   }
 }
 
-function createModuleCache(sourceIndex, parseSourceFile, counters) {
+function createModuleCache(root, sourceIndex, graph, counters) {
   const records = new Map()
+  let resolvedExports = new WeakMap()
+  const moduleName = file => relative(root, file).replaceAll(sep, "/")
+  const siteId = (node, role = "site") => {
+    const original = ts.getOriginalNode(node)
+    return `${role}:${original.getStart(original.getSourceFile())}:${original.end}`
+  }
+  const moduleSymbol = (file, node, name) => {
+    const site = siteId(node, "declaration")
+    const module = moduleName(file)
+    return { id: `${module}#${site}`, module, site, name }
+  }
   const increment = name => {
     if (counters) counters[name] = (counters[name] ?? 0) + 1
   }
@@ -32,12 +44,13 @@ function createModuleCache(sourceIndex, parseSourceFile, counters) {
     if (typeof source !== "string") throw new Error(`Source text is unavailable for ${file}`)
     const cached = records.get(file)
     if (cached?.source === source) return cached
-    const sourceFile = parseSourceFile(file, source)
+    const sourceFile = graph.parseSourceFile(file, source)
     increment("parsedModules")
-    const exports = summarizeExports(sourceFile)
+    const summary = summarizeModule(file, sourceFile, moduleSymbol, siteId)
     increment("exportSummaries")
-    const record = { source, sourceFile, exports }
+    const record = { source, sourceFile, ...summary }
     records.set(file, record)
+    resolvedExports = new WeakMap()
     return record
   }
   const clone = (file, factory, context) => {
@@ -52,39 +65,121 @@ function createModuleCache(sourceIndex, parseSourceFile, counters) {
     increment("clonedModules")
     return sourceFile
   }
-  return { clone, read }
+  const resolveExport = (file, exportName, sourceFiles) => {
+    let cached = resolvedExports.get(sourceFiles)
+    const cacheKey = `${file}:${exportName}`
+    const cachedResolution = cached?.get(cacheKey)
+    if (cachedResolution?.dependencies.every(([target, source]) => sourceIndex.get(target) === source)) return cachedResolution.symbol
+    const dependencies = new Set()
+    const resolveEntry = (currentFile, name, trail) => {
+      const key = `${currentFile}:${name}`
+      if (trail.includes(key)) return { cycle: [...trail, key] }
+      const record = read(currentFile)
+      dependencies.add(currentFile)
+      const entry = record.exports.get(name)
+      const nextTrail = [...trail, key]
+      if (entry?.kind === "local") {
+        const symbol = entry.symbol ?? record.declarations.get(entry.local)
+        return symbol ? { symbol } : {}
+      }
+      if (entry?.kind === "reexport") {
+        if (!entry.specifier.startsWith(".")) throw sourceNodeError(entry.node, record.sourceFile, "Imported keyed list components must use relative TypeScript re-exports")
+        return resolveEntry(graph.resolveSourceImport(currentFile, entry.specifier, sourceFiles), entry.imported, nextTrail)
+      }
+      if (name === "default") return {}
+      const matches = new Map()
+      let cycle
+      for (const star of record.exportStars) {
+        if (!star.specifier.startsWith(".")) continue
+        const result = resolveEntry(graph.resolveSourceImport(currentFile, star.specifier, sourceFiles), name, nextTrail)
+        if (result.symbol) matches.set(result.symbol.id, result.symbol)
+        else cycle ??= result.cycle
+      }
+      if (matches.size > 1) throw new Error(`${moduleName(currentFile)} has an ambiguous export named ${JSON.stringify(name)}`)
+      return matches.size ? { symbol: matches.values().next().value } : cycle ? { cycle } : {}
+    }
+    const result = resolveEntry(file, exportName, [])
+    if (result.cycle) throw new Error(`Imported keyed list component re-export cycle: ${result.cycle.map(entry => moduleName(entry.slice(0, entry.lastIndexOf(":")))).join(" -> ")}`)
+    cached = resolvedExports.get(sourceFiles) ?? new Map()
+    cached.set(cacheKey, { symbol: result.symbol, dependencies: [...dependencies].map(target => [target, sourceIndex.get(target)]) })
+    resolvedExports.set(sourceFiles, cached)
+    return result.symbol
+  }
+  const declaration = (symbol, sourceFile) => {
+    const file = resolve(root, symbol.module)
+    const record = read(file)
+    if (!sourceFile || sourceFile === record.sourceFile) return record.declarationSites.get(symbol.site)
+    for (const statement of sourceFile.statements) {
+      if (ts.isFunctionDeclaration(statement) && siteId(statement, "declaration") === symbol.site) return statement
+      if (ts.isVariableStatement(statement)) for (const entry of statement.declarationList.declarations) {
+        if (siteId(entry, "declaration") === symbol.site) return entry
+      }
+    }
+  }
+  return { clone, declaration, read, resolveExport, siteId, symbol: moduleSymbol }
 }
 
-function summarizeExports(sourceFile) {
+function summarizeModule(file, sourceFile, moduleSymbol, siteId) {
   const exports = new Map()
+  const imports = new Map()
+  const declarations = new Map()
+  const declarationSites = new Map()
+  const exportStars = []
   const add = (name, value) => {
     if (!exports.has(name)) exports.set(name, value)
   }
+  const declare = (name, node) => {
+    const symbol = moduleSymbol(file, node, name)
+    if (!declarations.has(name)) declarations.set(name, symbol)
+    declarationSites.set(symbol.site, node)
+    return symbol
+  }
   for (const statement of sourceFile.statements) {
+    if (ts.isImportDeclaration(statement) && !statement.importClause?.isTypeOnly && ts.isStringLiteral(statement.moduleSpecifier)) {
+      const specifier = statement.moduleSpecifier.text
+      const clause = statement.importClause
+      if (clause?.name) imports.set(clause.name.text, { kind: "default", imported: "default", specifier, site: siteId(clause.name, "import") })
+      if (clause?.namedBindings && ts.isNamespaceImport(clause.namedBindings)) imports.set(clause.namedBindings.name.text, { kind: "namespace", imported: "*", specifier, site: siteId(clause.namedBindings, "import") })
+      if (clause?.namedBindings && ts.isNamedImports(clause.namedBindings)) for (const element of clause.namedBindings.elements) {
+        if (!element.isTypeOnly) imports.set(element.name.text, { kind: "named", imported: (element.propertyName ?? element.name).text, specifier, site: siteId(element, "import") })
+      }
+      continue
+    }
     if (ts.isFunctionDeclaration(statement)) {
       const exported = statement.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.ExportKeyword)
       const isDefault = statement.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.DefaultKeyword)
-      if (isDefault) add("default", { kind: "function", local: statement.name?.text })
-      if (exported && statement.name) add(statement.name.text, { kind: "function", local: statement.name.text })
+      const name = statement.name?.text ?? (isDefault ? "default" : undefined)
+      const symbol = name ? declare(name, statement) : undefined
+      if (isDefault && symbol) add("default", { kind: "local", symbol })
+      if (exported && !isDefault && statement.name && symbol) add(statement.name.text, { kind: "local", local: statement.name.text, symbol })
       continue
     }
-    if (ts.isVariableStatement(statement) && statement.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.ExportKeyword)) {
-      for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name)) add(declaration.name.text, { kind: "local", local: declaration.name.text })
+    if (ts.isVariableStatement(statement)) {
+      const exported = statement.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.ExportKeyword)
+      for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name)) {
+        const symbol = declare(declaration.name.text, declaration)
+        if (exported) add(declaration.name.text, { kind: "local", local: declaration.name.text, symbol })
+      }
       continue
     }
     if (ts.isExportAssignment(statement) && !statement.isExportEquals && ts.isIdentifier(statement.expression)) {
       add("default", { kind: "local", local: statement.expression.text })
       continue
     }
-    if (!ts.isExportDeclaration(statement) || !statement.exportClause || !ts.isNamedExports(statement.exportClause)) continue
+    if (!ts.isExportDeclaration(statement)) continue
+    if (!statement.exportClause && statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)) {
+      exportStars.push({ specifier: statement.moduleSpecifier.text, site: siteId(statement, "reexport") })
+      continue
+    }
+    if (!statement.exportClause || !ts.isNamedExports(statement.exportClause)) continue
     for (const element of statement.exportClause.elements) {
       if (element.isTypeOnly) continue
       const name = element.name.text
       const imported = (element.propertyName ?? element.name).text
       add(name, statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)
-        ? { kind: "reexport", imported, specifier: statement.moduleSpecifier.text, node: statement }
+        ? { kind: "reexport", imported, specifier: statement.moduleSpecifier.text, site: siteId(element, "reexport"), node: statement }
         : { kind: "local", local: imported })
     }
   }
-  return exports
+  return { declarations, declarationSites, exports, exportStars, imports }
 }

package/framework/compiler/source-compiler.mjs

@@ -324,6 +324,10 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
       const original = ts.getOriginalNode(node)
       return original.pos >= 0 && original.end >= 0 ? { file: sourceName(original.getSourceFile()), start: original.getStart(), end: original.end } : undefined
     }
+    const analysisSite = (node, role) => {
+      const original = ts.getOriginalNode(node)
+      return original.pos >= 0 && original.end >= 0 ? modules.siteId(original, role) : undefined
+    }
     const analyzedProps = owner => {
       if (owner.parameters.length !== 1 || !ts.isObjectBindingPattern(owner.parameters[0].name)) return []
       return owner.parameters[0].name.elements.map(element => ({
@@ -334,14 +338,14 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
       }))
     }
     const ownerName = owner => owner.name?.text ?? (ts.isVariableDeclaration(owner.parent) && ts.isIdentifier(owner.parent.name) ? owner.parent.name.text : "anonymous")
-    const ensureOwner = (owner, kind = "component") => componentAnalysis.registerOwner(owner, { kind, name: ownerName(owner), props: analyzedProps(owner), source: analysisSource(owner) })
+    const ensureOwner = (owner, kind = "component") => componentAnalysis.registerOwner(owner, { kind, name: ownerName(owner), props: analyzedProps(owner), site: analysisSite(owner, "owner"), source: analysisSource(owner) })
     const registerState = (owner, state, setter, kind, node, externalOwner) => {
       const ownerRecord = ensureOwner(owner)
       const stateOwner = externalOwner ?? `owner:${ownerRecord.slot}`
       const stateOwners = stateOwnersByFunction.get(owner) ?? new Map()
       stateOwners.set(state, stateOwner)
       stateOwnersByFunction.set(owner, stateOwners)
-      return componentAnalysis.registerState(owner, { name: state, setter, kind, ...(externalOwner ? { owner: externalOwner } : {}), source: analysisSource(node) })
+      return componentAnalysis.registerState(owner, { name: state, setter, kind, ...(externalOwner ? { owner: externalOwner } : {}), site: analysisSite(node, "hook"), source: analysisSource(node) })
     }
     const stateOwnersForNode = node => {
       for (let current = node.parent; current; current = current.parent) {
@@ -643,12 +647,12 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
           if (!nullInitializer && owner.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.DefaultKeyword)) throw sourceNodeError(node.initializer, sourceFile, "Mutable value useRef() is unsupported except for an effect-owned useRef(0) animation-frame handle; otherwise keep resource-private mutable values inside the owning effect")
           if (nullInitializer) {
             ensureOwner(owner)
-            componentAnalysis.registerRef(owner, { name: node.name.text, source: analysisSource(node) })
+            componentAnalysis.registerRef(owner, { name: node.name.text, site: analysisSite(node, "hook"), source: analysisSource(node) })
           }
         }
         if (owner && node.initializer.expression.text === "useId" && node.initializer.arguments.length === 0) {
           ensureOwner(owner)
-          componentAnalysis.registerId(owner, { name: node.name.text, source: analysisSource(node) })
+          componentAnalysis.registerId(owner, { name: node.name.text, site: analysisSite(node, "hook"), source: analysisSource(node) })
         }
       }
       if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && ts.isCallExpression(node.initializer) && ts.isIdentifier(node.initializer.expression) && node.initializer.expression.text === "createContext") contexts.add(node.name.text)
@@ -834,6 +838,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
       result.analysis = componentAnalysis.registerSpecialization({
         kind: label,
         ...(owner ? { owner: ensureOwner(owner).slot } : {}),
+        ...(analysisSite(call, "component-call") ? { site: analysisSite(call, "component-call") } : {}),
         ...(analysisSource(call) ? { source: analysisSource(call) } : {}),
         props: result.props.map(prop => {
           const expression = result.propExpressions.get(prop.name)
@@ -841,11 +846,11 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
           return { ...prop, ...(signals.length ? { signals } : {}) }
         }),
         states: [
-          ...result.rowStates.map(({ state, setter, source }) => ({ name: state, setter, kind: "row", ...(analysisSource(source) ? { source: analysisSource(source) } : {}) })),
-          ...result.ordinaryStates.map(({ state, setter, source }) => ({ name: state, setter, kind: "component", ...(analysisSource(source) ? { source: analysisSource(source) } : {}) }))
+          ...result.rowStates.map(({ state, setter, source }) => ({ name: state, setter, kind: "row", ...(analysisSite(source, "hook") ? { site: analysisSite(source, "hook") } : {}), ...(analysisSource(source) ? { source: analysisSource(source) } : {}) })),
+          ...result.ordinaryStates.map(({ state, setter, source }) => ({ name: state, setter, kind: "component", ...(analysisSite(source, "hook") ? { site: analysisSite(source, "hook") } : {}), ...(analysisSource(source) ? { source: analysisSource(source) } : {}) }))
         ],
-        refs: [...result.rowRefs.map(({ name, source }) => ({ name, kind: "row", ...(analysisSource(source) ? { source: analysisSource(source) } : {}) })), ...result.ordinaryRefs.map(({ name, source }) => ({ name, kind: "component", ...(analysisSource(source) ? { source: analysisSource(source) } : {}) }))],
-        ids: result.ordinaryIds.map(({ name, source }) => ({ name, ...(analysisSource(source) ? { source: analysisSource(source) } : {}) }))
+        refs: [...result.rowRefs.map(({ name, source }) => ({ name, kind: "row", ...(analysisSite(source, "hook") ? { site: analysisSite(source, "hook") } : {}), ...(analysisSource(source) ? { source: analysisSource(source) } : {}) })), ...result.ordinaryRefs.map(({ name, source }) => ({ name, kind: "component", ...(analysisSite(source, "hook") ? { site: analysisSite(source, "hook") } : {}), ...(analysisSource(source) ? { source: analysisSource(source) } : {}) }))],
+        ids: result.ordinaryIds.map(({ name, source }) => ({ name, ...(analysisSite(source, "hook") ? { site: analysisSite(source, "hook") } : {}), ...(analysisSource(source) ? { source: analysisSource(source) } : {}) }))
       })
       for (const state of [...result.rowStates, ...result.ordinaryStates]) state.analysisOwner = `specialization:${result.analysis.slot}`
       for (const ref of [...result.rowRefs, ...result.ordinaryRefs]) ref.analysisOwner = `specialization:${result.analysis.slot}`
@@ -1427,6 +1432,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
       const rowRefs = (listParts.rowRefs ?? []).map(ref => ({ name: ref.name, owner: ref.analysisOwner, ...(analysisSource(ref.source) ? { source: analysisSource(ref.source) } : {}) }))
       const specializations = [...new Set([...(listParts.specializations ?? []), ...rowStates.map(state => state.owner), ...rowRefs.map(ref => ref.owner)].filter(value => value !== undefined).map(value => typeof value === "string" ? Number(value.slice(value.lastIndexOf(":") + 1)) : value))]
       const block = descriptors.registerKeyedBlock({
+        ...(analysisSite(node, "keyed-list") ? { site: analysisSite(node, "keyed-list") } : {}),
         ...(analysisSource(node) ? { source: analysisSource(node) } : {}),
         ...(parent ? { parent: parent.slot } : {}),
         children: [],
@@ -1607,9 +1613,10 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
           ownership: {
             kind: activeKeyedBlock ? "keyed" : "component",
             ...(activeKeyedBlock ? { keyedBlock: activeKeyedBlock.block.slot } : {}),
-            ...(lexicalOwner ? { component: { name: ownerName(lexicalOwner), ...(analysisSource(lexicalOwner) ? { source: analysisSource(lexicalOwner) } : {}) } } : {})
+            ...(lexicalOwner ? { component: { name: ownerName(lexicalOwner), ...(analysisSite(lexicalOwner, "owner") ? { site: analysisSite(lexicalOwner, "owner") } : {}), ...(analysisSource(lexicalOwner) ? { source: analysisSource(lexicalOwner) } : {}) } } : {})
           },
           workers,
+          ...(analysisSite(effectSource, "hook") ? { site: analysisSite(effectSource, "hook") } : {}),
           ...(analysisSource(effectSource) ? { source: analysisSource(effectSource) } : {})
         })
         const dependencyExpressions = effect.dependencies.map(dependency => dependency.kind === "derived" ? moduleIR.derived[dependency.derived].expression : ["state", dependency.name])
@@ -2719,25 +2726,12 @@ function normalizeImportedStaticCollections(sourceFile, collections, factory, co
   return ts.visitNode(sourceFile, visitor)
 }
 
-function resolveComponentExport(file, exportName, getSource, sourceFiles, trail = []) {
-  const key = `${file}:${exportName}`
-  if (trail.includes(key)) throw new Error(`Imported keyed list component re-export cycle: ${[...trail, key].map(entry => relative(root, entry.slice(0, entry.lastIndexOf(":")))).join(" -> ")}`)
-  const sourceFile = getSource(file)
-  const nextTrail = [...trail, key]
-  const entry = modules.read(file).exports.get(exportName)
-  if (entry?.kind === "reexport") {
-    if (!entry.specifier.startsWith(".")) throw sourceNodeError(entry.node, modules.read(file).sourceFile, "Imported keyed list components must use relative TypeScript re-exports")
-    const target = resolveSourceImport(file, entry.specifier, sourceFiles)
-    return resolveComponentExport(target, entry.imported, getSource, sourceFiles, nextTrail)
-  }
-  if (entry?.kind === "function" && !entry.local) {
-    const component = sourceFile.statements.find(statement => ts.isFunctionDeclaration(statement) && statement.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.DefaultKeyword))
-    if (component) return component
-  }
-  if (entry?.local) {
-    const component = localComponentDeclaration(sourceFile, entry.local)
-    if (component) return component
-  }
+function resolveComponentExport(file, exportName, getSource, sourceFiles) {
+  const symbol = modules.resolveExport(file, exportName, sourceFiles)
+  const target = symbol && resolve(root, symbol.module)
+  const declaration = symbol && modules.declaration(symbol, getSource(target))
+  if (declaration && ts.isFunctionDeclaration(declaration)) return declaration
+  if (declaration && ts.isVariableDeclaration(declaration) && declaration.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer))) return declaration.initializer
   throw new Error(`${relative(root, file)} does not export a statically analyzable keyed list component named ${JSON.stringify(exportName)}`)
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kudzujs/core",
-  "version": "0.8.34",
+  "version": "0.8.36",
   "description": "HTML-first TSX framework with synchronous state semantics and no virtual DOM",
   "type": "module",
   "license": "MIT",