@llui/compiler 0.3.0

package/dist/binding-descriptors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding-descriptors.js","sourceRoot":"","sources":["../src/binding-descriptors.ts"],"names":[],"mappings":"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","sourcesContent":["import ts from 'typescript'\n\n/**\n * Compiler passes that surface the Msg variants currently dispatchable\n * from rendered UI to the agent layer's `list_actions`. Two passes\n * cover two distinct dispatch shapes:\n *\n * 1. `tagEventHandlerSends` — tags event-handler arrow functions\n *    (`onClick`, `onInput`, …) whose body contains literal\n *    `<id>({type: 'X', …})` call sites. Wraps with\n *    `Object.assign(arrow, { __lluiVariants: ['X', …] })`. The\n *    runtime in `@llui/dom` `elements.ts` / `el-split.ts` reads the\n *    metadata at bind time and registers the variants on the active\n *    component instance for the lifetime of the binding's scope.\n *\n * 2. `injectScopeVariantRegistrations` — handles the\n *    dispatch-translation case that pass (1) can't follow:\n *    `<bag>.connect(get, sendFn, …)` where `sendFn` is a user-\n *    defined function that translates library Msgs into app Msgs via\n *    `dispatch({type: 'X', …})`. Static analysis of the library's\n *    internal onClick can't see across this hop. The pass detects the\n *    `*.connect(get, sendFn, …)` syntactic pattern, follows `sendFn`\n *    to its declaration, scans the body for literal dispatches, and\n *    inserts a runtime `__registerScopeVariants(['X', …])` call\n *    immediately before the connect call. Lifetime semantics fall\n *    out of the render context: the call's active scope is whatever\n *    `each(...)` / `branch(...)` / root scope happens to be live when\n *    the view evaluates that statement.\n *\n * Both passes are gated on `devMode || emitAgentMetadata` in\n * `transform.ts`. Production bundles without agent integration get\n * neither the per-handler `Object.assign` cost nor the registration\n * statements.\n *\n * False positives are deliberate. The alternative — proving the\n * callee resolves to the destructured `send` from a `View` bag, or\n * tracing function calls across files — would require full scope\n * tracking the compiler doesn't do. In practice the patterns\n * `<id>({type:'X',…})` and `*.connect(get, fn, …)` are reliable\n * shape-level signals; an extra entry in the live descriptor\n * registry just means the agent sees one more \"affordable variant\"\n * than necessary — never a wrong dispatch, never a runtime error.\n *\n * False negatives stay where they were: non-literal `type` values\n * (`send({ type: nextStep })`), and dispatch translators bound via\n * patterns other than `*.connect(get, fn, …)`. Apps that hit those\n * cases declare `agentAffordances` on the component def — the\n * documented escape hatch.\n *\n * @see agent spec §5.2, §12.2\n * @see @llui/dom binding-descriptors.ts (runtime registry + helper)\n */\n\n// ── Pass 1: dispatch-handler tagger (universal) ─────────────────────\n\n/**\n * Walks every `ArrowFunction` and `FunctionExpression` in the source\n * and wraps any whose body contains literal `<id>({type:'X', …})`\n * dispatches with `Object.assign(fn, {__lluiVariants: ['X', …]})`.\n *\n * The runtime (in `@llui/dom` `elements.ts` / `el-split.ts`) reads\n * `__lluiVariants` from event-handler bindings only — so tags placed\n * on functions in non-handler positions (a const declared but never\n * bound, an arrow passed to `Array.filter`, a view function whose\n * body has nested handlers with dispatches) are runtime-inert. The\n * compiler tags generously; the runtime registers selectively.\n *\n * Universal scope means three concrete patterns all surface their\n * variants without the app author having to think about it:\n *\n * 1. **Inline event-handler arrows** —\n *    `onClick: () => send({type:'X'})` (the original Pass 1 case).\n * 2. **Const-bound translator functions** —\n *    `const sendMenu = (m) => dispatch({type:'Y'})` paired with\n *    `*.connect(get, sendMenu, …)` (the original Pass 3 case). The\n *    tag travels with the function reference; library connect impls\n *    use `tagSend(send, libVariants, fn)` to propagate it onto\n *    returned handlers.\n * 3. **Positional-arg handlers** —\n *    `helper(label, () => send({type:'Z'}))` where `helper` is an\n *    app-defined wrapper like `navButton(label, onClick)` that\n *    eventually binds the function as an event listener. The arrow\n *    is still tagged at its declaration site, and the runtime reads\n *    the tag when the wrapper binds it.\n *\n * False positives are deliberate. The alternative — proving that a\n * tagged arrow actually reaches an event-handler binding — would\n * require cross-function, cross-file flow analysis the compiler\n * doesn't do. In practice the cost of an over-tagged arrow is bytes,\n * not behavior: the runtime never reads the tag from non-handler\n * bindings.\n *\n * Pass 2's `collectLocalFns` resolves identifiers to their original\n * arrow/function initializers; this pass replaces those initializers\n * with `Object.assign(arrow, {…})` wrappers. Run Pass 2 BEFORE Pass 1\n * so the resolver still sees raw arrows.\n *\n * Already-wrapped functions (CallExpressions, including user-applied\n * `tagSend(...)` or this pass's own prior output) are skipped — the\n * pass only fires on bare arrow/function expressions.\n */\nexport function tagDispatchHandlers(node: ts.SourceFile, f: ts.NodeFactory): ts.SourceFile {\n  const transformer: ts.TransformerFactory<ts.SourceFile> = (ctx) => {\n    const visit: ts.Visitor = (n) => {\n      if (ts.isArrowFunction(n) || ts.isFunctionExpression(n)) {\n        // Visit children first so nested arrows are tagged before\n        // their parents see them. The parent's\n        // `collectLiteralSendVariants` walks the original (unwrapped)\n        // body — the recursive collect doesn't descend into nested\n        // function bodies (that would cause an outer arrow to inherit\n        // every dispatch from every closure within it, which is too\n        // permissive).\n        const inner = ts.visitEachChild(n, visit, ctx) as ts.ArrowFunction | ts.FunctionExpression\n        const variants = collectLiteralSendVariants(inner.body)\n        if (variants.length > 0) {\n          return wrapWithVariants(inner, variants, f)\n        }\n        return inner\n      }\n      return ts.visitEachChild(n, visit, ctx)\n    }\n    return (sf) => ts.visitEachChild(sf, visit, ctx) as ts.SourceFile\n  }\n  const result = ts.transform(node, [transformer])\n  const out = result.transformed[0] as ts.SourceFile\n  result.dispose()\n  return out\n}\n\nfunction wrapWithVariants(\n  arrow: ts.ArrowFunction | ts.FunctionExpression,\n  variants: readonly string[],\n  f: ts.NodeFactory,\n): ts.CallExpression {\n  return f.createCallExpression(\n    f.createPropertyAccessExpression(f.createIdentifier('Object'), 'assign'),\n    undefined,\n    [\n      arrow,\n      f.createObjectLiteralExpression(\n        [\n          f.createPropertyAssignment(\n            '__lluiVariants',\n            f.createArrayLiteralExpression(\n              variants.map((v) => f.createStringLiteral(v)),\n              false,\n            ),\n          ),\n        ],\n        false,\n      ),\n    ],\n  )\n}\n\n// ── Pass 2: connect-pattern registration injector ────────────────\n\nexport interface InjectResult {\n  sf: ts.SourceFile\n  /** True when at least one `__registerScopeVariants(...)` call was inserted. */\n  injected: boolean\n}\n\nexport function injectScopeVariantRegistrations(\n  node: ts.SourceFile,\n  f: ts.NodeFactory,\n): InjectResult {\n  let injected = false\n\n  const transformer: ts.TransformerFactory<ts.SourceFile> = (ctx) => {\n    /**\n     * Tracks whether we're inside a function body. Top-level\n     * (module-scope) connect calls are skipped — there's no render\n     * context active when module code runs, so the registration\n     * would silently no-op anyway, and emitting it adds noise. Apps\n     * with module-scope translators (a single shared `parts` re-used\n     * across views) declare `agentAffordances` instead.\n     */\n    let inFunction = 0\n\n    function rewriteBlock<B extends ts.Block | ts.SourceFile>(block: B): B {\n      const stmts = (block as ts.Block | ts.SourceFile).statements\n      const localFns = collectLocalFns(stmts)\n      const out: ts.Statement[] = []\n      for (const stmt of stmts) {\n        const visited = ts.visitNode(stmt, (n) => visitNode(n, localFns)) as ts.Statement\n        out.push(visited)\n      }\n      if (ts.isSourceFile(block)) {\n        return f.updateSourceFile(block, out) as B\n      }\n      return f.updateBlock(block, out) as B\n    }\n\n    function visitNode(\n      n: ts.Node,\n      localFns: Map<string, ts.ArrowFunction | ts.FunctionExpression>,\n    ): ts.Node {\n      if (ts.isBlock(n)) {\n        return rewriteBlock(n)\n      }\n      // Track function-body nesting so we know whether the current\n      // call site can plausibly run within a render context. Arrow\n      // functions and function expressions/declarations both qualify.\n      if (\n        ts.isArrowFunction(n) ||\n        ts.isFunctionExpression(n) ||\n        ts.isFunctionDeclaration(n) ||\n        ts.isMethodDeclaration(n)\n      ) {\n        inFunction++\n        const r = ts.visitEachChild(n, (c) => visitNode(c, localFns), ctx)\n        inFunction--\n        return r\n      }\n      if (ts.isCallExpression(n) && inFunction > 0 && isConnectCallShape(n)) {\n        const sendArg = n.arguments[1]!\n        const sendFn = resolveSendFn(sendArg, localFns)\n        if (sendFn) {\n          const variants = collectLiteralSendVariants(sendFn.body)\n          if (variants.length > 0) {\n            // Replace the call expression with a comma expression:\n            //   (__registerScopeVariants([...]), originalCall)\n            // The comma keeps the call's value position intact (so\n            // `const parts = popover.connect(...)` still binds the\n            // original return), and ensures the registration fires\n            // *before* the call returns. This positions correctly\n            // regardless of the surrounding function context: view\n            // body, render callback inside `each(...)`, or any\n            // nested helper called from within a view.\n            injected = true\n            const inner = ts.visitEachChild(\n              n,\n              (c) => visitNode(c, localFns),\n              ctx,\n            ) as ts.CallExpression\n            return f.createParenthesizedExpression(\n              f.createBinaryExpression(\n                emitRegisterCall(variants, f),\n                f.createToken(ts.SyntaxKind.CommaToken),\n                inner,\n              ),\n            )\n          }\n        }\n      }\n      return ts.visitEachChild(n, (c) => visitNode(c, localFns), ctx)\n    }\n\n    return (sf) => rewriteBlock(sf)\n  }\n\n  const result = ts.transform(node, [transformer])\n  const out = result.transformed[0] as ts.SourceFile\n  result.dispose()\n  return { sf: out, injected }\n}\n\n/**\n * Collect `const fn = (m) => { … }` / `const fn = function(m){ … }`\n * declarations in `stmts` so an identifier passed to a connect call\n * later in the same scope can resolve to its body. Conservative —\n * only direct function-valued initializers count; aliasing\n * (`const a = b`) is not followed.\n */\nfunction collectLocalFns(\n  stmts: ts.NodeArray<ts.Statement>,\n): Map<string, ts.ArrowFunction | ts.FunctionExpression> {\n  const out = new Map<string, ts.ArrowFunction | ts.FunctionExpression>()\n  for (const stmt of stmts) {\n    if (!ts.isVariableStatement(stmt)) continue\n    for (const decl of stmt.declarationList.declarations) {\n      if (!ts.isIdentifier(decl.name)) continue\n      const init = decl.initializer\n      if (init && (ts.isArrowFunction(init) || ts.isFunctionExpression(init))) {\n        out.set(decl.name.text, init)\n      }\n    }\n  }\n  return out\n}\n\nfunction isConnectCallShape(node: ts.CallExpression): boolean {\n  if (!ts.isPropertyAccessExpression(node.expression)) return false\n  if (node.expression.name.text !== 'connect') return false\n  return node.arguments.length >= 2\n}\n\nfunction resolveSendFn(\n  arg: ts.Expression,\n  localFns: Map<string, ts.ArrowFunction | ts.FunctionExpression>,\n): ts.ArrowFunction | ts.FunctionExpression | null {\n  if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) return arg\n  if (ts.isIdentifier(arg)) return localFns.get(arg.text) ?? null\n  return null\n}\n\nfunction emitRegisterCall(variants: readonly string[], f: ts.NodeFactory): ts.CallExpression {\n  return f.createCallExpression(f.createIdentifier('__registerScopeVariants'), undefined, [\n    f.createArrayLiteralExpression(\n      variants.map((v) => f.createStringLiteral(v)),\n      false,\n    ),\n  ])\n}\n\n// ── Shared: literal-send variant collection ──────────────────────────\n\n/**\n * Walk `node`, collecting every literal type string from\n * `<id>({ type: 'literal', … })` call sites. De-dupes while preserving\n * first-seen order so the emitted array reads naturally for anyone\n * inspecting the compiled output.\n *\n * The walk stops at nested function/arrow boundaries — every function\n * \"owns\" its own dispatches, and the universal tagger visits each\n * function separately. Without this guard, an outer arrow whose body\n * includes a nested onClick arrow would be tagged with the inner\n * arrow's variants too: a parent view tagged with every dispatch in\n * every child handler. The runtime only reads the tag from event-\n * handler bindings, so functionally that's harmless — but it bloats\n * the wrapped output and obscures intent.\n */\nfunction collectLiteralSendVariants(body: ts.Node): string[] {\n  const seen = new Set<string>()\n  const out: string[] = []\n  function visit(n: ts.Node): void {\n    // Stop at every nested function/arrow boundary — those functions\n    // own their own variants and are tagged independently. An outer\n    // arrow whose body contains `setTimeout(() => send(...), 100)`\n    // doesn't dispatch directly when invoked; the inner arrow does\n    // when the timer fires. Counting the inner's variants on the\n    // outer would be too permissive.\n    if (\n      ts.isArrowFunction(n) ||\n      ts.isFunctionExpression(n) ||\n      ts.isFunctionDeclaration(n) ||\n      ts.isMethodDeclaration(n)\n    ) {\n      return\n    }\n    if (ts.isCallExpression(n)) {\n      const callee = n.expression\n      const first = n.arguments[0]\n      if (\n        callee &&\n        ts.isIdentifier(callee) &&\n        isDispatcherName(callee.text) &&\n        first &&\n        ts.isObjectLiteralExpression(first)\n      ) {\n        const variant = readTypeLiteral(first)\n        if (variant !== null && !seen.has(variant)) {\n          seen.add(variant)\n          out.push(variant)\n        }\n      }\n    }\n    ts.forEachChild(n, visit)\n  }\n  visit(body)\n  return out\n}\n\n/**\n * Recognize a callee as a dispatcher by name. The convention in LLui\n * apps is `send` (the framework-provided dispatch) or `dispatch` (a\n * common app-level alias), plus `send*` / `dispatch*` prefixes for\n * named translators (`sendMenu`, `dispatchMenu`).\n *\n * Without this filter, the tagger would treat element-helper calls\n * like `button({type: 'button'})` and `input({type: 'email'})` as\n * dispatch sites — they syntactically match `<Identifier>({type:\n * literal})`, but they construct DOM, not Msgs. Phantom variants\n * like `button` and `email` would then leak into the binding-\n * descriptor registry and surface as agent affordances. Filtering\n * by name keeps the convention narrow enough that false positives\n * are nearly zero while leaving room for translator naming.\n *\n * Apps that use unconventional dispatcher names (`forward`,\n * `tellMenu`) need to either rename to the convention or wrap their\n * handlers with the runtime `tagSend`/`tagVariants` helpers\n * explicitly — the same escape hatch library code already uses.\n */\nfunction isDispatcherName(name: string): boolean {\n  return /^(send|dispatch)/i.test(name)\n}\n\nfunction readTypeLiteral(obj: ts.ObjectLiteralExpression): string | null {\n  for (const prop of obj.properties) {\n    if (!ts.isPropertyAssignment(prop)) continue\n    if (!prop.name) continue\n    const nameOk =\n      (ts.isIdentifier(prop.name) && prop.name.text === 'type') ||\n      (ts.isStringLiteral(prop.name) && prop.name.text === 'type')\n    if (!nameOk) continue\n    const init = prop.initializer\n    if (ts.isStringLiteral(init)) return init.text\n    if (ts.isNoSubstitutionTemplateLiteral(init)) return init.text\n  }\n  return null\n}\n"]}

package/dist/collect-deps.d.ts

@@ -0,0 +1,49 @@
+import ts from 'typescript';
+/**
+ * Walk the AST and collect every unique state access path referenced by
+ * 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.
+ */
+export declare function collectStatePathsFromSource(sourceFile: ts.SourceFile): Set<string>;
+/**
+ * Per-accessor path sets — one entry per reactive arrow/function. Used
+ * by the bitmask-overflow diagnostic to find clusters of paths that
+ * always fire together (co-occurrence analysis).
+ */
+export declare function collectAccessorPathSets(sourceFile: ts.SourceFile): Set<string>[];
+/**
+ * Pre-scan a source file to collect all unique state access paths
+ * referenced by reactive accessors (arrow functions in props and text() calls).
+ *
+ * Returns a pair of maps:
+ *   - `lo`: paths at bit positions 0..30, with value `1 << position`
+ *   - `hi`: paths at bit positions 31..61, with value `1 << (position - 31)`
+ *
+ * Bit positions past 61 collapse to `-1` (FULL_MASK) in the `lo` map and
+ * cause every binding reading them to re-evaluate on every cycle. The
+ * `bitmask-overflow` lint rule warns the user to restructure state.
+ *
+ * Components with ≤31 paths see an empty `hi` map; the compiler skips
+ * all high-word emit so the generated code is byte-identical to the
+ * pre-multi-word baseline.
+ */
+export declare function collectDeps(source: string, extraPaths?: ReadonlySet<string>): {
+    lo: Map<string, number>;
+    hi: Map<string, number>;
+};
+//# sourceMappingURL=collect-deps.d.ts.map

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

@@ -0,0 +1 @@
+{"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;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,MAAM,EACd,UAAU,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,GAC/B;IACD,EAAE,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvB,EAAE,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACxB,CAsCA"}

package/dist/collect-deps.js

@@ -0,0 +1,444 @@
+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 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.
+ */
+export function collectStatePathsFromSource(sourceFile) {
+    const paths = new Set();
+    function visit(node) {
+        // Inline arrow / function expression at a reactive position.
+        if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+            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);
+    }
+    visit(sourceFile);
+    return paths;
+}
+/**
+ * Per-accessor path sets — one entry per reactive arrow/function. Used
+ * by the bitmask-overflow diagnostic to find clusters of paths that
+ * always fire together (co-occurrence analysis).
+ */
+export function collectAccessorPathSets(sourceFile) {
+    const sets = [];
+    function visit(node) {
+        if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
+            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);
+    }
+    visit(sourceFile);
+    return sets;
+}
+/**
+ * Pre-scan a source file to collect all unique state access paths
+ * referenced by reactive accessors (arrow functions in props and text() calls).
+ *
+ * Returns a pair of maps:
+ *   - `lo`: paths at bit positions 0..30, with value `1 << position`
+ *   - `hi`: paths at bit positions 31..61, with value `1 << (position - 31)`
+ *
+ * Bit positions past 61 collapse to `-1` (FULL_MASK) in the `lo` map and
+ * cause every binding reading them to re-evaluate on every cycle. The
+ * `bitmask-overflow` lint rule warns the user to restructure state.
+ *
+ * Components with ≤31 paths see an empty `hi` map; the compiler skips
+ * all high-word emit so the generated code is byte-identical to the
+ * pre-multi-word baseline.
+ */
+export function collectDeps(source, extraPaths) {
+    const sourceFile = ts.createSourceFile('input.ts', source, ts.ScriptTarget.Latest, true);
+    // Check if file imports from @llui/dom
+    if (!hasLluiImport(sourceFile)) {
+        return { lo: new Map(), hi: new Map() };
+    }
+    const paths = collectStatePathsFromSource(sourceFile);
+    // Cross-file extension (v2c pipeline integration): the host adapter may
+    // pass paths discovered by `crossFileAccessorPaths()` — paths read
+    // through in-repo view-helpers in *other* files. Union them with the
+    // file-local set before bit assignment. Without this merge the
+    // sentinel-`show()` workaround from v2b §1 remains necessary; with
+    // it, helpers in other files contribute to the consumer's __prefixes
+    // table automatically.
+    if (extraPaths) {
+        for (const p of extraPaths)
+            paths.add(p);
+    }
+    const lo = new Map();
+    const hi = new Map();
+    let index = 0;
+    for (const path of paths) {
+        if (index < 31) {
+            lo.set(path, 1 << index);
+        }
+        else if (index < 62) {
+            hi.set(path, 1 << (index - 31));
+        }
+        else {
+            // Past 61 paths — graceful FULL_MASK fallback in the low word.
+            // Realistic LLui components shouldn't hit this; the lint rule
+            // fires well before.
+            lo.set(path, -1);
+        }
+        index++;
+    }
+    return { lo, hi };
+}
+function hasLluiImport(sourceFile) {
+    for (const stmt of sourceFile.statements) {
+        if (ts.isImportDeclaration(stmt) &&
+            ts.isStringLiteral(stmt.moduleSpecifier) &&
+            stmt.moduleSpecifier.text === '@llui/dom') {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * 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;
+    // text(s => s.count) — first arg to a call
+    if (ts.isCallExpression(parent) && parent.arguments[0] === node) {
+        // Skip item(t => t.id) — per-item selectors inside each() render.
+        // Skip sample(s => s.x) — imperative one-shot read, no binding created
+        // (both the top-level import and the destructured-from-h form).
+        if (ts.isIdentifier(parent.expression)) {
+            if (parent.expression.text === 'item' || parent.expression.text === 'sample') {
+                return false;
+            }
+        }
+        // Skip array method callbacks: .filter(t => ...), .map(t => ...), .some(t => ...), etc.
+        // Allow view-helper primitive calls: h.text(s => ...), h.memo(s => ...)
+        if (ts.isPropertyAccessExpression(parent.expression)) {
+            const methodName = parent.expression.name.text;
+            if (methodName === 'text' || methodName === 'memo') {
+                return true;
+            }
+            return false;
+        }
+        return true;
+    }
+    // div({ title: s => s.title }) — value in a property assignment inside an object literal.
+    // Only treat as reactive if the containing call is a known framework API whose
+    // properties are reactive accessors. Otherwise user-land helpers like
+    // sliceHandler({ narrow: (m) => m.type === ... }) would pollute the path set.
+    if (ts.isPropertyAssignment(parent)) {
+        const key = parent.name;
+        if (ts.isIdentifier(key)) {
+            // Skip event handlers (onClick, onInput, etc.)
+            if (/^on[A-Z]/.test(key.text))
+                return false;
+            // Skip each() key function and other non-reactive props
+            if (key.text === 'key' || key.text === 'name')
+                return false;
+            // Walk up to find the enclosing call expression
+            let ancestor = parent.parent; // ObjectLiteralExpression
+            while (ancestor && !ts.isCallExpression(ancestor)) {
+                ancestor = ancestor.parent;
+            }
+            if (!ancestor)
+                return false;
+            const callExpr = ancestor;
+            if (!ts.isIdentifier(callExpr.expression))
+                return false;
+            return REACTIVE_API_NAMES.has(callExpr.expression.text);
+        }
+    }
+    return false;
+}
+// Framework APIs whose object-literal arguments contain reactive accessors.
+// Arrow functions in property values of these calls are state-tracked.
+const REACTIVE_API_NAMES = new Set([
+    // Element helpers (see ELEMENT_HELPERS in transform.ts — we keep a superset here)
+    ...[
+        'a',
+        'abbr',
+        'article',
+        'aside',
+        'b',
+        'blockquote',
+        'br',
+        'button',
+        'canvas',
+        'code',
+        'dd',
+        'details',
+        'dialog',
+        'div',
+        'dl',
+        'dt',
+        'em',
+        'fieldset',
+        'figcaption',
+        'figure',
+        'footer',
+        'form',
+        'h1',
+        'h2',
+        'h3',
+        'h4',
+        'h5',
+        'h6',
+        'header',
+        'hr',
+        'i',
+        'iframe',
+        'img',
+        'input',
+        'label',
+        'legend',
+        'li',
+        'main',
+        'mark',
+        'nav',
+        'ol',
+        'optgroup',
+        'option',
+        'output',
+        'p',
+        'pre',
+        'progress',
+        'section',
+        'select',
+        'small',
+        'span',
+        'strong',
+        'sub',
+        'summary',
+        'sup',
+        'table',
+        'tbody',
+        'td',
+        'textarea',
+        'tfoot',
+        'th',
+        'thead',
+        'time',
+        'tr',
+        'ul',
+        'video',
+    ],
+    // Structural primitives
+    'each',
+    'branch',
+    'scope',
+    'show',
+    'memo',
+    'portal',
+    'foreign',
+    'child',
+    'errorBoundary',
+    // track({ deps: (s) => [...] }) — explicit reactivity declaration for
+    // paths static analysis can't infer. The compiler treats `deps` as a
+    // reactive accessor so its paths fold into the host component's
+    // __prefixes; the call expression is then stripped from emission
+    // (see transform.ts). v2b §3.
+    'track',
+]);
+/**
+ * Extract state access paths from an expression body.
+ * Handles:
+ * - Direct property access: param.field, param.field.subfield
+ * - Bracket notation with string literal: param['field']
+ */
+function extractPaths(node, paramName, _prefix, paths) {
+    if (ts.isPropertyAccessExpression(node)) {
+        // Skip if this is an intermediate in a deeper chain
+        if (ts.isPropertyAccessExpression(node.parent)) {
+            // handled when the leaf is visited
+        }
+        // Skip if this is the callee of a method call: s.todos.filter(...)
+        else if (ts.isCallExpression(node.parent) && node.parent.expression === node) {
+            // It's a method call — record the object, not the method
+            // e.g. s.todos.filter(...) → record 'todos', not 'todos.filter'
+            if (ts.isPropertyAccessExpression(node.expression)) {
+                const chain = resolvePropertyChain(node.expression, paramName);
+                if (chain)
+                    paths.add(chain);
+            }
+        }
+        else {
+            const chain = resolvePropertyChain(node, paramName);
+            if (chain) {
+                paths.add(chain);
+            }
+        }
+    }
+    if (ts.isElementAccessExpression(node)) {
+        const chain = resolveElementAccess(node, paramName);
+        if (chain) {
+            paths.add(chain);
+        }
+    }
+    ts.forEachChild(node, (child) => extractPaths(child, paramName, _prefix, paths));
+}
+/**
+ * Resolve a property access chain like s.user.name to "user.name".
+ * Returns null if the chain doesn't start with the state parameter.
+ * Stops at depth 2.
+ */
+function resolvePropertyChain(node, paramName) {
+    const parts = [];
+    let current = node;
+    while (ts.isPropertyAccessExpression(current)) {
+        parts.unshift(current.name.text);
+        current = current.expression;
+    }
+    // The root must be the state parameter
+    if (!ts.isIdentifier(current) || current.text !== paramName) {
+        return null;
+    }
+    // Limit to depth 2
+    if (parts.length > 2) {
+        return parts.slice(0, 2).join('.');
+    }
+    return parts.join('.');
+}
+/**
+ * Resolve bracket access with string literal: s['count'] → "count"
+ */
+function resolveElementAccess(node, paramName) {
+    if (!ts.isIdentifier(node.expression) || node.expression.text !== paramName) {
+        return null;
+    }
+    if (ts.isStringLiteral(node.argumentExpression)) {
+        return node.argumentExpression.text;
+    }
+    return null;
+}
+//# sourceMappingURL=collect-deps.js.map

package/dist/collect-deps.js.map

@@ -0,0 +1 @@
+{"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 *\n * Returns a pair of maps:\n *   - `lo`: paths at bit positions 0..30, with value `1 << position`\n *   - `hi`: paths at bit positions 31..61, with value `1 << (position - 31)`\n *\n * Bit positions past 61 collapse to `-1` (FULL_MASK) in the `lo` map and\n * cause every binding reading them to re-evaluate on every cycle. The\n * `bitmask-overflow` lint rule warns the user to restructure state.\n *\n * Components with ≤31 paths see an empty `hi` map; the compiler skips\n * all high-word emit so the generated code is byte-identical to the\n * pre-multi-word baseline.\n */\nexport function collectDeps(\n  source: string,\n  extraPaths?: ReadonlySet<string>,\n): {\n  lo: Map<string, number>\n  hi: Map<string, number>\n} {\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 { lo: new Map(), hi: new Map() }\n  }\n\n  const paths = collectStatePathsFromSource(sourceFile)\n  // Cross-file extension (v2c pipeline integration): the host adapter may\n  // pass paths discovered by `crossFileAccessorPaths()` — paths read\n  // through in-repo view-helpers in *other* files. Union them with the\n  // file-local set before bit assignment. Without this merge the\n  // sentinel-`show()` workaround from v2b §1 remains necessary; with\n  // it, helpers in other files contribute to the consumer's __prefixes\n  // table automatically.\n  if (extraPaths) {\n    for (const p of extraPaths) paths.add(p)\n  }\n\n  const lo = new Map<string, number>()\n  const hi = new Map<string, number>()\n  let index = 0\n  for (const path of paths) {\n    if (index < 31) {\n      lo.set(path, 1 << index)\n    } else if (index < 62) {\n      hi.set(path, 1 << (index - 31))\n    } else {\n      // Past 61 paths — graceful FULL_MASK fallback in the low word.\n      // Realistic LLui components shouldn't hit this; the lint rule\n      // fires well before.\n      lo.set(path, -1)\n    }\n    index++\n  }\n\n  return { lo, hi }\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  // track({ deps: (s) => [...] }) — explicit reactivity declaration for\n  // paths static analysis can't infer. The compiler treats `deps` as a\n  // reactive accessor so its paths fold into the host component's\n  // __prefixes; the call expression is then stripped from emission\n  // (see transform.ts). v2b §3.\n  'track',\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/compiler-cache.d.ts

@@ -0,0 +1,20 @@
+export interface BindingSourceEntry {
+    bindingIndex: number;
+    file: string;
+    line: number;
+    column: number;
+}
+export interface CompilerCacheEntry {
+    preSource: string;
+    postSource: string;
+    msgMaskMap: Record<string, number>;
+    bindingSources: BindingSourceEntry[];
+}
+export declare class CompilerCache {
+    private readonly cache;
+    set(componentName: string, entry: CompilerCacheEntry): void;
+    get(componentName: string): CompilerCacheEntry | undefined;
+    has(componentName: string): boolean;
+}
+export declare const compilerCache: CompilerCache;
+//# sourceMappingURL=compiler-cache.d.ts.map

package/dist/compiler-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler-cache.d.ts","sourceRoot":"","sources":["../src/compiler-cache.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,kBAAkB;IACjC,YAAY,EAAE,MAAM,CAAA;IACpB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;CACf;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAA;IACjB,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,cAAc,EAAE,kBAAkB,EAAE,CAAA;CACrC;AAID,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAwC;IAE9D,GAAG,CAAC,aAAa,EAAE,MAAM,EAAE,KAAK,EAAE,kBAAkB,GAAG,IAAI;IAQ3D,GAAG,CAAC,aAAa,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS;IAI1D,GAAG,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO;CAGpC;AAED,eAAO,MAAM,aAAa,eAAsB,CAAA"}

package/dist/compiler-cache.js

@@ -0,0 +1,20 @@
+const MAX_ENTRIES = 50;
+export class CompilerCache {
+    cache = new Map();
+    set(componentName, entry) {
+        if (this.cache.has(componentName))
+            this.cache.delete(componentName);
+        this.cache.set(componentName, entry);
+        if (this.cache.size > MAX_ENTRIES) {
+            this.cache.delete(this.cache.keys().next().value);
+        }
+    }
+    get(componentName) {
+        return this.cache.get(componentName);
+    }
+    has(componentName) {
+        return this.cache.has(componentName);
+    }
+}
+export const compilerCache = new CompilerCache();
+//# sourceMappingURL=compiler-cache.js.map