@kudzujs/core 0.8.32 → 0.8.34

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.32` 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.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.
 
 [`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.
 
@@ -302,6 +302,18 @@ This queue orders the next investigations by general migration value. Start only
 - Same-root builds use an exclusive PID lock, stale locks fail closed, interrupted promotion backups recover on the next admitted build after lock removal, and successful replacement removes stale output.
 - Route HTML writes use bounded batches, keyed reverse/remove paths avoid repeated map reconstruction, and binding/condition commits share one dispatch without adding a runtime or public API.
 
+### Completed In 0.8.33
+
+- Build root, source paths, source graph resolution, source records, and Worker compilation now belong to one explicit ProjectSession created for each build.
+- Programmatic build and development entry points accept an explicit root while omitted roots preserve call-time CWD and existing CLI behavior.
+- One process compiles two independent roots with identical module names and verifies isolated config, HTML, `.kudzu`, source results, and Worker output; no browser runtime or migration syntax changes.
+
+### Completed In 0.8.34
+
+- Each unchanged source module is parsed and export-summarized once per ProjectSession, with source-text invalidation and no cross-project cache sharing.
+- 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.
+
 ## Cross-Cutting Performance Gates
 
 Every migration feature must preserve:

package/PERFORMANCE.md

@@ -1,6 +1,57 @@
 # Performance Records
 
-Reproducibility classes: `npm run benchmark`, `npm run benchmark:keyed`, and `npm run benchmark:native` 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.
+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.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:
+
+```bash
+git diff --binary v0.8.33..v0.8.34 -- framework/compiler/project-session.mjs framework/compiler/source-compiler.mjs framework/compiler/worker-compiler.mjs test/compiler-passes.test.mjs test/module-cache-performance.mjs package.json | sha256sum
+```
+
+The maintained in-memory fixture has 100 page importers sharing one barrel component and helper, for 103 unique modules. Each sample starts a fresh Node process; fixture generation and result hashing occur outside timing. Three warm-ups followed by 21 alternating samples compiled every reachable module. The candidate parsed and summarized each unique module once and created 200 importer-local normalization clones. Baseline and candidate produced the same 382,603-byte serialized source-result graph with SHA-256 `8c35b3f6d2c571306bd97c4d51d4af76ca244badd36c57363bf579ef961f41aa`.
+
+| Target | Compiler median | Range | Peak RSS median | Parse / summary / clone misses |
+|---|---:|---:|---:|---:|
+| `v0.8.33` | 2,386.735 ms | 1,183.385–3,249.719 ms | 261.3 MiB | not instrumented |
+| P0.7 candidate | 2,188.745 ms | 1,321.352–2,957.883 ms | 257.1 MiB | 103 / 103 / 200 |
+
+Both timing arrays drifted upward during the run, making their raw 8.29% median difference unsuitable as an improvement claim. Round-paired candidate-minus-baseline differences had a +33.324 ms median, with the candidate faster in 9/21 pairs and the baseline faster in 12/21. Peak RSS ranges also overlap. This establishes bounded parse/summary work and identical compiler output with no material performance conclusion on this machine; it does not establish a speedup.
+
+```text
+v0.8.33: [1512.096,1244.231,1183.385,1655.352,1669.380,2033.448,1820.868,1774.702,1847.652,1889.290,2386.735,2926.474,2853.159,3249.719,2716.963,2569.254,2531.427,2727.951,2483.411,2492.172,2597.774]
+candidate: [1943.630,1416.969,1321.352,1603.967,1340.557,1440.993,1913.509,2060.240,1796.133,2011.796,2188.745,2888.145,2957.883,2947.417,2750.287,2745.883,2799.166,2620.866,2499.916,2541.054,2530.391]
+paired candidate-baseline: [431.534,172.738,137.967,-51.385,-328.823,-592.455,92.641,285.538,-51.519,122.506,-197.990,-38.329,104.724,-302.302,33.324,176.629,267.739,-107.085,16.505,48.882,-67.383]
+```
+
+```bash
+git worktree add --detach /tmp/opencode/kudzu-v0.8.33 v0.8.33
+ln -s "$PWD/node_modules" /tmp/opencode/kudzu-v0.8.33/node_modules
+BASELINE_ROOT=/tmp/opencode/kudzu-v0.8.33 CANDIDATE_ROOT="$PWD" WARMUPS=3 RUNS=21 npm run benchmark:module-cache
+```
+
+### 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.
+
+| 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 |
+
+```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]
+```
+
+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.
 
 ## 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.32 - Staged and collision-safe output.** Builds complete in an isolated staging tree, reject public/generated collisions, preserve the previous `dist` on ordinary build and hook failures, recover interrupted promotion backups after a stale lock is cleared, and reject overlapping same-root builds. Read the [release notes](./RELEASES.md#0832---staged-and-collision-safe-output), open the [release page](https://github.com/kudzujs/kudzu/releases/tag/v0.8.32), or follow the [architecture packet](./docs/next-architecture/README.md).
+**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).
 
 - [Documentation](https://kudzujs.cloud/docs)
 - [Installation guide](https://kudzujs.cloud/docs#install)

package/RELEASES.md

@@ -1,5 +1,65 @@
 # Kudzu Releases
 
+## 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.
+
+### Changed in 0.8.34
+
+- ProjectSession caches one canonical read-only TypeScript AST and one narrow export summary for each file/source-text pair.
+- Reachability, static collection, Zustand, client-helper, style, layout-diagnostic, and Worker graph consumers reuse canonical module records.
+- Importer normalization receives a deep clone of every node with independent parent links; transformed mutable AST is never shared between transformer contexts.
+- Source-text changes invalidate the parsed tree and export summary together, and independent ProjectSessions never share records.
+- Export summaries preserve the existing supported direct, aliased, default, and named re-export forms. Stable ModuleSymbol/SiteId identity and `export *` expansion remain P0.8 work.
+- Optional injected counters expose parse, summary, and clone misses to tests and the maintained benchmark without production logging.
+
+### Performance
+
+- A 100-importer fixture contains 103 unique page/barrel/component/helper modules. The candidate records exactly 103 parses, 103 export summaries, and 200 importer-local clones.
+- Baseline and candidate produce the same 382,603-byte source-result graph and SHA-256 digest.
+- The 21-pair timing run drifted materially on the measurement host. Paired candidate-minus-baseline differences had a +33.324 ms median, with the candidate faster in 9/21 pairs; no material speedup or regression is claimed.
+- A separate matched SSR/native whole-build check measured Kudzu at 856.2 ms, Astro at 1,482.9 ms, Vue at 2,295.3 ms, React at 2,802.0 ms, and Svelte at 2,972.9 ms. Every target passed the same Chrome behavior validation; this is whole-build context, not a module-cache comparison.
+
+### Validation
+
+- `npm run check`, `npm test`, `npm run test:package`, and all 193 tests pass.
+- Unit coverage verifies cache hits, source-text invalidation, export summaries, cross-session isolation, independent cloned node identity, and clone-local parent links.
+- Existing imported components, re-export cycles, static collections, Zustand, client helpers, Workers, source diagnostics, and generated artifacts remain covered.
+- The repository build emits 149 pages; unaffected static routes remain complete zero-JavaScript documents.
+- P0.8 stable ModuleSymbol and SiteId is next.
+
+### Upgrade
+
+```bash
+npm install @kudzujs/core@^0.8.34
+```
+
+## 0.8.33 - Project-scoped compilation
+
+Kudzu 0.8.33 completes P0.6 by replacing import-time project globals with an explicit build-scoped ProjectSession. Independent roots can now compile in one Node process without sharing paths, source records, graph resolution, or Worker compiler ownership.
+
+### Changed in 0.8.33
+
+- Each `build()` creates a ProjectSession containing the absolute project root, `src`, `src/pages`, `.kudzu`, and `dist` paths.
+- Source graph resolution, source indexes, reachable source sets, source compiler helpers, and Worker compilation are bound to that session instead of the directory where compiler modules were first imported.
+- The internal programmatic build and development entry points accept an explicit `root`; omitted roots still use call-time `process.cwd()`, preserving existing `kudzu build` and `kudzu dev` behavior.
+- Config loading, styles, static assets, route diagnostics, generated modules, output locking, staging, promotion, and development serving all resolve against the selected project.
+- Parsed-module and export-summary caching remains deferred to P0.7; this release establishes ownership without adding speculative shared caches or changing browser output.
+
+### Validation
+
+- `npm run check`, `npm test`, `npm run test:package`, and all 191 tests pass.
+- One imported `build()` function compiles two roots with identical source filenames in sequence and verifies isolated config metadata, HTML, source results, `.kudzu` modules, and content-distinct Worker bundles.
+- The standard CLI output-safety fixture still verifies staging, collision rejection, lock behavior, recovery, and replacement through call-time CWD.
+- The repository build emits 148 pages, and existing static zero-JavaScript, interactive capability, Worker, navigation, ownership, and migration behavior remains covered.
+- P0.7 parsed module and export summary caching is next.
+
+### Upgrade
+
+```bash
+npm install @kudzujs/core@^0.8.33
+```
+
 ## 0.8.32 - Staged and collision-safe output
 
 Kudzu 0.8.32 completes P0.5 by building production artifacts away from the active deploy tree, rejecting public/generated collisions, and replacing `dist` only after generation and trusted `afterBuild()` work succeed.

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.32` implementation sequence is [`large-application-ai-native-roadmap.md`](./large-application-ai-native-roadmap.md). P0.5 staged and collision-safe output is complete; P0.6 ProjectSession and explicit root 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.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.
 
 ## Required Invariants
 

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

@@ -1,12 +1,14 @@
 # Current Compiler Architecture
 
-This maps the current `0.8.32` 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.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.
 
 ## Responsibility Map
 
 | Responsibility | Current owner | Current contract |
 |---|---|---|
 | 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. |
 | 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. |
@@ -37,6 +39,7 @@ This maps the current `0.8.32` architecture built on the completed `0.8.23` Goal
 
 ```text
 src/pages entries + config
+  -> ProjectSession(root) with project paths, source records, parsed/export caches, graph, and Worker compiler
   -> project discovery and reachable relative graph
   -> compileSource()
        -> ordered normalization and parent repair
@@ -68,7 +71,7 @@ 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 share one module because both consume the same normalization and import graph contracts.
+- 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.
 
 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.32`. 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.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.
 
 [`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.
 
@@ -34,7 +34,7 @@ The current limiting architecture is observable in these files:
 
 | Concern | Current owner | Limitation to remove |
 |---|---|---|
-| Project graph | `framework/compiler/source-graph.mjs`, `framework/build.mjs` | Global root, repeated parsing, narrow export resolution, no incremental project session |
+| Project graph | `framework/compiler/project-session.mjs`, `source-graph.mjs`, `build.mjs` | Explicit build-scoped root, parsed-module/export-summary cache, and source ownership; narrow export resolution and no incremental invalidation remain |
 | Normalization | `framework/compiler/source-compiler.mjs`, focused passes | Pass order and package ownership are implicit; semantically equal source often follows different shape-specific paths |
 | Component/state analysis | `framework/compiler/source-compiler.mjs`, `analysis/component-analysis.mjs` | AST identity, identifier text, source offsets, and caller-side AST specialization remain central |
 | Handler/binding analysis | `framework/compiler/descriptor-session.mjs`, `handler-lowering.mjs` | Capture/import/state discovery is name-based and arbitrary handlers become code before IR finalization |
@@ -112,7 +112,7 @@ This is an incremental evolution of the current repository:
 - Resource-specific ownership passes into a package-neutral ResourceIR when evidence permits.
 - Serialized handler URL searches into explicit artifact references.
 - Site-wide capability unions into route capability signatures.
-- Full destructive development builds into project-session invalidation and rollback-safe output.
+- Full development rebuilds into project-session invalidation; rollback-safe production output and explicit session ownership are complete.
 - String-only diagnostics into structured diagnostics suitable for machines and AI agents.
 
 ### Avoid
@@ -134,7 +134,9 @@ This is an incremental evolution of the current repository:
 - [x] P0.3 Graph diagnostics is complete in `0.8.30`. Reachable ordinary modules validate relative runtime imports/re-exports and reject every dynamic `import()` at the importer source location before compilation or generated module loading. Ordinary and Worker traversal retain separate ownership, type-only and unreachable edges remain excluded, focused page/helper/re-export/dynamic fixtures pass with all 189 tests and packed-package smoke, and no export-symbol graph, ProjectSession, runtime, or public API is added.
 - [x] P0.4 Async native handler ownership is complete in `0.8.31`. Mounted native registrations invalidate direct/captured setters, queued commits, and captured refs before listener removal. Chrome route, keyed-row, document-disposal, and synchronous event-dispatch checks, all 189 tests, and packed-package smoke pass without cancelling application promises or adding a scheduler.
 - [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.
-- [ ] P0.6 Explicit ProjectSession is next. Root and caches must become build-scoped so independent projects can compile safely in one process.
+- [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.
 
 ### P0: Semantic Correctness And Compiler Foundation
 
@@ -296,6 +298,8 @@ Every result carries a stable source-local binding slot, debug name, declaration
 
 **Done condition:** two independent roots compile in one process, current CLI behavior and artifacts remain unchanged, and source caches cannot leak between projects.
 
+**Completed in `0.8.33`:** `createProjectSession()` resolves one explicit or call-time-CWD root and owns standard paths, source records, bound graph resolution, and a root-bound Worker compiler. Build, development, config, styles, routes, generated modules, locking, staging, and promotion consume that ownership. One process compiles two roots with identical module names and verifies distinct config, HTML, `.kudzu`, source results, and Worker bundles. Existing CLI output-safety coverage remains unchanged; no parsed-module cache, browser runtime, source syntax, or public migration API is added.
+
 ### PR 7: Parsed Module And Export Summary Cache
 
 **Objective:** make work proportional to unique modules instead of importer edges.
@@ -306,6 +310,8 @@ Every result carries a stable source-local binding slot, debug name, declaration
 
 **Done condition:** each unchanged module is parsed and summarized once per project session; transformed mutable AST is not shared across transformer contexts.
 
+**Completed in `0.8.34`:** ProjectSession caches one canonical parsed tree and one supported-export summary per file/source-text pair. Reachability, static collection, Zustand, client-helper, style, layout-diagnostic, and Worker graph reads reuse canonical trees; importer normalization deep-clones every node and repairs clone-local parents. Optional injected counters add no production logging. Unit coverage proves source invalidation and cross-session isolation; 100 pages sharing one barrel component and helper produce 103 parse misses, 103 summary misses, and 200 independent normalization clones.
+
 ### PR 8: Stable ModuleSymbol And SiteId
 
 **Objective:** represent declarations, imports, re-exports, component calls, hooks, and ownership sites independently of transformed AST identity.
@@ -460,4 +466,4 @@ The first comparison is Kudzu versus React + Vite using the same agent, model, t
 
 ## Immediate Decision
 
-PR 1 through PR 5 are complete. The next PR is **PR 6: ProjectSession And Explicit Root**. Do not skip directly to a store, resource, router, virtualization, or ecosystem package feature.
+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.

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.32` are completed scopes represented by package/release records.
+This is an execution sequence, not release history. `0.8.16` through `0.8.34` 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.
 
@@ -23,6 +23,8 @@ Keep each patch behavior-preserving and independently reviewable. If a boundary
 | `0.8.30` | Validate ordinary runtime graph edges before code generation and reject dynamic imports at the importer source. | Page/helper/re-export/dynamic fixtures report original file/range/specifier without `.kudzu` paths; Worker, type-only, unreachable, output, and runtime behavior remain unchanged. |
 | `0.8.31` | Invalidate pending native-handler contexts when their route, keyed, conditional, or document DOM owner is released. | Late setters, queued commits, and captured refs cannot mutate replacement ownership; synchronous dispatch remains within the performance gate and runtime bytes are recorded. |
 | `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. |
 
 ## Sequence Rules
 

package/framework/build.mjs

@@ -6,24 +6,18 @@ import { build as bundle, transform } from "esbuild"
 import { createEffectCodegen } from "./compiler/effect-codegen.mjs"
 import { generateListRuntime } from "./compiler/list-runtime-codegen.mjs"
 import { assetPath, browserPath, relativeModulePath, withBase } from "./compiler/path-helpers.mjs"
-import { collectClientModules, compileClientModule, compiledPath, compileSource, layoutExportError, orderSourceStyles, reachableSourceFiles, safeStaticFiles } from "./compiler/source-compiler.mjs"
+import { createProjectSession } from "./compiler/project-session.mjs"
+import { createSourceCompiler } from "./compiler/source-compiler.mjs"
 import { createParamCodegen } from "./compiler/param-codegen.mjs"
 import { planRouteCapabilities, usesRouteDependencyRuntime } from "./compiler/route-capability-planner.mjs"
 import { generateBindingRuntime, generateCoreRuntime, generateEffectRuntime, generateNativeRuntime, generateNavigationRuntime, specializeRuntime } from "./compiler/runtime-codegen.mjs"
-import { emitWorkers } from "./compiler/worker-compiler.mjs"
 import { renderPage } from "./core.mjs"
 import { parseDevHost, parseDevPort, startDevServer } from "./dev-server.mjs"
 
 export { parseDevHost, parseDevPort }
 export { specializeRuntime }
 
-const root = process.cwd()
-const sourceDirectory = join(root, "src")
-const pagesDirectory = join(sourceDirectory, "pages")
-const workDirectory = join(root, ".kudzu")
-const outputDirectory = join(root, "dist")
-
-async function loadConfig() {
+async function loadConfig(root) {
   for (const name of ["kudzu.config.mjs", "kudzu.config.js"]) {
     const file = join(root, name)
     if (!(await exists(file))) continue
@@ -34,7 +28,9 @@ async function loadConfig() {
   return {}
 }
 
-export async function build({ quiet = false, minify = true } = {}) {
+export async function build({ quiet = false, minify = true, root: projectRoot = process.cwd() } = {}) {
+  const project = createProjectSession(projectRoot)
+  const { root, outputDirectory } = project
   const stagedOutput = join(root, ".kudzu-dist-staging")
   const backupOutput = join(root, ".kudzu-dist-backup")
   const lockPath = join(root, ".kudzu-build.lock")
@@ -42,7 +38,7 @@ export async function build({ quiet = false, minify = true } = {}) {
   try {
     await recoverOutput(outputDirectory, backupOutput)
     await rm(stagedOutput, { recursive: true, force: true })
-    const { result, pageCount, behaviorCount } = await buildInto(stagedOutput, { minify })
+    const { result, pageCount, behaviorCount } = await buildInto(project, stagedOutput, { minify })
     await promoteOutput(stagedOutput, outputDirectory, backupOutput)
     if (!quiet) console.log(`Built ${pageCount} page(s), ${behaviorCount} interactive page(s) into dist/`)
     return result
@@ -59,11 +55,13 @@ export async function build({ quiet = false, minify = true } = {}) {
   }
 }
 
-async function buildInto(outputDirectory, { minify }) {
-  const config = await loadConfig()
+async function buildInto(project, outputDirectory, { minify }) {
+  const { root, sourceDirectory, pagesDirectory, workDirectory } = project
+  const { collectClientModules, compileClientModule, compiledPath, compileSource, layoutExportError, orderSourceStyles, reachableSourceFiles, safeStaticFiles } = createSourceCompiler(project)
+  const config = await loadConfig(root)
   const base = normalizeBase(config.base)
-  const configuredStyles = normalizeStyles(config.styles, base)
-  const publicDirectory = normalizePublicDirectory(config.publicDir)
+  const configuredStyles = normalizeStyles(config.styles, base, project)
+  const publicDirectory = normalizePublicDirectory(config.publicDir, project)
   const navigationGroups = normalizeNavigation(config.navigation)
   const navigationRoutes = navigationGroups.flatMap(group => group.routes)
   const navigationByRoute = new Map(navigationGroups.flatMap(group => group.routes.map(route => [route, group])))
@@ -86,15 +84,17 @@ async function buildInto(outputDirectory, { minify }) {
   const discoveredCssFiles = projectFiles.filter(file => file.toLowerCase().endsWith(".css") && !configuredStyleSources.has(file)).sort()
   if (!allSourceFiles.length) throw new Error("No TypeScript files found in src/")
   const allSourceFileSet = new Set(allSourceFiles)
-  const sourceIndex = new Map(await Promise.all(allSourceFiles.map(async file => [file, await readFile(file, "utf8")])))
+  const sourceIndex = project.sourceIndex
+  for (const [file, source] of await Promise.all(allSourceFiles.map(async file => [file, await readFile(file, "utf8")]))) sourceIndex.set(file, source)
   const pageFiles = allSourceFiles.filter(file => file.startsWith(`${pagesDirectory}${sep}`) && file.endsWith(".tsx"))
   if (!pageFiles.length) throw new Error("No pages found in src/pages/")
   const sourceFiles = reachableSourceFiles(pageFiles, allSourceFileSet, sourceIndex)
-  const sourceFileSet = new Set(sourceFiles)
+  const sourceFileSet = project.sourceFiles
+  for (const file of sourceFiles) sourceFileSet.add(file)
   const staticFiles = await safeStaticFiles(projectFiles)
   const cssFiles = orderSourceStyles(discoveredCssFiles, sourceFiles, sourceIndex, staticFiles)
   const importedAssets = new Set()
-  const { cssModules, cssOutputs } = await prepareSourceStyles(cssFiles, staticFiles, importedAssets, base)
+  const { cssModules, cssOutputs } = await prepareSourceStyles(cssFiles, staticFiles, importedAssets, base, project)
 
   const sourceResults = []
   for (const file of sourceFiles) {
@@ -137,7 +137,7 @@ async function buildInto(outputDirectory, { minify }) {
     if (typeof module.default !== "function") throw new Error(`${relative(root, pageFile)} must export a default component`)
     if (Object.hasOwn(module, "layout") && typeof module.layout !== "function") throw layoutExportError(pageFile, sourceIndex.get(pageFile))
 
-    const runtimeSchema = runtimeRouteSchema(module, pageFile)
+    const runtimeSchema = runtimeRouteSchema(module, pageFile, project)
     if (runtimeSchema) {
       const conflicting = rewrites.find(rewrite => sameRuntimePrecedence(rewrite, runtimeSchema))
       if (conflicting) throw new Error(`Ambiguous runtime routes: ${conflicting.route} and ${runtimeSchema.route}`)
@@ -149,9 +149,9 @@ async function buildInto(outputDirectory, { minify }) {
         segments: runtimeSchema.segments
       })
     }
-    const entries = runtimeSchema ? [{ params: {}, props: {} }] : await staticPathEntries(module, pageFile)
+    const entries = runtimeSchema ? [{ params: {}, props: {} }] : await staticPathEntries(module, pageFile, root)
     for (const { params, props } of entries) {
-      const route = runtimeSchema?.route ?? routeFromPage(pageFile, params)
+      const route = runtimeSchema?.route ?? routeFromPage(pageFile, params, pagesDirectory)
       const applicationRoute = `/${route}`
       const routePath = withBase(base, `/${route}`)
       const metadataContext = { route: routePath, params, props }
@@ -231,7 +231,7 @@ async function buildInto(outputDirectory, { minify }) {
   const renderedEffects = new Set(plans.flatMap(plan => plan.effects.map(effect => `${effect.module}:${effect.handler}`)))
   const renderedWorkerReferences = workerReferences.filter(reference => renderedEffects.has(`${reference.module}:${reference.handler}`))
   if (renderedWorkerReferences.length && await exists(join(publicDirectory, "assets", "workers"))) throw new Error("public/assets/workers collides with Kudzu's generated Worker asset namespace")
-  const workerAssets = await emitWorkers(renderedWorkerReferences, sourceFileSet, assetsDirectory, base, minify)
+  const workerAssets = await project.workerCompiler.emit(renderedWorkerReferences, sourceFileSet, assetsDirectory, base, minify)
   for (const module of emittedHandlerModules) {
     for (const reference of workerReferences) {
       if (reference.module !== assetPath(base, `assets/${module.path}`)) continue
@@ -366,7 +366,7 @@ async function buildInto(outputDirectory, { minify }) {
     await writeFile(output, css)
   }
   if (await exists(publicDirectory)) {
-    await copyPublic(publicDirectory, outputDirectory)
+    await copyPublic(publicDirectory, outputDirectory, outputDirectory, root)
   }
   if (config.afterBuild !== undefined) {
     if (typeof config.afterBuild !== "function") throw new Error("kudzu.config afterBuild must be a function")
@@ -376,7 +376,7 @@ async function buildInto(outputDirectory, { minify }) {
   return { result: { sourceResults }, pageCount: plans.length, behaviorCount }
 }
 
-async function acquireBuildLock(lockPath) {
+async function acquireBuildLock(lockPath, root = dirname(lockPath)) {
   let lock
   try {
     lock = await open(lockPath, "wx")
@@ -432,7 +432,7 @@ async function promoteOutput(stagedOutput, finalOutput, backup) {
   if (previous) await rm(backup, { recursive: true, force: true }).catch(error => console.warn(`Built output was promoted, but ${backup} could not be removed and will be retried on the next build: ${error.message}`))
 }
 
-async function copyPublic(sourceDirectory, destinationDirectory, destinationRoot = destinationDirectory) {
+async function copyPublic(sourceDirectory, destinationDirectory, destinationRoot, root) {
   for (const entry of await readdir(sourceDirectory, { withFileTypes: true })) {
     const source = join(sourceDirectory, entry.name)
     const destination = join(destinationDirectory, entry.name)
@@ -445,7 +445,7 @@ async function copyPublic(sourceDirectory, destinationDirectory, destinationRoot
     if (!generated) {
       await cp(source, destination, { recursive: entry.isDirectory(), force: false, errorOnExist: true })
     } else if (entry.isDirectory() && generated.isDirectory()) {
-      await copyPublic(source, destination, destinationRoot)
+      await copyPublic(source, destination, destinationRoot, root)
     } else {
       throw new Error(`${relative(root, source)} collides with generated output ${relative(destinationRoot, destination).replaceAll(sep, "/")}`)
     }
@@ -514,11 +514,13 @@ async function writeBundledJavaScript(file, source, minify, define) {
   await writeFile(file, result.outputFiles[0].contents)
 }
 
-export async function dev({ port = parseDevPort(process.env.PORT), host = parseDevHost(process.env.HOST) } = {}) {
+export async function dev({ port = parseDevPort(process.env.PORT), host = parseDevHost(process.env.HOST), root: projectRoot = process.cwd() } = {}) {
   if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error(`Invalid dev server port: ${port}`)
   if (typeof host !== "string" || !host.trim()) throw new Error(`Invalid dev server host: ${host}`)
-  const base = normalizeBase((await loadConfig()).base)
-  return startDevServer({ build, port, host, base, sourceDirectory, workDirectory, outputDirectory })
+  const project = createProjectSession(projectRoot)
+  const { root, sourceDirectory, workDirectory, outputDirectory } = project
+  const base = normalizeBase((await loadConfig(root)).base)
+  return startDevServer({ build: options => build({ ...options, root }), port, host, base, sourceDirectory, workDirectory, outputDirectory })
 }
 
 function inlineJson(value) {
@@ -533,11 +535,11 @@ function escapeAttribute(value) {
   return escapeHtml(value).replaceAll('"', "&quot;").replaceAll("'", "&#39;")
 }
 
-async function prepareSourceStyles(cssFiles, staticFiles, importedAssets, base) {
+async function prepareSourceStyles(cssFiles, staticFiles, importedAssets, base, { root, sourceDirectory }) {
   const cssModules = new Map()
   const cssOutputs = new Map()
   for (const file of cssFiles) {
-    let css = rewriteCssUrls(await readFile(file, "utf8"), file, staticFiles, importedAssets, base)
+    let css = rewriteCssUrls(await readFile(file, "utf8"), file, staticFiles, importedAssets, base, root, sourceDirectory)
     if (file.toLowerCase().endsWith(".module.css")) {
       if (/\bcomposes\s*:/i.test(maskCssCommentsAndStrings(css))) throw new Error(`${relative(root, file)} CSS Modules composes is not supported`)
       const prefix = `k${createHash("sha256").update(relative(sourceDirectory, file).replaceAll(sep, "/")).digest("hex").slice(0, 8)}`
@@ -551,7 +553,7 @@ async function prepareSourceStyles(cssFiles, staticFiles, importedAssets, base)
   return { cssModules, cssOutputs }
 }
 
-function rewriteCssUrls(css, file, staticFiles, importedAssets, base) {
+function rewriteCssUrls(css, file, staticFiles, importedAssets, base, root, sourceDirectory) {
   let output = ""
   let cursor = 0
   let index = 0
@@ -596,7 +598,7 @@ function rewriteCssUrls(css, file, staticFiles, importedAssets, base) {
       continue
     }
     const value = css.slice(valueStart, end).trim()
-    const replacement = rewriteCssUrl(value, quote, file, staticFiles, importedAssets, base)
+    const replacement = rewriteCssUrl(value, quote, file, staticFiles, importedAssets, base, root, sourceDirectory)
     output += css.slice(cursor, index) + (replacement ?? css.slice(index, close + 1))
     cursor = close + 1
     index = close + 1
@@ -604,7 +606,7 @@ function rewriteCssUrls(css, file, staticFiles, importedAssets, base) {
   return output + css.slice(cursor)
 }
 
-function rewriteCssUrl(value, quote, file, staticFiles, importedAssets, base) {
+function rewriteCssUrl(value, quote, file, staticFiles, importedAssets, base, root, sourceDirectory) {
   if (!value || value.startsWith("/") || value.startsWith("#") || value.startsWith("//") || /^[a-z][a-z\d+.-]*:/i.test(value)) return undefined
   const split = value.search(/[?#]/)
   const pathname = split === -1 ? value : value.slice(0, split)
@@ -646,7 +648,7 @@ function maskCssCommentsAndStrings(css) {
   return masked.join("")
 }
 
-function normalizeStyles(value, base) {
+function normalizeStyles(value, base, { root }) {
   if (value === undefined) return { urls: [], sources: [] }
   if (!Array.isArray(value)) throw new Error("kudzu.config styles must be an array")
   const urls = []
@@ -680,7 +682,7 @@ function normalizeStyles(value, base) {
   return { urls, sources }
 }
 
-function normalizePublicDirectory(value) {
+function normalizePublicDirectory(value, { root, outputDirectory, workDirectory }) {
   if (value === undefined) return join(root, "public")
   if (typeof value !== "string" || !value) throw new Error("kudzu.config publicDir must be a non-empty directory path")
   const directory = resolve(root, value)
@@ -771,7 +773,7 @@ function normalizeBase(value) {
 const printEffectEntry = createEffectCodegen({ assetPath, inlineJson, relativeModulePath })
 const printParamEntry = createParamCodegen({ browserPath, inlineJson, relativeModulePath })
 
-async function staticPathEntries(module, file) {
+async function staticPathEntries(module, file, root) {
   if (typeof module.getStaticPaths !== "function") return [{ params: {}, props: {} }]
   const entries = await module.getStaticPaths()
   if (!Array.isArray(entries)) throw new Error(`${relative(root, file)} getStaticPaths() must return an array`)
@@ -785,11 +787,11 @@ async function staticPathEntries(module, file) {
   })
 }
 
-function runtimeRouteSchema(module, file) {
+function runtimeRouteSchema(module, file, { root, pagesDirectory }) {
   if (!Object.hasOwn(module, "runtimeParams")) return undefined
   if (module.runtimeParams !== true) throw new Error(`${relative(root, file)} runtimeParams must be exactly true`)
   if (typeof module.getStaticPaths === "function") throw new Error(`${relative(root, file)} runtimeParams cannot be combined with getStaticPaths()`)
-  const route = pageRoutePattern(file)
+  const route = pageRoutePattern(file, pagesDirectory)
   if (route.includes("[...")) throw new Error(`Catch-all routes are not supported: ${route}`)
   const names = new Set()
   const segments = route.split("/").map(segment => {
@@ -808,7 +810,7 @@ function runtimeRouteSchema(module, file) {
   return { route, segments, params: [...names] }
 }
 
-function pageRoutePattern(file) {
+function pageRoutePattern(file, pagesDirectory) {
   const page = relative(pagesDirectory, file).replace(/\\/g, "/").replace(/\.tsx$/, "")
   return page === "index" ? "" : page.replace(/\/index$/, "")
 }
@@ -822,7 +824,7 @@ function sameRuntimePrecedence(left, right) {
   return left.segments.every((segment, index) => segment.literal === undefined || right.segments[index].literal === undefined || segment.literal === right.segments[index].literal)
 }
 
-function routeFromPage(file, params = {}) {
+function routeFromPage(file, params = {}, pagesDirectory) {
   const page = relative(pagesDirectory, file).replace(/\\/g, "/").replace(/\.tsx$/, "")
   if (page.includes("[...")) throw new Error(`Catch-all routes are not supported: ${page}`)
   const filled = page.replace(/\[([^\]]+)\]/g, (_, name) => {

package/framework/compiler/project-session.mjs

@@ -0,0 +1,90 @@
+import { join, resolve } from "node:path"
+import ts from "typescript"
+import { assetPath } from "./path-helpers.mjs"
+import { createSourceGraph } from "./source-graph.mjs"
+import { createWorkerCompiler } from "./worker-compiler.mjs"
+
+export function createProjectSession(projectRoot = process.cwd(), { counters, sourceIndex = new Map() } = {}) {
+  const root = resolve(projectRoot)
+  const sourceDirectory = join(root, "src")
+  const graph = createSourceGraph(root)
+  const modules = createModuleCache(sourceIndex, graph.parseSourceFile, counters)
+  return {
+    root,
+    sourceDirectory,
+    pagesDirectory: join(sourceDirectory, "pages"),
+    workDirectory: join(root, ".kudzu"),
+    outputDirectory: join(root, "dist"),
+    sourceIndex,
+    sourceFiles: new Set(),
+    graph,
+    modules,
+    workerCompiler: createWorkerCompiler({ root, sourceDirectory, assetPath, readSourceModule: modules.read, ...graph })
+  }
+}
+
+function createModuleCache(sourceIndex, parseSourceFile, counters) {
+  const records = new Map()
+  const increment = name => {
+    if (counters) counters[name] = (counters[name] ?? 0) + 1
+  }
+  const read = (file, source = sourceIndex.get(file)) => {
+    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)
+    increment("parsedModules")
+    const exports = summarizeExports(sourceFile)
+    increment("exportSummaries")
+    const record = { source, sourceFile, exports }
+    records.set(file, record)
+    return record
+  }
+  const clone = (file, factory, context) => {
+    const visit = node => {
+      const copy = factory.cloneNode(node)
+      ts.setTextRange(copy, node)
+      ts.setOriginalNode(copy, node)
+      return ts.visitEachChild(copy, visit, context)
+    }
+    const sourceFile = visit(read(file).sourceFile)
+    ts.setParentRecursive(sourceFile, false)
+    increment("clonedModules")
+    return sourceFile
+  }
+  return { clone, read }
+}
+
+function summarizeExports(sourceFile) {
+  const exports = new Map()
+  const add = (name, value) => {
+    if (!exports.has(name)) exports.set(name, value)
+  }
+  for (const statement of sourceFile.statements) {
+    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 })
+      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 })
+      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
+    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: "local", local: imported })
+    }
+  }
+  return exports
+}

package/framework/compiler/source-compiler.mjs

@@ -18,17 +18,16 @@ import { assetPath, relativeModulePath, withBase } from "./path-helpers.mjs"
 import { createReactMigrationPass, reactMemoExpression } from "./react-migration-pass.mjs"
 import { normalizeRenderControlFlow } from "./render-control-pass.mjs"
 import { createRouterPass } from "./router-pass.mjs"
-import { ordinaryRuntimeDependencies, parseSourceFile, resolveSourceImport, runtimeModuleReference } from "./source-graph.mjs"
-import { createWorkerCompiler } from "./worker-compiler.mjs"
+import { createProjectSession } from "./project-session.mjs"
 import { createZustandPass } from "./zustand-pass.mjs"
 
-const root = process.cwd()
-const sourceDirectory = join(root, "src")
-const pagesDirectory = join(sourceDirectory, "pages")
-const workDirectory = join(root, ".kudzu")
+export function createSourceCompiler(project) {
+const { root, sourceDirectory, pagesDirectory, workDirectory, workerCompiler, modules } = project
+const { ordinaryRuntimeDependencies, resolveSourceImport, runtimeModuleReference } = project.graph
+const parseSourceFile = (file, source) => modules.read(file, source).sourceFile
 const staticAssetExtensions = new Set([".avif", ".gif", ".ico", ".jpeg", ".jpg", ".otf", ".png", ".svg", ".ttf", ".webp", ".woff", ".woff2"])
 
-export function compileSource(file, sourceFiles, sourceIndex, staticFiles, cssModules, base) {
+function compileSource(file, sourceFiles, sourceIndex, staticFiles, cssModules, base) {
   const importedAssets = new Set()
   const source = sourceIndex.get(file)
   const semantic = createSemanticArtifact(relative(root, file).replaceAll(sep, "/"))
@@ -90,7 +89,7 @@ function emittedPackageReference(source, file, packages) {
   return found
 }
 
-export function reachableSourceFiles(entries, sourceFiles, sourceIndex) {
+function reachableSourceFiles(entries, sourceFiles, sourceIndex) {
   const reachable = new Set()
   const ordinary = new Set()
   const workers = new Set()
@@ -284,7 +283,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
     const importedSource = target => {
       let result = importedSourceCache.get(target)
       if (!result) {
-        result = normalizeCompilerSource(parseSourceFile(target, sourceIndex.get(target)), { base, context, file: target, sourceFiles, sourceIndex })
+        result = normalizeCompilerSource(modules.clone(target, context.factory, context), { base, context, file: target, sourceFiles, sourceIndex })
         importedSourceCache.set(target, result)
       }
       return result.sourceFile
@@ -2725,33 +2724,19 @@ function resolveComponentExport(file, exportName, getSource, sourceFiles, trail
   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]
-
-  for (const statement of sourceFile.statements) {
-    if (ts.isFunctionDeclaration(statement)) {
-      const isDefault = statement.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.DefaultKeyword)
-      const isExported = statement.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.ExportKeyword)
-      if (exportName === "default" && isDefault || exportName !== "default" && isExported && statement.name?.text === exportName) return statement
-    }
-    if (ts.isVariableStatement(statement) && statement.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.ExportKeyword) && exportName !== "default") {
-      const declaration = statement.declarationList.declarations.find(entry => ts.isIdentifier(entry.name) && entry.name.text === exportName)
-      if (declaration?.initializer && (ts.isArrowFunction(declaration.initializer) || ts.isFunctionExpression(declaration.initializer))) return declaration.initializer
-    }
-    if (exportName === "default" && ts.isExportAssignment(statement) && !statement.isExportEquals && ts.isIdentifier(statement.expression)) {
-      const component = localComponentDeclaration(sourceFile, statement.expression.text)
-      if (component) return component
-    }
-    if (ts.isExportDeclaration(statement) && ts.isNamedExports(statement.exportClause)) {
-      const entry = statement.exportClause.elements.find(element => !element.isTypeOnly && element.name.text === exportName)
-      if (!entry) continue
-      const imported = (entry.propertyName ?? entry.name).text
-      if (statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)) {
-        if (!statement.moduleSpecifier.text.startsWith(".")) throw sourceNodeError(statement, sourceFile, "Imported keyed list components must use relative TypeScript re-exports")
-        const target = resolveSourceImport(file, statement.moduleSpecifier.text, sourceFiles)
-        return resolveComponentExport(target, imported, getSource, sourceFiles, nextTrail)
-      }
-      const component = localComponentDeclaration(sourceFile, imported)
-      if (component) return component
-    }
+  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
   }
   throw new Error(`${relative(root, file)} does not export a statically analyzable keyed list component named ${JSON.stringify(exportName)}`)
 }
@@ -2767,14 +2752,14 @@ function localComponentDeclaration(sourceFile, name) {
   return undefined
 }
 
-export async function collectClientModules(entries, sourceFiles) {
+async function collectClientModules(entries, sourceFiles) {
   const modules = new Set()
   const queue = [...new Set(entries)]
   while (queue.length) {
     const file = queue.shift()
     if (modules.has(file)) continue
-    const source = await readFile(file, "utf8")
-    const sourceFile = parseSourceFile(file, source)
+    const source = project.sourceIndex.get(file) ?? await readFile(file, "utf8")
+    const sourceFile = project.modules.read(file, source).sourceFile
     workerCompiler.rejectConstructions(sourceFile, sourceFile, "Relative TypeScript Worker construction is only supported directly inside an inline useEffect() callback, not imported client helpers")
     if (containsJsx(sourceFile)) throw new Error(`${relative(root, file)} Imported client helpers must not contain JSX`)
     rejectUnsupportedClientImports(sourceFile, file)
@@ -2795,7 +2780,7 @@ export async function collectClientModules(entries, sourceFiles) {
   return [...modules].sort()
 }
 
-export async function compileClientModule(file, sourceFiles, staticFiles, cssModules, base) {
+async function compileClientModule(file, sourceFiles, staticFiles, cssModules, base) {
   const importedAssets = new Set()
   const source = await readFile(file, "utf8")
   const transformer = context => sourceFile => {
@@ -2840,7 +2825,7 @@ function resolveStaticImport(importer, specifier, staticFiles) {
   return target
 }
 
-export async function safeStaticFiles(files) {
+async function safeStaticFiles(files) {
   const sourceRoot = await realpath(sourceDirectory)
   const entries = await Promise.all(files.map(async file => {
     try {
@@ -2855,7 +2840,7 @@ export async function safeStaticFiles(files) {
   return new Set(entries.filter(Boolean))
 }
 
-export function orderSourceStyles(cssFiles, sourceFiles, sourceIndex, staticFiles) {
+function orderSourceStyles(cssFiles, sourceFiles, sourceIndex, staticFiles) {
   const ordered = []
   const seenStyles = new Set()
   const seenSources = new Set()
@@ -2940,7 +2925,7 @@ function rejectUnsupportedClientImports(sourceFile, file) {
   visit(sourceFile)
 }
 
-export function layoutExportError(file, source) {
+function layoutExportError(file, source) {
   const sourceFile = parseSourceFile(file, source)
   for (const statement of sourceFile.statements) {
     if (ts.isExportDeclaration(statement) && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
@@ -2956,20 +2941,32 @@ export function layoutExportError(file, source) {
   return new Error(`${relative(root, file)} layout export must be a function`)
 }
 
-export function clientModulePath(file) {
+function clientModulePath(file) {
   return `modules/${relative(sourceDirectory, file).replaceAll(sep, "/").replace(/\.(?:ts|tsx)$/, ".js")}`
 }
 
-export function compiledPath(file) {
+function compiledPath(file) {
   return join(workDirectory, relative(sourceDirectory, file)).replace(/\.(?:ts|tsx)$/, ".mjs")
 }
 
 const compileEventCommand = createCommandSpecializer({ isPrimitiveLiteral: isPrimitiveDefaultLiteral })
 const { analyzeZustandStores, normalizeZustandMigrationSyntax } = createZustandPass({ isSerializableStateLiteral, nativeCaptureNames, sourceDirectory })
-const workerCompiler = createWorkerCompiler({ root, sourceDirectory, assetPath, parseSourceFile, resolveSourceImport, runtimeModuleReference })
 const handlerLowering = createHandlerLowering({ cloneAst, synthesizeTree })
 const printHandlerModule = createHandlerCodegen({
   resolveClientImport: (entry, handlerPath) => entry.package ? entry.target : relativeModulePath(handlerPath, clientModulePath(entry.target))
 })
 const { normalizeReactMigrationSyntax, validateUseIdSyntax } = createReactMigrationPass({ cloneAst, jsxTagName })
 const normalizeReactRouterSyntax = createRouterPass({ withBase })
+
+return { collectClientModules, compileClientModule, compiledPath, compileSource, layoutExportError, orderSourceStyles, reachableSourceFiles, safeStaticFiles }
+}
+
+const currentCompiler = sourceIndex => createSourceCompiler(createProjectSession(process.cwd(), { sourceIndex }))
+export const collectClientModules = (...arguments_) => currentCompiler().collectClientModules(...arguments_)
+export const compileClientModule = (...arguments_) => currentCompiler().compileClientModule(...arguments_)
+export const compiledPath = (...arguments_) => currentCompiler().compiledPath(...arguments_)
+export const compileSource = (...arguments_) => currentCompiler(arguments_[2]).compileSource(...arguments_)
+export const layoutExportError = (...arguments_) => currentCompiler(new Map([[arguments_[0], arguments_[1]]])).layoutExportError(...arguments_)
+export const orderSourceStyles = (...arguments_) => currentCompiler(arguments_[2]).orderSourceStyles(...arguments_)
+export const reachableSourceFiles = (...arguments_) => currentCompiler(arguments_[2]).reachableSourceFiles(...arguments_)
+export const safeStaticFiles = (...arguments_) => currentCompiler().safeStaticFiles(...arguments_)

package/framework/compiler/source-graph.mjs

@@ -2,18 +2,46 @@ import { dirname, extname, join, relative, resolve } from "node:path"
 import ts from "typescript"
 import { sourceNodeError } from "./ast-helpers.mjs"
 
-const root = process.cwd()
+export function createSourceGraph(root) {
+  const resolveSourceImport = (importer, specifier, sourceFiles) => {
+    const base = resolve(dirname(importer), specifier)
+    const extension = extname(base)
+    const stem = /\.(?:js|jsx|ts|tsx)$/.test(extension) ? base.slice(0, -extension.length) : base
+    const candidates = extension === ".ts" || extension === ".tsx"
+      ? [base]
+      : [`${stem}.ts`, `${stem}.tsx`, join(stem, "index.ts"), join(stem, "index.tsx")]
+    const matches = candidates.filter(candidate => sourceFiles.has(candidate))
+    if (matches.length !== 1) throw new Error(`${relative(root, importer)} Relative import ${JSON.stringify(specifier)} must resolve to one TypeScript file in src/`)
+    return matches[0]
+  }
+
+  const ordinaryRuntimeDependencies = (file, sourceFile, sourceFiles, isStaticImport) => {
+    const dependencies = []
+    const rejectDynamicImports = node => {
+      if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+        const argument = node.arguments[0]
+        const specifier = node.arguments.length === 1 && ts.isStringLiteralLike(argument) ? JSON.stringify(argument.text) : argument?.getText(sourceFile) ?? "<missing>"
+        throw sourceNodeError(node, sourceFile, `Dynamic import ${specifier} is not supported in ordinary source modules`)
+      }
+      ts.forEachChild(node, rejectDynamicImports)
+    }
+    rejectDynamicImports(sourceFile)
+    for (const node of sourceFile.statements) {
+      if ((!ts.isImportDeclaration(node) && !ts.isExportDeclaration(node)) || !runtimeModuleReference(node) || !node.moduleSpecifier || !ts.isStringLiteral(node.moduleSpecifier)) continue
+      const specifier = node.moduleSpecifier
+      if (!specifier.text.startsWith(".") || isStaticImport(specifier.text)) continue
+      try {
+        dependencies.push(resolveSourceImport(file, specifier.text, sourceFiles))
+      } catch (error) {
+        const detail = error.message.slice(error.message.indexOf("Relative import"))
+        const edge = ts.isExportDeclaration(node) ? "re-export" : "import"
+        throw sourceNodeError(specifier, sourceFile, detail.replace("Relative import", `Relative runtime ${edge}`))
+      }
+    }
+    return dependencies
+  }
 
-export function resolveSourceImport(importer, specifier, sourceFiles) {
-  const base = resolve(dirname(importer), specifier)
-  const extension = extname(base)
-  const stem = /\.(?:js|jsx|ts|tsx)$/.test(extension) ? base.slice(0, -extension.length) : base
-  const candidates = extension === ".ts" || extension === ".tsx"
-    ? [base]
-    : [`${stem}.ts`, `${stem}.tsx`, join(stem, "index.ts"), join(stem, "index.tsx")]
-  const matches = candidates.filter(candidate => sourceFiles.has(candidate))
-  if (matches.length !== 1) throw new Error(`${relative(root, importer)} Relative import ${JSON.stringify(specifier)} must resolve to one TypeScript file in src/`)
-  return matches[0]
+  return { ordinaryRuntimeDependencies, parseSourceFile, resolveSourceImport, runtimeModuleReference }
 }
 
 export function runtimeModuleReference(node) {
@@ -25,32 +53,6 @@ export function runtimeModuleReference(node) {
   return clause.namedBindings?.elements.some(entry => !entry.isTypeOnly) ?? false
 }
 
-export function ordinaryRuntimeDependencies(file, sourceFile, sourceFiles, isStaticImport) {
-  const dependencies = []
-  const rejectDynamicImports = node => {
-    if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
-      const argument = node.arguments[0]
-      const specifier = node.arguments.length === 1 && ts.isStringLiteralLike(argument) ? JSON.stringify(argument.text) : argument?.getText(sourceFile) ?? "<missing>"
-      throw sourceNodeError(node, sourceFile, `Dynamic import ${specifier} is not supported in ordinary source modules`)
-    }
-    ts.forEachChild(node, rejectDynamicImports)
-  }
-  rejectDynamicImports(sourceFile)
-  for (const node of sourceFile.statements) {
-    if ((!ts.isImportDeclaration(node) && !ts.isExportDeclaration(node)) || !runtimeModuleReference(node) || !node.moduleSpecifier || !ts.isStringLiteral(node.moduleSpecifier)) continue
-    const specifier = node.moduleSpecifier
-    if (!specifier.text.startsWith(".") || isStaticImport(specifier.text)) continue
-    try {
-      dependencies.push(resolveSourceImport(file, specifier.text, sourceFiles))
-    } catch (error) {
-      const detail = error.message.slice(error.message.indexOf("Relative import"))
-      const edge = ts.isExportDeclaration(node) ? "re-export" : "import"
-      throw sourceNodeError(specifier, sourceFile, detail.replace("Relative import", `Relative runtime ${edge}`))
-    }
-  }
-  return dependencies
-}
-
 export function parseSourceFile(file, source) {
   return ts.createSourceFile(file, source, ts.ScriptTarget.ES2022, true, file.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS)
 }

package/framework/compiler/worker-compiler.mjs

@@ -1,17 +1,15 @@
 import { createHash } from "node:crypto"
-import { mkdir, readFile } from "node:fs/promises"
+import { mkdir } from "node:fs/promises"
 import { dirname, relative, resolve, sep } from "node:path"
 import { build as bundle } from "esbuild"
 import ts from "typescript"
 import { containsJsx, isUnshadowedGlobal, nearestFunction, sourceNodeError } from "./ast-helpers.mjs"
-import { assetPath } from "./path-helpers.mjs"
-import { parseSourceFile, resolveSourceImport, runtimeModuleReference } from "./source-graph.mjs"
 
 export function createWorkerCompiler({
   root,
   sourceDirectory,
   assetPath,
-  parseSourceFile,
+  readSourceModule,
   resolveSourceImport,
   runtimeModuleReference
 }) {
@@ -108,7 +106,7 @@ export function createWorkerCompiler({
       const file = queue.shift()
       if (visited.has(file)) continue
       visited.add(file)
-      const sourceFile = parseSourceFile(file, await readFile(file, "utf8"))
+      const sourceFile = readSourceModule(file).sourceFile
       if (containsJsx(sourceFile)) throw sourceNodeError(sourceFile, sourceFile, "Worker modules must not contain JSX")
       const visit = node => {
         if (ts.isImportEqualsDeclaration(node)) throw sourceNodeError(node, sourceFile, "TypeScript import-equals declarations are not supported in Worker modules; use a relative ESM import")
@@ -168,9 +166,3 @@ export function createWorkerCompiler({
 
   return { candidate, emit, rejectConstructions, rejectOrdinaryImports, rewriteEffect }
 }
-
-export function emitWorkers(references, sourceFiles, assetsDirectory, base, minify) {
-  const root = process.cwd()
-  const sourceDirectory = resolve(root, "src")
-  return createWorkerCompiler({ root, sourceDirectory, assetPath, parseSourceFile, resolveSourceImport, runtimeModuleReference }).emit(references, sourceFiles, assetsDirectory, base, minify)
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kudzujs/core",
-  "version": "0.8.32",
+  "version": "0.8.34",
   "description": "HTML-first TSX framework with synchronous state semantics and no virtual DOM",
   "type": "module",
   "license": "MIT",
@@ -58,6 +58,7 @@
     "benchmark": "node test/performance.mjs",
     "benchmark:keyed": "node test/keyed-performance.mjs",
     "benchmark:commerce": "node test/commerce-build-performance.mjs",
+    "benchmark:module-cache": "node test/module-cache-performance.mjs",
     "benchmark:native": "node test/native-performance.mjs",
     "prepublishOnly": "npm run check && npm test",
     "deploy": "wrangler deploy",