@kudzujs/core 0.8.28 → 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.28` 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.
 
@@ -276,6 +276,12 @@ This queue orders the next investigations by general migration value. Start only
 - 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.28 - Source-local binding index.** The first large-application compiler foundation classifies locals, parameters, imports, captures, globals, and unresolved references by lexical identity, then uses that index for reactive binding capture/import discovery and lowering. Read the [release notes](./RELEASES.md#0828---source-local-binding-index), open the [release page](https://github.com/kudzujs/kudzu/releases/tag/v0.8.28), 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,35 @@
 # 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.

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.28` 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.28` 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,7 +12,7 @@ This maps the current `0.8.28` 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. Reactive binding discovery/lowering consumes complete indexed expressions; synthesized expressions retain the existing fallback. |
+| 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. |

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

@@ -2,7 +2,7 @@
 
 ## Status
 
-Active execution plan after `0.8.28`. 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.
 
@@ -130,7 +130,8 @@ This is an incremental evolution of the current repository:
 ### 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.
-- [ ] P0.2 Symbol-aware descriptor discovery is next. It must migrate native handler, effect, and remaining binding discovery without broadening into cross-module symbols, semantic StateWrite IR, or ecosystem features.
+- [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
 
@@ -454,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.28` 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.
 
@@ -19,6 +19,7 @@ Keep each patch behavior-preserving and independently reviewable. If a boundary
 | `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

@@ -206,7 +206,7 @@ export function createBindingIndex(sourceFile) {
     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, ts.getOriginalNode(boundary))) kind = binding.declarationKind === "parameter" ? "parameter" : "local"
+    else if (inside(binding.declaration, boundary)) kind = binding.declarationKind === "parameter" ? "parameter" : "local"
     else kind = "capture"
     return {
       kind,
@@ -234,16 +234,21 @@ export function createBindingIndex(sourceFile) {
     return complete ? found : undefined
   }
 
-  return { bindings: () => bindings.map(({ declaration, ...binding }) => ({ ...binding, ...(declaration ? { declarationRange: range(declaration) } : {}) })), references, resolveReference }
+  return { bindings: () => bindings.map(({ declaration, ...binding }) => ({ ...binding, ...(declaration ? { declarationRange: range(declaration) } : {}) })), hasNode: node => scopeByNode.has(node), references, resolveReference }
 }
 
 function inside(node, boundary) {
-  for (let current = node; current; current = current.parent) if (current === boundary) return true
+  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) {
-  return node.pos >= 0 && node.end >= 0 ? { start: node.getStart(), end: node.end } : undefined
+  if (node.pos < 0 || node.end < 0) return undefined
+  return { start: node.getSourceFile() ? node.getStart() : node.pos, end: node.end }
 }
 
 function isFunctionLike(node) {

package/framework/compiler/descriptor-session.mjs

@@ -17,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_)
@@ -27,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, [
@@ -36,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])
     }
@@ -58,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)
@@ -66,8 +71,8 @@ export function createDescriptorSession({ semantic, handlerUrl, factory, context
   }
 
   function compileReactiveExpression(expression, setters, importBindings = new Map(), keyedBlock) {
-    const usedStates = referencedStateNames(expression, setters)
-    const indexed = bindingIndex?.references(expression, expression)
+    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)
@@ -113,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)
@@ -143,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
@@ -152,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)
   }
@@ -241,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) {
@@ -254,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)
@@ -264,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))
@@ -277,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)
@@ -291,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 => {
@@ -315,3 +346,7 @@ export function captureNames(declarationRoot, referenceRoot, setters) {
   visit(referenceRoot)
   return captures
 }
+
+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,
@@ -195,7 +200,7 @@ export function createHandlerLowering({ cloneAst, synthesizeTree }) {
       const visitor = node => {
         const reference = ts.isShorthandPropertyAssignment(node) ? node.name : ts.isIdentifier(node) ? node : undefined
         const resolution = reference ? bindingIndex?.resolveReference(reference, expression) : undefined
-        const indexedState = resolution?.kind === "capture" && states.has(resolution.debugName)
+        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(
@@ -241,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

@@ -795,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
@@ -822,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({
@@ -1371,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 })
     }
 
@@ -1379,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
@@ -1534,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")
@@ -1559,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
@@ -1688,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
@@ -1701,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
@@ -1955,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)
   }
@@ -2016,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
       }
@@ -2044,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.28",
+  "version": "0.8.29",
   "description": "HTML-first TSX framework with synchronous state semantics and no virtual DOM",
   "type": "module",
   "license": "MIT",