@llui/compiler 0.3.0

package/dist/modules/agent-warning-on-confirm.js

@@ -0,0 +1,46 @@
+// `agent-warning-on-confirm` — errors when a Msg variant tagged
+// `@requiresConfirm` lacks a `@warning("…")`. Without the warning,
+// the LLM sees "this needs confirmation" with no reason — so it
+// either dispatches blindly or refuses. The warning is what makes
+// the confirm gate honest. Migrated from
+// `@llui/eslint-plugin/src/rules/agent-warning-on-confirm.ts`.
+import ts from 'typescript';
+import { rangeFromOffsets } from '../diagnostic.js';
+import { forEachMsgVariant } from './_msg-variants.js';
+export function agentWarningOnConfirmModule() {
+    return {
+        name: 'agent-warning-on-confirm',
+        compilerVersion: '^0.3.0',
+        diagnostics: [
+            {
+                id: 'llui/agent-warning-on-confirm',
+                description: '@requiresConfirm without @warning — LLM should see why the action is gated.',
+            },
+        ],
+        visitors: {
+            [ts.SyntaxKind.SourceFile]: (ctx, node) => {
+                const visited = node;
+                const sf = ts.createSourceFile(visited.fileName, visited.text, ts.ScriptTarget.Latest, true);
+                forEachMsgVariant(sf, ({ variant, node: typeLit, leadingCommentText }) => {
+                    if (!/@requiresConfirm\b/.test(leadingCommentText))
+                        return;
+                    if (/@warning\s*\(/.test(leadingCommentText))
+                        return;
+                    ctx.reportDiagnostic({
+                        id: 'llui/agent-warning-on-confirm',
+                        severity: 'error',
+                        category: 'agent',
+                        message: `Msg variant "${variant}" has \`@requiresConfirm\` but no \`@warning("…")\`. ` +
+                            `Add a short consequence-shaped warning so the LLM sees why this action is gated: ` +
+                            `\`/** @requiresConfirm @warning("Deletes all unsaved drafts.") */\`.`,
+                        location: {
+                            file: sf.fileName,
+                            range: rangeFromOffsets(sf.text, typeLit.getStart(sf), typeLit.getEnd()),
+                        },
+                    });
+                });
+            },
+        },
+    };
+}
+//# sourceMappingURL=agent-warning-on-confirm.js.map

package/dist/modules/agent-warning-on-confirm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-warning-on-confirm.js","sourceRoot":"","sources":["../../src/modules/agent-warning-on-confirm.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,mEAAmE;AACnE,gEAAgE;AAChE,kEAAkE;AAClE,yCAAyC;AACzC,+DAA+D;AAE/D,OAAO,EAAE,MAAM,YAAY,CAAA;AAC3B,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAEnD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAEtD,MAAM,UAAU,2BAA2B;IACzC,OAAO;QACL,IAAI,EAAE,0BAA0B;QAChC,eAAe,EAAE,QAAQ;QACzB,WAAW,EAAE;YACX;gBACE,EAAE,EAAE,+BAA+B;gBACnC,WAAW,EAAE,6EAA6E;aAC3F;SACF;QACD,QAAQ,EAAE;YACR,CAAC,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE;gBACxC,MAAM,OAAO,GAAG,IAAqB,CAAA;gBACrC,MAAM,EAAE,GAAG,EAAE,CAAC,gBAAgB,CAAC,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,IAAI,CAAC,CAAA;gBAC5F,iBAAiB,CAAC,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,kBAAkB,EAAE,EAAE,EAAE;oBACvE,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,kBAAkB,CAAC;wBAAE,OAAM;oBAC1D,IAAI,eAAe,CAAC,IAAI,CAAC,kBAAkB,CAAC;wBAAE,OAAM;oBACpD,GAAG,CAAC,gBAAgB,CAAC;wBACnB,EAAE,EAAE,+BAA+B;wBACnC,QAAQ,EAAE,OAAO;wBACjB,QAAQ,EAAE,OAAO;wBACjB,OAAO,EACL,gBAAgB,OAAO,uDAAuD;4BAC9E,mFAAmF;4BACnF,sEAAsE;wBACxE,QAAQ,EAAE;4BACR,IAAI,EAAE,EAAE,CAAC,QAAQ;4BACjB,KAAK,EAAE,gBAAgB,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC,EAAE,OAAO,CAAC,MAAM,EAAE,CAAC;yBACzE;qBACF,CAAC,CAAA;gBACJ,CAAC,CAAC,CAAA;YACJ,CAAC;SACF;KACF,CAAA;AACH,CAAC","sourcesContent":["// `agent-warning-on-confirm` — errors when a Msg variant tagged\n// `@requiresConfirm` lacks a `@warning(\"…\")`. Without the warning,\n// the LLM sees \"this needs confirmation\" with no reason — so it\n// either dispatches blindly or refuses. The warning is what makes\n// the confirm gate honest. Migrated from\n// `@llui/eslint-plugin/src/rules/agent-warning-on-confirm.ts`.\n\nimport ts from 'typescript'\nimport { rangeFromOffsets } from '../diagnostic.js'\nimport type { CompilerModule } from '../module.js'\nimport { forEachMsgVariant } from './_msg-variants.js'\n\nexport function agentWarningOnConfirmModule(): CompilerModule {\n  return {\n    name: 'agent-warning-on-confirm',\n    compilerVersion: '^0.3.0',\n    diagnostics: [\n      {\n        id: 'llui/agent-warning-on-confirm',\n        description: '@requiresConfirm without @warning — LLM should see why the action is gated.',\n      },\n    ],\n    visitors: {\n      [ts.SyntaxKind.SourceFile]: (ctx, node) => {\n        const visited = node as ts.SourceFile\n        const sf = ts.createSourceFile(visited.fileName, visited.text, ts.ScriptTarget.Latest, true)\n        forEachMsgVariant(sf, ({ variant, node: typeLit, leadingCommentText }) => {\n          if (!/@requiresConfirm\\b/.test(leadingCommentText)) return\n          if (/@warning\\s*\\(/.test(leadingCommentText)) return\n          ctx.reportDiagnostic({\n            id: 'llui/agent-warning-on-confirm',\n            severity: 'error',\n            category: 'agent',\n            message:\n              `Msg variant \"${variant}\" has \\`@requiresConfirm\\` but no \\`@warning(\"…\")\\`. ` +\n              `Add a short consequence-shaped warning so the LLM sees why this action is gated: ` +\n              `\\`/** @requiresConfirm @warning(\"Deletes all unsaved drafts.\") */\\`.`,\n            location: {\n              file: sf.fileName,\n              range: rangeFromOffsets(sf.text, typeLit.getStart(sf), typeLit.getEnd()),\n            },\n          })\n        })\n      },\n    },\n  }\n}\n"]}

package/dist/modules/async-update.d.ts

@@ -0,0 +1,3 @@
+import type { CompilerModule } from '../module.js';
+export declare function asyncUpdateModule(): CompilerModule;
+//# sourceMappingURL=async-update.d.ts.map

package/dist/modules/async-update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-update.d.ts","sourceRoot":"","sources":["../../src/modules/async-update.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAkBlD,wBAAgB,iBAAiB,IAAI,cAAc,CAkElD"}

package/dist/modules/async-update.js

@@ -0,0 +1,86 @@
+// `async-update` — errors on `async update` or `await` inside a
+// component's update function. Update must be synchronous and pure;
+// async work belongs in effects. Migrated from
+// `@llui/eslint-plugin/src/rules/async-update.ts`.
+import ts from 'typescript';
+import { rangeFromOffsets } from '../diagnostic.js';
+import { findComponentCalls } from './_shared.js';
+function findUpdateProperty(call) {
+    const arg = call.arguments[0];
+    if (!arg || !ts.isObjectLiteralExpression(arg))
+        return undefined;
+    for (const prop of arg.properties) {
+        if (ts.isPropertyAssignment(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === 'update') {
+            return prop;
+        }
+    }
+    return undefined;
+}
+export function asyncUpdateModule() {
+    return {
+        name: 'async-update',
+        compilerVersion: '^0.3.0',
+        diagnostics: [
+            {
+                id: 'llui/async-update',
+                description: 'update() must be synchronous and pure. Move async operations to effects.',
+            },
+        ],
+        visitors: {
+            [ts.SyntaxKind.SourceFile]: (ctx, node) => {
+                const visited = node;
+                const sf = ts.createSourceFile(visited.fileName, visited.text, ts.ScriptTarget.Latest, true);
+                for (const call of findComponentCalls(sf)) {
+                    const updateProp = findUpdateProperty(call);
+                    if (!updateProp)
+                        continue;
+                    const fn = updateProp.initializer;
+                    if (!ts.isArrowFunction(fn) && !ts.isFunctionExpression(fn))
+                        continue;
+                    const asyncMod = fn.modifiers?.find((m) => m.kind === ts.SyntaxKind.AsyncKeyword);
+                    if (asyncMod) {
+                        ctx.reportDiagnostic({
+                            id: 'llui/async-update',
+                            severity: 'error',
+                            category: 'reactivity',
+                            message: 'update() is declared `async`. update() must be synchronous and pure — return effects instead, and run async work in the effect handler.',
+                            location: {
+                                file: sf.fileName,
+                                range: rangeFromOffsets(sf.text, fn.getStart(sf), fn.getEnd()),
+                            },
+                        });
+                    }
+                    // Walk the function body top-down. An `await` outside a nested
+                    // function boundary is inside update() itself; an `await` inside
+                    // a nested arrow/function is fine (those are deferred callbacks).
+                    const walk = (n) => {
+                        if (ts.isArrowFunction(n) ||
+                            ts.isFunctionExpression(n) ||
+                            ts.isFunctionDeclaration(n)) {
+                            if (n !== fn)
+                                return; // boundary — don't descend
+                        }
+                        if (ts.isAwaitExpression(n)) {
+                            ctx.reportDiagnostic({
+                                id: 'llui/async-update',
+                                severity: 'error',
+                                category: 'reactivity',
+                                message: '`await` inside update(). update() must be synchronous — move the async operation to an effect (return `[newState, [myEffect]]`).',
+                                location: {
+                                    file: sf.fileName,
+                                    range: rangeFromOffsets(sf.text, n.getStart(sf), n.getEnd()),
+                                },
+                            });
+                        }
+                        ts.forEachChild(n, walk);
+                    };
+                    if (fn.body)
+                        walk(fn.body);
+                }
+            },
+        },
+    };
+}
+//# sourceMappingURL=async-update.js.map

package/dist/modules/async-update.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-update.js","sourceRoot":"","sources":["../../src/modules/async-update.ts"],"names":[],"mappings":"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","sourcesContent":["// `async-update` — errors on `async update` or `await` inside a\n// component's update function. Update must be synchronous and pure;\n// async work belongs in effects. Migrated from\n// `@llui/eslint-plugin/src/rules/async-update.ts`.\n\nimport ts from 'typescript'\nimport { rangeFromOffsets } from '../diagnostic.js'\nimport type { CompilerModule } from '../module.js'\nimport { findComponentCalls } from './_shared.js'\n\nfunction findUpdateProperty(call: ts.CallExpression): ts.PropertyAssignment | undefined {\n  const arg = call.arguments[0]\n  if (!arg || !ts.isObjectLiteralExpression(arg)) return undefined\n  for (const prop of arg.properties) {\n    if (\n      ts.isPropertyAssignment(prop) &&\n      ts.isIdentifier(prop.name) &&\n      prop.name.text === 'update'\n    ) {\n      return prop\n    }\n  }\n  return undefined\n}\n\nexport function asyncUpdateModule(): CompilerModule {\n  return {\n    name: 'async-update',\n    compilerVersion: '^0.3.0',\n    diagnostics: [\n      {\n        id: 'llui/async-update',\n        description: 'update() must be synchronous and pure. Move async operations to effects.',\n      },\n    ],\n    visitors: {\n      [ts.SyntaxKind.SourceFile]: (ctx, node) => {\n        const visited = node as ts.SourceFile\n        const sf = ts.createSourceFile(visited.fileName, visited.text, ts.ScriptTarget.Latest, true)\n        for (const call of findComponentCalls(sf)) {\n          const updateProp = findUpdateProperty(call)\n          if (!updateProp) continue\n          const fn = updateProp.initializer\n          if (!ts.isArrowFunction(fn) && !ts.isFunctionExpression(fn)) continue\n\n          const asyncMod = fn.modifiers?.find((m) => m.kind === ts.SyntaxKind.AsyncKeyword)\n          if (asyncMod) {\n            ctx.reportDiagnostic({\n              id: 'llui/async-update',\n              severity: 'error',\n              category: 'reactivity',\n              message:\n                'update() is declared `async`. update() must be synchronous and pure — return effects instead, and run async work in the effect handler.',\n              location: {\n                file: sf.fileName,\n                range: rangeFromOffsets(sf.text, fn.getStart(sf), fn.getEnd()),\n              },\n            })\n          }\n\n          // Walk the function body top-down. An `await` outside a nested\n          // function boundary is inside update() itself; an `await` inside\n          // a nested arrow/function is fine (those are deferred callbacks).\n          const walk = (n: ts.Node): void => {\n            if (\n              ts.isArrowFunction(n) ||\n              ts.isFunctionExpression(n) ||\n              ts.isFunctionDeclaration(n)\n            ) {\n              if (n !== fn) return // boundary — don't descend\n            }\n            if (ts.isAwaitExpression(n)) {\n              ctx.reportDiagnostic({\n                id: 'llui/async-update',\n                severity: 'error',\n                category: 'reactivity',\n                message:\n                  '`await` inside update(). update() must be synchronous — move the async operation to an effect (return `[newState, [myEffect]]`).',\n                location: {\n                  file: sf.fileName,\n                  range: rangeFromOffsets(sf.text, n.getStart(sf), n.getEnd()),\n                },\n              })\n            }\n            ts.forEachChild(n, walk)\n          }\n          if (fn.body) walk(fn.body)\n        }\n      },\n    },\n  }\n}\n"]}

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

@@ -0,0 +1,4 @@
+import type { CompilerModule } from '../module.js';
+export declare const BINDING_DESCRIPTORS_SLOT = "binding-descriptors:state";
+export declare const bindingDescriptorsModule: CompilerModule;
+//# sourceMappingURL=binding-descriptors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"binding-descriptors.d.ts","sourceRoot":"","sources":["../../src/modules/binding-descriptors.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AASlD,eAAO,MAAM,wBAAwB,8BAA8B,CAAA;AAEnE,eAAO,MAAM,wBAAwB,EAAE,cAuBtC,CAAA"}

package/dist/modules/binding-descriptors.js

@@ -0,0 +1,48 @@
+// `binding-descriptors` — agent-runtime hook tagging. Pre-transform
+// CompilerModule wrapping `tagDispatchHandlers` + `injectScopeVariantRegistrations`.
+//
+// Both functions mutate the AST in ways the visitor model can't
+// cleanly express:
+//   - `tagDispatchHandlers`: walks every arrow/fn expression, wraps
+//     those whose body contains `send({type:'X'})` with
+//     `Object.assign(arrow, {__lluiVariants: ['X']})`. The visitor
+//     pattern records findings but doesn't rewrite; rewriting is what
+//     this pass does.
+//   - `injectScopeVariantRegistrations`: walks for `*.connect(get,
+//     send, ...)` call sites and inserts `__registerScopeVariants([...])`
+//     adjacent statements. The visitor pattern can't insert siblings
+//     into the source file at arbitrary positions.
+//
+// Both are pre-passes — they produce a rewritten SourceFile that the
+// main visitor walks. v2c §2.1's "walker runs once per file" invariant
+// is preserved: the VISITOR walk runs once. preTransform passes are
+// additional but typically cheap and targeted.
+//
+// The `injected` flag from `injectScopeVariantRegistrations` is
+// surfaced via a shared analysis slot — the umbrella's
+// `cleanupImports` reads it to know whether to add the
+// `__registerScopeVariants` runtime helper to the @llui/dom imports.
+import { tagDispatchHandlers, injectScopeVariantRegistrations } from '../binding-descriptors.js';
+export const BINDING_DESCRIPTORS_SLOT = 'binding-descriptors:state';
+export const bindingDescriptorsModule = {
+    name: 'binding-descriptors',
+    compilerVersion: '^0.3.0',
+    diagnostics: [],
+    visitors: {},
+    preTransform(ctx, sf) {
+        // injectScopeVariantRegistrations runs FIRST so its
+        // `collectLocalFns` resolver still sees raw arrow initializers in
+        // const declarations (the universal tagger below replaces those
+        // initializers with `Object.assign(...)` wrappers).
+        const injection = injectScopeVariantRegistrations(sf, ctx.factory);
+        const tagged = tagDispatchHandlers(injection.sf, ctx.factory);
+        // Surface the injected flag for the umbrella's cleanupImports
+        // pass. The umbrella reads this from `analysis.perModule` after
+        // `registry.run()` returns.
+        ctx.analysis.perModule.set(BINDING_DESCRIPTORS_SLOT, {
+            scopeRegistrationsInjected: injection.injected,
+        });
+        return tagged;
+    },
+};
+//# sourceMappingURL=binding-descriptors.js.map

package/dist/modules/binding-descriptors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"binding-descriptors.js","sourceRoot":"","sources":["../../src/modules/binding-descriptors.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE,qFAAqF;AACrF,EAAE;AACF,gEAAgE;AAChE,mBAAmB;AACnB,oEAAoE;AACpE,wDAAwD;AACxD,mEAAmE;AACnE,sEAAsE;AACtE,sBAAsB;AACtB,mEAAmE;AACnE,0EAA0E;AAC1E,qEAAqE;AACrE,mDAAmD;AACnD,EAAE;AACF,qEAAqE;AACrE,uEAAuE;AACvE,oEAAoE;AACpE,+CAA+C;AAC/C,EAAE;AACF,gEAAgE;AAChE,uDAAuD;AACvD,uDAAuD;AACvD,qEAAqE;AAErE,OAAO,EAAE,mBAAmB,EAAE,+BAA+B,EAAE,MAAM,2BAA2B,CAAA;AAUhG,MAAM,CAAC,MAAM,wBAAwB,GAAG,2BAA2B,CAAA;AAEnE,MAAM,CAAC,MAAM,wBAAwB,GAAmB;IACtD,IAAI,EAAE,qBAAqB;IAC3B,eAAe,EAAE,QAAQ;IACzB,WAAW,EAAE,EAAE;IACf,QAAQ,EAAE,EAAE;IAEZ,YAAY,CAAC,GAAG,EAAE,EAAE;QAClB,oDAAoD;QACpD,kEAAkE;QAClE,gEAAgE;QAChE,oDAAoD;QACpD,MAAM,SAAS,GAAG,+BAA+B,CAAC,EAAE,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;QAClE,MAAM,MAAM,GAAG,mBAAmB,CAAC,SAAS,CAAC,EAAE,EAAE,GAAG,CAAC,OAAO,CAAC,CAAA;QAE7D,8DAA8D;QAC9D,gEAAgE;QAChE,4BAA4B;QAC5B,GAAG,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,wBAAwB,EAAE;YACnD,0BAA0B,EAAE,SAAS,CAAC,QAAQ;SACrB,CAAC,CAAA;QAE5B,OAAO,MAAM,CAAA;IACf,CAAC;CACF,CAAA","sourcesContent":["// `binding-descriptors` — agent-runtime hook tagging. Pre-transform\n// CompilerModule wrapping `tagDispatchHandlers` + `injectScopeVariantRegistrations`.\n//\n// Both functions mutate the AST in ways the visitor model can't\n// cleanly express:\n//   - `tagDispatchHandlers`: walks every arrow/fn expression, wraps\n//     those whose body contains `send({type:'X'})` with\n//     `Object.assign(arrow, {__lluiVariants: ['X']})`. The visitor\n//     pattern records findings but doesn't rewrite; rewriting is what\n//     this pass does.\n//   - `injectScopeVariantRegistrations`: walks for `*.connect(get,\n//     send, ...)` call sites and inserts `__registerScopeVariants([...])`\n//     adjacent statements. The visitor pattern can't insert siblings\n//     into the source file at arbitrary positions.\n//\n// Both are pre-passes — they produce a rewritten SourceFile that the\n// main visitor walks. v2c §2.1's \"walker runs once per file\" invariant\n// is preserved: the VISITOR walk runs once. preTransform passes are\n// additional but typically cheap and targeted.\n//\n// The `injected` flag from `injectScopeVariantRegistrations` is\n// surfaced via a shared analysis slot — the umbrella's\n// `cleanupImports` reads it to know whether to add the\n// `__registerScopeVariants` runtime helper to the @llui/dom imports.\n\nimport { tagDispatchHandlers, injectScopeVariantRegistrations } from '../binding-descriptors.js'\nimport type { CompilerModule } from '../module.js'\n\ninterface BindingDescriptorsSlot {\n  /** Whether `injectScopeVariantRegistrations` actually inserted any\n   *  call sites — drives import-cleanup's decision about the\n   *  `__registerScopeVariants` runtime helper. */\n  scopeRegistrationsInjected: boolean\n}\n\nexport const BINDING_DESCRIPTORS_SLOT = 'binding-descriptors:state'\n\nexport const bindingDescriptorsModule: CompilerModule = {\n  name: 'binding-descriptors',\n  compilerVersion: '^0.3.0',\n  diagnostics: [],\n  visitors: {},\n\n  preTransform(ctx, sf) {\n    // injectScopeVariantRegistrations runs FIRST so its\n    // `collectLocalFns` resolver still sees raw arrow initializers in\n    // const declarations (the universal tagger below replaces those\n    // initializers with `Object.assign(...)` wrappers).\n    const injection = injectScopeVariantRegistrations(sf, ctx.factory)\n    const tagged = tagDispatchHandlers(injection.sf, ctx.factory)\n\n    // Surface the injected flag for the umbrella's cleanupImports\n    // pass. The umbrella reads this from `analysis.perModule` after\n    // `registry.run()` returns.\n    ctx.analysis.perModule.set(BINDING_DESCRIPTORS_SLOT, {\n      scopeRegistrationsInjected: injection.injected,\n    } as BindingDescriptorsSlot)\n\n    return tagged\n  },\n}\n"]}

package/dist/modules/bitmask-overflow.d.ts

@@ -0,0 +1,3 @@
+import type { CompilerModule } from '../module.js';
+export declare function bitmaskOverflowModule(): CompilerModule;
+//# sourceMappingURL=bitmask-overflow.d.ts.map

package/dist/modules/bitmask-overflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitmask-overflow.d.ts","sourceRoot":"","sources":["../../src/modules/bitmask-overflow.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAgDlD,wBAAgB,qBAAqB,IAAI,cAAc,CAqFtD"}

package/dist/modules/bitmask-overflow.js

@@ -0,0 +1,152 @@
+// `bitmask-overflow` — errors when a component reads more than 62 unique
+// state paths. The runtime bitmask is two 31-bit words (`mask` 0..30,
+// `maskHi` 31..61); paths past the 62-path limit collapse to FULL_MASK
+// (-1) and re-evaluate every binding on change, negating the optimization.
+//
+// Migrated from `@llui/eslint-plugin`'s bitmask-overflow rule
+// (v0.x). Promoted to a compiler error (was an ESLint warning) so the
+// LLM-first authoring path cannot silently ship overflowing components.
+// LLMs ignore warnings; the compiler-error channel is non-bypassable.
+//
+// The diagnostic message includes:
+//   - the per-top-level-field breakdown so authors know where to slice,
+//   - a co-occurrence note for fields whose every sub-path always fires
+//     in the same accessor sets (those collapse to one bit if the parent
+//     object is read as a unit),
+//   - a recommendation to restructure state so the most-read paths
+//     collapse to fewer top-level prefixes, or to factor the offending
+//     subtree into a subApp.
+//
+// Anchors the diagnostic on the file's first `component(...)` call so
+// the location is meaningful. Files without a `component()` call are
+// silent — utility modules that happen to read state-shaped accessors
+// don't trigger the rule.
+import ts from 'typescript';
+import { collectAccessorPathSets, collectStatePathsFromSource } from '../collect-deps.js';
+import { rangeFromOffsets } from '../diagnostic.js';
+import { findComponentCalls } from './_shared.js';
+const PATH_LIMIT = 62;
+function setsEqual(a, b) {
+    if (a.size !== b.size)
+        return false;
+    for (const x of a)
+        if (!b.has(x))
+            return false;
+    return true;
+}
+function findCooccurringFields(paths, accessorSets) {
+    const subPathsByTop = new Map();
+    for (const p of paths) {
+        const dot = p.indexOf('.');
+        if (dot < 0)
+            continue;
+        const top = p.slice(0, dot);
+        const arr = subPathsByTop.get(top) ?? [];
+        arr.push(p);
+        subPathsByTop.set(top, arr);
+    }
+    const appearances = new Map();
+    for (let i = 0; i < accessorSets.length; i++) {
+        for (const path of accessorSets[i]) {
+            if (!appearances.has(path))
+                appearances.set(path, new Set());
+            appearances.get(path).add(i);
+        }
+    }
+    const out = [];
+    for (const [field, subPaths] of subPathsByTop) {
+        if (subPaths.length < 2)
+            continue;
+        const first = appearances.get(subPaths[0]) ?? new Set();
+        let uniform = true;
+        for (let i = 1; i < subPaths.length; i++) {
+            const set = appearances.get(subPaths[i]) ?? new Set();
+            if (!setsEqual(first, set)) {
+                uniform = false;
+                break;
+            }
+        }
+        if (uniform)
+            out.push({ field, saved: subPaths.length - 1 });
+    }
+    return out.sort((a, b) => b.saved - a.saved);
+}
+export function bitmaskOverflowModule() {
+    return {
+        name: 'bitmask-overflow',
+        compilerVersion: '^0.3.0',
+        diagnostics: [
+            {
+                id: 'llui/bitmask-overflow',
+                description: 'Component reads more than 62 unique state paths — paths past the limit fall back to FULL_MASK.',
+            },
+        ],
+        visitors: {
+            [ts.SyntaxKind.SourceFile]: (ctx, node) => {
+                const visited = node;
+                // Re-parse from text. PreTransform passes (e.g.
+                // `bindingDescriptorsModule` in agent mode) produce synthetic
+                // AST nodes that lack parent pointers; `collectStatePathsFromSource`
+                // walks parent chains and crashes on undefined. Re-parsing
+                // guarantees a clean tree with `setParentNodes=true` — the
+                // analysis is over the user's source, which is what we want
+                // regardless of upstream rewrites.
+                const sf = ts.createSourceFile(visited.fileName, visited.text, ts.ScriptTarget.Latest, true);
+                const componentCalls = findComponentCalls(sf);
+                if (componentCalls.length === 0)
+                    return;
+                const componentCall = componentCalls[0];
+                const paths = collectStatePathsFromSource(sf);
+                const pathCount = paths.size;
+                if (pathCount <= PATH_LIMIT)
+                    return;
+                const overflow = pathCount - PATH_LIMIT;
+                const byTopLevel = new Map();
+                for (const p of paths) {
+                    const top = p.split('.', 1)[0];
+                    byTopLevel.set(top, (byTopLevel.get(top) ?? 0) + 1);
+                }
+                const sorted = [...byTopLevel.entries()].sort((a, b) => b[1] - a[1]);
+                const candidates = [];
+                let saved = 0;
+                for (const [field, n] of sorted) {
+                    if (pathCount - saved <= 31)
+                        break;
+                    candidates.push(field);
+                    saved += n;
+                }
+                const breakdown = sorted.map(([field, n]) => `${field} (${n})`).join(', ');
+                const candidateList = candidates.map((f) => `\`${f}\``).join(', ');
+                const accessorSets = collectAccessorPathSets(sf);
+                const cooccurring = findCooccurringFields(paths, accessorSets);
+                const cooccurrenceNote = cooccurring.length > 0
+                    ? `\n\nCo-occurrence detected: ` +
+                        cooccurring
+                            .map(({ field, saved: s }) => `every sub-path under \`${field}\` always fires together; reading \`s.${field}\` as one unit saves ${s} bit${s === 1 ? '' : 's'}`)
+                            .join('; ') +
+                        `. Bundle those reads into a single \`s.${cooccurring[0].field}\` access (e.g. \`const ${cooccurring[0].field} = s.${cooccurring[0].field}\`) before extraction — cheaper refactor, same budget relief.`
+                    : '';
+                const message = `Component has ${pathCount} unique state access paths (${overflow} past the ${PATH_LIMIT}-path limit). ` +
+                    `Paths ${PATH_LIMIT + 1}..${pathCount} fall back to FULL_MASK — their changes re-evaluate every binding ` +
+                    `in the component, negating the bitmask optimization for those updates.\n\n` +
+                    `Top-level fields by path count: ${breakdown}.${cooccurrenceNote}\n\n` +
+                    `Recommended fix: restructure state so ${candidateList} are grouped under one or two ` +
+                    `reference-stable parents, or factor that subtree into a separate module that consumes ` +
+                    `the parent's state via the standard view-function \`(props, send)\` convention. ` +
+                    `Alternative: use \`combine()\` to split the reducer into slices when the parent's \`update()\` ` +
+                    `is mostly mechanical routing.`;
+                ctx.reportDiagnostic({
+                    id: 'llui/bitmask-overflow',
+                    severity: 'error',
+                    category: 'perf',
+                    message,
+                    location: {
+                        file: sf.fileName,
+                        range: rangeFromOffsets(sf.text, componentCall.getStart(sf), componentCall.getEnd()),
+                    },
+                });
+            },
+        },
+    };
+}
+//# sourceMappingURL=bitmask-overflow.js.map

package/dist/modules/bitmask-overflow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitmask-overflow.js","sourceRoot":"","sources":["../../src/modules/bitmask-overflow.ts"],"names":[],"mappings":"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","sourcesContent":["// `bitmask-overflow` — errors when a component reads more than 62 unique\n// state paths. The runtime bitmask is two 31-bit words (`mask` 0..30,\n// `maskHi` 31..61); paths past the 62-path limit collapse to FULL_MASK\n// (-1) and re-evaluate every binding on change, negating the optimization.\n//\n// Migrated from `@llui/eslint-plugin`'s bitmask-overflow rule\n// (v0.x). Promoted to a compiler error (was an ESLint warning) so the\n// LLM-first authoring path cannot silently ship overflowing components.\n// LLMs ignore warnings; the compiler-error channel is non-bypassable.\n//\n// The diagnostic message includes:\n//   - the per-top-level-field breakdown so authors know where to slice,\n//   - a co-occurrence note for fields whose every sub-path always fires\n//     in the same accessor sets (those collapse to one bit if the parent\n//     object is read as a unit),\n//   - a recommendation to restructure state so the most-read paths\n//     collapse to fewer top-level prefixes, or to factor the offending\n//     subtree into a subApp.\n//\n// Anchors the diagnostic on the file's first `component(...)` call so\n// the location is meaningful. Files without a `component()` call are\n// silent — utility modules that happen to read state-shaped accessors\n// don't trigger the rule.\n\nimport ts from 'typescript'\nimport { collectAccessorPathSets, collectStatePathsFromSource } from '../collect-deps.js'\nimport { rangeFromOffsets } from '../diagnostic.js'\nimport type { CompilerModule } from '../module.js'\nimport { findComponentCalls } from './_shared.js'\n\nconst PATH_LIMIT = 62\n\nfunction setsEqual<T>(a: Set<T>, b: Set<T>): boolean {\n  if (a.size !== b.size) return false\n  for (const x of a) if (!b.has(x)) return false\n  return true\n}\n\nfunction findCooccurringFields(\n  paths: Set<string>,\n  accessorSets: Set<string>[],\n): Array<{ field: string; saved: number }> {\n  const subPathsByTop = new Map<string, string[]>()\n  for (const p of paths) {\n    const dot = p.indexOf('.')\n    if (dot < 0) continue\n    const top = p.slice(0, dot)\n    const arr = subPathsByTop.get(top) ?? []\n    arr.push(p)\n    subPathsByTop.set(top, arr)\n  }\n  const appearances = new Map<string, Set<number>>()\n  for (let i = 0; i < accessorSets.length; i++) {\n    for (const path of accessorSets[i]!) {\n      if (!appearances.has(path)) appearances.set(path, new Set())\n      appearances.get(path)!.add(i)\n    }\n  }\n  const out: Array<{ field: string; saved: number }> = []\n  for (const [field, subPaths] of subPathsByTop) {\n    if (subPaths.length < 2) continue\n    const first = appearances.get(subPaths[0]!) ?? new Set<number>()\n    let uniform = true\n    for (let i = 1; i < subPaths.length; i++) {\n      const set = appearances.get(subPaths[i]!) ?? new Set<number>()\n      if (!setsEqual(first, set)) {\n        uniform = false\n        break\n      }\n    }\n    if (uniform) out.push({ field, saved: subPaths.length - 1 })\n  }\n  return out.sort((a, b) => b.saved - a.saved)\n}\n\nexport function bitmaskOverflowModule(): CompilerModule {\n  return {\n    name: 'bitmask-overflow',\n    compilerVersion: '^0.3.0',\n    diagnostics: [\n      {\n        id: 'llui/bitmask-overflow',\n        description:\n          'Component reads more than 62 unique state paths — paths past the limit fall back to FULL_MASK.',\n      },\n    ],\n    visitors: {\n      [ts.SyntaxKind.SourceFile]: (ctx, node) => {\n        const visited = node as ts.SourceFile\n        // Re-parse from text. PreTransform passes (e.g.\n        // `bindingDescriptorsModule` in agent mode) produce synthetic\n        // AST nodes that lack parent pointers; `collectStatePathsFromSource`\n        // walks parent chains and crashes on undefined. Re-parsing\n        // guarantees a clean tree with `setParentNodes=true` — the\n        // analysis is over the user's source, which is what we want\n        // regardless of upstream rewrites.\n        const sf = ts.createSourceFile(visited.fileName, visited.text, ts.ScriptTarget.Latest, true)\n        const componentCalls = findComponentCalls(sf)\n        if (componentCalls.length === 0) return\n        const componentCall = componentCalls[0]!\n\n        const paths = collectStatePathsFromSource(sf)\n        const pathCount = paths.size\n        if (pathCount <= PATH_LIMIT) return\n\n        const overflow = pathCount - PATH_LIMIT\n        const byTopLevel = new Map<string, number>()\n        for (const p of paths) {\n          const top = p.split('.', 1)[0]!\n          byTopLevel.set(top, (byTopLevel.get(top) ?? 0) + 1)\n        }\n        const sorted = [...byTopLevel.entries()].sort((a, b) => b[1] - a[1])\n        const candidates: string[] = []\n        let saved = 0\n        for (const [field, n] of sorted) {\n          if (pathCount - saved <= 31) break\n          candidates.push(field)\n          saved += n\n        }\n        const breakdown = sorted.map(([field, n]) => `${field} (${n})`).join(', ')\n        const candidateList = candidates.map((f) => `\\`${f}\\``).join(', ')\n\n        const accessorSets = collectAccessorPathSets(sf)\n        const cooccurring = findCooccurringFields(paths, accessorSets)\n        const cooccurrenceNote =\n          cooccurring.length > 0\n            ? `\\n\\nCo-occurrence detected: ` +\n              cooccurring\n                .map(\n                  ({ field, saved: s }) =>\n                    `every sub-path under \\`${field}\\` always fires together; reading \\`s.${field}\\` as one unit saves ${s} bit${s === 1 ? '' : 's'}`,\n                )\n                .join('; ') +\n              `. Bundle those reads into a single \\`s.${cooccurring[0]!.field}\\` access (e.g. \\`const ${cooccurring[0]!.field} = s.${cooccurring[0]!.field}\\`) before extraction — cheaper refactor, same budget relief.`\n            : ''\n\n        const message =\n          `Component has ${pathCount} unique state access paths (${overflow} past the ${PATH_LIMIT}-path limit). ` +\n          `Paths ${PATH_LIMIT + 1}..${pathCount} fall back to FULL_MASK — their changes re-evaluate every binding ` +\n          `in the component, negating the bitmask optimization for those updates.\\n\\n` +\n          `Top-level fields by path count: ${breakdown}.${cooccurrenceNote}\\n\\n` +\n          `Recommended fix: restructure state so ${candidateList} are grouped under one or two ` +\n          `reference-stable parents, or factor that subtree into a separate module that consumes ` +\n          `the parent's state via the standard view-function \\`(props, send)\\` convention. ` +\n          `Alternative: use \\`combine()\\` to split the reducer into slices when the parent's \\`update()\\` ` +\n          `is mostly mechanical routing.`\n\n        ctx.reportDiagnostic({\n          id: 'llui/bitmask-overflow',\n          severity: 'error',\n          category: 'perf',\n          message,\n          location: {\n            file: sf.fileName,\n            range: rangeFromOffsets(sf.text, componentCall.getStart(sf), componentCall.getEnd()),\n          },\n        })\n      },\n    },\n  }\n}\n"]}

package/dist/modules/compiler-stamp.d.ts

@@ -0,0 +1,3 @@
+import type { CompilerModule } from '../module.js';
+export declare const compilerStampModule: CompilerModule;
+//# sourceMappingURL=compiler-stamp.d.ts.map

package/dist/modules/compiler-stamp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler-stamp.d.ts","sourceRoot":"","sources":["../../src/modules/compiler-stamp.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,cAAc,EAAwB,MAAM,cAAc,CAAA;AAGxE,eAAO,MAAM,mBAAmB,EAAE,cA0BjC,CAAA"}

package/dist/modules/compiler-stamp.js

@@ -0,0 +1,44 @@
+// `compiler-stamp` — emits the umbrella-level integrity marker on
+// every compiled `component()` call:
+//
+//   - `__lluiCompilerEmitted: 1` — the marker scanned by the Vite
+//     adapter's closeBundle integrity check. A bundled component
+//     missing this property indicates the LLui transform was skipped
+//     for that file, which is a hard build error.
+//   - `__compilerVersion: '<semver>'` — the runtime contract version
+//     (v2a §2.4 / v2b §5). The runtime gates feature-detection on
+//     this; a missing version falls back to `genericUpdate`
+//     (FULL_MASK) with a console warning.
+//
+// Per-target emission so each `component()` call in a multi-component
+// file gets its own pair. Always-on regardless of agent/dev mode —
+// no activation gate. This is the umbrella's mandatory module.
+import { COMPILER_VERSION } from '../version.js';
+import { findComponentCalls } from './_shared.js';
+export const compilerStampModule = {
+    name: 'compiler-stamp',
+    compilerVersion: '^0.3.0',
+    diagnostics: [],
+    // Targets captured in `emit` — see `_shared.ts`.
+    visitors: {},
+    emit(ctx, analysis) {
+        const f = ctx.factory;
+        const contributions = [];
+        for (const n of findComponentCalls(analysis.sourceFile)) {
+            contributions.push({
+                module: 'compiler-stamp',
+                field: '__lluiCompilerEmitted',
+                value: f.createNumericLiteral(1),
+                target: n,
+            });
+            contributions.push({
+                module: 'compiler-stamp',
+                field: '__compilerVersion',
+                value: f.createStringLiteral(COMPILER_VERSION),
+                target: n,
+            });
+        }
+        return contributions;
+    },
+};
+//# sourceMappingURL=compiler-stamp.js.map

package/dist/modules/compiler-stamp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compiler-stamp.js","sourceRoot":"","sources":["../../src/modules/compiler-stamp.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,qCAAqC;AACrC,EAAE;AACF,kEAAkE;AAClE,iEAAiE;AACjE,qEAAqE;AACrE,kDAAkD;AAClD,qEAAqE;AACrE,kEAAkE;AAClE,4DAA4D;AAC5D,0CAA0C;AAC1C,EAAE;AACF,sEAAsE;AACtE,mEAAmE;AACnE,+DAA+D;AAE/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAEhD,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAEjD,MAAM,CAAC,MAAM,mBAAmB,GAAmB;IACjD,IAAI,EAAE,gBAAgB;IACtB,eAAe,EAAE,QAAQ;IACzB,WAAW,EAAE,EAAE;IACf,iDAAiD;IACjD,QAAQ,EAAE,EAAE;IAEZ,IAAI,CAAC,GAAG,EAAE,QAAQ;QAChB,MAAM,CAAC,GAAG,GAAG,CAAC,OAAO,CAAA;QACrB,MAAM,aAAa,GAA2B,EAAE,CAAA;QAChD,KAAK,MAAM,CAAC,IAAI,kBAAkB,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;YACxD,aAAa,CAAC,IAAI,CAAC;gBACjB,MAAM,EAAE,gBAAgB;gBACxB,KAAK,EAAE,uBAAuB;gBAC9B,KAAK,EAAE,CAAC,CAAC,oBAAoB,CAAC,CAAC,CAAC;gBAChC,MAAM,EAAE,CAAC;aACV,CAAC,CAAA;YACF,aAAa,CAAC,IAAI,CAAC;gBACjB,MAAM,EAAE,gBAAgB;gBACxB,KAAK,EAAE,mBAAmB;gBAC1B,KAAK,EAAE,CAAC,CAAC,mBAAmB,CAAC,gBAAgB,CAAC;gBAC9C,MAAM,EAAE,CAAC;aACV,CAAC,CAAA;QACJ,CAAC;QACD,OAAO,aAAa,CAAA;IACtB,CAAC;CACF,CAAA","sourcesContent":["// `compiler-stamp` — emits the umbrella-level integrity marker on\n// every compiled `component()` call:\n//\n//   - `__lluiCompilerEmitted: 1` — the marker scanned by the Vite\n//     adapter's closeBundle integrity check. A bundled component\n//     missing this property indicates the LLui transform was skipped\n//     for that file, which is a hard build error.\n//   - `__compilerVersion: '<semver>'` — the runtime contract version\n//     (v2a §2.4 / v2b §5). The runtime gates feature-detection on\n//     this; a missing version falls back to `genericUpdate`\n//     (FULL_MASK) with a console warning.\n//\n// Per-target emission so each `component()` call in a multi-component\n// file gets its own pair. Always-on regardless of agent/dev mode —\n// no activation gate. This is the umbrella's mandatory module.\n\nimport { COMPILER_VERSION } from '../version.js'\nimport type { CompilerModule, EmissionContribution } from '../module.js'\nimport { findComponentCalls } from './_shared.js'\n\nexport const compilerStampModule: CompilerModule = {\n  name: 'compiler-stamp',\n  compilerVersion: '^0.3.0',\n  diagnostics: [],\n  // Targets captured in `emit` — see `_shared.ts`.\n  visitors: {},\n\n  emit(ctx, analysis) {\n    const f = ctx.factory\n    const contributions: EmissionContribution[] = []\n    for (const n of findComponentCalls(analysis.sourceFile)) {\n      contributions.push({\n        module: 'compiler-stamp',\n        field: '__lluiCompilerEmitted',\n        value: f.createNumericLiteral(1),\n        target: n,\n      })\n      contributions.push({\n        module: 'compiler-stamp',\n        field: '__compilerVersion',\n        value: f.createStringLiteral(COMPILER_VERSION),\n        target: n,\n      })\n    }\n    return contributions\n  },\n}\n"]}

package/dist/modules/component-meta.d.ts

@@ -0,0 +1,3 @@
+import type { CompilerModule } from '../module.js';
+export declare const componentMetaModule: CompilerModule;
+//# sourceMappingURL=component-meta.d.ts.map

package/dist/modules/component-meta.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-meta.d.ts","sourceRoot":"","sources":["../../src/modules/component-meta.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,cAAc,EAAwB,MAAM,cAAc,CAAA;AAGxE,eAAO,MAAM,mBAAmB,EAAE,cAoCjC,CAAA"}

package/dist/modules/component-meta.js

@@ -0,0 +1,44 @@
+// `component-meta` — emits `__componentMeta: { file, line }` per
+// `component()` call. Today's `injectComponentMeta` in transform.ts
+// is gated on devMode; this module keeps the gating semantics by
+// accepting an option (the umbrella passes `devMode` through).
+//
+// This is the first per-component-targeted emission in the registry.
+// It validates the `EmissionContribution.target` shape (v2c §7.9
+// finding from the schema-hash POC): when multiple `component()`
+// calls live in one file, each gets its own `__componentMeta` with
+// its own line number, and the conflict-detector lets each emission
+// through because the `(field, target)` tuples are distinct.
+import { findComponentCalls } from './_shared.js';
+export const componentMetaModule = {
+    name: 'component-meta',
+    compilerVersion: '^0.3.0',
+    diagnostics: [],
+    // Targets captured in `emit` (not `visit`) — see `_shared.ts`
+    // `findComponentCalls` for the rationale (Phase 2b rebuilds
+    // ancestor nodes, invalidating visit-captured refs).
+    visitors: {},
+    emit(ctx, analysis) {
+        const sf = analysis.sourceFile;
+        const calls = findComponentCalls(sf);
+        if (calls.length === 0)
+            return [];
+        const out = [];
+        for (const n of calls) {
+            const pos = n.pos >= 0 ? n.getStart(sf) : 0;
+            const { line } = sf.getLineAndCharacterOfPosition(pos);
+            const meta = ctx.factory.createObjectLiteralExpression([
+                ctx.factory.createPropertyAssignment('file', ctx.factory.createStringLiteral(sf.fileName)),
+                ctx.factory.createPropertyAssignment('line', ctx.factory.createNumericLiteral(line + 1)),
+            ], false);
+            out.push({
+                module: 'component-meta',
+                field: '__componentMeta',
+                value: meta,
+                target: n,
+            });
+        }
+        return out;
+    },
+};
+//# sourceMappingURL=component-meta.js.map

package/dist/modules/component-meta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-meta.js","sourceRoot":"","sources":["../../src/modules/component-meta.ts"],"names":[],"mappings":"AAAA,iEAAiE;AACjE,oEAAoE;AACpE,iEAAiE;AACjE,+DAA+D;AAC/D,EAAE;AACF,qEAAqE;AACrE,iEAAiE;AACjE,iEAAiE;AACjE,mEAAmE;AACnE,oEAAoE;AACpE,6DAA6D;AAG7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAEjD,MAAM,CAAC,MAAM,mBAAmB,GAAmB;IACjD,IAAI,EAAE,gBAAgB;IACtB,eAAe,EAAE,QAAQ;IACzB,WAAW,EAAE,EAAE;IACf,8DAA8D;IAC9D,4DAA4D;IAC5D,qDAAqD;IACrD,QAAQ,EAAE,EAAE;IAEZ,IAAI,CAAC,GAAG,EAAE,QAAQ;QAChB,MAAM,EAAE,GAAG,QAAQ,CAAC,UAAU,CAAA;QAC9B,MAAM,KAAK,GAAG,kBAAkB,CAAC,EAAE,CAAC,CAAA;QACpC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,EAAE,CAAA;QACjC,MAAM,GAAG,GAA2B,EAAE,CAAA;QACtC,KAAK,MAAM,CAAC,IAAI,KAAK,EAAE,CAAC;YACtB,MAAM,GAAG,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;YAC3C,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,CAAC,6BAA6B,CAAC,GAAG,CAAC,CAAA;YACtD,MAAM,IAAI,GAAG,GAAG,CAAC,OAAO,CAAC,6BAA6B,CACpD;gBACE,GAAG,CAAC,OAAO,CAAC,wBAAwB,CAClC,MAAM,EACN,GAAG,CAAC,OAAO,CAAC,mBAAmB,CAAC,EAAE,CAAC,QAAQ,CAAC,CAC7C;gBACD,GAAG,CAAC,OAAO,CAAC,wBAAwB,CAAC,MAAM,EAAE,GAAG,CAAC,OAAO,CAAC,oBAAoB,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC;aACzF,EACD,KAAK,CACN,CAAA;YACD,GAAG,CAAC,IAAI,CAAC;gBACP,MAAM,EAAE,gBAAgB;gBACxB,KAAK,EAAE,iBAAiB;gBACxB,KAAK,EAAE,IAAI;gBACX,MAAM,EAAE,CAAC;aACV,CAAC,CAAA;QACJ,CAAC;QACD,OAAO,GAAG,CAAA;IACZ,CAAC;CACF,CAAA","sourcesContent":["// `component-meta` — emits `__componentMeta: { file, line }` per\n// `component()` call. Today's `injectComponentMeta` in transform.ts\n// is gated on devMode; this module keeps the gating semantics by\n// accepting an option (the umbrella passes `devMode` through).\n//\n// This is the first per-component-targeted emission in the registry.\n// It validates the `EmissionContribution.target` shape (v2c §7.9\n// finding from the schema-hash POC): when multiple `component()`\n// calls live in one file, each gets its own `__componentMeta` with\n// its own line number, and the conflict-detector lets each emission\n// through because the `(field, target)` tuples are distinct.\n\nimport type { CompilerModule, EmissionContribution } from '../module.js'\nimport { findComponentCalls } from './_shared.js'\n\nexport const componentMetaModule: CompilerModule = {\n  name: 'component-meta',\n  compilerVersion: '^0.3.0',\n  diagnostics: [],\n  // Targets captured in `emit` (not `visit`) — see `_shared.ts`\n  // `findComponentCalls` for the rationale (Phase 2b rebuilds\n  // ancestor nodes, invalidating visit-captured refs).\n  visitors: {},\n\n  emit(ctx, analysis): EmissionContribution[] {\n    const sf = analysis.sourceFile\n    const calls = findComponentCalls(sf)\n    if (calls.length === 0) return []\n    const out: EmissionContribution[] = []\n    for (const n of calls) {\n      const pos = n.pos >= 0 ? n.getStart(sf) : 0\n      const { line } = sf.getLineAndCharacterOfPosition(pos)\n      const meta = ctx.factory.createObjectLiteralExpression(\n        [\n          ctx.factory.createPropertyAssignment(\n            'file',\n            ctx.factory.createStringLiteral(sf.fileName),\n          ),\n          ctx.factory.createPropertyAssignment('line', ctx.factory.createNumericLiteral(line + 1)),\n        ],\n        false,\n      )\n      out.push({\n        module: 'component-meta',\n        field: '__componentMeta',\n        value: meta,\n        target: n,\n      })\n    }\n    return out\n  },\n}\n"]}

package/dist/modules/controlled-input.d.ts

@@ -0,0 +1,3 @@
+import type { CompilerModule } from '../module.js';
+export declare function controlledInputModule(): CompilerModule;
+//# sourceMappingURL=controlled-input.d.ts.map

package/dist/modules/controlled-input.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controlled-input.d.ts","sourceRoot":"","sources":["../../src/modules/controlled-input.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAalD,wBAAgB,qBAAqB,IAAI,cAAc,CAoDtD"}