@llui/vite-plugin 0.0.40 → 0.0.42

package/dist/accessor-resolver.d.ts

@@ -0,0 +1,58 @@
+import ts from 'typescript';
+/**
+ * Helpers for resolving identifier references at reactive-accessor
+ * positions. Shared by `transform.ts` (compile-time prop classification
+ * + Pass 2 mask injection) and `collect-deps.ts` (state-path scanning
+ * for `__dirty` / `__maskLegend`).
+ *
+ * The compiler must distinguish the legitimate accessor shapes:
+ *
+ *   - Inline arrow / function expression at the call site
+ *   - Inline `memo(arrow)` at the call site
+ *   - Identifier referencing a const-bound arrow / function expression
+ *   - Identifier referencing a hoisted function declaration
+ *   - Identifier referencing `const x = memo(arrow)`
+ *
+ * …from values we can't classify (imports, parameters, opaque calls), so
+ * those can be bailed-to-runtime instead of silently miscompiled. See the
+ * `disabled` binding bug, where a function reference at a reactive prop
+ * position was statically assigned (`__e.disabled = isGated`) — writing
+ * the function object onto the boolean DOM property and never re-evaluating.
+ */
+/**
+ * Walk parent chains to find a `const X = ...` declaration matching
+ * `use.text`, or a hoisted `function X(...)` declaration. Returns the
+ * resolved declaration or `null` for unresolvable references (imports,
+ * parameters, this-bindings, etc.).
+ *
+ * Limitations:
+ *   - Only `const`. `let` resolution is unsafe — we can't track later
+ *     reassignments without a type checker.
+ *   - Only single-binding declarations (`const a = …`, not `const a = …, b = …`).
+ *   - The declaration must dominate the use (lexical scope).
+ */
+export declare function resolveLocalConstInitializer(use: ts.Identifier): ts.Expression | ts.FunctionDeclaration | null;
+/**
+ * Recognize `memo(arrow)` / `memo(fn)` calls so the inner accessor can
+ * be analyzed for state-path masking. The runtime `memo()` returns a
+ * cached accessor — its body's reads determine when it re-evaluates,
+ * not the call site.
+ */
+export declare function isMemoCallWithArrowArg(expr: ts.Expression): expr is ts.CallExpression & {
+    arguments: readonly [ts.ArrowFunction | ts.FunctionExpression, ...ts.Expression[]];
+};
+/**
+ * Resolve a value at a reactive-accessor position down to the callable
+ * AST node we can mask-analyze. Returns `null` when the value isn't a
+ * recognized accessor shape — caller leaves the call unchanged (runtime
+ * falls back to FULL_MASK, which is correct just slower).
+ *
+ * Recognized shapes:
+ *   - `(s) => …` (ArrowFunction)
+ *   - `function (s) { … }` (FunctionExpression)
+ *   - `memo((s) => …)` — returns the inner arrow
+ *   - `someIdentifier` resolving to any of the above (or to a hoisted
+ *     `function X(s) { … }` declaration)
+ */
+export declare function resolveAccessorBody(value: ts.Expression): ts.ArrowFunction | ts.FunctionExpression | ts.FunctionDeclaration | null;
+//# sourceMappingURL=accessor-resolver.d.ts.map

package/dist/accessor-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessor-resolver.d.ts","sourceRoot":"","sources":["../src/accessor-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;;;;;;;GAWG;AACH,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,EAAE,CAAC,UAAU,GACjB,EAAE,CAAC,UAAU,GAAG,EAAE,CAAC,mBAAmB,GAAG,IAAI,CA8B/C;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,GAAG,IAAI,IAAI,EAAE,CAAC,cAAc,GAAG;IACvF,SAAS,EAAE,SAAS,CAAC,EAAE,CAAC,aAAa,GAAG,EAAE,CAAC,kBAAkB,EAAE,GAAG,EAAE,CAAC,UAAU,EAAE,CAAC,CAAA;CACnF,CAQA;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,EAAE,CAAC,UAAU,GACnB,EAAE,CAAC,aAAa,GAAG,EAAE,CAAC,kBAAkB,GAAG,EAAE,CAAC,mBAAmB,GAAG,IAAI,CAoB1E"}

package/dist/accessor-resolver.js

@@ -0,0 +1,119 @@
+import ts from 'typescript';
+/**
+ * Helpers for resolving identifier references at reactive-accessor
+ * positions. Shared by `transform.ts` (compile-time prop classification
+ * + Pass 2 mask injection) and `collect-deps.ts` (state-path scanning
+ * for `__dirty` / `__maskLegend`).
+ *
+ * The compiler must distinguish the legitimate accessor shapes:
+ *
+ *   - Inline arrow / function expression at the call site
+ *   - Inline `memo(arrow)` at the call site
+ *   - Identifier referencing a const-bound arrow / function expression
+ *   - Identifier referencing a hoisted function declaration
+ *   - Identifier referencing `const x = memo(arrow)`
+ *
+ * …from values we can't classify (imports, parameters, opaque calls), so
+ * those can be bailed-to-runtime instead of silently miscompiled. See the
+ * `disabled` binding bug, where a function reference at a reactive prop
+ * position was statically assigned (`__e.disabled = isGated`) — writing
+ * the function object onto the boolean DOM property and never re-evaluating.
+ */
+/**
+ * Walk parent chains to find a `const X = ...` declaration matching
+ * `use.text`, or a hoisted `function X(...)` declaration. Returns the
+ * resolved declaration or `null` for unresolvable references (imports,
+ * parameters, this-bindings, etc.).
+ *
+ * Limitations:
+ *   - Only `const`. `let` resolution is unsafe — we can't track later
+ *     reassignments without a type checker.
+ *   - Only single-binding declarations (`const a = …`, not `const a = …, b = …`).
+ *   - The declaration must dominate the use (lexical scope).
+ */
+export function resolveLocalConstInitializer(use) {
+    const name = use.text;
+    let node = use;
+    while (node.parent) {
+        const parent = node.parent;
+        let statements = null;
+        if (ts.isBlock(parent) || ts.isSourceFile(parent) || ts.isModuleBlock(parent)) {
+            statements = parent.statements;
+        }
+        else if (ts.isCaseClause(parent) || ts.isDefaultClause(parent)) {
+            statements = parent.statements;
+        }
+        if (statements) {
+            for (const stmt of statements) {
+                if (ts.isFunctionDeclaration(stmt)) {
+                    if (stmt.name && stmt.name.text === name)
+                        return stmt;
+                    continue;
+                }
+                if (!ts.isVariableStatement(stmt))
+                    continue;
+                const flags = stmt.declarationList.flags;
+                if (!(flags & ts.NodeFlags.Const))
+                    continue;
+                if (stmt.declarationList.declarations.length !== 1)
+                    continue;
+                const decl = stmt.declarationList.declarations[0];
+                if (!ts.isIdentifier(decl.name) || decl.name.text !== name)
+                    continue;
+                if (!decl.initializer)
+                    continue;
+                return decl.initializer;
+            }
+        }
+        node = parent;
+    }
+    return null;
+}
+/**
+ * Recognize `memo(arrow)` / `memo(fn)` calls so the inner accessor can
+ * be analyzed for state-path masking. The runtime `memo()` returns a
+ * cached accessor — its body's reads determine when it re-evaluates,
+ * not the call site.
+ */
+export function isMemoCallWithArrowArg(expr) {
+    return (ts.isCallExpression(expr) &&
+        ts.isIdentifier(expr.expression) &&
+        expr.expression.text === 'memo' &&
+        expr.arguments.length >= 1 &&
+        (ts.isArrowFunction(expr.arguments[0]) || ts.isFunctionExpression(expr.arguments[0])));
+}
+/**
+ * Resolve a value at a reactive-accessor position down to the callable
+ * AST node we can mask-analyze. Returns `null` when the value isn't a
+ * recognized accessor shape — caller leaves the call unchanged (runtime
+ * falls back to FULL_MASK, which is correct just slower).
+ *
+ * Recognized shapes:
+ *   - `(s) => …` (ArrowFunction)
+ *   - `function (s) { … }` (FunctionExpression)
+ *   - `memo((s) => …)` — returns the inner arrow
+ *   - `someIdentifier` resolving to any of the above (or to a hoisted
+ *     `function X(s) { … }` declaration)
+ */
+export function resolveAccessorBody(value) {
+    if (ts.isArrowFunction(value) || ts.isFunctionExpression(value))
+        return value;
+    if (isMemoCallWithArrowArg(value)) {
+        return value.arguments[0];
+    }
+    if (ts.isIdentifier(value)) {
+        const resolved = resolveLocalConstInitializer(value);
+        if (!resolved)
+            return null;
+        if (ts.isArrowFunction(resolved) ||
+            ts.isFunctionExpression(resolved) ||
+            ts.isFunctionDeclaration(resolved)) {
+            return resolved;
+        }
+        if (isMemoCallWithArrowArg(resolved)) {
+            return resolved.arguments[0];
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=accessor-resolver.js.map

package/dist/accessor-resolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessor-resolver.js","sourceRoot":"","sources":["../src/accessor-resolver.ts"],"names":[],"mappings":"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","sourcesContent":["import ts from 'typescript'\n\n/**\n * Helpers for resolving identifier references at reactive-accessor\n * positions. Shared by `transform.ts` (compile-time prop classification\n * + Pass 2 mask injection) and `collect-deps.ts` (state-path scanning\n * for `__dirty` / `__maskLegend`).\n *\n * The compiler must distinguish the legitimate accessor shapes:\n *\n *   - Inline arrow / function expression at the call site\n *   - Inline `memo(arrow)` at the call site\n *   - Identifier referencing a const-bound arrow / function expression\n *   - Identifier referencing a hoisted function declaration\n *   - Identifier referencing `const x = memo(arrow)`\n *\n * …from values we can't classify (imports, parameters, opaque calls), so\n * those can be bailed-to-runtime instead of silently miscompiled. See the\n * `disabled` binding bug, where a function reference at a reactive prop\n * position was statically assigned (`__e.disabled = isGated`) — writing\n * the function object onto the boolean DOM property and never re-evaluating.\n */\n\n/**\n * Walk parent chains to find a `const X = ...` declaration matching\n * `use.text`, or a hoisted `function X(...)` declaration. Returns the\n * resolved declaration or `null` for unresolvable references (imports,\n * parameters, this-bindings, etc.).\n *\n * Limitations:\n *   - Only `const`. `let` resolution is unsafe — we can't track later\n *     reassignments without a type checker.\n *   - Only single-binding declarations (`const a = …`, not `const a = …, b = …`).\n *   - The declaration must dominate the use (lexical scope).\n */\nexport function resolveLocalConstInitializer(\n  use: ts.Identifier,\n): ts.Expression | ts.FunctionDeclaration | null {\n  const name = use.text\n  let node: ts.Node = use\n  while (node.parent) {\n    const parent = node.parent\n    let statements: readonly ts.Statement[] | null = null\n    if (ts.isBlock(parent) || ts.isSourceFile(parent) || ts.isModuleBlock(parent)) {\n      statements = parent.statements\n    } else if (ts.isCaseClause(parent) || ts.isDefaultClause(parent)) {\n      statements = parent.statements\n    }\n    if (statements) {\n      for (const stmt of statements) {\n        if (ts.isFunctionDeclaration(stmt)) {\n          if (stmt.name && stmt.name.text === name) return stmt\n          continue\n        }\n        if (!ts.isVariableStatement(stmt)) continue\n        const flags = stmt.declarationList.flags\n        if (!(flags & ts.NodeFlags.Const)) continue\n        if (stmt.declarationList.declarations.length !== 1) continue\n        const decl = stmt.declarationList.declarations[0]!\n        if (!ts.isIdentifier(decl.name) || decl.name.text !== name) continue\n        if (!decl.initializer) continue\n        return decl.initializer\n      }\n    }\n    node = parent\n  }\n  return null\n}\n\n/**\n * Recognize `memo(arrow)` / `memo(fn)` calls so the inner accessor can\n * be analyzed for state-path masking. The runtime `memo()` returns a\n * cached accessor — its body's reads determine when it re-evaluates,\n * not the call site.\n */\nexport function isMemoCallWithArrowArg(expr: ts.Expression): expr is ts.CallExpression & {\n  arguments: readonly [ts.ArrowFunction | ts.FunctionExpression, ...ts.Expression[]]\n} {\n  return (\n    ts.isCallExpression(expr) &&\n    ts.isIdentifier(expr.expression) &&\n    expr.expression.text === 'memo' &&\n    expr.arguments.length >= 1 &&\n    (ts.isArrowFunction(expr.arguments[0]!) || ts.isFunctionExpression(expr.arguments[0]!))\n  )\n}\n\n/**\n * Resolve a value at a reactive-accessor position down to the callable\n * AST node we can mask-analyze. Returns `null` when the value isn't a\n * recognized accessor shape — caller leaves the call unchanged (runtime\n * falls back to FULL_MASK, which is correct just slower).\n *\n * Recognized shapes:\n *   - `(s) => …` (ArrowFunction)\n *   - `function (s) { … }` (FunctionExpression)\n *   - `memo((s) => …)` — returns the inner arrow\n *   - `someIdentifier` resolving to any of the above (or to a hoisted\n *     `function X(s) { … }` declaration)\n */\nexport function resolveAccessorBody(\n  value: ts.Expression,\n): ts.ArrowFunction | ts.FunctionExpression | ts.FunctionDeclaration | null {\n  if (ts.isArrowFunction(value) || ts.isFunctionExpression(value)) return value\n  if (isMemoCallWithArrowArg(value)) {\n    return value.arguments[0] as ts.ArrowFunction | ts.FunctionExpression\n  }\n  if (ts.isIdentifier(value)) {\n    const resolved = resolveLocalConstInitializer(value)\n    if (!resolved) return null\n    if (\n      ts.isArrowFunction(resolved) ||\n      ts.isFunctionExpression(resolved) ||\n      ts.isFunctionDeclaration(resolved)\n    ) {\n      return resolved\n    }\n    if (isMemoCallWithArrowArg(resolved)) {\n      return resolved.arguments[0] as ts.ArrowFunction | ts.FunctionExpression\n    }\n  }\n  return null\n}\n"]}

package/dist/collect-deps.d.ts

@@ -1,16 +1,23 @@
 import ts from 'typescript';
 /**
  * Walk the AST and collect every unique state access path referenced by
- * a reactive accessor. A reactive accessor is an arrow/function whose
- * placement passes `isReactiveAccessor` — text()/memo() first args,
- * element-helper prop values, and allowlisted framework-API prop values.
- * Paths are rooted at the accessor's single parameter name.
+ * a reactive accessor. A reactive accessor is one of:
+ *
+ *   - An inline arrow / function expression at a reactive position
+ *     (`text(s => s.count)`, `div({ title: s => s.title })`,
+ *     `show({ when: s => s.gated })`, etc.).
+ *   - An Identifier at a reactive position that resolves to a callable
+ *     in this file — a const-bound arrow / function expression,
+ *     a hoisted function declaration, or `const x = memo(arrow)`.
+ *
+ * The second case lets authors refactor a literal arrow into a named
+ * helper without losing the reactive-mask optimization (a precise mask
+ * for `__dirty` and structural-primitive `__mask`). Without it, the
+ * runtime falls back to FULL_MASK — correct, but every binding fires
+ * on every state change.
  *
  * Shared by the bit-assignment path (`collectDeps`, below) and the
- * `diagnostics.ts` bitmask-overflow warning. Extracted so both consumers
- * see the same truth — previously the diagnostics side had its own naïve
- * walker that produced false positives for `each({ key })`, `item(...)`,
- * array-method callbacks, and user-land helpers.
+ * `diagnostics.ts` bitmask-overflow warning.
  */
 export declare function collectStatePathsFromSource(sourceFile: ts.SourceFile): Set<string>;
 /**

package/dist/collect-deps.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collect-deps.d.ts","sourceRoot":"","sources":["../src/collect-deps.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B;;;;;;;;;;;;GAYG;AACH,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,GAAG,GAAG,CAAC,MAAM,CAAC,CAyBlF;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE,CAoBhF;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CA4B/D"}
+{"version":3,"file":"collect-deps.d.ts","sourceRoot":"","sources":["../src/collect-deps.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAyG3B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,GAAG,GAAG,CAAC,MAAM,CAAC,CAuBlF;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,GAAG,GAAG,CAAC,MAAM,CAAC,EAAE,CAwBhF;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CA4B/D"}

package/dist/collect-deps.js

@@ -1,34 +1,131 @@
 import ts from 'typescript';
+import { resolveAccessorBody } from './accessor-resolver.js';
+/**
+ * Names whose first arg is itself a reactive accessor (the existing
+ * arrow walker handles them) or which are explicitly excluded
+ * (sample/item read state imperatively / per-row, not as state
+ * accessors). When a delegating accessor's body contains a call to one
+ * of these, we don't follow it — recursion is reserved for "this is
+ * just a thin wrapper that hands the state to another local helper."
+ */
+const NON_DELEGATION_HELPERS = new Set(['sample', 'item', 'memo', 'text', 'unsafeHtml']);
+/**
+ * Walk a delegating accessor's body looking for calls to OTHER local
+ * functions that take the state param verbatim — `helper(s)` where
+ * `s` matches the outer accessor's param name. For each, hand the
+ * resolved declaration back so the caller can recurse into its body.
+ *
+ * Skips:
+ *   - Framework helpers (`memo`, `text`, etc.) — their arrow args are
+ *     visited by the top-level arrow walker; we'd double-count.
+ *   - Method calls (`s.items.filter(...)`) — the callee is a builtin,
+ *     not a local function we can resolve.
+ *   - Nested function bodies — params inside a `(item) => …` shadow
+ *     ours, so a `helper(s)` deep in there isn't (necessarily)
+ *     handing OUR state in. Conservative: don't recurse through
+ *     lambda boundaries.
+ */
+function visitTopLevelDelegations(body, stateParamName, follow) {
+    function visit(node) {
+        if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+            const name = node.expression.text;
+            if (!NON_DELEGATION_HELPERS.has(name)) {
+                const arg0 = node.arguments[0];
+                if (arg0 && ts.isIdentifier(arg0) && arg0.text === stateParamName) {
+                    const resolved = resolveAccessorBody(node.expression);
+                    if (resolved)
+                        follow(resolved);
+                }
+            }
+        }
+        // Don't descend into nested function bodies — their params shadow
+        // ours, and any call inside them isn't unambiguously delegating
+        // our state.
+        if (ts.isArrowFunction(node) ||
+            ts.isFunctionExpression(node) ||
+            ts.isFunctionDeclaration(node)) {
+            return;
+        }
+        ts.forEachChild(node, visit);
+    }
+    // If the body itself is a function, there's nothing at the top
+    // level to inspect — its own body is a separate scope.
+    if (ts.isArrowFunction(body) || ts.isFunctionExpression(body) || ts.isFunctionDeclaration(body)) {
+        return;
+    }
+    visit(body);
+}
+/**
+ * Extract paths from a callable accessor (arrow / fn-expr / fn-decl)
+ * into the given set. Recurses through call-delegations to other local
+ * helpers so that `(s) => filtered(s)` / `(s) => { void s.x; return
+ * inner(s) }` correctly contribute the helper's state-path reads.
+ * Without recursion the precise mask under-counts — fields read only
+ * via the helper drop off the bitmask, and any sibling reactive
+ * accessor that reads them produces a non-zero `dirty` that AND'd with
+ * the narrow each.__mask is zero, silently skipping the reconcile.
+ *
+ * `visited` breaks cycles on mutually-recursive helpers — terminates
+ * the walk; doesn't try to be precise about what such helpers read.
+ */
+function extractAccessorPaths(accessor, paths, visited = new Set()) {
+    if (visited.has(accessor))
+        return false;
+    visited.add(accessor);
+    const params = accessor.parameters;
+    if (params.length !== 1)
+        return false;
+    const paramName = params[0].name;
+    if (!ts.isIdentifier(paramName))
+        return false;
+    if (!accessor.body)
+        return false;
+    const before = paths.size;
+    extractPaths(accessor.body, paramName.text, '', paths);
+    // Follow delegations: `(s) => helper(s)` — extract `helper`'s body's
+    // state paths too. Reuses the `visited` set across the recursion
+    // chain so cycles terminate.
+    visitTopLevelDelegations(accessor.body, paramName.text, (resolved) => {
+        extractAccessorPaths(resolved, paths, visited);
+    });
+    return paths.size > before;
+}
 /**
  * Walk the AST and collect every unique state access path referenced by
- * a reactive accessor. A reactive accessor is an arrow/function whose
- * placement passes `isReactiveAccessor` — text()/memo() first args,
- * element-helper prop values, and allowlisted framework-API prop values.
- * Paths are rooted at the accessor's single parameter name.
+ * a reactive accessor. A reactive accessor is one of:
+ *
+ *   - An inline arrow / function expression at a reactive position
+ *     (`text(s => s.count)`, `div({ title: s => s.title })`,
+ *     `show({ when: s => s.gated })`, etc.).
+ *   - An Identifier at a reactive position that resolves to a callable
+ *     in this file — a const-bound arrow / function expression,
+ *     a hoisted function declaration, or `const x = memo(arrow)`.
+ *
+ * The second case lets authors refactor a literal arrow into a named
+ * helper without losing the reactive-mask optimization (a precise mask
+ * for `__dirty` and structural-primitive `__mask`). Without it, the
+ * runtime falls back to FULL_MASK — correct, but every binding fires
+ * on every state change.
  *
  * Shared by the bit-assignment path (`collectDeps`, below) and the
- * `diagnostics.ts` bitmask-overflow warning. Extracted so both consumers
- * see the same truth — previously the diagnostics side had its own naïve
- * walker that produced false positives for `each({ key })`, `item(...)`,
- * array-method callbacks, and user-land helpers.
+ * `diagnostics.ts` bitmask-overflow warning.
  */
 export function collectStatePathsFromSource(sourceFile) {
     const paths = new Set();
     function visit(node) {
-        // Look for arrow functions that are reactive accessors:
-        // - First arg to text(): text(s => s.count)
-        // - Prop values in element helper calls: div({ title: s => s.title })
+        // Inline arrow / function expression at a reactive position.
         if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
-            const params = node.parameters;
-            if (params.length === 1) {
-                const paramName = params[0].name;
-                if (ts.isIdentifier(paramName)) {
-                    // Check if this looks like a reactive accessor (not an event handler)
-                    if (isReactiveAccessor(node)) {
-                        extractPaths(node.body, paramName.text, '', paths);
-                    }
-                }
-            }
+            if (isReactiveAccessor(node))
+                extractAccessorPaths(node, paths);
+        }
+        // Identifier at a reactive position — resolve to its declaration
+        // and extract paths from the resolved body. Skip identifiers
+        // imported from elsewhere (resolver returns null) — there's no
+        // body to scan, runtime falls back to FULL_MASK.
+        if (ts.isIdentifier(node) && isReactiveAccessor(node)) {
+            const resolved = resolveAccessorBody(node);
+            if (resolved)
+                extractAccessorPaths(resolved, paths);
         }
         ts.forEachChild(node, visit);
     }
@@ -44,15 +141,18 @@ export function collectAccessorPathSets(sourceFile) {
     const sets = [];
     function visit(node) {
         if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
-            const params = node.parameters;
-            if (params.length === 1) {
-                const paramName = params[0].name;
-                if (ts.isIdentifier(paramName) && isReactiveAccessor(node)) {
-                    const set = new Set();
-                    extractPaths(node.body, paramName.text, '', set);
-                    if (set.size > 0)
-                        sets.push(set);
-                }
+            if (isReactiveAccessor(node)) {
+                const set = new Set();
+                if (extractAccessorPaths(node, set))
+                    sets.push(set);
+            }
+        }
+        if (ts.isIdentifier(node) && isReactiveAccessor(node)) {
+            const resolved = resolveAccessorBody(node);
+            if (resolved) {
+                const set = new Set();
+                if (extractAccessorPaths(resolved, set))
+                    sets.push(set);
             }
         }
         ts.forEachChild(node, visit);
@@ -102,8 +202,10 @@ function hasLluiImport(sourceFile) {
     return false;
 }
 /**
- * Determines if an arrow/function expression is a reactive accessor
- * (not an event handler, not a callback like onClick).
+ * Determines if a node is at a reactive-accessor position — either an
+ * inline arrow / function expression OR an identifier that's about to
+ * be resolved to one. The check is identity-based on `parent.arguments[0]`
+ * etc., so the same logic works for both shapes.
  */
 function isReactiveAccessor(node) {
     const parent = node.parent;

package/dist/collect-deps.js.map

@@ -1 +1 @@
-{"version":3,"file":"collect-deps.js","sourceRoot":"","sources":["../src/collect-deps.ts"],"names":[],"mappings":"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","sourcesContent":["import ts from 'typescript'\n\n/**\n * Walk the AST and collect every unique state access path referenced by\n * a reactive accessor. A reactive accessor is an arrow/function whose\n * placement passes `isReactiveAccessor` — text()/memo() first args,\n * element-helper prop values, and allowlisted framework-API prop values.\n * Paths are rooted at the accessor's single parameter name.\n *\n * Shared by the bit-assignment path (`collectDeps`, below) and the\n * `diagnostics.ts` bitmask-overflow warning. Extracted so both consumers\n * see the same truth — previously the diagnostics side had its own naïve\n * walker that produced false positives for `each({ key })`, `item(...)`,\n * array-method callbacks, and user-land helpers.\n */\nexport function collectStatePathsFromSource(sourceFile: ts.SourceFile): Set<string> {\n  const paths = new Set<string>()\n\n  function visit(node: ts.Node): void {\n    // Look for arrow functions that are reactive accessors:\n    // - First arg to text(): text(s => s.count)\n    // - Prop values in element helper calls: div({ title: s => s.title })\n    if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {\n      const params = node.parameters\n      if (params.length === 1) {\n        const paramName = params[0]!.name\n        if (ts.isIdentifier(paramName)) {\n          // Check if this looks like a reactive accessor (not an event handler)\n          if (isReactiveAccessor(node)) {\n            extractPaths(node.body, paramName.text, '', paths)\n          }\n        }\n      }\n    }\n\n    ts.forEachChild(node, visit)\n  }\n\n  visit(sourceFile)\n  return paths\n}\n\n/**\n * Per-accessor path sets — one entry per reactive arrow/function. Used\n * by the bitmask-overflow diagnostic to find clusters of paths that\n * always fire together (co-occurrence analysis).\n */\nexport function collectAccessorPathSets(sourceFile: ts.SourceFile): Set<string>[] {\n  const sets: Set<string>[] = []\n\n  function visit(node: ts.Node): void {\n    if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {\n      const params = node.parameters\n      if (params.length === 1) {\n        const paramName = params[0]!.name\n        if (ts.isIdentifier(paramName) && isReactiveAccessor(node)) {\n          const set = new Set<string>()\n          extractPaths(node.body, paramName.text, '', set)\n          if (set.size > 0) sets.push(set)\n        }\n      }\n    }\n    ts.forEachChild(node, visit)\n  }\n\n  visit(sourceFile)\n  return sets\n}\n\n/**\n * Pre-scan a source file to collect all unique state access paths\n * referenced by reactive accessors (arrow functions in props and text() calls).\n * Returns a Map<path, bitPosition> where each path gets a unique power-of-two bit.\n */\nexport function collectDeps(source: string): Map<string, number> {\n  const sourceFile = ts.createSourceFile('input.ts', source, ts.ScriptTarget.Latest, true)\n\n  // Check if file imports from @llui/dom\n  if (!hasLluiImport(sourceFile)) {\n    return new Map()\n  }\n\n  const paths = collectStatePathsFromSource(sourceFile)\n\n  // Assign bit positions. The bitmask holds 31 unique paths (positions\n  // 0..30). When the count exceeds 31, overflow paths use FULL_MASK (-1)\n  // — they always trigger re-evaluation, degrading gracefully. The\n  // diagnostic warns the user to decompose.\n  const fieldBits = new Map<string, number>()\n  let bit = 1\n  let index = 0\n  for (const path of paths) {\n    if (index >= 31) {\n      fieldBits.set(path, -1)\n    } else {\n      fieldBits.set(path, bit)\n      bit <<= 1\n    }\n    index++\n  }\n\n  return fieldBits\n}\n\nfunction hasLluiImport(sourceFile: ts.SourceFile): boolean {\n  for (const stmt of sourceFile.statements) {\n    if (\n      ts.isImportDeclaration(stmt) &&\n      ts.isStringLiteral(stmt.moduleSpecifier) &&\n      stmt.moduleSpecifier.text === '@llui/dom'\n    ) {\n      return true\n    }\n  }\n  return false\n}\n\n/**\n * Determines if an arrow/function expression is a reactive accessor\n * (not an event handler, not a callback like onClick).\n */\nfunction isReactiveAccessor(node: ts.ArrowFunction | ts.FunctionExpression): boolean {\n  const parent = node.parent\n\n  // text(s => s.count) — first arg to a call\n  if (ts.isCallExpression(parent) && parent.arguments[0] === node) {\n    // Skip item(t => t.id) — per-item selectors inside each() render.\n    // Skip sample(s => s.x) — imperative one-shot read, no binding created\n    // (both the top-level import and the destructured-from-h form).\n    if (ts.isIdentifier(parent.expression)) {\n      if (parent.expression.text === 'item' || parent.expression.text === 'sample') {\n        return false\n      }\n    }\n    // Skip array method callbacks: .filter(t => ...), .map(t => ...), .some(t => ...), etc.\n    // Allow view-helper primitive calls: h.text(s => ...), h.memo(s => ...)\n    if (ts.isPropertyAccessExpression(parent.expression)) {\n      const methodName = parent.expression.name.text\n      if (methodName === 'text' || methodName === 'memo') {\n        return true\n      }\n      return false\n    }\n    return true\n  }\n\n  // div({ title: s => s.title }) — value in a property assignment inside an object literal.\n  // Only treat as reactive if the containing call is a known framework API whose\n  // properties are reactive accessors. Otherwise user-land helpers like\n  // sliceHandler({ narrow: (m) => m.type === ... }) would pollute the path set.\n  if (ts.isPropertyAssignment(parent)) {\n    const key = parent.name\n    if (ts.isIdentifier(key)) {\n      // Skip event handlers (onClick, onInput, etc.)\n      if (/^on[A-Z]/.test(key.text)) return false\n      // Skip each() key function and other non-reactive props\n      if (key.text === 'key' || key.text === 'name') return false\n      // Walk up to find the enclosing call expression\n      let ancestor: ts.Node | undefined = parent.parent // ObjectLiteralExpression\n      while (ancestor && !ts.isCallExpression(ancestor)) {\n        ancestor = ancestor.parent\n      }\n      if (!ancestor) return false\n      const callExpr = ancestor as ts.CallExpression\n      if (!ts.isIdentifier(callExpr.expression)) return false\n      return REACTIVE_API_NAMES.has(callExpr.expression.text)\n    }\n  }\n\n  return false\n}\n\n// Framework APIs whose object-literal arguments contain reactive accessors.\n// Arrow functions in property values of these calls are state-tracked.\nconst REACTIVE_API_NAMES = new Set([\n  // Element helpers (see ELEMENT_HELPERS in transform.ts — we keep a superset here)\n  ...[\n    'a',\n    'abbr',\n    'article',\n    'aside',\n    'b',\n    'blockquote',\n    'br',\n    'button',\n    'canvas',\n    'code',\n    'dd',\n    'details',\n    'dialog',\n    'div',\n    'dl',\n    'dt',\n    'em',\n    'fieldset',\n    'figcaption',\n    'figure',\n    'footer',\n    'form',\n    'h1',\n    'h2',\n    'h3',\n    'h4',\n    'h5',\n    'h6',\n    'header',\n    'hr',\n    'i',\n    'iframe',\n    'img',\n    'input',\n    'label',\n    'legend',\n    'li',\n    'main',\n    'mark',\n    'nav',\n    'ol',\n    'optgroup',\n    'option',\n    'output',\n    'p',\n    'pre',\n    'progress',\n    'section',\n    'select',\n    'small',\n    'span',\n    'strong',\n    'sub',\n    'summary',\n    'sup',\n    'table',\n    'tbody',\n    'td',\n    'textarea',\n    'tfoot',\n    'th',\n    'thead',\n    'time',\n    'tr',\n    'ul',\n    'video',\n  ],\n  // Structural primitives\n  'each',\n  'branch',\n  'scope',\n  'show',\n  'memo',\n  'portal',\n  'foreign',\n  'child',\n  'errorBoundary',\n])\n\n/**\n * Extract state access paths from an expression body.\n * Handles:\n * - Direct property access: param.field, param.field.subfield\n * - Bracket notation with string literal: param['field']\n */\nfunction extractPaths(node: ts.Node, paramName: string, _prefix: string, paths: Set<string>): void {\n  if (ts.isPropertyAccessExpression(node)) {\n    // Skip if this is an intermediate in a deeper chain\n    if (ts.isPropertyAccessExpression(node.parent)) {\n      // handled when the leaf is visited\n    }\n    // Skip if this is the callee of a method call: s.todos.filter(...)\n    else if (ts.isCallExpression(node.parent) && node.parent.expression === node) {\n      // It's a method call — record the object, not the method\n      // e.g. s.todos.filter(...) → record 'todos', not 'todos.filter'\n      if (ts.isPropertyAccessExpression(node.expression)) {\n        const chain = resolvePropertyChain(node.expression, paramName)\n        if (chain) paths.add(chain)\n      }\n    } else {\n      const chain = resolvePropertyChain(node, paramName)\n      if (chain) {\n        paths.add(chain)\n      }\n    }\n  }\n\n  if (ts.isElementAccessExpression(node)) {\n    const chain = resolveElementAccess(node, paramName)\n    if (chain) {\n      paths.add(chain)\n    }\n  }\n\n  ts.forEachChild(node, (child) => extractPaths(child, paramName, _prefix, paths))\n}\n\n/**\n * Resolve a property access chain like s.user.name to \"user.name\".\n * Returns null if the chain doesn't start with the state parameter.\n * Stops at depth 2.\n */\nfunction resolvePropertyChain(node: ts.PropertyAccessExpression, paramName: string): string | null {\n  const parts: string[] = []\n  let current: ts.Expression = node\n\n  while (ts.isPropertyAccessExpression(current)) {\n    parts.unshift(current.name.text)\n    current = current.expression\n  }\n\n  // The root must be the state parameter\n  if (!ts.isIdentifier(current) || current.text !== paramName) {\n    return null\n  }\n\n  // Limit to depth 2\n  if (parts.length > 2) {\n    return parts.slice(0, 2).join('.')\n  }\n\n  return parts.join('.')\n}\n\n/**\n * Resolve bracket access with string literal: s['count'] → \"count\"\n */\nfunction resolveElementAccess(node: ts.ElementAccessExpression, paramName: string): string | null {\n  if (!ts.isIdentifier(node.expression) || node.expression.text !== paramName) {\n    return null\n  }\n\n  if (ts.isStringLiteral(node.argumentExpression)) {\n    return node.argumentExpression.text\n  }\n\n  return null\n}\n"]}
+{"version":3,"file":"collect-deps.js","sourceRoot":"","sources":["../src/collect-deps.ts"],"names":[],"mappings":"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","sourcesContent":["import ts from 'typescript'\nimport { resolveAccessorBody } from './accessor-resolver.js'\n\n/**\n * Names whose first arg is itself a reactive accessor (the existing\n * arrow walker handles them) or which are explicitly excluded\n * (sample/item read state imperatively / per-row, not as state\n * accessors). When a delegating accessor's body contains a call to one\n * of these, we don't follow it — recursion is reserved for \"this is\n * just a thin wrapper that hands the state to another local helper.\"\n */\nconst NON_DELEGATION_HELPERS = new Set(['sample', 'item', 'memo', 'text', 'unsafeHtml'])\n\n/**\n * Walk a delegating accessor's body looking for calls to OTHER local\n * functions that take the state param verbatim — `helper(s)` where\n * `s` matches the outer accessor's param name. For each, hand the\n * resolved declaration back so the caller can recurse into its body.\n *\n * Skips:\n *   - Framework helpers (`memo`, `text`, etc.) — their arrow args are\n *     visited by the top-level arrow walker; we'd double-count.\n *   - Method calls (`s.items.filter(...)`) — the callee is a builtin,\n *     not a local function we can resolve.\n *   - Nested function bodies — params inside a `(item) => …` shadow\n *     ours, so a `helper(s)` deep in there isn't (necessarily)\n *     handing OUR state in. Conservative: don't recurse through\n *     lambda boundaries.\n */\nfunction visitTopLevelDelegations(\n  body: ts.Node,\n  stateParamName: string,\n  follow: (resolved: ts.ArrowFunction | ts.FunctionExpression | ts.FunctionDeclaration) => void,\n): void {\n  function visit(node: ts.Node): void {\n    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {\n      const name = node.expression.text\n      if (!NON_DELEGATION_HELPERS.has(name)) {\n        const arg0 = node.arguments[0]\n        if (arg0 && ts.isIdentifier(arg0) && arg0.text === stateParamName) {\n          const resolved = resolveAccessorBody(node.expression)\n          if (resolved) follow(resolved)\n        }\n      }\n    }\n    // Don't descend into nested function bodies — their params shadow\n    // ours, and any call inside them isn't unambiguously delegating\n    // our state.\n    if (\n      ts.isArrowFunction(node) ||\n      ts.isFunctionExpression(node) ||\n      ts.isFunctionDeclaration(node)\n    ) {\n      return\n    }\n    ts.forEachChild(node, visit)\n  }\n  // If the body itself is a function, there's nothing at the top\n  // level to inspect — its own body is a separate scope.\n  if (ts.isArrowFunction(body) || ts.isFunctionExpression(body) || ts.isFunctionDeclaration(body)) {\n    return\n  }\n  visit(body)\n}\n\n/**\n * Extract paths from a callable accessor (arrow / fn-expr / fn-decl)\n * into the given set. Recurses through call-delegations to other local\n * helpers so that `(s) => filtered(s)` / `(s) => { void s.x; return\n * inner(s) }` correctly contribute the helper's state-path reads.\n * Without recursion the precise mask under-counts — fields read only\n * via the helper drop off the bitmask, and any sibling reactive\n * accessor that reads them produces a non-zero `dirty` that AND'd with\n * the narrow each.__mask is zero, silently skipping the reconcile.\n *\n * `visited` breaks cycles on mutually-recursive helpers — terminates\n * the walk; doesn't try to be precise about what such helpers read.\n */\nfunction extractAccessorPaths(\n  accessor: ts.ArrowFunction | ts.FunctionExpression | ts.FunctionDeclaration,\n  paths: Set<string>,\n  visited: Set<ts.Node> = new Set(),\n): boolean {\n  if (visited.has(accessor)) return false\n  visited.add(accessor)\n\n  const params = accessor.parameters\n  if (params.length !== 1) return false\n  const paramName = params[0]!.name\n  if (!ts.isIdentifier(paramName)) return false\n  if (!accessor.body) return false\n  const before = paths.size\n\n  extractPaths(accessor.body, paramName.text, '', paths)\n\n  // Follow delegations: `(s) => helper(s)` — extract `helper`'s body's\n  // state paths too. Reuses the `visited` set across the recursion\n  // chain so cycles terminate.\n  visitTopLevelDelegations(accessor.body, paramName.text, (resolved) => {\n    extractAccessorPaths(resolved, paths, visited)\n  })\n\n  return paths.size > before\n}\n\n/**\n * Walk the AST and collect every unique state access path referenced by\n * a reactive accessor. A reactive accessor is one of:\n *\n *   - An inline arrow / function expression at a reactive position\n *     (`text(s => s.count)`, `div({ title: s => s.title })`,\n *     `show({ when: s => s.gated })`, etc.).\n *   - An Identifier at a reactive position that resolves to a callable\n *     in this file — a const-bound arrow / function expression,\n *     a hoisted function declaration, or `const x = memo(arrow)`.\n *\n * The second case lets authors refactor a literal arrow into a named\n * helper without losing the reactive-mask optimization (a precise mask\n * for `__dirty` and structural-primitive `__mask`). Without it, the\n * runtime falls back to FULL_MASK — correct, but every binding fires\n * on every state change.\n *\n * Shared by the bit-assignment path (`collectDeps`, below) and the\n * `diagnostics.ts` bitmask-overflow warning.\n */\nexport function collectStatePathsFromSource(sourceFile: ts.SourceFile): Set<string> {\n  const paths = new Set<string>()\n\n  function visit(node: ts.Node): void {\n    // Inline arrow / function expression at a reactive position.\n    if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {\n      if (isReactiveAccessor(node)) extractAccessorPaths(node, paths)\n    }\n\n    // Identifier at a reactive position — resolve to its declaration\n    // and extract paths from the resolved body. Skip identifiers\n    // imported from elsewhere (resolver returns null) — there's no\n    // body to scan, runtime falls back to FULL_MASK.\n    if (ts.isIdentifier(node) && isReactiveAccessor(node)) {\n      const resolved = resolveAccessorBody(node)\n      if (resolved) extractAccessorPaths(resolved, paths)\n    }\n\n    ts.forEachChild(node, visit)\n  }\n\n  visit(sourceFile)\n  return paths\n}\n\n/**\n * Per-accessor path sets — one entry per reactive arrow/function. Used\n * by the bitmask-overflow diagnostic to find clusters of paths that\n * always fire together (co-occurrence analysis).\n */\nexport function collectAccessorPathSets(sourceFile: ts.SourceFile): Set<string>[] {\n  const sets: Set<string>[] = []\n\n  function visit(node: ts.Node): void {\n    if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {\n      if (isReactiveAccessor(node)) {\n        const set = new Set<string>()\n        if (extractAccessorPaths(node, set)) sets.push(set)\n      }\n    }\n\n    if (ts.isIdentifier(node) && isReactiveAccessor(node)) {\n      const resolved = resolveAccessorBody(node)\n      if (resolved) {\n        const set = new Set<string>()\n        if (extractAccessorPaths(resolved, set)) sets.push(set)\n      }\n    }\n\n    ts.forEachChild(node, visit)\n  }\n\n  visit(sourceFile)\n  return sets\n}\n\n/**\n * Pre-scan a source file to collect all unique state access paths\n * referenced by reactive accessors (arrow functions in props and text() calls).\n * Returns a Map<path, bitPosition> where each path gets a unique power-of-two bit.\n */\nexport function collectDeps(source: string): Map<string, number> {\n  const sourceFile = ts.createSourceFile('input.ts', source, ts.ScriptTarget.Latest, true)\n\n  // Check if file imports from @llui/dom\n  if (!hasLluiImport(sourceFile)) {\n    return new Map()\n  }\n\n  const paths = collectStatePathsFromSource(sourceFile)\n\n  // Assign bit positions. The bitmask holds 31 unique paths (positions\n  // 0..30). When the count exceeds 31, overflow paths use FULL_MASK (-1)\n  // — they always trigger re-evaluation, degrading gracefully. The\n  // diagnostic warns the user to decompose.\n  const fieldBits = new Map<string, number>()\n  let bit = 1\n  let index = 0\n  for (const path of paths) {\n    if (index >= 31) {\n      fieldBits.set(path, -1)\n    } else {\n      fieldBits.set(path, bit)\n      bit <<= 1\n    }\n    index++\n  }\n\n  return fieldBits\n}\n\nfunction hasLluiImport(sourceFile: ts.SourceFile): boolean {\n  for (const stmt of sourceFile.statements) {\n    if (\n      ts.isImportDeclaration(stmt) &&\n      ts.isStringLiteral(stmt.moduleSpecifier) &&\n      stmt.moduleSpecifier.text === '@llui/dom'\n    ) {\n      return true\n    }\n  }\n  return false\n}\n\n/**\n * Determines if a node is at a reactive-accessor position — either an\n * inline arrow / function expression OR an identifier that's about to\n * be resolved to one. The check is identity-based on `parent.arguments[0]`\n * etc., so the same logic works for both shapes.\n */\nfunction isReactiveAccessor(node: ts.Node): boolean {\n  const parent = node.parent\n\n  // text(s => s.count) — first arg to a call\n  if (ts.isCallExpression(parent) && parent.arguments[0] === node) {\n    // Skip item(t => t.id) — per-item selectors inside each() render.\n    // Skip sample(s => s.x) — imperative one-shot read, no binding created\n    // (both the top-level import and the destructured-from-h form).\n    if (ts.isIdentifier(parent.expression)) {\n      if (parent.expression.text === 'item' || parent.expression.text === 'sample') {\n        return false\n      }\n    }\n    // Skip array method callbacks: .filter(t => ...), .map(t => ...), .some(t => ...), etc.\n    // Allow view-helper primitive calls: h.text(s => ...), h.memo(s => ...)\n    if (ts.isPropertyAccessExpression(parent.expression)) {\n      const methodName = parent.expression.name.text\n      if (methodName === 'text' || methodName === 'memo') {\n        return true\n      }\n      return false\n    }\n    return true\n  }\n\n  // div({ title: s => s.title }) — value in a property assignment inside an object literal.\n  // Only treat as reactive if the containing call is a known framework API whose\n  // properties are reactive accessors. Otherwise user-land helpers like\n  // sliceHandler({ narrow: (m) => m.type === ... }) would pollute the path set.\n  if (ts.isPropertyAssignment(parent)) {\n    const key = parent.name\n    if (ts.isIdentifier(key)) {\n      // Skip event handlers (onClick, onInput, etc.)\n      if (/^on[A-Z]/.test(key.text)) return false\n      // Skip each() key function and other non-reactive props\n      if (key.text === 'key' || key.text === 'name') return false\n      // Walk up to find the enclosing call expression\n      let ancestor: ts.Node | undefined = parent.parent // ObjectLiteralExpression\n      while (ancestor && !ts.isCallExpression(ancestor)) {\n        ancestor = ancestor.parent\n      }\n      if (!ancestor) return false\n      const callExpr = ancestor as ts.CallExpression\n      if (!ts.isIdentifier(callExpr.expression)) return false\n      return REACTIVE_API_NAMES.has(callExpr.expression.text)\n    }\n  }\n\n  return false\n}\n\n// Framework APIs whose object-literal arguments contain reactive accessors.\n// Arrow functions in property values of these calls are state-tracked.\nconst REACTIVE_API_NAMES = new Set([\n  // Element helpers (see ELEMENT_HELPERS in transform.ts — we keep a superset here)\n  ...[\n    'a',\n    'abbr',\n    'article',\n    'aside',\n    'b',\n    'blockquote',\n    'br',\n    'button',\n    'canvas',\n    'code',\n    'dd',\n    'details',\n    'dialog',\n    'div',\n    'dl',\n    'dt',\n    'em',\n    'fieldset',\n    'figcaption',\n    'figure',\n    'footer',\n    'form',\n    'h1',\n    'h2',\n    'h3',\n    'h4',\n    'h5',\n    'h6',\n    'header',\n    'hr',\n    'i',\n    'iframe',\n    'img',\n    'input',\n    'label',\n    'legend',\n    'li',\n    'main',\n    'mark',\n    'nav',\n    'ol',\n    'optgroup',\n    'option',\n    'output',\n    'p',\n    'pre',\n    'progress',\n    'section',\n    'select',\n    'small',\n    'span',\n    'strong',\n    'sub',\n    'summary',\n    'sup',\n    'table',\n    'tbody',\n    'td',\n    'textarea',\n    'tfoot',\n    'th',\n    'thead',\n    'time',\n    'tr',\n    'ul',\n    'video',\n  ],\n  // Structural primitives\n  'each',\n  'branch',\n  'scope',\n  'show',\n  'memo',\n  'portal',\n  'foreign',\n  'child',\n  'errorBoundary',\n])\n\n/**\n * Extract state access paths from an expression body.\n * Handles:\n * - Direct property access: param.field, param.field.subfield\n * - Bracket notation with string literal: param['field']\n */\nfunction extractPaths(node: ts.Node, paramName: string, _prefix: string, paths: Set<string>): void {\n  if (ts.isPropertyAccessExpression(node)) {\n    // Skip if this is an intermediate in a deeper chain\n    if (ts.isPropertyAccessExpression(node.parent)) {\n      // handled when the leaf is visited\n    }\n    // Skip if this is the callee of a method call: s.todos.filter(...)\n    else if (ts.isCallExpression(node.parent) && node.parent.expression === node) {\n      // It's a method call — record the object, not the method\n      // e.g. s.todos.filter(...) → record 'todos', not 'todos.filter'\n      if (ts.isPropertyAccessExpression(node.expression)) {\n        const chain = resolvePropertyChain(node.expression, paramName)\n        if (chain) paths.add(chain)\n      }\n    } else {\n      const chain = resolvePropertyChain(node, paramName)\n      if (chain) {\n        paths.add(chain)\n      }\n    }\n  }\n\n  if (ts.isElementAccessExpression(node)) {\n    const chain = resolveElementAccess(node, paramName)\n    if (chain) {\n      paths.add(chain)\n    }\n  }\n\n  ts.forEachChild(node, (child) => extractPaths(child, paramName, _prefix, paths))\n}\n\n/**\n * Resolve a property access chain like s.user.name to \"user.name\".\n * Returns null if the chain doesn't start with the state parameter.\n * Stops at depth 2.\n */\nfunction resolvePropertyChain(node: ts.PropertyAccessExpression, paramName: string): string | null {\n  const parts: string[] = []\n  let current: ts.Expression = node\n\n  while (ts.isPropertyAccessExpression(current)) {\n    parts.unshift(current.name.text)\n    current = current.expression\n  }\n\n  // The root must be the state parameter\n  if (!ts.isIdentifier(current) || current.text !== paramName) {\n    return null\n  }\n\n  // Limit to depth 2\n  if (parts.length > 2) {\n    return parts.slice(0, 2).join('.')\n  }\n\n  return parts.join('.')\n}\n\n/**\n * Resolve bracket access with string literal: s['count'] → \"count\"\n */\nfunction resolveElementAccess(node: ts.ElementAccessExpression, paramName: string): string | null {\n  if (!ts.isIdentifier(node.expression) || node.expression.text !== paramName) {\n    return null\n  }\n\n  if (ts.isStringLiteral(node.argumentExpression)) {\n    return node.argumentExpression.text\n  }\n\n  return null\n}\n"]}

package/dist/transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../src/transform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EAIpB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,qBAAqB,EAA2B,MAAM,sBAAsB,CAAA;AACrF,OAAO,EAAE,kBAAkB,EAAkB,MAAM,mBAAmB,CAAA;AA6KtE;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;IACX,WAAW,EAAE,MAAM,CAAA;CACpB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,mBAAmB;IAClC,KAAK,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAA;IAC5C,GAAG,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAA;IAC1C,MAAM,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAA;CAC9C;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,mBAAmB;IAClC,SAAS,CAAC,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAA;IAC/C,cAAc,CAAC,EAAE,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAA;IACzD,WAAW,CAAC,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAA;IACnD,YAAY,CAAC,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAA;CACtD;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,UAAQ,EACf,iBAAiB,UAAQ,EACzB,OAAO,GAAE,MAAM,GAAG,IAAW,EAC7B,OAAO,UAAQ,EACf,WAAW,CAAC,EAAE,mBAAmB,EACjC,YAAY,CAAC,EAAE,mBAAmB,GACjC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,aAAa,EAAE,CAAA;CAAE,GAAG,IAAI,CAqYnD;AAuvID,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,EAAE,CAAA;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,wBAAwB,GAAG,IAAI,CAoGjC;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CA4B7D;AAID;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAI3D;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,EAAE,CAAC,cAAc,GAAG,MAAM,GAAG,IAAI,CAcrF;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CASzF;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,KAAK,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC,GAChE,MAAM,CAYR"}
+{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../src/transform.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAO3B,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EAIpB,MAAM,iBAAiB,CAAA;AACxB,OAAO,EAAE,qBAAqB,EAA2B,MAAM,sBAAsB,CAAA;AACrF,OAAO,EAAE,kBAAkB,EAAkB,MAAM,mBAAmB,CAAA;AAiOtE;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,MAAM,CAAA;IACb,GAAG,EAAE,MAAM,CAAA;IACX,WAAW,EAAE,MAAM,CAAA;CACpB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,mBAAmB;IAClC,KAAK,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAA;IAC5C,GAAG,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAA;IAC1C,MAAM,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAA;CAC9C;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,mBAAmB;IAClC,SAAS,CAAC,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAA;IAC/C,cAAc,CAAC,EAAE,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAA;IACzD,WAAW,CAAC,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAA;IACnD,YAAY,CAAC,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAA;CACtD;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,UAAQ,EACf,iBAAiB,UAAQ,EACzB,OAAO,GAAE,MAAM,GAAG,IAAW,EAC7B,OAAO,UAAQ,EACf,WAAW,CAAC,EAAE,mBAAmB,EACjC,YAAY,CAAC,EAAE,mBAAmB,GACjC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,aAAa,EAAE,CAAA;CAAE,GAAG,IAAI,CAqYnD;AAm0ID,MAAM,WAAW,wBAAwB;IACvC,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,EAAE,CAAA;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,GAChB,wBAAwB,GAAG,IAAI,CAoGjC;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CA4B7D;AAID;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAI3D;AAED;;;GAGG;AACH,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,EAAE,CAAC,cAAc,GAAG,MAAM,GAAG,IAAI,CAcrF;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CASzF;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,MAAM,EACd,cAAc,EAAE,KAAK,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC,GAChE,MAAM,CAYR"}