@kudzujs/core 0.8.27 → 0.8.29

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.27` 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.29` 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.
 
@@ -270,6 +270,18 @@ This queue orders the next investigations by general migration value. Start only
 - Unsupported page-level mutable value refs fail during source analysis with a source location and the existing effect-owned animation-frame exception; no resource API or runtime is added.
 - The large-application and AI-native execution plan orders symbol resolution, semantic operations, project/module analysis, IR authority, application foundations, ecosystem compatibility, AI tooling, and scale validation before broad feature work.
 
+### Completed In 0.8.28
+
+- A source-local binding index assigns deterministic lexical identities to locals, parameters, imports, captures, known globals, and unresolved references after normalization.
+- Reactive binding capture/import discovery and lowering distinguish outer application values from same-named browser globals and nested callback parameters without changing source syntax or adding browser bytes.
+- Synthesized keyed expressions retain the existing fail-safe lowering path; native handler, effect, and remaining descriptor consumers stay ordered behind the next symbol-aware compiler patch.
+
+### Completed In 0.8.29
+
+- Native handler, effect, remaining binding, keyed evaluator, optimized-command, and effect-resource discovery/lowering use source-local lexical identity when the binding index owns the complete AST.
+- Same-named callback parameters, locals, imports, browser globals, state values, setters, reducers, observer handles, and animation-frame handles no longer alias through identifier spelling alone.
+- Imported, specialized, and compiler-synthesized trees retain the existing conservative fallback; no public API, source syntax, ModuleIR contract, browser runtime, or capability bytes were added.
+
 ## Cross-Cutting Performance Gates
 
 Every migration feature must preserve:

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.27 - Large-application compiler roadmap.** A reduced E2B terminal fixture now establishes the first Goal C resource boundary with a source-located diagnostic, while the architecture packet fixes the ordered semantic-compiler, application-scale, compatibility, AI-tooling, and production-validation program. Read the [release notes](./RELEASES.md#0827---large-application-compiler-roadmap), open the [release page](https://github.com/kudzujs/kudzu/releases/tag/v0.8.27), or follow the [architecture packet](./docs/next-architecture/README.md).
+**Latest release: 0.8.29 - Symbol-aware descriptor discovery.** Native handlers, effects, reactive bindings, keyed evaluators, optimized commands, and effect-resource validation now use source-local lexical identity when the binding index owns the complete AST, while synthesized trees retain the established fail-safe path. Read the [release notes](./RELEASES.md#0829---symbol-aware-descriptor-discovery), open the [release page](https://github.com/kudzujs/kudzu/releases/tag/v0.8.29), 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.29 - Symbol-aware descriptor discovery
+
+Kudzu 0.8.29 completes P0.2 by moving native handler, effect, binding, and list descriptor decisions from identifier spelling onto the source-local binding index introduced in 0.8.28.
+
+### Changed in 0.8.29
+
+- Native handlers and effects discover state, setters, reducers, imports, captures, and nested snapshots by lexical reference identity when the complete callback belongs to the source index.
+- Handler lowering consumes the same indexed identity used during discovery, so callback parameters and locals that shadow state, setters, reducers, imports, or captures remain untouched.
+- Reactive conditionals, bindings, keyed-list evaluators, and list state rewrites distinguish outer state from same-named nested callback parameters.
+- The command fast path accepts state and setter references only when they resolve outside the callback, and recognizes `console.log()` only when `console` is the actual browser global.
+- Effect resource validation distinguishes real `IntersectionObserver`, `requestAnimationFrame()`, and `cancelAnimationFrame()` globals from shadowed application bindings and matches cleanup to the exact observer or frame declaration.
+
+### Compiler Boundary
+
+- The binding index now recognizes normalized and original TypeScript node boundaries and exposes whether it directly owns an AST node.
+- Imported, specialized, or compiler-synthesized trees continue through the established conservative shadow walker rather than borrowing an unrelated source index.
+- P0.2 changes no public API, accepted source syntax, ModuleIR shape, browser runtime, or generated capability contract. P0.3 graph failure diagnostics is next.
+
+### Validation
+
+- `npm run check`, `npm test`, `npm run test:package`, and all 187 tests pass.
+- Focused tests cover shadowed imports, browser globals, state, setters, list parameters, JSON-safe HandlerIR/BindingIR round trips, and same-named effect resource cleanup.
+- Existing Context actions, keyed component callbacks, React Router search parameters, native events, effects, Workers, navigation, and static-route zero-JavaScript behavior remain covered.
+
+### Upgrade
+
+```bash
+npm install @kudzujs/core@^0.8.29
+```
+
+## 0.8.28 - Source-local binding index
+
+Kudzu 0.8.28 completes the first large-application compiler foundation by resolving source-local lexical bindings before descriptor discovery and lowering.
+
+### Changed in 0.8.28
+
+- A source-local binding index classifies value references as local declarations, parameters, imports, outer captures, known globals, or unresolved names with deterministic slots and source ranges.
+- The index models module, function parameter/body, block, loop, catch, switch, class, computed method, namespace, import, destructuring, `var`, `let`, and `const` scopes without adding a TypeScript Program or cross-module graph.
+- Reactive binding capture/import discovery uses lexical identity, so component locals named `document`, `location`, `history`, `navigator`, or `console` no longer become browser globals and shadowed callback parameters no longer become imports.
+- Reactive binding lowering rewrites only the indexed occurrences that resolve to state or capture bindings. Same-named nested parameters remain local.
+- Synthesized keyed expressions use the existing fail-safe path unless the complete expression can be indexed, preserving keyed row state and identity behavior.
+
+### Performance And Architecture
+
+- A focused 1,000-reference guard verifies one index construction followed by direct indexed lookups and reports construction/lookup timing without making a cross-machine performance claim.
+- The index is constructed after ordered normalization and parent repair, once per compiled source. It adds no public API, browser runtime, client metadata, or JavaScript bytes.
+- Native handler, effect, and remaining descriptor discovery still use the existing analysis path; symbol-aware migration of those consumers remains the next P0.2 scope.
+
+### Validation
+
+- `npm run check`, `npm run test:package`, and all 185 tests pass.
+- Browser integration verifies shadowed browser-global names through initial HTML and reactive evaluator updates.
+- React, Router, Zustand, keyed row, nested list, effect, Worker, navigation, and static-route zero-JavaScript behavior remain covered.
+
+### Upgrade
+
+```bash
+npm install @kudzujs/core@^0.8.28
+```
+
 ## 0.8.27 - Large-application compiler roadmap
 
 Kudzu 0.8.27 records the evidence-backed path from the current static-first compiler to large production applications without adding a React runtime, generic client framework, or speculative resource API.

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.27` implementation sequence is [`large-application-ai-native-roadmap.md`](./large-application-ai-native-roadmap.md). It orders compiler semantic generalization, large-application foundations, compatibility boundaries, AI tooling, and production validation without changing the invariants below.
+The active post-`0.8.29` implementation sequence is [`large-application-ai-native-roadmap.md`](./large-application-ai-native-roadmap.md). It 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.27` 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.29` 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
 
@@ -12,6 +12,7 @@ This maps the current `0.8.27` architecture built on the completed `0.8.23` Goal
 | 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. |
 | Focused normalization passes | [`framework/compiler/`](../../framework/compiler/) | React, Router, browser signals, animation-frame refs, custom-hook timers, Zustand, and render control each validate and lower a narrow source shape. |
 | Shared AST/scope helpers | [`framework/compiler/ast-helpers.mjs`](../../framework/compiler/ast-helpers.mjs) | Binding, scope, reference, effect-return, and source-location analysis. |
+| 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. |
@@ -38,7 +39,9 @@ This maps the current `0.8.27` architecture built on the completed `0.8.23` Goal
 src/pages entries + config
   -> project discovery and reachable relative graph
   -> compileSource()
-       -> ordered normalization and main transformer semantic analysis
+       -> ordered normalization and parent repair
+       -> source-local binding index
+       -> main transformer semantic analysis
        -> TypeScript transpilation
        -> JSON-safe build module, ModuleIR, handler module, and imported assets
   -> build orchestration writes .kudzu executable and handler modules
@@ -64,6 +67,7 @@ The browser consumes static HTML first. State seeds and descriptors in that HTML
 - `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.
+- Native handler, effect, state/setter, list, Router, React, and Zustand discovery still contains name-based analysis. The binding index is intentionally adopted one consumer family at a time; P0.2 moves the next descriptor consumers without changing cross-module semantics.
 
 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.27`. 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.29`. 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.
 
@@ -127,6 +127,12 @@ This is an incremental evolution of the current repository:
 
 ## Priority Program
 
+### Execution Status
+
+- [x] P0.1 Source-local binding index is complete in `0.8.28`. Reactive binding capture/import discovery and lowering use the index only when the complete expression is indexed; synthesized keyed expressions retain the existing fail-safe path. Focused scope tests, a 1,000-reference guard, browser integration, all 185 tests, and packed-package smoke pass.
+- [x] P0.2 Symbol-aware descriptor discovery is complete in `0.8.29`. Native handler, effect, remaining binding, list evaluator, optimized-command, and effect-resource discovery/lowering use the source-local binding index when it owns the complete AST; synthesized trees retain the existing fail-safe path. Focused lexical-shadow, JSON-safe IR, resource-ownership checks, all 187 tests, and packed-package smoke pass.
+- [ ] P0.3 Graph diagnostics is next. It must fail unresolved relative imports/re-exports and ordinary dynamic imports at the importer source location without broadening into ProjectSession or cross-module symbol work.
+
 ### P0: Semantic Correctness And Compiler Foundation
 
 P0 creates the semantic base required by every later large-application capability. Do not begin broad ecosystem or application features before the relevant P0 dependencies are complete.
@@ -449,4 +455,4 @@ The first comparison is Kudzu versus React + Vite using the same agent, model, t
 
 The first implementation PR is **PR 1: Source-Local Binding Index**. It is compile-time only, adds no browser bytes or public API, fixes an existing correctness class, and creates the stable semantic foundation required by component graphs, state operations, cross-module analysis, compatibility adapters, structured diagnostics, and AI explanation tooling.
 
-The next PR is **PR 2: Symbol-Aware Descriptor Discovery**. Do not skip directly to a store, resource, router, virtualization, or ecosystem package feature.
+The next PR is **PR 3: Graph Failure Diagnostics**. 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.27` are completed scopes represented by package/release records.
+This is an execution sequence, not release history. `0.8.16` through `0.8.29` 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.
 
@@ -18,6 +18,8 @@ Keep each patch behavior-preserving and independently reviewable. If a boundary
 | `0.8.25` | Reuse byte-identical generated native, parameter, and effect route-entry transforms within one build and strengthen compiler/release boundaries. | Alternating 1,011-page builds improve materially with identical deploy hashes; normalization and ModuleIR fail closed; Node, Chrome, package, and registry gates pass. |
 | `0.8.26` | Harden Goal B benchmark reproducibility and ordinary regression coverage without changing runtime behavior. | Commerce comparison defaults to exact output; route transform counts and keyed bulk/fallback guards are protected by the standard suite; baseline coverage and limits are explicit. |
 | `0.8.27` | Characterize the first Goal C browser-resource boundary and publish the ordered large-application and AI-native compiler execution plan. | The E2B-derived fixture fails with a source-located diagnostic, no resource runtime or API is added, and the next PR dependencies and completion evidence are explicit. |
+| `0.8.28` | Add the source-local binding index and adopt it for reactive binding capture/import discovery and lowering. | Lexical shadowing is identity-based for complete indexed bindings, synthesized keyed expressions retain their fallback, the 1,000-reference guard passes, and no browser bytes or public API are added. |
+| `0.8.29` | Move native handler, effect, remaining binding, list evaluator, optimized-command, and effect-resource discovery/lowering onto source-local lexical identity. | Shadowed imports/globals/state/resources remain distinct, HandlerIR/BindingIR round trips pass, synthesized trees retain the fallback, and no runtime or public API is added. |
 
 ## Sequence Rules
 

package/framework/compiler/analysis/binding-index.mjs

@@ -0,0 +1,278 @@
+import ts from "typescript"
+
+export const knownGlobalNames = new Set([
+  "Array", "ArrayBuffer", "BigInt", "Blob", "Boolean", "Date", "Error", "Event", "FileReader", "FormData", "Infinity", "IntersectionObserver", "Intl", "JSON", "Map", "Math", "NaN", "Number", "Object", "Promise", "Proxy", "RangeError", "ReferenceError", "Reflect", "RegExp", "Set", "String", "Symbol", "TypeError", "URL", "URLSearchParams", "WeakMap", "WeakSet", "WebSocket", "Worker", "alert", "atob", "btoa", "cancelAnimationFrame", "clearInterval", "clearTimeout", "console", "crypto", "document", "fetch", "globalThis", "history", "isFinite", "isNaN", "localStorage", "location", "navigator", "parseFloat", "parseInt", "performance", "queueMicrotask", "requestAnimationFrame", "setInterval", "setTimeout", "structuredClone", "undefined", "window"
+])
+
+export function createBindingIndex(sourceFile) {
+  const scopeByNode = new WeakMap()
+  const referenceBindings = new WeakMap()
+  const originalReferenceBindings = new WeakMap()
+  const bindings = []
+  const rootScope = createScope(undefined, sourceFile, "module")
+  const pseudoBindings = new Map()
+
+  collect(sourceFile, rootScope)
+  resolveReferences(sourceFile)
+
+  function createScope(parent, node, kind) {
+    return { parent, node, kind, bindings: new Map() }
+  }
+
+  function mark(node, scope) {
+    scopeByNode.set(node, scope)
+  }
+
+  function declare(identifier, scope, declarationKind) {
+    mark(identifier, scope)
+    let binding = scope.bindings.get(identifier.text)
+    if (!binding) {
+      binding = { slot: bindings.length, debugName: identifier.text, declarationKind, declaration: identifier }
+      bindings.push(binding)
+      scope.bindings.set(identifier.text, binding)
+    }
+    return binding
+  }
+
+  function declareName(name, scope, declarationKind) {
+    mark(name, scope)
+    if (ts.isIdentifier(name)) {
+      declare(name, scope, declarationKind)
+      return
+    }
+    for (const element of name.elements) if (ts.isBindingElement(element)) declareName(element.name, scope, declarationKind)
+  }
+
+  function collectBindingExpressions(name, scope) {
+    if (ts.isIdentifier(name)) return
+    for (const element of name.elements) if (ts.isBindingElement(element)) {
+      if (element.propertyName && ts.isComputedPropertyName(element.propertyName)) collect(element.propertyName.expression, scope)
+      if (element.initializer) collect(element.initializer, scope)
+      collectBindingExpressions(element.name, scope)
+    }
+  }
+
+  function nearestVarScope(scope) {
+    for (let current = scope; current; current = current.parent) if (["function", "module"].includes(current.kind)) return current
+    return rootScope
+  }
+
+  function collectFunction(node, scope) {
+    if (ts.isFunctionDeclaration(node) && node.name) declare(node.name, scope, "function")
+    const parameterScope = createScope(scope, node, "parameters")
+    const functionScope = createScope(parameterScope, node.body ?? node, "function")
+    mark(node, parameterScope)
+    if (ts.isFunctionExpression(node) && node.name) declare(node.name, parameterScope, "function-name")
+    for (const parameter of node.parameters) {
+      mark(parameter, parameterScope)
+      declareName(parameter.name, parameterScope, "parameter")
+      collectBindingExpressions(parameter.name, parameterScope)
+      if (parameter.initializer) collect(parameter.initializer, parameterScope)
+    }
+    if (node.body) collect(node.body, functionScope)
+  }
+
+  function collectClass(node, scope) {
+    if (ts.isClassDeclaration(node) && node.name) declare(node.name, scope, "class")
+    const classScope = createScope(scope, node, "class")
+    mark(node, classScope)
+    if (ts.isClassExpression(node) && node.name) declare(node.name, classScope, "class-name")
+    for (const heritage of node.heritageClauses ?? []) for (const type of heritage.types) collect(type.expression, classScope)
+    for (const member of node.members) collect(member, classScope)
+  }
+
+  function collectLoop(node, scope) {
+    const loopScope = createScope(scope, node, "block")
+    mark(node, loopScope)
+    if (node.initializer) collect(node.initializer, loopScope)
+    if (ts.isForStatement(node)) {
+      if (node.condition) collect(node.condition, loopScope)
+      if (node.incrementor) collect(node.incrementor, loopScope)
+    } else collect(node.expression, loopScope)
+    collect(node.statement, loopScope)
+  }
+
+  function collect(node, scope) {
+    mark(node, scope)
+    if (ts.isTypeNode(node)) return
+    if (ts.isSourceFile(node)) {
+      for (const statement of node.statements) collect(statement, scope)
+      return
+    }
+    if (ts.isImportDeclaration(node)) {
+      const clause = node.importClause
+      if (!clause || clause.isTypeOnly) return
+      if (clause.name) declare(clause.name, scope, "import-default")
+      if (clause.namedBindings && ts.isNamespaceImport(clause.namedBindings)) declare(clause.namedBindings.name, scope, "import-namespace")
+      if (clause.namedBindings && ts.isNamedImports(clause.namedBindings)) for (const element of clause.namedBindings.elements) if (!element.isTypeOnly) declare(element.name, scope, "import-named")
+      return
+    }
+    if (ts.isImportEqualsDeclaration(node)) {
+      if (!node.isTypeOnly) declare(node.name, scope, "import-equals")
+      return
+    }
+    if (isFunctionLike(node)) {
+      if (node.name && ts.isComputedPropertyName(node.name)) collect(node.name.expression, scope)
+      collectFunction(node, scope)
+      return
+    }
+    if (ts.isClassDeclaration(node) || ts.isClassExpression(node)) {
+      collectClass(node, scope)
+      return
+    }
+    if (ts.isBlock(node)) {
+      const blockScope = createScope(scope, node, "block")
+      mark(node, blockScope)
+      for (const statement of node.statements) collect(statement, blockScope)
+      return
+    }
+    if (ts.isCaseBlock(node)) {
+      const caseScope = createScope(scope, node, "block")
+      mark(node, caseScope)
+      for (const clause of node.clauses) collect(clause, caseScope)
+      return
+    }
+    if (ts.isCatchClause(node)) {
+      const catchScope = createScope(scope, node, "block")
+      mark(node, catchScope)
+      if (node.variableDeclaration) {
+        declareName(node.variableDeclaration.name, catchScope, "catch")
+        collectBindingExpressions(node.variableDeclaration.name, catchScope)
+      }
+      collect(node.block, catchScope)
+      return
+    }
+    if (ts.isForStatement(node) || ts.isForInStatement(node) || ts.isForOfStatement(node)) {
+      collectLoop(node, scope)
+      return
+    }
+    if (ts.isVariableDeclaration(node)) {
+      const list = node.parent
+      const declarationKind = ts.isVariableDeclarationList(list) && (list.flags & ts.NodeFlags.Const) ? "const" : ts.isVariableDeclarationList(list) && (list.flags & ts.NodeFlags.Let) ? "let" : "var"
+      const declarationScope = declarationKind === "var" ? nearestVarScope(scope) : scope
+      declareName(node.name, declarationScope, declarationKind)
+      collectBindingExpressions(node.name, scope)
+      if (node.initializer) collect(node.initializer, scope)
+      return
+    }
+    if (ts.isEnumDeclaration(node)) declare(node.name, scope, "enum")
+    if (ts.isModuleDeclaration(node) && ts.isIdentifier(node.name)) {
+      declare(node.name, scope, "namespace")
+      const moduleScope = createScope(scope, node, "module")
+      if (node.body && ts.isModuleBlock(node.body)) {
+        mark(node.body, moduleScope)
+        for (const statement of node.body.statements) collect(statement, moduleScope)
+      } else if (node.body) collect(node.body, moduleScope)
+      return
+    }
+    ts.forEachChild(node, child => collect(child, scope))
+  }
+
+  function lexicalBinding(scope, name) {
+    for (let current = scope; current; current = current.parent) {
+      const binding = current.bindings.get(name)
+      if (binding) return binding
+    }
+  }
+
+  function pseudoBinding(kind, name) {
+    const key = `${kind}:${name}`
+    let binding = pseudoBindings.get(key)
+    if (!binding) {
+      binding = { slot: bindings.length, debugName: name, declarationKind: kind }
+      bindings.push(binding)
+      pseudoBindings.set(key, binding)
+    }
+    return binding
+  }
+
+  function resolveReferences(node) {
+    if (ts.isTypeNode(node)) return
+    if (ts.isIdentifier(node) && isValueReference(node)) {
+      const lexical = lexicalBinding(scopeByNode.get(node) ?? rootScope, node.text)
+      const binding = lexical ?? pseudoBinding(knownGlobalNames.has(node.text) ? "global" : "unresolved", node.text)
+      referenceBindings.set(node, binding)
+      const original = ts.getOriginalNode(node)
+      if (original !== node) originalReferenceBindings.set(original, binding)
+    }
+    ts.forEachChild(node, resolveReferences)
+  }
+
+  function resolveReference(identifier, boundary = sourceFile) {
+    const original = ts.getOriginalNode(identifier)
+    const binding = referenceBindings.get(identifier) ?? referenceBindings.get(original) ?? originalReferenceBindings.get(original)
+    if (!binding) return undefined
+    let kind
+    if (binding.declarationKind.startsWith("import")) kind = "import"
+    else if (binding.declarationKind === "global") kind = "global"
+    else if (binding.declarationKind === "unresolved") kind = "unresolved"
+    else if (inside(binding.declaration, boundary)) kind = binding.declarationKind === "parameter" ? "parameter" : "local"
+    else kind = "capture"
+    return {
+      kind,
+      slot: binding.slot,
+      debugName: binding.debugName,
+      declarationKind: binding.declarationKind,
+      ...(binding.declaration ? { declaration: binding.declaration, declarationRange: range(binding.declaration) } : {}),
+      referenceRange: range(original)
+    }
+  }
+
+  function references(root, boundary = root) {
+    const found = []
+    let complete = true
+    const visit = node => {
+      if (ts.isTypeNode(node)) return
+      if (ts.isIdentifier(node) && isValueReference(node)) {
+        const resolution = resolveReference(node, boundary)
+        if (resolution) found.push(resolution)
+        else complete = false
+      }
+      ts.forEachChild(node, visit)
+    }
+    visit(root)
+    return complete ? found : undefined
+  }
+
+  return { bindings: () => bindings.map(({ declaration, ...binding }) => ({ ...binding, ...(declaration ? { declarationRange: range(declaration) } : {}) })), hasNode: node => scopeByNode.has(node), references, resolveReference }
+}
+
+function inside(node, boundary) {
+  const originalBoundary = ts.getOriginalNode(boundary)
+  for (let current = node; current; current = current.parent) {
+    const original = ts.getOriginalNode(current)
+    if (current === boundary || current === originalBoundary || original === boundary || original === originalBoundary) return true
+  }
+  return false
+}
+
+function range(node) {
+  if (node.pos < 0 || node.end < 0) return undefined
+  return { start: node.getSourceFile() ? node.getStart() : node.pos, end: node.end }
+}
+
+function isFunctionLike(node) {
+  return ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node) || ts.isMethodDeclaration(node) || ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node) || ts.isConstructorDeclaration(node)
+}
+
+function isValueReference(node) {
+  const parent = node.parent
+  if (!parent) return true
+  if (ts.isTypeNode(parent)) return false
+  if ((ts.isPropertyAccessExpression(parent) && parent.name === node)
+    || (ts.isPropertyAssignment(parent) && parent.name === node)
+    || ((ts.isMethodDeclaration(parent) || ts.isGetAccessorDeclaration(parent) || ts.isSetAccessorDeclaration(parent) || ts.isPropertyDeclaration(parent) || ts.isPropertySignature(parent) || ts.isMethodSignature(parent)) && parent.name === node)
+    || (ts.isVariableDeclaration(parent) && parent.name === node)
+    || (ts.isParameter(parent) && parent.name === node)
+    || ((ts.isFunctionDeclaration(parent) || ts.isFunctionExpression(parent) || ts.isClassDeclaration(parent) || ts.isClassExpression(parent) || ts.isEnumDeclaration(parent) || ts.isModuleDeclaration(parent)) && parent.name === node)
+    || (ts.isJsxAttribute(parent) && parent.name === node)
+    || (ts.isBindingElement(parent) && (parent.name === node || parent.propertyName === node))
+    || ts.isImportSpecifier(parent) || ts.isImportClause(parent) || ts.isNamespaceImport(parent) || ts.isImportEqualsDeclaration(parent)
+    || ts.isExportSpecifier(parent)
+    || ts.isLabeledStatement(parent) || ts.isBreakStatement(parent) || ts.isContinueStatement(parent)
+    || (ts.isEnumMember(parent) && parent.name === node)) return false
+  if ((ts.isTypeAliasDeclaration(parent) || ts.isInterfaceDeclaration(parent)) && parent.name === node) return false
+  if (ts.isJsxClosingElement(parent) && parent.tagName === node) return false
+  if ((ts.isJsxOpeningElement(parent) || ts.isJsxSelfClosingElement(parent)) && parent.tagName === node) return node.text[0] === node.text[0].toUpperCase()
+  return true
+}

package/framework/compiler/descriptor-session.mjs

@@ -1,5 +1,6 @@
 import ts from "typescript"
 import { createComponentAnalysis } from "./analysis/component-analysis.mjs"
+import { knownGlobalNames } from "./analysis/binding-index.mjs"
 import { bindingNames, isFunctionLike, isReferenceIdentifier, isShadowedByParameter, isShadowedIdentifier, unwrapExpression } from "./ast-helpers.mjs"
 import { generateCommandBehavior } from "./codegen/command-codegen.mjs"
 import { assertModuleIRReferences, createModuleIR, registerBinding, registerCommandHandler, registerDerived, registerEffect, registerKeyedBlock, registerModuleHandler } from "./ir/module-ir.mjs"
@@ -8,7 +9,7 @@ export function createSemanticArtifact(file) {
   return { componentAnalysis: createComponentAnalysis(file), moduleIR: createModuleIR(file) }
 }
 
-export function createDescriptorSession({ semantic, handlerUrl, factory, context, compileEventCommand, handlerLowering, isPrimitiveLiteral, rejectWorkerConstructions, sourceName = source => source.fileName }) {
+export function createDescriptorSession({ semantic, handlerUrl, factory, context, bindingIndex, compileEventCommand, handlerLowering, isPrimitiveLiteral, rejectWorkerConstructions, sourceName = source => source.fileName }) {
   const { moduleIR } = semantic
   const nativeHandlers = []
   const effectHandlers = []
@@ -16,9 +17,9 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
   const listExpressions = []
   const clientModules = new Set()
 
-  function compileListExpression(read, expression, item, index, states = new Set(), keyedBlock) {
+  function compileListExpression(read, expression, item, index, states = new Set(), keyedBlock, indexedBindingIndex) {
     const exportName = `listExpression${listExpressions.length}`
-    listExpressions.push({ exportName, expression, item, index, states, role: "list-expression", keyedBlock })
+    listExpressions.push({ exportName, expression, item, index, states, role: "list-expression", keyedBlock, bindingIndex: indexedBindingIndex })
     const arguments_ = [read, factory.createStringLiteral(handlerUrl), factory.createStringLiteral(exportName)]
     if (states.size) arguments_.push(factory.createArrayLiteralExpression([...states].map(name => factory.createArrayLiteralExpression([factory.createStringLiteral(name), factory.createIdentifier(name)]))))
     return factory.createCallExpression(factory.createIdentifier("__kListExpression"), undefined, arguments_)
@@ -26,7 +27,8 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
 
   function compileListConditional(entry) {
     const exportName = `listExpression${listExpressions.length}`
-    listExpressions.push({ exportName, expression: entry.condition, item: entry.item, index: entry.index, role: "list-conditional", keyedBlock: entry.keyedBlock })
+    const indexed = indexedReferences(bindingIndex, entry.condition, entry.condition)
+    listExpressions.push({ exportName, expression: entry.condition, item: entry.item, index: entry.index, role: "list-conditional", keyedBlock: entry.keyedBlock, bindingIndex: indexed ? bindingIndex : undefined })
     const read = factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), entry.condition)
     const thunk = branch => factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), branch)
     return factory.createCallExpression(factory.createIdentifier("__kListConditional"), undefined, [
@@ -35,21 +37,25 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
   }
 
   function compileListValue(expression, entry) {
+    const indexed = indexedReferences(bindingIndex, expression, expression)
     const rewrite = node => {
-      if (ts.isShorthandPropertyAssignment(node) && entry.states?.has(node.name.text)) return factory.createPropertyAssignment(node.name, factory.createPropertyAccessExpression(node.name, "value"))
-      if (ts.isIdentifier(node) && entry.states?.has(node.text) && isReferenceIdentifier(node)) return factory.createPropertyAccessExpression(node, "value")
+      const reference = ts.isShorthandPropertyAssignment(node) ? node.name : ts.isIdentifier(node) ? node : undefined
+      const resolution = reference && indexed ? bindingIndex.resolveReference(reference, expression) : undefined
+      const state = ["capture", "unresolved"].includes(resolution?.kind) && entry.states?.has(resolution.debugName)
+      if (ts.isShorthandPropertyAssignment(node) && entry.states?.has(node.name.text) && (!indexed || state)) return factory.createPropertyAssignment(node.name, factory.createPropertyAccessExpression(node.name, "value"))
+      if (ts.isIdentifier(node) && entry.states?.has(node.text) && isReferenceIdentifier(node) && (!indexed || state)) return factory.createPropertyAccessExpression(node, "value")
       return ts.visitEachChild(node, rewrite, context)
     }
     const initial = entry.states?.size ? ts.visitNode(expression, rewrite) : expression
     const read = factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), initial)
     return entry.field
       ? factory.createCallExpression(factory.createIdentifier("__kListField"), undefined, [read, factory.createStringLiteral(entry.field)])
-      : compileListExpression(read, expression, entry.item, entry.index, entry.states, entry.keyedBlock)
+      : compileListExpression(read, expression, entry.item, entry.index, entry.states, entry.keyedBlock, indexed ? bindingIndex : undefined)
   }
 
   function compileReactiveBinding(expression, { setters, importBindings = new Map(), keyedBlock }) {
     const parts = conditionalParts(expression)
-    const state = parts && directStateIdentifier(parts.condition, setters)
+    const state = parts && directStateIdentifier(parts.condition, setters, bindingIndex)
     if (state && isPrimitiveLiteral(parts.truthy) && isPrimitiveLiteral(parts.falsy)) {
       return factory.createCallExpression(factory.createIdentifier("__kSelect"), undefined, [state, parts.truthy, parts.falsy])
     }
@@ -57,7 +63,7 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
   }
 
   function compileConditional(kind, expression, truthy, falsy, setters) {
-    const state = directStateIdentifier(expression, setters)
+    const state = directStateIdentifier(expression, setters, bindingIndex)
     const thunk = branch => factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), branch)
     if (state) return factory.createCallExpression(factory.createIdentifier("__kStateConditional"), undefined, [factory.createStringLiteral(kind), state, thunk(truthy), thunk(falsy)])
     const [initial, ...descriptor] = compileReactiveExpression(expression, setters)
@@ -65,13 +71,17 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
   }
 
   function compileReactiveExpression(expression, setters, importBindings = new Map(), keyedBlock) {
-    const usedStates = referencedStateNames(expression, setters)
-    const importedNames = referencedImportedBindings(expression, importBindings)
+    const usedStates = referencedStateNames(expression, setters, expression, bindingIndex)
+    const indexed = indexedReferences(bindingIndex, expression, expression)
+    const importedNames = indexed ? new Set(indexed.filter(reference => reference.kind === "import" && importBindings.has(reference.debugName)).map(reference => reference.debugName)) : referencedImportedBindings(expression, importBindings)
     const imports = [...importedNames].map(name => importBindings.get(name))
     registerClientImports(imports)
-    const captures = new Set([...captureNames(expression, expression, setters)].filter(name => !importedNames.has(name)))
+    const allStateNames = new Set(setters.values())
+    const captures = indexed
+      ? new Set(indexed.filter(reference => ["capture", "unresolved"].includes(reference.kind) && !setters.has(reference.debugName) && !allStateNames.has(reference.debugName) && !importedNames.has(reference.debugName)).map(reference => reference.debugName))
+      : new Set([...captureNames(expression, expression, setters)].filter(name => !importedNames.has(name)))
     const exportName = `binding${reactiveBindings.length}`
-    reactiveBindings.push({ exportName, expression, captures, states: usedStates, imports, role: "binding", keyedBlock })
+    reactiveBindings.push({ exportName, expression, captures, states: usedStates, imports, role: "binding", keyedBlock, ...(indexed ? { bindingIndex } : {}) })
     const states = [...usedStates].map(name => factory.createArrayLiteralExpression([factory.createStringLiteral(name), factory.createIdentifier(name)]))
     const scope = [...captures].map(name => factory.createArrayLiteralExpression([factory.createStringLiteral(name), factory.createIdentifier(name)]))
     const stateNames = new Set(usedStates)
@@ -108,19 +118,20 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
   }
 
   function compileNativeCallback(expression, { setters, reducers, entries, importBindings, prefix, role, listItem, keyedBlock, deferValues = false, snapshotNested = false, liveStates = new Set() }) {
-    const allCaptures = nativeCaptureNames(expression, setters)
-    const usedReducers = referencedReducerDispatches(expression.body, reducers, expression)
-    const imports = [...referencedImportedBindings(expression, importBindings)].map(name => importBindings.get(name))
+    const indexedBindingIndex = indexedReferences(bindingIndex, expression, expression) ? bindingIndex : undefined
+    const allCaptures = nativeCaptureNames(expression, setters, indexedBindingIndex)
+    const usedReducers = referencedReducerDispatches(expression.body, reducers, expression, indexedBindingIndex)
+    const imports = [...referencedImportedBindings(expression, importBindings, indexedBindingIndex)].map(name => importBindings.get(name))
     imports.push(...[...usedReducers].map(name => reducers.get(name).import).filter(Boolean))
     const captures = new Set([...allCaptures].filter(name => !importBindings.has(name) && !usedReducers.has(name)))
     registerClientImports(imports)
-    const usedStates = referencedStateNames(expression.body, setters, expression)
+    const usedStates = referencedStateNames(expression.body, setters, expression, indexedBindingIndex)
     for (const name of usedReducers) {
       const reducer = reducers.get(name)
-      if (reducer.contextAction) for (const state of referencedStateNames(reducer.contextAction.body, reducer.states, reducer.contextAction)) usedStates.add(state)
+      if (reducer.contextAction) for (const state of referencedStateNames(reducer.contextAction.body, reducer.states, reducer.contextAction, bindingIndex)) usedStates.add(state)
     }
     const exportName = `${prefix}${entries.length}`
-    entries.push({ exportName, expression, captures, deferValues, imports, listItem, keyedBlock, liveStates, role, setters: new Map([...setters].filter(([, state]) => usedStates.has(state))), reducers: new Map([...reducers].filter(([name]) => usedReducers.has(name))), snapshotNested, usedStates })
+    entries.push({ exportName, expression, captures, deferValues, imports, listItem, keyedBlock, liveStates, role, setters: new Map([...setters].filter(([, state]) => usedStates.has(state))), reducers: new Map([...reducers].filter(([name]) => usedReducers.has(name))), snapshotNested, usedStates, bindingIndex: indexedBindingIndex })
     const value = name => deferValues
       ? factory.createArrowFunction(undefined, undefined, [], undefined, factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), factory.createIdentifier(name))
       : factory.createIdentifier(name)
@@ -138,7 +149,7 @@ 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) ? compileEventCommand(statement.expression, setters) : undefined)
+    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
     const original = ts.getOriginalNode(expression)
     const source = original.pos >= 0 && original.end >= 0 ? { file: sourceName(original.getSourceFile()), start: original.getStart(), end: original.end } : undefined
@@ -147,6 +158,17 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
     return generateCommandBehavior(moduleIR, handler, factory)
   }
 
+  function canSpecializeCommand(command, expression, setters) {
+    const references = indexedReferences(bindingIndex, command, expression)
+    if (!references) return true
+    const stateNames = new Set(setters.values())
+    return references.every(reference => {
+      if (setters.has(reference.debugName) || stateNames.has(reference.debugName)) return ["capture", "unresolved"].includes(reference.kind)
+      if (reference.debugName === "console") return reference.kind === "global"
+      return true
+    })
+  }
+
   function registerClientImports(imports) {
     for (const entry of imports) if (!entry.package) clientModules.add(entry.target)
   }
@@ -236,9 +258,12 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
   return { compileConditional, compileEffectCallback, compileEvent, compileListConditional, compileListValue, compileReactiveBinding, finalize, registerDerived: registerDerivedResult, registerEffect: registerEffectResult, registerKeyedBlock: registerKeyedBlockResult }
 }
 
-function directStateIdentifier(expression, setters) {
+function directStateIdentifier(expression, setters, bindingIndex) {
   const value = unwrapExpression(expression)
-  return ts.isIdentifier(value) && new Set(setters.values()).has(value.text) ? value : undefined
+  if (!ts.isIdentifier(value) || !new Set(setters.values()).has(value.text)) return undefined
+  const indexed = bindingIndex?.hasNode(expression) ? bindingIndex : undefined
+  const resolution = indexed?.resolveReference(value, expression)
+  return !indexed || ["capture", "unresolved"].includes(resolution?.kind) ? value : undefined
 }
 
 function conditionalParts(expression) {
@@ -249,7 +274,9 @@ function conditionalParts(expression) {
   return undefined
 }
 
-export function referencedReducerDispatches(root, reducers, scopeRoot = root) {
+export function referencedReducerDispatches(root, reducers, scopeRoot = root, bindingIndex) {
+  const indexed = indexedReferences(bindingIndex, root, scopeRoot)
+  if (indexed) return new Set(indexed.filter(reference => ["capture", "unresolved"].includes(reference.kind) && reducers.has(reference.debugName)).map(reference => reference.debugName))
   const used = new Set()
   const visit = node => {
     if (ts.isIdentifier(node) && reducers.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, scopeRoot)) used.add(node.text)
@@ -259,8 +286,10 @@ export function referencedReducerDispatches(root, reducers, scopeRoot = root) {
   return used
 }
 
-export function referencedStateNames(root, setters, scopeRoot = root) {
+export function referencedStateNames(root, setters, scopeRoot = root, bindingIndex) {
   const stateNames = new Set(setters.values())
+  const indexed = indexedReferences(bindingIndex, root, scopeRoot)
+  if (indexed) return new Set(indexed.filter(reference => ["capture", "unresolved"].includes(reference.kind) && (setters.has(reference.debugName) || stateNames.has(reference.debugName))).map(reference => setters.get(reference.debugName) ?? reference.debugName))
   const used = new Set()
   const visit = node => {
     if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && setters.has(node.expression.text) && !isShadowedIdentifier(node.expression, scopeRoot)) used.add(setters.get(node.expression.text))
@@ -272,11 +301,13 @@ export function referencedStateNames(root, setters, scopeRoot = root) {
   return used
 }
 
-export function nativeCaptureNames(expression, setters) {
-  return captureNames(expression, expression.body, setters)
+export function nativeCaptureNames(expression, setters, bindingIndex) {
+  return captureNames(expression, expression.body, setters, bindingIndex)
 }
 
-function referencedImportedBindings(expression, imports) {
+function referencedImportedBindings(expression, imports, bindingIndex) {
+  const indexed = indexedReferences(bindingIndex, expression.body ?? expression, expression)
+  if (indexed) return new Set(indexed.filter(reference => reference.kind === "import" && imports.has(reference.debugName)).map(reference => reference.debugName))
   const names = new Set()
   const visit = node => {
     if (ts.isIdentifier(node) && imports.has(node.text) && isReferenceIdentifier(node)) names.add(node.text)
@@ -286,7 +317,12 @@ function referencedImportedBindings(expression, imports) {
   return names
 }
 
-export function captureNames(declarationRoot, referenceRoot, setters) {
+export function captureNames(declarationRoot, referenceRoot, setters, bindingIndex) {
+  const indexed = indexedReferences(bindingIndex, referenceRoot, declarationRoot)
+  if (indexed) {
+    const stateNames = new Set(setters.values())
+    return new Set(indexed.filter(reference => ["capture", "unresolved"].includes(reference.kind) && !setters.has(reference.debugName) && !stateNames.has(reference.debugName)).map(reference => reference.debugName))
+  }
   const local = new Set()
   if (!isFunctionLike(declarationRoot)) {
     const collectDeclarations = node => {
@@ -303,7 +339,7 @@ export function captureNames(declarationRoot, referenceRoot, setters) {
     if (ts.isTypeNode(node)) return
     if (ts.isIdentifier(node)) {
       const declared = isFunctionLike(declarationRoot) ? isShadowedIdentifier(node, declarationRoot) : local.has(node.text)
-      if (isReferenceIdentifier(node) && !declared && !setters.has(node.text) && !stateNames.has(node.text) && !nativeGlobals.has(node.text)) captures.add(node.text)
+      if (isReferenceIdentifier(node) && !declared && !setters.has(node.text) && !stateNames.has(node.text) && !knownGlobalNames.has(node.text)) captures.add(node.text)
     }
     ts.forEachChild(node, visit)
   }
@@ -311,6 +347,6 @@ export function captureNames(declarationRoot, referenceRoot, setters) {
   return captures
 }
 
-const nativeGlobals = new Set([
-  "Array", "ArrayBuffer", "BigInt", "Blob", "Boolean", "Date", "Error", "Event", "FileReader", "FormData", "Infinity", "IntersectionObserver", "Intl", "JSON", "Map", "Math", "NaN", "Number", "Object", "Promise", "Proxy", "RangeError", "ReferenceError", "Reflect", "RegExp", "Set", "String", "Symbol", "TypeError", "URL", "URLSearchParams", "WeakMap", "WeakSet", "WebSocket", "Worker", "alert", "atob", "btoa", "cancelAnimationFrame", "clearInterval", "clearTimeout", "console", "crypto", "document", "fetch", "globalThis", "history", "isFinite", "isNaN", "localStorage", "location", "navigator", "parseFloat", "parseInt", "performance", "queueMicrotask", "requestAnimationFrame", "setInterval", "setTimeout", "structuredClone", "undefined", "window"
-])
+function indexedReferences(bindingIndex, root, boundary) {
+  return bindingIndex?.hasNode(root) && bindingIndex.hasNode(boundary) ? bindingIndex.references(root, boundary) : undefined
+}

package/framework/compiler/effect-analysis.mjs

@@ -3,7 +3,7 @@ import { nearestFunction, referencesIdentifier, unwrapExpression } from "./ast-h
 import { collectionExpression } from "./collection-analysis.mjs"
 import { referencedStateNames } from "./descriptor-session.mjs"
 
-export function analyzeEffectDependencies({ dependencies, node, listEffect, keyedItem, setters, localDeclarations, factory, fail }) {
+export function analyzeEffectDependencies({ dependencies, node, listEffect, keyedItem, setters, localDeclarations, factory, fail, bindingIndex }) {
   const itemDependencies = []
   const ordinaryDependencies = []
   let dependencyItem = listEffect ? keyedItem : undefined
@@ -32,8 +32,9 @@ export function analyzeEffectDependencies({ dependencies, node, listEffect, keye
   for (const dependency of ordinaryDependencies) {
     const declarations = localDeclarations?.get(dependency.text)
     const initializer = declarations?.length === 1 ? declarations[0].initializer : undefined
-    const directAlias = initializer && ts.isIdentifier(unwrapExpression(initializer)) && stateNames.has(unwrapExpression(initializer).text)
-    const derivedStates = initializer && !directAlias ? referencedStateNames(initializer, setters) : new Set()
+    const indexedInitializer = initializer && bindingIndex?.hasNode(initializer) ? bindingIndex : undefined
+    const directAlias = initializer && ts.isIdentifier(unwrapExpression(initializer)) && stateNames.has(unwrapExpression(initializer).text) && (!indexedInitializer || ["capture", "unresolved"].includes(indexedInitializer.resolveReference(unwrapExpression(initializer), initializer)?.kind))
+    const derivedStates = initializer && !directAlias ? referencedStateNames(initializer, setters, initializer, bindingIndex) : new Set()
     if (derivedStates.size) {
       const usedStates = new Set()
       const expression = collectionExpression(initializer, { fail, stateNames, selectorStates: usedStates })
@@ -55,7 +56,8 @@ export function analyzeEffectDependencies({ dependencies, node, listEffect, keye
   return { dependencyItem, itemDependencies, ordinaryDependencies, entries, dependencyStates, substitutions, subscriptions, hasDerived }
 }
 
-export function validateEffectOwnedBrowserResources(callback, returns, fail) {
+export function validateEffectOwnedBrowserResources(callback, returns, fail, bindingIndex) {
+  bindingIndex = bindingIndex?.hasNode(callback) ? bindingIndex : undefined
   const observers = []
   const frameAssignments = []
   const cancellations = new Set()
@@ -64,18 +66,20 @@ export function validateEffectOwnedBrowserResources(callback, returns, fail) {
     for (let current = node; current; current = current.parent) if (current === cleanup) return true
     return false
   })
+  const isGlobal = (identifier, name) => identifier.text === name && (!bindingIndex || bindingIndex.resolveReference(identifier, callback)?.kind === "global")
+  const resource = identifier => bindingIndex?.resolveReference(identifier, callback)?.declaration ?? identifier.text
   const visit = node => {
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && ts.isNewExpression(unwrapExpression(node.initializer)) && ts.isIdentifier(unwrapExpression(node.initializer).expression) && unwrapExpression(node.initializer).expression.text === "IntersectionObserver") observers.push(node)
-    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isIdentifier(unwrapExpression(node.left)) && ts.isCallExpression(unwrapExpression(node.right)) && ts.isIdentifier(unwrapExpression(node.right).expression) && unwrapExpression(node.right).expression.text === "requestAnimationFrame") frameAssignments.push(node)
-    if (insideCleanup(node) && ts.isCallExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === "cancelAnimationFrame" && node.arguments.length === 1 && ts.isIdentifier(unwrapExpression(node.arguments[0]))) cancellations.add(unwrapExpression(node.arguments[0]).text)
-    if (insideCleanup(node) && ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.name.text === "disconnect" && node.arguments.length === 0) disconnected.add(node.expression.expression.text)
+    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && ts.isNewExpression(unwrapExpression(node.initializer)) && ts.isIdentifier(unwrapExpression(node.initializer).expression) && isGlobal(unwrapExpression(node.initializer).expression, "IntersectionObserver")) observers.push(node)
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isIdentifier(unwrapExpression(node.left)) && ts.isCallExpression(unwrapExpression(node.right)) && ts.isIdentifier(unwrapExpression(node.right).expression) && isGlobal(unwrapExpression(node.right).expression, "requestAnimationFrame")) frameAssignments.push(node)
+    if (insideCleanup(node) && ts.isCallExpression(node) && ts.isIdentifier(node.expression) && isGlobal(node.expression, "cancelAnimationFrame") && node.arguments.length === 1 && ts.isIdentifier(unwrapExpression(node.arguments[0]))) cancellations.add(resource(unwrapExpression(node.arguments[0])))
+    if (insideCleanup(node) && ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.name.text === "disconnect" && node.arguments.length === 0) disconnected.add(resource(node.expression.expression))
     ts.forEachChild(node, visit)
   }
   visit(callback.body)
-  for (const observer of observers) if (!disconnected.has(observer.name.text)) fail(observer, `IntersectionObserver effects must disconnect ${JSON.stringify(observer.name.text)} in cleanup`)
+  for (const observer of observers) if (!disconnected.has(bindingIndex ? observer.name : observer.name.text)) fail(observer, `IntersectionObserver effects must disconnect ${JSON.stringify(observer.name.text)} in cleanup`)
   for (const assignment of frameAssignments) {
-    const name = unwrapExpression(assignment.left).text
-    if (!cancellations.has(name)) fail(assignment, `Animation loop effects must cancel ${JSON.stringify(name)} in cleanup`)
+    const left = unwrapExpression(assignment.left)
+    if (!cancellations.has(resource(left))) fail(assignment, `Animation loop effects must cancel ${JSON.stringify(left.text)} in cleanup`)
   }
 }
 

package/framework/compiler/handler-lowering.mjs

@@ -4,16 +4,16 @@ import { isFunctionLike, isReferenceIdentifier, isShadowedByParameter, isShadowe
 export function createHandlerLowering({ cloneAst, synthesizeTree }) {
   return { lowerListExpression: printListExpression, lowerNativeHandler: printNativeHandler, lowerReactiveBinding: printReactiveBinding }
 
-  function printNativeHandler({ exportName, expression, captures, setters, reducers = new Map(), snapshotNested, liveStates = new Set() }) {
+  function printNativeHandler({ exportName, expression, captures, setters, reducers = new Map(), snapshotNested, liveStates = new Set(), bindingIndex }) {
     const factory = ts.factory
     const stateNames = new Set(setters.values())
-    const snapshotNames = snapshotNested ? nestedStateNames(expression, setters, liveStates) : new Set()
+    const snapshotNames = snapshotNested ? nestedStateNames(expression, setters, liveStates, bindingIndex) : new Set()
     const snapshots = new Map([...snapshotNames].map(name => [name, factory.createUniqueName("__kEffectState")]))
-    const captureSnapshotNames = snapshotNested ? nestedCaptureNames(expression, captures) : new Set()
+    const captureSnapshotNames = snapshotNested ? nestedCaptureNames(expression, captures, bindingIndex) : new Set()
     const captureSnapshots = new Map([...captureSnapshotNames].map(name => [name, factory.createUniqueName("__kEffectCapture")]))
     const transformer = context => root => {
       const visitor = node => {
-        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && reducers.has(node.expression.text) && !isShadowedIdentifier(node.expression, expression)) {
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && reducers.has(node.expression.text) && matchesExternalReference(node.expression, expression, bindingIndex)) {
           const reducer = reducers.get(node.expression.text)
           if (reducer.contextAction) {
             const action = synthesizeTree(cloneAst(reducer.contextAction, factory, context))
@@ -25,34 +25,34 @@ export function createHandlerLowering({ cloneAst, synthesizeTree }) {
           if (node.arguments.length !== 1) throw sourceNodeError(node, expression.getSourceFile(), "Reducer dispatches require exactly one action")
           return reducerDispatch(factory, reducer, ts.visitNode(node.arguments[0], visitor))
         }
-        if (ts.isShorthandPropertyAssignment(node) && reducers.has(node.name.text) && !isShadowedIdentifier(node.name, expression)) {
+        if (ts.isShorthandPropertyAssignment(node) && reducers.has(node.name.text) && matchesExternalReference(node.name, expression, bindingIndex)) {
           if (reducers.get(node.name.text).contextAction) throw sourceNodeError(node, expression.getSourceFile(), "Context actions must be called directly inside an event handler")
           if (reducers.get(node.name.text).store) throw sourceNodeError(node, expression.getSourceFile(), "Zustand actions must be called directly inside an event handler")
           return factory.createPropertyAssignment(node.name, reducerReference(factory, reducers.get(node.name.text)))
         }
-        if (ts.isIdentifier(node) && reducers.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, expression)) {
+        if (ts.isIdentifier(node) && reducers.has(node.text) && isReferenceIdentifier(node) && matchesExternalReference(node, expression, bindingIndex)) {
           if (reducers.get(node.text).contextAction) throw sourceNodeError(node, expression.getSourceFile(), "Context actions must be called directly inside an event handler")
           if (reducers.get(node.text).store) throw sourceNodeError(node, expression.getSourceFile(), "Zustand actions must be called directly inside an event handler")
           return reducerReference(factory, reducers.get(node.text))
         }
-        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && setters.has(node.expression.text) && !isShadowedIdentifier(node.expression, expression)) {
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && setters.has(node.expression.text) && matchesExternalReference(node.expression, expression, bindingIndex)) {
           return factory.createCallExpression(
             factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "set"),
             undefined,
             [factory.createStringLiteral(setters.get(node.expression.text)), ...node.arguments.map(argument => ts.visitNode(argument, visitor))]
           )
         }
-        if (ts.isShorthandPropertyAssignment(node) && setters.has(node.name.text) && !isShadowedIdentifier(node.name, expression)) {
+        if (ts.isShorthandPropertyAssignment(node) && setters.has(node.name.text) && matchesExternalReference(node.name, expression, bindingIndex)) {
           return factory.createPropertyAssignment(node.name, setterReference(factory, setters.get(node.name.text)))
         }
-        if (ts.isIdentifier(node) && setters.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, expression)) {
+        if (ts.isIdentifier(node) && setters.has(node.text) && isReferenceIdentifier(node) && matchesExternalReference(node, expression, bindingIndex)) {
           return setterReference(factory, setters.get(node.text))
         }
-        if (ts.isShorthandPropertyAssignment(node) && stateNames.has(node.name.text) && !isShadowedIdentifier(node.name, expression)) {
+        if (ts.isShorthandPropertyAssignment(node) && stateNames.has(node.name.text) && matchesExternalReference(node.name, expression, bindingIndex)) {
           if (snapshots.has(node.name.text) && insideNestedFunction(node, expression)) return factory.createPropertyAssignment(node.name, snapshots.get(node.name.text))
           return factory.createPropertyAssignment(node.name, factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"), undefined, [factory.createStringLiteral(node.name.text)]))
         }
-        if (ts.isIdentifier(node) && stateNames.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, expression)) {
+        if (ts.isIdentifier(node) && stateNames.has(node.text) && isReferenceIdentifier(node) && matchesExternalReference(node, expression, bindingIndex)) {
           if (snapshots.has(node.text) && insideNestedFunction(node, expression)) return snapshots.get(node.text)
           return factory.createCallExpression(
             factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"),
@@ -60,11 +60,11 @@ export function createHandlerLowering({ cloneAst, synthesizeTree }) {
             [factory.createStringLiteral(node.text)]
           )
         }
-        if (ts.isShorthandPropertyAssignment(node) && captures.has(node.name.text) && !isShadowedIdentifier(node.name, expression)) {
+        if (ts.isShorthandPropertyAssignment(node) && captures.has(node.name.text) && matchesExternalReference(node.name, expression, bindingIndex)) {
           if (captureSnapshots.has(node.name.text) && insideNestedFunction(node, expression)) return factory.createPropertyAssignment(node.name, captureSnapshots.get(node.name.text))
           return factory.createPropertyAssignment(node.name, scopeRead(factory, node.name.text))
         }
-        if (ts.isIdentifier(node) && captures.has(node.text) && isReferenceIdentifier(node) && !isShadowedIdentifier(node, expression)) {
+        if (ts.isIdentifier(node) && captures.has(node.text) && isReferenceIdentifier(node) && matchesExternalReference(node, expression, bindingIndex)) {
           if (captureSnapshots.has(node.text) && insideNestedFunction(node, expression)) return captureSnapshots.get(node.text)
           return scopeRead(factory, node.text)
         }
@@ -106,21 +106,21 @@ export function createHandlerLowering({ cloneAst, synthesizeTree }) {
     }
   }
 
-  function nestedCaptureNames(expression, captures) {
+  function nestedCaptureNames(expression, captures, bindingIndex) {
     const names = new Set()
     const visit = node => {
-      if (ts.isIdentifier(node) && captures.has(node.text) && isReferenceIdentifier(node) && insideNestedFunction(node, expression) && !isShadowedIdentifier(node, expression)) names.add(node.text)
+      if (ts.isIdentifier(node) && captures.has(node.text) && isReferenceIdentifier(node) && insideNestedFunction(node, expression) && matchesExternalReference(node, expression, bindingIndex)) names.add(node.text)
       ts.forEachChild(node, visit)
     }
     visit(expression.body)
     return names
   }
 
-  function nestedStateNames(expression, setters, liveStates = new Set()) {
+  function nestedStateNames(expression, setters, liveStates = new Set(), bindingIndex) {
     const states = new Set(setters.values())
     const names = new Set()
     const visit = node => {
-      if (ts.isIdentifier(node) && states.has(node.text) && !liveStates.has(node.text) && isReferenceIdentifier(node) && insideNestedFunction(node, expression) && !isShadowedIdentifier(node, expression)) names.add(node.text)
+      if (ts.isIdentifier(node) && states.has(node.text) && !liveStates.has(node.text) && isReferenceIdentifier(node) && insideNestedFunction(node, expression) && matchesExternalReference(node, expression, bindingIndex)) names.add(node.text)
       ts.forEachChild(node, visit)
     }
     visit(expression.body)
@@ -134,6 +134,11 @@ export function createHandlerLowering({ cloneAst, synthesizeTree }) {
     return false
   }
 
+  function matchesExternalReference(node, boundary, bindingIndex) {
+    if (!bindingIndex?.hasNode(node)) return !isShadowedIdentifier(node, boundary)
+    return ["capture", "unresolved"].includes(bindingIndex.resolveReference(node, boundary)?.kind)
+  }
+
   function setterReference(factory, stateName) {
     return factory.createArrowFunction(
       undefined,
@@ -189,11 +194,15 @@ export function createHandlerLowering({ cloneAst, synthesizeTree }) {
     return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "set"), undefined, [factory.createStringLiteral(reducer.state), update])
   }
 
-  function printReactiveBinding({ exportName, expression, captures, states }) {
+  function printReactiveBinding({ exportName, expression, captures, states, bindingIndex }) {
     const factory = ts.factory
     const transformer = context => root => {
       const visitor = node => {
-        if (ts.isShorthandPropertyAssignment(node) && states.has(node.name.text)) {
+        const reference = ts.isShorthandPropertyAssignment(node) ? node.name : ts.isIdentifier(node) ? node : undefined
+        const resolution = reference ? bindingIndex?.resolveReference(reference, expression) : undefined
+        const indexedState = ["capture", "unresolved"].includes(resolution?.kind) && states.has(resolution.debugName)
+        const indexedCapture = ["capture", "unresolved"].includes(resolution?.kind) && captures.has(resolution.debugName)
+        if (ts.isShorthandPropertyAssignment(node) && states.has(node.name.text) && (!bindingIndex || indexedState)) {
           return factory.createPropertyAssignment(
             node.name,
             factory.createCallExpression(
@@ -203,17 +212,17 @@ export function createHandlerLowering({ cloneAst, synthesizeTree }) {
             )
           )
         }
-        if (ts.isIdentifier(node) && states.has(node.text) && isReferenceIdentifier(node) && !isShadowedByParameter(node, expression)) {
+        if (ts.isIdentifier(node) && states.has(node.text) && isReferenceIdentifier(node) && (bindingIndex ? indexedState : !isShadowedByParameter(node, expression))) {
           return factory.createCallExpression(
             factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"),
             undefined,
             [factory.createStringLiteral(node.text)]
           )
         }
-        if (ts.isShorthandPropertyAssignment(node) && captures.has(node.name.text)) {
+        if (ts.isShorthandPropertyAssignment(node) && captures.has(node.name.text) && (!bindingIndex || indexedCapture)) {
           return factory.createPropertyAssignment(node.name, scopeRead(factory, node.name.text))
         }
-        if (ts.isIdentifier(node) && captures.has(node.text) && isReferenceIdentifier(node)) {
+        if (ts.isIdentifier(node) && captures.has(node.text) && isReferenceIdentifier(node) && (!bindingIndex || indexedCapture)) {
           return scopeRead(factory, node.text)
         }
         return ts.visitEachChild(node, visitor, context)
@@ -237,14 +246,14 @@ export function createHandlerLowering({ cloneAst, synthesizeTree }) {
     }
   }
 
-  function printListExpression({ exportName, expression, item, index, states = new Set() }) {
+  function printListExpression({ exportName, expression, item, index, states = new Set(), bindingIndex }) {
     const factory = ts.factory
     const transformer = context => root => {
       const visitor = node => {
-        if (ts.isShorthandPropertyAssignment(node) && states.has(node.name.text)) {
+        if (ts.isShorthandPropertyAssignment(node) && states.has(node.name.text) && matchesExternalReference(node.name, expression, bindingIndex)) {
           return factory.createPropertyAssignment(node.name, factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"), undefined, [factory.createStringLiteral(node.name.text)]))
         }
-        if (ts.isIdentifier(node) && states.has(node.text) && isReferenceIdentifier(node) && !isShadowedByParameter(node, expression)) {
+        if (ts.isIdentifier(node) && states.has(node.text) && isReferenceIdentifier(node) && (bindingIndex ? matchesExternalReference(node, expression, bindingIndex) : !isShadowedByParameter(node, expression))) {
           return factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier("__k"), "get"), undefined, [factory.createStringLiteral(node.text)])
         }
         return ts.visitEachChild(node, visitor, context)

package/framework/compiler/source-compiler.mjs

@@ -1,6 +1,7 @@
 import { readFile, realpath, stat } from "node:fs/promises"
 import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path"
 import ts from "typescript"
+import { createBindingIndex } from "./analysis/binding-index.mjs"
 import { createComponentAnalysisSession } from "./analysis/component-analysis.mjs"
 import { normalizeEffectAnimationFrameRefs } from "./animation-frame-pass.mjs"
 import { bindingNames, containsJsx, effectReturns, functionVarDeclaresName, importDeclarationNames, isFunctionLike, isLocalConst, isReferenceIdentifier, isShadowedByParameter, isShadowedIdentifier, isUnshadowedGlobal, nearestFunction, referenceIdentifiers, referencesIdentifier, sourceLocation, sourceNodeError, statementDeclaresName, unwrapExpression } from "./ast-helpers.mjs"
@@ -248,6 +249,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
     const normalized = normalizeCompilerSource(sourceFile, { base, context, file, importedCollections, importedStaticCollections, sourceFiles, sourceIndex })
     sourceFile = normalized.sourceFile
     const { customHookTimerStates } = normalized
+    const bindingIndex = createBindingIndex(sourceFile)
     const factory = context.factory
     const sourceName = source => relative(root, source.fileName).replaceAll(sep, "/")
     const componentAnalysis = createComponentAnalysisSession(semantic.componentAnalysis)
@@ -256,6 +258,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
       handlerUrl,
       factory,
       context,
+      bindingIndex,
       compileEventCommand,
       handlerLowering,
       isPrimitiveLiteral: isPrimitiveDefaultLiteral,
@@ -792,9 +795,9 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
       const expanded = substituteClone(expression, substitutions, factory, context)
       ts.setParentRecursive(expanded, false)
       expanded.parent = expression.parent
-      const usedStates = referencedStateNames(expanded, setters)
+      const usedStates = referencedStateNames(expanded, setters, expanded, bindingIndex)
       if (!usedStates.size) return expression
-      const captures = captureNames(expanded, expanded, setters)
+      const captures = captureNames(expanded, expanded, setters, bindingIndex)
       const allowedNames = new Set([...setters.values(), ...captures])
       validateReactiveJsxExpression(expanded, allowedNames)
       return expanded
@@ -819,7 +822,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
         const signals = new Set()
         if (ts.isIdentifier(expression) && setters.has(expression.text)) signals.add(setters.get(expression.text))
         const callback = ts.isIdentifier(expression) ? callbacks.get(expression.text) : undefined
-        for (const state of referencedStateNames((callback ?? expression).body ?? callback ?? expression, setters, callback ?? expression)) signals.add(state)
+        for (const state of referencedStateNames((callback ?? expression).body ?? callback ?? expression, setters, callback ?? expression, bindingIndex)) signals.add(state)
         return [...signals].map(name => ({ name, owner: stateOwners.get(name) ?? (owner ? `owner:${ensureOwner(owner).slot}` : "module") }))
       }
       result.analysis = componentAnalysis.registerSpecialization({
@@ -1368,7 +1371,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
         calculation.parent = callback
         validateListExpression(calculation, parts.item, originalParts.root, fail)
       }
-      const analysis = validateKeyedList(parts, sourceFile, settersForNode(originalParts.root, settersByFunction), specialization.rowStates, componentSpecializations, expandedRowSpecializations, nestedRowSpecializations, factory, prepareListCallback)
+      const analysis = validateKeyedList(parts, sourceFile, settersForNode(originalParts.root, settersByFunction), specialization.rowStates, componentSpecializations, expandedRowSpecializations, nestedRowSpecializations, factory, prepareListCallback, bindingIndex)
       preparedRenderedLists.push({ node, parts, analysis })
     }
 
@@ -1376,8 +1379,8 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
       const parts = conditionalParts(expression)
       if (!parts) return ts.visitNode(expression, visitor)
       const setters = settersForNode(anchor, settersByFunction)
-      const usedStates = referencedStateNames(parts.condition, setters)
-      const captures = captureNames(parts.condition, parts.condition, setters)
+      const usedStates = referencedStateNames(parts.condition, setters, parts.condition, bindingIndex)
+      const captures = captureNames(parts.condition, parts.condition, setters, bindingIndex)
       if (!usedStates.size && !captures.size) return ts.visitEachChild(expression, visitor, context)
       usesBehavior = true
       usesConditional = true
@@ -1531,7 +1534,8 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
           setters,
           localDeclarations: jsxLocalDeclarations.get(nearestFunction(node)),
           factory,
-          fail: effectFail
+          fail: effectFail,
+          bindingIndex
         })
         const { dependencyItem, itemDependencies, ordinaryDependencies, entries: dependencyEntries, dependencyStates, substitutions: dependencySubstitutions, subscriptions: subscriptionDependencies, hasDerived: hasDerivedDependency } = dependencyAnalysis
         if (!effectOwner) fail(node, "useEffect() cannot be used outside a Kudzu component")
@@ -1556,7 +1560,7 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
         const invalidCleanup = returns.cleanups.find(cleanup => cleanup.parameters.length || cleanup.asteriskToken)
         if (invalidCleanup) effectFail(invalidCleanup, "useEffect() cleanup functions cannot declare parameters or be generators")
         if (returns.cleanup && callback.modifiers?.some(modifier => modifier.kind === ts.SyntaxKind.AsyncKeyword)) effectFail(callback, "useEffect() async callbacks cannot return cleanup functions")
-        validateEffectOwnedBrowserResources(callback, returns, effectFail)
+        validateEffectOwnedBrowserResources(callback, returns, effectFail, bindingIndex)
         const callbackSource = specializedEffect?.sourceFile ?? sourceFile
         const callbackFile = callbackSource.fileName
         let compiledCallback = dependencySubstitutions.size ? substituteClone(callback, dependencySubstitutions, factory, context) : callback
@@ -1685,8 +1689,8 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
         }
         const setters = settersForNode(node, settersByFunction)
         const expression = resolveReactiveJsxExpression(node.expression, nearestFunction(node), setters)
-        const usedStates = referencedStateNames(expression, setters)
-        const captures = captureNames(expression, expression, setters)
+        const usedStates = referencedStateNames(expression, setters, expression, bindingIndex)
+        const captures = captureNames(expression, expression, setters, bindingIndex)
         if ((usedStates.size || captures.size) && !ts.isIdentifier(expression) && !containsJsx(expression)) {
           usesBehavior = true
           usesBinding = true
@@ -1698,8 +1702,8 @@ function createKudzuTransformer({ semantic, handlerUrl, file, sourceFiles, sourc
         const sourceExpression = node.initializer.expression
         const setters = settersForNode(node, settersByFunction)
         const expression = resolveReactiveJsxExpression(sourceExpression, nearestFunction(node), setters)
-        const usedStates = referencedStateNames(expression, setters)
-        const captures = captureNames(expression, expression, setters)
+        const usedStates = referencedStateNames(expression, setters, expression, bindingIndex)
+        const captures = captureNames(expression, expression, setters, bindingIndex)
         if ((usedStates.size || captures.size) && !ts.isIdentifier(expression)) {
           usesBehavior = true
           usesBinding = true
@@ -1952,7 +1956,7 @@ function insideJsxEventHandler(node, root) {
   return false
 }
 
-function validateKeyedList(parts, sourceFile, setters, rowStates, componentSpecializations, expandedRowSpecializations, nestedRowSpecializations, factory, prepareListCallback) {
+function validateKeyedList(parts, sourceFile, setters, rowStates, componentSpecializations, expandedRowSpecializations, nestedRowSpecializations, factory, prepareListCallback, bindingIndex) {
   const fail = (node, message) => {
     throw sourceNodeError(node, sourceFile, message)
   }
@@ -2013,7 +2017,7 @@ function validateKeyedList(parts, sourceFile, setters, rowStates, componentSpeci
           calculation.parent = callback
           validateListExpression(calculation, nested.item, nested.root, fail)
         }
-        const nestedAnalysis = validateKeyedList(nestedParts, sourceFile, setters, specialization?.rowStates ?? [], componentSpecializations, expandedRowSpecializations, nestedRowSpecializations, factory, prepareListCallback)
+        const nestedAnalysis = validateKeyedList(nestedParts, sourceFile, setters, specialization?.rowStates ?? [], componentSpecializations, expandedRowSpecializations, nestedRowSpecializations, factory, prepareListCallback, bindingIndex)
         analysis.nested.push({ node: expression, parts: nestedParts, analysis: nestedAnalysis })
         return
       }
@@ -2041,7 +2045,7 @@ function validateKeyedList(parts, sourceFile, setters, rowStates, componentSpeci
         return
       }
       if (referencesIdentifier(expression, item) || parts.index && referencesIdentifier(expression, parts.index)) {
-        const states = referencedStateNames(expression, setters)
+        const states = referencedStateNames(expression, setters, expression, bindingIndex)
         for (const rowState of rowStates) states.delete(rowState.state)
         if (parts.nested && states.size) fail(node, "Nested keyed list item expressions cannot read parent state")
         validateListExpression(expression, item, node, fail, parts.index, states)

package/package.json

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