@llui/vite-plugin 0.0.31 → 0.0.33

package/README.md

@@ -44,12 +44,11 @@ The compiler runs 3 passes over every `.ts`/`.tsx` file using the TypeScript Com
 
 ## Diagnostics
 
-The compiler emits warnings for common issues:
-
-| Diagnostic            | Description                                      |
-| --------------------- | ------------------------------------------------ |
-| Missing alt attribute | Accessibility: `img` without `alt`               |
-| Non-exhaustive update | `update()` switch missing msg type cases         |
-| Empty props           | Element helper called with empty props object    |
-| Namespace imports     | `import * as` prevents tree-shaking              |
-| Spread children       | Spread in children array defeats static analysis |
+Static analysis lives in `@llui/eslint-plugin`. The compiler used to emit
+its own warnings during `transform()`; those have all migrated to ESLint
+rules so they surface as editor squiggles instead of build-time console
+output. Install the plugin and enable its `recommended` config to get the
+full set — `empty-props`, `namespace-import`, `spread-in-children`,
+`map-on-state-array`, `exhaustive-update`, `accessibility`,
+`controlled-input`, `child-static-props`, `bitmask-overflow`,
+`static-on`, and the `agent-*` annotation rules.

package/dist/binding-descriptors.d.ts

@@ -1,23 +1,105 @@
-export type BindingDescriptor = {
-    variant: string;
-};
+import ts from 'typescript';
 /**
- * Walk the `view` arrow function of every top-level `component({...})` call
- * in the source and collect every `send({type: '...'})` call site's variant
- * literal. Returns them in encounter order.
+ * Compiler passes that surface the Msg variants currently dispatchable
+ * from rendered UI to the agent layer's `list_actions`. Two passes
+ * cover two distinct dispatch shapes:
  *
- * False positives: any call of the form `identifier({ type: 'x', ... })` —
- * we don't verify the callee resolves to the destructured `send` from the
- * view argument, because that level of scope tracking is beyond the budget
- * of this MVP extractor. Apps that call other identifiers with similarly
- * shaped literals would see those in the output. In practice, the pattern
- * is uncommon enough that false positives are rare.
+ * 1. `tagEventHandlerSends` — tags event-handler arrow functions
+ *    (`onClick`, `onInput`, …) whose body contains literal
+ *    `<id>({type: 'X', …})` call sites. Wraps with
+ *    `Object.assign(arrow, { __lluiVariants: ['X', …] })`. The
+ *    runtime in `@llui/dom` `elements.ts` / `el-split.ts` reads the
+ *    metadata at bind time and registers the variants on the active
+ *    component instance for the lifetime of the binding's scope.
  *
- * Missing: non-literal `type` values (e.g. `send({type: nextStep})`) are
- * skipped. This is the correct behavior — we can only record statically-
- * known variants.
+ * 2. `injectScopeVariantRegistrations` — handles the
+ *    dispatch-translation case that pass (1) can't follow:
+ *    `<bag>.connect(get, sendFn, …)` where `sendFn` is a user-
+ *    defined function that translates library Msgs into app Msgs via
+ *    `dispatch({type: 'X', …})`. Static analysis of the library's
+ *    internal onClick can't see across this hop. The pass detects the
+ *    `*.connect(get, sendFn, …)` syntactic pattern, follows `sendFn`
+ *    to its declaration, scans the body for literal dispatches, and
+ *    inserts a runtime `__registerScopeVariants(['X', …])` call
+ *    immediately before the connect call. Lifetime semantics fall
+ *    out of the render context: the call's active scope is whatever
+ *    `each(...)` / `branch(...)` / root scope happens to be live when
+ *    the view evaluates that statement.
+ *
+ * Both passes are gated on `devMode || emitAgentMetadata` in
+ * `transform.ts`. Production bundles without agent integration get
+ * neither the per-handler `Object.assign` cost nor the registration
+ * statements.
+ *
+ * False positives are deliberate. The alternative — proving the
+ * callee resolves to the destructured `send` from a `View` bag, or
+ * tracing function calls across files — would require full scope
+ * tracking the compiler doesn't do. In practice the patterns
+ * `<id>({type:'X',…})` and `*.connect(get, fn, …)` are reliable
+ * shape-level signals; an extra entry in the live descriptor
+ * registry just means the agent sees one more "affordable variant"
+ * than necessary — never a wrong dispatch, never a runtime error.
+ *
+ * False negatives stay where they were: non-literal `type` values
+ * (`send({ type: nextStep })`), and dispatch translators bound via
+ * patterns other than `*.connect(get, fn, …)`. Apps that hit those
+ * cases declare `agentAffordances` on the component def — the
+ * documented escape hatch.
  *
  * @see agent spec §5.2, §12.2
+ * @see @llui/dom binding-descriptors.ts (runtime registry + helper)
+ */
+/**
+ * Walks every `ArrowFunction` and `FunctionExpression` in the source
+ * and wraps any whose body contains literal `<id>({type:'X', …})`
+ * dispatches with `Object.assign(fn, {__lluiVariants: ['X', …]})`.
+ *
+ * The runtime (in `@llui/dom` `elements.ts` / `el-split.ts`) reads
+ * `__lluiVariants` from event-handler bindings only — so tags placed
+ * on functions in non-handler positions (a const declared but never
+ * bound, an arrow passed to `Array.filter`, a view function whose
+ * body has nested handlers with dispatches) are runtime-inert. The
+ * compiler tags generously; the runtime registers selectively.
+ *
+ * Universal scope means three concrete patterns all surface their
+ * variants without the app author having to think about it:
+ *
+ * 1. **Inline event-handler arrows** —
+ *    `onClick: () => send({type:'X'})` (the original Pass 1 case).
+ * 2. **Const-bound translator functions** —
+ *    `const sendMenu = (m) => dispatch({type:'Y'})` paired with
+ *    `*.connect(get, sendMenu, …)` (the original Pass 3 case). The
+ *    tag travels with the function reference; library connect impls
+ *    use `tagSend(send, libVariants, fn)` to propagate it onto
+ *    returned handlers.
+ * 3. **Positional-arg handlers** —
+ *    `helper(label, () => send({type:'Z'}))` where `helper` is an
+ *    app-defined wrapper like `navButton(label, onClick)` that
+ *    eventually binds the function as an event listener. The arrow
+ *    is still tagged at its declaration site, and the runtime reads
+ *    the tag when the wrapper binds it.
+ *
+ * False positives are deliberate. The alternative — proving that a
+ * tagged arrow actually reaches an event-handler binding — would
+ * require cross-function, cross-file flow analysis the compiler
+ * doesn't do. In practice the cost of an over-tagged arrow is bytes,
+ * not behavior: the runtime never reads the tag from non-handler
+ * bindings.
+ *
+ * Pass 2's `collectLocalFns` resolves identifiers to their original
+ * arrow/function initializers; this pass replaces those initializers
+ * with `Object.assign(arrow, {…})` wrappers. Run Pass 2 BEFORE Pass 1
+ * so the resolver still sees raw arrows.
+ *
+ * Already-wrapped functions (CallExpressions, including user-applied
+ * `tagSend(...)` or this pass's own prior output) are skipped — the
+ * pass only fires on bare arrow/function expressions.
  */
-export declare function extractBindingDescriptors(source: string): BindingDescriptor[];
+export declare function tagDispatchHandlers(node: ts.SourceFile, f: ts.NodeFactory): ts.SourceFile;
+export interface InjectResult {
+    sf: ts.SourceFile;
+    /** True when at least one `__registerScopeVariants(...)` call was inserted. */
+    injected: boolean;
+}
+export declare function injectScopeVariantRegistrations(node: ts.SourceFile, f: ts.NodeFactory): InjectResult;
 //# sourceMappingURL=binding-descriptors.d.ts.map

package/dist/binding-descriptors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"binding-descriptors.d.ts","sourceRoot":"","sources":["../src/binding-descriptors.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,EAAE,CA2D7E"}
+{"version":3,"file":"binding-descriptors.d.ts","sourceRoot":"","sources":["../src/binding-descriptors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AAIH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC,WAAW,GAAG,EAAE,CAAC,UAAU,CA0BzF;AA8BD,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,EAAE,CAAC,UAAU,CAAA;IACjB,+EAA+E;IAC/E,QAAQ,EAAE,OAAO,CAAA;CAClB;AAED,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,EAAE,CAAC,UAAU,EACnB,CAAC,EAAE,EAAE,CAAC,WAAW,GAChB,YAAY,CA0Fd"}

package/dist/binding-descriptors.js

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

package/dist/binding-descriptors.js.map

@@ -1 +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\nexport type BindingDescriptor = {\n  variant: string\n}\n\n/**\n * Walk the `view` arrow function of every top-level `component({...})` call\n * in the source and collect every `send({type: '...'})` call site's variant\n * literal. Returns them in encounter order.\n *\n * False positives: any call of the form `identifier({ type: 'x', ... })` —\n * we don't verify the callee resolves to the destructured `send` from the\n * view argument, because that level of scope tracking is beyond the budget\n * of this MVP extractor. Apps that call other identifiers with similarly\n * shaped literals would see those in the output. In practice, the pattern\n * is uncommon enough that false positives are rare.\n *\n * Missing: non-literal `type` values (e.g. `send({type: nextStep})`) are\n * skipped. This is the correct behavior — we can only record statically-\n * known variants.\n *\n * @see agent spec §5.2, §12.2\n */\nexport function extractBindingDescriptors(source: string): BindingDescriptor[] {\n  const sf = ts.createSourceFile('view.ts', source, ts.ScriptTarget.Latest, true)\n  const out: BindingDescriptor[] = []\n\n  function visitComponentConfig(config: ts.ObjectLiteralExpression): void {\n    for (const prop of config.properties) {\n      if (!ts.isPropertyAssignment(prop)) continue\n      if (!prop.name || !ts.isIdentifier(prop.name) || prop.name.text !== 'view') continue\n      const viewExpr = prop.initializer\n      if (!ts.isArrowFunction(viewExpr) && !ts.isFunctionExpression(viewExpr)) continue\n      collectSendCalls(viewExpr.body)\n    }\n  }\n\n  function collectSendCalls(node: ts.Node): void {\n    if (ts.isCallExpression(node)) {\n      const callee = node.expression\n      const first = node.arguments[0]\n      if (callee && ts.isIdentifier(callee) && first && ts.isObjectLiteralExpression(first)) {\n        const variant = readTypeLiteral(first)\n        if (variant !== null) {\n          out.push({ variant })\n        }\n      }\n    }\n    ts.forEachChild(node, collectSendCalls)\n  }\n\n  function 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\n  function visitTopLevel(node: ts.Node): void {\n    if (ts.isCallExpression(node)) {\n      const callee = node.expression\n      const calleeName = ts.isIdentifier(callee) ? callee.text : null\n      if (calleeName === 'component' && node.arguments.length > 0) {\n        const firstArg = node.arguments[0]\n        if (firstArg && ts.isObjectLiteralExpression(firstArg)) {\n          visitComponentConfig(firstArg)\n        }\n      }\n    }\n    ts.forEachChild(node, visitTopLevel)\n  }\n\n  ts.forEachChild(sf, visitTopLevel)\n  return out\n}\n"]}
+{"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"]}