@kudzujs/core 0.8.27 → 0.8.28

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.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.
 
 [`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,12 @@ 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.
+
 ## 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.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).
 
 - [Documentation](https://kudzujs.cloud/docs)
 - [Installation guide](https://kudzujs.cloud/docs#install)

package/RELEASES.md

@@ -1,5 +1,35 @@
 # Kudzu Releases
 
+## 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.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.
 
 ## 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.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.
 
 ## 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. Reactive binding discovery/lowering consumes complete indexed expressions; 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.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.
 
 [`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,11 @@ 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.
+- [ ] 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.
+
 ### 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.

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.28` 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,7 @@ 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. |
 
 ## Sequence Rules
 

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

@@ -0,0 +1,273 @@
+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, ts.getOriginalNode(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) } : {}) })), references, resolveReference }
+}
+
+function inside(node, boundary) {
+  for (let current = node; current; current = current.parent) if (current === boundary) return true
+  return false
+}
+
+function range(node) {
+  return node.pos >= 0 && node.end >= 0 ? { start: node.getStart(), end: node.end } : undefined
+}
+
+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 = []
@@ -66,12 +67,16 @@ 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 indexed = bindingIndex?.references(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)
@@ -303,14 +308,10 @@ 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)
   }
   visit(referenceRoot)
   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"
-])

package/framework/compiler/handler-lowering.mjs

@@ -189,11 +189,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 = resolution?.kind === "capture" && 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 +207,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)

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,

package/package.json

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