@llui/compiler 0.3.0

package/dist/transform.js

@@ -0,0 +1,1390 @@
+import ts from 'typescript';
+import { collectDeps } from './collect-deps.js';
+import { resolveAccessorBody } from './accessor-resolver.js';
+import { extractMsgSchema, extractEffectSchema } from './msg-schema.js';
+import { extractMsgAnnotations } from './msg-annotations.js';
+import { extractStateSchema } from './state-schema.js';
+// `computeSchemaHash` no longer imported here — `schemaHashModule` owns
+// the __schemaHash emission. See modules/schema-hash.ts.
+// `tagDispatchHandlers` + `injectScopeVariantRegistrations` are now
+// consumed by `bindingDescriptorsModule` via the registry's preTransform
+// hook — no longer imported here. See modules/binding-descriptors.ts.
+import { compilerCache } from './compiler-cache.js';
+import { ModuleRegistry } from './module.js';
+// Introspection modules (v2c/decomp-26) and devtools modules
+// (v2c/decomp-27) moved to their sibling packages. Hosts register
+// factories via `registerIntrospectionFactory` / `registerDevtoolsFactory`;
+// transformLlui invokes them via the getters when their respective
+// modes are active. BINDING_DESCRIPTORS_SLOT is re-exported from
+// introspection-factory.ts as a string constant so the orchestrator
+// can read the slot without importing the sibling package.
+import { getIntrospectionFactory, getDevtoolsFactory, BINDING_DESCRIPTORS_SLOT, } from './introspection-factory.js';
+import { maskLegendModule } from './modules/mask-legend.js';
+import { compilerStampModule } from './modules/compiler-stamp.js';
+import { eachMemoModule, EACH_MEMO_SLOT } from './modules/each-memo.js';
+import { structuralMaskModule } from './modules/structural-mask.js';
+import { textMaskModule } from './modules/text-mask.js';
+import { itemDedupModule } from './modules/item-dedup.js';
+import { elementRewriteModule, ELEMENT_REWRITE_SLOT, } from './modules/element-rewrite.js';
+import { rowFactoryModule } from './modules/row-factory.js';
+import { coreSynthesisModule, CORE_SYNTHESIS_SLOT, } from './modules/core-synthesis.js';
+import { bitmaskOverflowModule } from './modules/bitmask-overflow.js';
+import { asyncUpdateModule } from './modules/async-update.js';
+import { mapOnStateArrayModule } from './modules/map-on-state-array.js';
+import { nestedSendInUpdateModule } from './modules/nested-send-in-update.js';
+import { directStateInViewModule } from './modules/direct-state-in-view.js';
+import { imperativeDomInViewModule } from './modules/imperative-dom-in-view.js';
+import { accessorSideEffectModule } from './modules/accessor-side-effect.js';
+import { stateMutationModule } from './modules/state-mutation.js';
+import { effectWithoutHandlerModule } from './modules/effect-without-handler.js';
+import { exhaustiveEffectHandlingModule } from './modules/exhaustive-effect-handling.js';
+import { noEagerItemAccessorModule } from './modules/no-eager-item-accessor.js';
+import { pureUpdateFunctionModule } from './modules/pure-update-function.js';
+import { exhaustiveUpdateModule } from './modules/exhaustive-update.js';
+import { noLetReactiveAccessorModule } from './modules/no-let-reactive-accessor.js';
+import { eachClosureViolationModule } from './modules/each-closure-violation.js';
+import { stringEffectCallbackModule } from './modules/string-effect-callback.js';
+import { agentMissingIntentModule } from './modules/agent-missing-intent.js';
+import { agentWarningOnConfirmModule } from './modules/agent-warning-on-confirm.js';
+import { agentExampleOnPayloadModule } from './modules/agent-example-on-payload.js';
+import { agentExclusiveAnnotationsModule } from './modules/agent-exclusive-annotations.js';
+import { agentOptionalFieldUndocumentedModule } from './modules/agent-optional-field-undocumented.js';
+import { agentTagsendTranslatorMissingModule } from './modules/agent-tagsend-translator-missing.js';
+import { agentNonextractableHandlerModule } from './modules/agent-nonextractable-handler.js';
+import { subappRequiresReasonModule } from './modules/subapp-requires-reason.js';
+import { emptyPropsModule } from './modules/empty-props.js';
+import { forgottenSpreadModule } from './modules/forgotten-spread.js';
+import { accessibilityModule } from './modules/accessibility.js';
+import { viewBagImportModule } from './modules/view-bag-import.js';
+import { controlledInputModule } from './modules/controlled-input.js';
+import { missingMemoModule } from './modules/missing-memo.js';
+import { namespaceImportModule } from './modules/namespace-import.js';
+import { noBarrelImportWhenSubpathExistsModule } from './modules/no-barrel-import-when-subpath-exists.js';
+import { formBoilerplateModule } from './modules/form-boilerplate.js';
+import { spreadInChildrenModule } from './modules/spread-in-children.js';
+import { staticItemsModule } from './modules/static-items.js';
+import { staticOnModule } from './modules/static-on.js';
+import { noListRenderInSampleModule } from './modules/no-list-render-in-sample.js';
+import { noSampleInAccessorModule } from './modules/no-sample-in-accessor.js';
+import { noSampleInReactivePositionModule } from './modules/no-sample-in-reactive-position.js';
+import { agentEmitsDriftModule } from './modules/agent-emits-drift.js';
+import { agentMsgResolvableModule } from './modules/agent-msg-resolvable.js';
+export function createMaskLiteral(f, mask) {
+    if (mask >= 0)
+        return f.createNumericLiteral(mask);
+    // -1 (0xFFFFFFFF | 0) — emit as bitwise OR: 0xFFFFFFFF | 0
+    return f.createBinaryExpression(f.createNumericLiteral(0xffffffff), ts.SyntaxKind.BarToken, f.createNumericLiteral(0));
+}
+// HTML element helper names that the compiler can transform
+const ELEMENT_HELPERS = new Set([
+    'a',
+    'abbr',
+    'article',
+    'aside',
+    'b',
+    'blockquote',
+    'br',
+    'button',
+    'canvas',
+    'code',
+    'dd',
+    'details',
+    'dialog',
+    'div',
+    'dl',
+    'dt',
+    'em',
+    'fieldset',
+    'figcaption',
+    'figure',
+    'footer',
+    'form',
+    'h1',
+    'h2',
+    'h3',
+    'h4',
+    'h5',
+    'h6',
+    'header',
+    'hr',
+    'i',
+    'iframe',
+    'img',
+    'input',
+    'label',
+    'legend',
+    'li',
+    'main',
+    'mark',
+    'nav',
+    'ol',
+    'optgroup',
+    'option',
+    'output',
+    'p',
+    'pre',
+    'progress',
+    'section',
+    'select',
+    'small',
+    'span',
+    'strong',
+    'sub',
+    'summary',
+    'sup',
+    'table',
+    'tbody',
+    'td',
+    'textarea',
+    'tfoot',
+    'th',
+    'thead',
+    'time',
+    'tr',
+    'ul',
+    'video',
+]);
+export function transformLlui(source, _filename, devMode = false, emitAgentMetadata = false, mcpPort = 5200, verbose = false, typeSources, preExtracted, crossFilePaths) {
+    // Use the caller-provided filename so any module reading `sf.fileName`
+    // (e.g. `componentMetaModule` emitting `__componentMeta: { file }`)
+    // sees the real path instead of a placeholder. The monolith's inline
+    // `injectComponentMeta` used the `_filename` parameter directly; the
+    // bridge needs the same source via the AST node.
+    let sourceFile = ts.createSourceFile(_filename, source, ts.ScriptTarget.Latest, true);
+    // Find the @llui/dom import
+    const imp = findLluiImport(sourceFile);
+    if (!imp)
+        return null;
+    const lluiImport = imp;
+    // Collect imported element helper names (local → original)
+    const importedHelpers = getImportedHelpers(lluiImport);
+    // Previously: `if (importedHelpers.size === 0 && !hasReactiveAccessors(sourceFile)) return null`.
+    // Removed in lint-migration-8: lint-rule modules (namespace-import,
+    // form-boilerplate, etc.) need to fire on files whose only @llui/dom
+    // usage is a namespace import, a type-only import, or a Msg-union
+    // declaration — none of which produce element-helper or text/component
+    // call sites. The registry's per-file cost is small enough that running
+    // it on these files is fine; the late return-null still bails when
+    // there's no work to emit (no edits AND no diagnostics).
+    // Connect-pattern pass: detects `*.connect(get, sendFn, …)` call
+    // sites and inserts a runtime `__registerScopeVariants([...])`
+    // adjacent to each, with the variants statically extracted from the
+    // sendFn's body. Handles the dispatch-translation case at the
+    // syntactic level — handler propagation via `tagSend` covers the
+    // rest. 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).
+    //
+    // Universal handler-tagger pass: walks every arrow/function
+    // expression and wraps any whose body contains literal
+    // `send({type:'X'})` / `dispatch({type:'X'})` calls with
+    // `Object.assign(arrow, {__lluiVariants: ['X']})`. The runtime
+    // (`@llui/dom` `elements.ts` / `el-split.ts`) reads the tag from
+    // event-handler bindings only — so tags placed on functions in
+    // non-handler positions are runtime-inert. This deliberately covers
+    // three patterns at once:
+    //   • Inline event handlers (`onClick: () => send(...)`)
+    //   • Const-bound translators (`const sendMenu = (m) => dispatch(...)`)
+    //   • Positional-arg helpers (`navButton(label, () => dispatch(...))`)
+    //
+    // Both passes gated on dev/agent-metadata so production bundles
+    // without agent integration don't pay the per-handler `Object.assign`
+    // cost.
+    // Binding-descriptors pre-pass migrated to `bindingDescriptorsModule`
+    // via the registry's `preTransform` hook (v2c/decomp-7). The module
+    // wraps `injectScopeVariantRegistrations` + `tagDispatchHandlers` and
+    // runs inside `registry.run()` below — the resulting (post-transform)
+    // sourceFile is re-assigned from `registryResult.analysis.sourceFile`.
+    // `scopeRegistrationsInjected` reads from the module's slot after
+    // the registry run.
+    let scopeRegistrationsInjected = false;
+    // Pass 2 pre-scan: collect all state access paths
+    // Only use precise masks in files that define a component() — the __dirty
+    // function is generated per-component, so bit assignments in other files
+    // won't match. Files without component() get FULL_MASK on all bindings.
+    const fileHasComponent = hasComponentDef(sourceFile, lluiImport);
+    const { lo: fieldBits, hi: fieldBitsHi } = fileHasComponent
+        ? collectDeps(source, crossFilePaths)
+        : { lo: new Map(), hi: new Map() };
+    if (verbose && fileHasComponent) {
+        const pairs = [...fieldBits.entries()]
+            .map(([path, bit]) => `${path}=${bit === -1 ? 'FULL' : bit}`)
+            .join(', ');
+        console.info(`[llui] ${_filename}: ${fieldBits.size} reactive path${fieldBits.size === 1 ? '' : 's'}` +
+            (pairs.length > 0 ? ` — ${pairs}` : ''));
+    }
+    // Identifier names bound to the View<S,M> helpers parameter of a `view` callback.
+    // When the user writes `h.text(...)` / `h.show(...)` / `h.each(...)`, the
+    // compiler treats the call as if it were a bare import call.
+    const viewHelperNames = collectViewHelperNames(sourceFile, lluiImport);
+    // Destructured aliases: `view: (_, { show, text: t }) => [...]` → { show→show, t→text }.
+    const viewHelperAliases = collectViewHelperAliases(sourceFile, lluiImport, viewHelperNames);
+    // Track which helpers were compiled vs bailed out
+    const compiledHelpers = new Set();
+    const bailedHelpers = new Set();
+    let usesElTemplate = false;
+    let usesElSplit = false;
+    let usesMemo = false;
+    let usesApplyBinding = false;
+    let usesCloneStaticTemplate = false;
+    const f = ts.factory;
+    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+    // Collect source positions of transformed nodes for source mapping
+    const edits = [];
+    // ── Module registry (v2c §2) ────────────────────────────────────
+    //
+    // Active CompilerModules run as a single AST pass over the source
+    // before the main visitor; their emissions are spliced into the
+    // matching `component()` call's config-arg by `applyRegistryEmissions`
+    // alongside the monolith's inline `inject*` helpers. As modules
+    // incrementally absorb inline-injector concerns (`__componentMeta`,
+    // `__stateSchema` today, `__msgSchema` / `__msgAnnotations` /
+    // `__schemaHash` / `__prefixes` next), the matching inline call
+    // sites delete and the registry becomes the sole emission path.
+    //
+    // Module activation rules:
+    //   - `componentMetaModule` registers only in `devMode` (matches the
+    //     monolith's `if (devMode) injectComponentMeta(...)` gate).
+    //   - `stateSchemaModule` registers when `shouldEmitAgentMetadata`
+    //     (devMode OR emitAgentMetadata flag) — matches the monolith's
+    //     gating block at the inline-inject sites.
+    //   - All other agent modules are dormant in this push.
+    //
+    // When the registry is empty the bridge collapses to a no-op — the
+    // monolith's existing emissions continue to dominate.
+    const shouldEmitAgentMetadataAtToplevel = devMode || emitAgentMetadata;
+    // Pre-compute the state schema once per file. The monolith previously
+    // computed this inside the visitor's component() block (re-running
+    // per call site); since the inputs are file-level (typeSources,
+    // preExtracted, source) the result is identical across calls, so we
+    // hoist for the module-registration. The inline computation below
+    // (in the visitor's `if (shouldEmitAgentMetadata)` block) gets its
+    // value from this same variable.
+    const hoistedStateSchema = shouldEmitAgentMetadataAtToplevel
+        ? preExtracted?.stateSchema !== undefined
+            ? preExtracted.stateSchema
+            : extractStateSchema(typeSources?.state?.source ?? source, typeSources?.state?.typeName ?? 'State')
+        : null;
+    const hoistedMsgAnnotations = shouldEmitAgentMetadataAtToplevel
+        ? preExtracted?.msgAnnotations !== undefined
+            ? preExtracted.msgAnnotations
+            : extractMsgAnnotations(typeSources?.msg?.source ?? source, typeSources?.msg?.typeName ?? 'Msg')
+        : null;
+    const hoistedMsgSchema = shouldEmitAgentMetadataAtToplevel
+        ? preExtracted?.msgSchema !== undefined
+            ? preExtracted.msgSchema
+            : extractMsgSchema(typeSources?.msg?.source ?? source, typeSources?.msg?.typeName ?? 'Msg')
+        : null;
+    const hoistedEffectSchema = shouldEmitAgentMetadataAtToplevel
+        ? preExtracted?.effectSchema !== undefined
+            ? preExtracted.effectSchema
+            : extractEffectSchema(typeSources?.effect?.source ?? source, typeSources?.effect?.typeName ?? 'Effect')
+        : null;
+    const activeModules = [];
+    // Devtools modules (componentMeta + future trace instrumentation)
+    // live in @llui/compiler-devtools. The host registers the factory
+    // once via `registerDevtoolsFactory`; the factory gates on devMode
+    // and any future per-module flags.
+    const devtools = getDevtoolsFactory();
+    if (devtools) {
+        activeModules.push(...devtools({ sourceFile, devMode }));
+    }
+    // Introspection modules (binding-descriptors, msg-schema,
+    // state-schema, msg-annotations, schema-hash) live in
+    // @llui/compiler-introspection. The host registers the factory
+    // once via `registerIntrospectionFactory`. The factory itself
+    // decides which modules to activate based on
+    // `shouldEmitAgentMetadata`: producer modules + binding-descriptors
+    // run only in agent mode, but schemaHashModule runs always (HMR
+    // re-send gating uses it even in prod builds — spec §7.4).
+    const introspection = getIntrospectionFactory();
+    if (introspection) {
+        activeModules.push(...introspection({
+            sourceFile,
+            msgSchema: hoistedMsgSchema,
+            effectSchema: hoistedEffectSchema,
+            stateSchema: hoistedStateSchema,
+            msgAnnotations: hoistedMsgAnnotations,
+            shouldEmitAgentMetadata: shouldEmitAgentMetadataAtToplevel,
+        }));
+    }
+    // maskLegendModule registers whenever the file has any reactive paths.
+    // The module's own emit() gates on empty bit maps so registering
+    // here when fieldBits/fieldBitsHi are non-empty is sufficient.
+    if (fieldBits.size > 0 || fieldBitsHi.size > 0) {
+        activeModules.push(maskLegendModule({ fieldBits, fieldBitsHi }));
+    }
+    // compilerStampModule is unconditional — the integrity marker fires
+    // on every compiled `component()` call regardless of mode. Replaces
+    // the umbrella's last remaining inline injector
+    // (`injectCompilerEmittedMarker`, deleted below).
+    activeModules.push(compilerStampModule);
+    // bitmaskOverflowModule is always-on. Emits `llui/bitmask-overflow`
+    // (severity: error) when a component reads more than 62 unique state
+    // paths. Migrated from @llui/eslint-plugin (v0.x); promoted from
+    // ESLint warning to compiler error because LLMs ignore warnings.
+    activeModules.push(bitmaskOverflowModule());
+    // Correctness rules migrated from @llui/eslint-plugin as compile-time
+    // errors. LLM-first authoring requires non-bypassable correctness
+    // signals; ESLint warnings are silently ignored by LLM agents and
+    // may not even be installed in a downstream project.
+    activeModules.push(asyncUpdateModule());
+    activeModules.push(mapOnStateArrayModule());
+    activeModules.push(nestedSendInUpdateModule());
+    activeModules.push(directStateInViewModule());
+    activeModules.push(imperativeDomInViewModule());
+    activeModules.push(accessorSideEffectModule());
+    activeModules.push(stateMutationModule());
+    activeModules.push(effectWithoutHandlerModule());
+    activeModules.push(exhaustiveEffectHandlingModule());
+    activeModules.push(noEagerItemAccessorModule());
+    activeModules.push(pureUpdateFunctionModule());
+    activeModules.push(exhaustiveUpdateModule());
+    activeModules.push(noLetReactiveAccessorModule());
+    activeModules.push(eachClosureViolationModule());
+    activeModules.push(stringEffectCallbackModule());
+    activeModules.push(agentMissingIntentModule());
+    activeModules.push(agentWarningOnConfirmModule());
+    activeModules.push(agentExampleOnPayloadModule());
+    activeModules.push(agentExclusiveAnnotationsModule());
+    activeModules.push(agentOptionalFieldUndocumentedModule());
+    activeModules.push(agentTagsendTranslatorMissingModule());
+    activeModules.push(agentNonextractableHandlerModule());
+    activeModules.push(subappRequiresReasonModule());
+    activeModules.push(emptyPropsModule());
+    activeModules.push(forgottenSpreadModule());
+    activeModules.push(accessibilityModule());
+    activeModules.push(viewBagImportModule());
+    activeModules.push(controlledInputModule());
+    activeModules.push(missingMemoModule());
+    activeModules.push(namespaceImportModule());
+    activeModules.push(noBarrelImportWhenSubpathExistsModule());
+    activeModules.push(formBoilerplateModule());
+    activeModules.push(spreadInChildrenModule());
+    activeModules.push(staticItemsModule());
+    activeModules.push(staticOnModule());
+    activeModules.push(noListRenderInSampleModule());
+    activeModules.push(noSampleInAccessorModule());
+    activeModules.push(noSampleInReactivePositionModule());
+    activeModules.push(agentEmitsDriftModule());
+    activeModules.push(agentMsgResolvableModule());
+    // eachMemoModule wraps allocating each() items accessors in
+    // `memo(...)` via `transformCallEnter`. Activated when the file
+    // has any reactive paths (mirrors the inline call's gating).
+    // The module sets a per-file slot when at least one wrap fired;
+    // the umbrella reads it to decide whether `memo` needs to enter
+    // the @llui/dom imports via `cleanupImports`.
+    if (fieldBits.size > 0 || fieldBitsHi.size > 0) {
+        activeModules.push(eachMemoModule({
+            fieldBits,
+            viewHelperNames,
+            viewHelperAliases,
+        }));
+    }
+    // itemDedupModule lifts repeated `item(selector)` / `item.field`
+    // accesses into hoisted `__sN` selectors + `__aN` accessors.
+    // Registered unconditionally — the original inline call ran on every
+    // each() regardless of reactive paths, since the optimization is a
+    // pure rewrite of the render body. Module fires top-down
+    // (`transformCallEnter`) so subsequent structural-mask + element
+    // rewrites see the hoisted form.
+    activeModules.push(itemDedupModule({
+        viewHelperNames,
+        viewHelperAliases,
+    }));
+    // elementRewriteModule transforms `div(...)` / `button(...)` /
+    // etc. into `elSplit(...)` / `elTemplate(...)` / `__cloneStaticTemplate(...)`.
+    // Activated unconditionally — the underlying `tryTransformElementCall`
+    // gates on the `importedHelpers` map (only rewrites helpers that
+    // were actually imported from @llui/dom). The module signals which
+    // helpers compiled / bailed and which runtime functions need
+    // imports via `ELEMENT_REWRITE_SLOT`; the umbrella reads the slot
+    // before `cleanupImports`.
+    activeModules.push(elementRewriteModule({
+        importedHelpers,
+        fieldBits,
+        fieldBitsHi,
+    }));
+    // rowFactoryModule fires bottom-up (`transformCall` not
+    // `transformCallEnter`) so it observes the each() call AFTER the
+    // render body's element children have been rewritten by
+    // `elementRewriteModule` into `elTemplate(...)` calls. Without that
+    // ordering it would always bail (`if (!templateCall) return null`).
+    activeModules.push(rowFactoryModule({
+        viewHelperNames,
+        viewHelperAliases,
+        filename: _filename,
+        source,
+    }));
+    // coreSynthesisModule injects `__update` / `__handlers` / `__prefixes`
+    // onto every `component()` call's config-arg literal. These three
+    // share `topLevelBits` / `structuralMask` intermediates and are
+    // co-emitted by `tryInjectDirty` (still inline in transform.ts;
+    // the module is a thin wrapper per v2c §7.9.2 decision (b)). Fires
+    // top-down so subsequent per-target emissions (componentMeta,
+    // compilerStamp, schemaHash, stateSchema, msgSchema, msgAnnotations)
+    // observe the synthesized config-arg via `findComponentCalls`.
+    activeModules.push(coreSynthesisModule({
+        fieldBits,
+        fieldBitsHi,
+        lluiImport,
+    }));
+    // structuralMaskModule injects `__mask` into each()/branch()/scope()/show()
+    // options. Activated when the file has any low-word reactive paths
+    // (matches the inline `fieldBits.size === 0` early-return). Module
+    // fires top-down (transformCallEnter) so subsequent passes — and
+    // the visitor-level inline `tryInjectDirty`'s structuralMask read —
+    // see the injected `__mask` prop on the options literal.
+    if (fieldBits.size > 0) {
+        activeModules.push(structuralMaskModule({
+            fieldBits,
+            viewHelperNames,
+            viewHelperAliases,
+        }));
+    }
+    // textMaskModule injects a `__mask` (precise or FULL_MASK) as
+    // text()'s second argument on every eligible text() call. Activated
+    // unconditionally — the inline `tryInjectTextMask` had no early
+    // return on empty fieldBits and always emitted FULL_MASK in the
+    // zero-path case so the runtime sees a uniform 2-arg shape.
+    activeModules.push(textMaskModule({
+        fieldBits,
+        viewHelperNames,
+        viewHelperAliases,
+        lluiImport,
+    }));
+    const registry = new ModuleRegistry(activeModules);
+    const registryResult = registry.run(sourceFile);
+    // The registry phases (preTransform v2c/decomp-7, transformCall
+    // v2c/decomp-11/12) may have mutated the source file — replace our
+    // local reference so all subsequent code (fieldBits, visitor,
+    // cleanupImports) sees the post-registry AST. When no rewriting
+    // module is active this is a no-op assignment.
+    sourceFile = registryResult.analysis.sourceFile;
+    // Read the binding-descriptors module's slot for the
+    // cleanupImports decision about the `__registerScopeVariants`
+    // runtime helper import. When the module didn't run (no agent
+    // metadata mode) the slot is absent and scopeRegistrationsInjected
+    // stays false.
+    const bdState = registryResult.analysis.perModule.get(BINDING_DESCRIPTORS_SLOT);
+    if (bdState)
+        scopeRegistrationsInjected = bdState.scopeRegistrationsInjected;
+    // each-memo module signals memo-usage via its slot — surfaces here
+    // so `cleanupImports` adds the `memo` runtime import. Mirrors the
+    // monolith's `usesMemo` flag that the inline `tryWrapEachItemsWithMemo`
+    // used to set.
+    const emState = registryResult.analysis.perModule.get(EACH_MEMO_SLOT);
+    if (emState?.usesMemo)
+        usesMemo = true;
+    // element-rewrite module signals compiled/bailed helpers and which
+    // runtime imports it referenced. Surfaces here so the umbrella's
+    // `cleanupImports` decision matches the inline path's behavior.
+    // Also pushes a sentinel edit when the module rewrote — the
+    // `edits.length === 0` short-circuit downstream would otherwise
+    // skip the per-statement diff that surfaces Phase 2b rewrites to
+    // the output.
+    const erState = registryResult.analysis.perModule.get(ELEMENT_REWRITE_SLOT);
+    if (erState) {
+        for (const h of erState.compiled)
+            compiledHelpers.add(h);
+        for (const h of erState.bailed)
+            bailedHelpers.add(h);
+        if (erState.usesElSplit)
+            usesElSplit = true;
+        if (erState.usesElTemplate)
+            usesElTemplate = true;
+        if (erState.usesCloneStaticTemplate)
+            usesCloneStaticTemplate = true;
+        if (erState.compiled.size > 0 ||
+            erState.usesElSplit ||
+            erState.usesElTemplate ||
+            erState.usesCloneStaticTemplate) {
+            edits.push({ start: 0, end: 0, replacement: '' });
+        }
+    }
+    // core-synthesis module signals __update/__handlers/__prefixes
+    // emission. Drives `__runPhase2` + `__handleMsg` runtime imports
+    // via `cleanupImports`. Also pushes a sentinel edit so the
+    // per-statement diff catches the synthesized config-arg.
+    const csState = registryResult.analysis.perModule.get(CORE_SYNTHESIS_SLOT);
+    if (csState?.usesApplyBinding) {
+        usesApplyBinding = true;
+        edits.push({ start: 0, end: 0, replacement: '' });
+    }
+    const emissionsByTarget = new Map();
+    const globalEmissions = [];
+    for (const emission of registryResult.emissions) {
+        if (emission.target) {
+            const list = emissionsByTarget.get(emission.target);
+            if (list)
+                list.push(emission);
+            else
+                emissionsByTarget.set(emission.target, [emission]);
+        }
+        else {
+            globalEmissions.push(emission);
+        }
+    }
+    /**
+     * Splice registry-collected emissions into a `component()` call's
+     * config-arg object literal. Idempotent: emissions whose `field`
+     * already exists on the config arg are skipped (matches the
+     * monolith's inline `inject*` helpers' "if-already-present-return"
+     * behaviour). The caller passes both the *original* call (the one
+     * the registry walked) and the current *transformed* call (the
+     * accumulator that previous `inject*` helpers built up).
+     */
+    function applyRegistryEmissions(transformedCall, originalCall) {
+        const targeted = emissionsByTarget.get(originalCall) ?? [];
+        const all = [...globalEmissions, ...targeted];
+        if (all.length === 0)
+            return transformedCall;
+        const configArg = transformedCall.arguments[0];
+        if (!configArg || !ts.isObjectLiteralExpression(configArg))
+            return transformedCall;
+        const existing = new Set();
+        for (const prop of configArg.properties) {
+            if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+                existing.add(prop.name.text);
+            }
+        }
+        const adds = [];
+        for (const emission of all) {
+            if (existing.has(emission.field))
+                continue;
+            adds.push(f.createPropertyAssignment(emission.field, emission.value));
+        }
+        if (adds.length === 0)
+            return transformedCall;
+        const newConfig = f.createObjectLiteralExpression([...configArg.properties, ...adds], true);
+        return f.createCallExpression(transformedCall.expression, transformedCall.typeArguments, [
+            newConfig,
+            ...transformedCall.arguments.slice(1),
+        ]);
+    }
+    // ── track() strip pass (v2b §3) ─────────────────────────────────
+    // `track({ deps: (s) => [...] })` is a compile-time declaration only.
+    // collectDeps already merged its paths into `fieldBits` because 'track'
+    // is in REACTIVE_API_NAMES. Now emit an edit deleting the statement
+    // and mark 'track' as compiled so cleanupImports strips the import.
+    //
+    // A track() call is stripped only when it's the entire ExpressionStatement
+    // (the documented form). track() inside a larger expression is left as a
+    // call to the runtime stub — which throws — so the developer notices
+    // they wrote an unsupported form. The llui/prefer-static-deps lint
+    // rule catches the unusual usages.
+    // `track` is imported from @llui/dom but is not an element helper, so
+    // `importedHelpers.has('track')` is always false. Check the named
+    // imports directly to gate the strip pass.
+    const lluiImportNames = new Set();
+    if (lluiImport.importClause?.namedBindings &&
+        ts.isNamedImports(lluiImport.importClause.namedBindings)) {
+        for (const spec of lluiImport.importClause.namedBindings.elements) {
+            lluiImportNames.add(spec.name.text);
+        }
+    }
+    // Track-strip recognition. The main visitor returns an EmptyStatement
+    // for any `track({ deps: ... })` ExpressionStatement — the per-statement
+    // diff then surfaces the deletion. Paths are already in fieldBits
+    // because 'track' is in REACTIVE_API_NAMES.
+    if (lluiImportNames.has('track')) {
+        // Pre-scan to detect track() use so cleanupImports strips the import.
+        let foundTrackCall = false;
+        const visitForTrackDetect = (node) => {
+            if (foundTrackCall)
+                return;
+            if (ts.isExpressionStatement(node) &&
+                ts.isCallExpression(node.expression) &&
+                ts.isIdentifier(node.expression.expression) &&
+                node.expression.expression.text === 'track') {
+                foundTrackCall = true;
+                return;
+            }
+            ts.forEachChild(node, visitForTrackDetect);
+        };
+        visitForTrackDetect(sourceFile);
+        if (foundTrackCall)
+            compiledHelpers.add('track');
+    }
+    function visitor(node) {
+        // Synthetic nodes (created by ts.factory) don't have real positions
+        const hasPos = node.pos >= 0 && node.end >= 0;
+        const origStart = hasPos ? node.getStart(sourceFile) : -1;
+        const origEnd = hasPos ? node.getEnd() : -1;
+        // track({ deps: (s) => [...] }) is a compile-time declaration — paths
+        // already in fieldBits, call expression is dead weight. Return an
+        // EmptyStatement so the per-statement diff strips it from the output
+        // (cleanupImports separately removes the `track` import via the
+        // compiledHelpers set populated above).
+        if (ts.isExpressionStatement(node) &&
+            ts.isCallExpression(node.expression) &&
+            ts.isIdentifier(node.expression.expression) &&
+            node.expression.expression.text === 'track' &&
+            lluiImportNames.has('track')) {
+            return f.createEmptyStatement();
+        }
+        // each() optimizations + row-factory all migrated to modules:
+        //   - memo-wrap        → eachMemoModule (v2c/decomp-13)
+        //   - item-dedup       → itemDedupModule (v2c/decomp-16)
+        //   - structural-mask  → structuralMaskModule (v2c/decomp-14)
+        //   - row-factory      → rowFactoryModule (v2c/decomp-18)
+        // Phase 2b chains the top-down hooks (memo, dedup, mask, element)
+        // then recurses, then fires the bottom-up exit hook (row-factory).
+        // The visitor's inline each() block is gone.
+        if (ts.isCallExpression(node)) {
+            // Pass 1: element rewrite (`div` → `elSplit`/`elTemplate`/
+            // `__cloneStaticTemplate`) moved to `elementRewriteModule`
+            // (v2c/decomp-17). Phase 2b ran before this visitor; the call
+            // is already rewritten on `node` when it was eligible.
+            // text() mask injection moved to `textMaskModule` (v2c/decomp-15).
+            // Structural-mask injection (each/branch/scope/show) moved to
+            // `structuralMaskModule` (v2c/decomp-14). Both ran in Phase 2b
+            // before this visitor; nothing to do here.
+        }
+        // Pass 2: component() metadata splicing. Core synthesis
+        // (__update/__handlers/__prefixes) moved to `coreSynthesisModule`
+        // (v2c/decomp-19) — fires top-down in Phase 2b before this
+        // visitor sees the call. The remaining work here is just the
+        // registry-emission splice (per-target __componentMeta,
+        // __compilerVersion, __lluiCompilerEmitted, __schemaHash,
+        // __stateSchema, __msgSchema, __effectSchema, __msgAnnotations).
+        if (ts.isCallExpression(node) && isComponentCall(node, lluiImport)) {
+            let result = null;
+            // Extract schema data once — used both for devMode injections and the
+            // unconditional __schemaHash (spec §7.4: hash ships in prod too).
+            //
+            // Resolution priority for each schema:
+            //  1. preExtracted.* — used when the plugin's async hook has already
+            //     done cross-file + composition extraction (the production path).
+            //  2. typeSources.* — file-local extraction against an alternate
+            //     source file (legacy path; covers cross-file but not composition).
+            //  3. file-local — the test path: extract from `source` itself.
+            //
+            // When `preExtracted` is provided, treat it as authoritative even
+            // when the value is `null` (the resolver was run and found
+            // nothing) — falling back to local extraction would mask the
+            // resolver's "not extractable" verdict.
+            // `msgSchema` previously computed here; uses the pre-hoisted value.
+            const msgSchema = hoistedMsgSchema;
+            // `msgAnnotations` previously computed here; uses the pre-hoisted
+            // value so the module + the inline `computeSchemaHash` call see
+            // the same input.
+            const msgAnnotations = hoistedMsgAnnotations;
+            // `stateSchema` was previously computed here; it now uses the
+            // pre-hoisted value (file-level inputs only). The `__stateSchema`
+            // emission migrated to `stateSchemaModule` via the registry
+            // bridge — the inline `injectStateSchema` call below deletes.
+            const stateSchema = hoistedStateSchema;
+            const shouldEmitAgentMetadata = devMode || emitAgentMetadata;
+            if (shouldEmitAgentMetadata) {
+                // __msgSchema: migrated to msgSchemaModule (v2c/decomp-5).
+                // __msgAnnotations: migrated to msgAnnotationsModule (v2c/decomp-4).
+                // __stateSchema: migrated to stateSchemaModule (v2c/decomp-3).
+                // __effectSchema: migrated to msgSchemaModule (handles both
+                //   the Msg and Effect discriminated-union shapes since they
+                //   share the same wire format).
+                const effectSchema = hoistedEffectSchema;
+                void effectSchema; // referenced by hoistedEffectSchema's narrow scope; the
+                //                  cache snapshot below reads msgSchema directly.
+                // Note: binding descriptors are no longer emitted on the
+                // component def. They're now collected at runtime by walking
+                // event-handler arrows that the `tagEventHandlerSends` pass
+                // wrapped with `__lluiVariants` metadata. See
+                // `binding-descriptors.ts` (compiler) and the matching
+                // `@llui/dom binding-descriptors.ts` (runtime registry).
+                // Populate compiler cache — preSource and msgMaskMap are known now;
+                // postSource is filled in after the full output is assembled.
+                const cachedComponentName = extractComponentNameFromConfig(node);
+                if (cachedComponentName) {
+                    const preSource = extractViewBody(source) ?? '';
+                    const msgMaskMap = {};
+                    for (const [path, bit] of fieldBits) {
+                        msgMaskMap[path] = bit;
+                    }
+                    compilerCache.set(cachedComponentName, {
+                        preSource,
+                        postSource: '',
+                        msgMaskMap,
+                        bindingSources: [],
+                    });
+                }
+            }
+            // v2c §2 bridge: registry-emission splicing replaces the inline
+            // `injectComponentMeta` here. `componentMetaModule` is registered
+            // when `devMode` is true, so the dev-mode gating semantics match
+            // the prior `if (devMode)` guard. When `devMode` is false the
+            // registry is empty and this call is a no-op.
+            result = applyRegistryEmissions(result ?? node, node);
+            // __schemaHash: migrated to schemaHashModule (v2c/decomp-5).
+            // When shouldEmitAgentMetadata is true, schemaHashModule is in
+            // the active module list and produces the emission via the
+            // bridge. Out-of-agent-mode files don't emit __schemaHash today
+            // either (the monolith's inline path was always-on, but the
+            // hash only matters when the runtime is in agent mode — see
+            // agent spec §12.3). Aligned during the migration.
+            //
+            // The `msgSchema` / `stateSchema` / `msgAnnotations` variables
+            // remain in scope so they can feed the cache snapshot below.
+            void msgSchema;
+            void stateSchema;
+            void msgAnnotations;
+            // `__lluiCompilerEmitted` + `__compilerVersion` migrated to
+            // `compilerStampModule` (v2c/decomp-10). They flow through the
+            // same `applyRegistryEmissions` splice as every other registry
+            // contribution; the umbrella now contains zero inline injectors.
+            if (result) {
+                if (hasPos)
+                    edits.push({ start: origStart, end: origEnd, replacement: '' });
+                return ts.visitEachChild(result, visitor, undefined);
+            }
+        }
+        return ts.visitEachChild(node, visitor, undefined);
+    }
+    let transformed = ts.visitNode(sourceFile, visitor);
+    // Pass 3: Clean up imports — use the old cleanupImports approach
+    // which operates on the transformed SourceFile safely
+    const safeToRemove = new Set([...compiledHelpers].filter((h) => !bailedHelpers.has(h)));
+    transformed = cleanupImports(transformed, lluiImport, importedHelpers, safeToRemove, usesElSplit, usesElTemplate, usesMemo, usesApplyBinding, usesCloneStaticTemplate, scopeRegistrationsInjected, f);
+    if (edits.length === 0) {
+        // No element-helper rewrites — but registry may still have
+        // collected diagnostics (e.g. agent-rule errors on Msg variants
+        // in a Msg-declaration-only file). Surface them so the adapter
+        // can fail the build.
+        if (registryResult.analysis.diagnostics.length > 0) {
+            return { output: source, edits: [], diagnostics: registryResult.analysis.diagnostics };
+        }
+        return null;
+    }
+    // Find component declarations for HMR and agent metadata
+    const componentDecls = devMode || emitAgentMetadata ? findComponentDeclarations(sourceFile, lluiImport) : [];
+    // Build per-statement edits by comparing original vs transformed.
+    // Only emit edits for statements that actually changed.
+    // Untouched code keeps its original positions → accurate source maps.
+    const finalEdits = [];
+    const origStmts = sourceFile.statements;
+    const xfStmts = transformed.statements;
+    for (let i = 0; i < origStmts.length && i < xfStmts.length; i++) {
+        const origStart = origStmts[i].getStart(sourceFile);
+        const origEnd = origStmts[i].getEnd();
+        const origText = source.slice(origStart, origEnd);
+        let xfText;
+        try {
+            xfText = printer.printNode(ts.EmitHint.Unspecified, xfStmts[i], transformed);
+        }
+        catch {
+            // Synthetic nodes may fail to print individually — fall back to full reprint
+            const { top: _top, bottom: _bottom } = devMode
+                ? generateDevCode(componentDecls, mcpPort)
+                : { top: '', bottom: '' };
+            let output = (_top ? _top + '\n' : '') + printer.printFile(transformed) + (_bottom ? '\n' + _bottom : '');
+            if (devMode || emitAgentMetadata) {
+                output = appendCompilerCacheProps(output, componentDecls);
+            }
+            return {
+                output,
+                edits: [{ start: 0, end: source.length, replacement: output }],
+                diagnostics: registryResult.analysis.diagnostics,
+            };
+        }
+        // Compare ignoring trailing semicolons and whitespace (printer adds them)
+        const origNorm = origText.trim().replace(/;$/, '');
+        const xfNorm = xfText.trim().replace(/;$/, '');
+        if (origNorm !== xfNorm) {
+            // Match the original style: if the original didn't end with a semicolon,
+            // strip the one the printer added
+            const origHasSemi = origText.trimEnd().endsWith(';');
+            const replacement = origHasSemi ? xfText : xfText.replace(/;(\s*)$/, '$1');
+            finalEdits.push({ start: origStart, end: origEnd, replacement });
+        }
+    }
+    // Dev setup: enable* must run BEFORE user's mountApp (top of file),
+    // but import.meta.hot.accept needs to reference user's component vars
+    // (bottom of file). So split the injection.
+    if (devMode) {
+        const { top, bottom } = generateDevCode(componentDecls, mcpPort);
+        if (top)
+            finalEdits.push({ start: 0, end: 0, replacement: top + '\n' });
+        if (bottom)
+            finalEdits.push({ start: source.length, end: source.length, replacement: '\n' + bottom });
+    }
+    if (finalEdits.length === 0) {
+        // No rewrites — but registry may still have collected diagnostics
+        // (e.g. bitmask-overflow on an otherwise-clean file). Surface them
+        // so the adapter can fail the build.
+        if (registryResult.analysis.diagnostics.length > 0) {
+            return { output: source, edits: [], diagnostics: registryResult.analysis.diagnostics };
+        }
+        return null;
+    }
+    // Build the full output by applying edits (for backward compat)
+    const sorted = [...finalEdits].sort((a, b) => b.start - a.start);
+    let output = source;
+    for (const edit of sorted) {
+        output = output.slice(0, edit.start) + edit.replacement + output.slice(edit.end);
+    }
+    // After output is assembled, update postSource in cache and emit non-enumerable props
+    if ((devMode || emitAgentMetadata) && componentDecls.length > 0) {
+        const cacheProps = appendCompilerCacheProps(output, componentDecls);
+        if (cacheProps !== output) {
+            output = cacheProps;
+        }
+    }
+    return { output, edits: finalEdits, diagnostics: registryResult.analysis.diagnostics };
+}
+// ── HMR ──────────────────────────────────────────────────────────
+function generateDevCode(components, mcpPort) {
+    if (components.length === 0) {
+        return {
+            top: '',
+            bottom: `if (import.meta.hot) {\n  import.meta.hot.accept()\n}`,
+        };
+    }
+    const relayImport = mcpPort !== null ? ', startRelay as __startRelay' : '';
+    const relayCall = mcpPort !== null ? `\n__startRelay(${mcpPort})` : '';
+    const top = `
+import { enableHmr as __enableHmr, replaceComponent as __replaceComponent } from '@llui/dom/hmr'
+import { enableDevTools as __enableDevTools${relayImport} } from '@llui/dom/devtools'
+__enableHmr()
+__enableDevTools()${relayCall}
+`.trim();
+    const replaceCalls = components
+        .map(({ varName, componentName }) => `      __replaceComponent("${componentName}", ${varName})`)
+        .join('\n');
+    // HMR auto-connect: when the Vite plugin detects that @llui/mcp's
+    // active marker file exists or appears, it sends `llui:mcp-ready`
+    // with the MCP bridge port. We forward that to __lluiConnect so the
+    // browser connects automatically — no console gymnastics, no retry
+    // spam, regardless of whether MCP or Vite started first.
+    const mcpHmrHandler = mcpPort !== null
+        ? `
+  import.meta.hot.on('llui:mcp-ready', (data) => {
+    if (typeof globalThis.__lluiConnect === 'function') {
+      globalThis.__lluiConnect(data?.port)
+    }
+  })`
+        : '';
+    const bottom = `
+if (import.meta.hot) {
+  import.meta.hot.accept(() => {
+${replaceCalls}
+  })${mcpHmrHandler}
+}
+`.trim();
+    return { top, bottom };
+}
+/** Find all component() calls and extract the variable name and component name */
+function findComponentDeclarations(sf, lluiImport) {
+    const result = [];
+    function visit(node) {
+        // Match: const Foo = component({ name: 'Foo', ... })
+        if (ts.isVariableDeclaration(node) &&
+            ts.isIdentifier(node.name) &&
+            node.initializer &&
+            ts.isCallExpression(node.initializer) &&
+            isComponentCall(node.initializer, lluiImport)) {
+            const varName = node.name.text;
+            const config = node.initializer.arguments[0];
+            if (config && ts.isObjectLiteralExpression(config)) {
+                for (const prop of config.properties) {
+                    if (ts.isPropertyAssignment(prop) &&
+                        ts.isIdentifier(prop.name) &&
+                        prop.name.text === 'name' &&
+                        ts.isStringLiteral(prop.initializer)) {
+                        result.push({ varName, componentName: prop.initializer.text });
+                    }
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sf);
+    return result;
+}
+// ── Helpers ──────────────────────────────────────────────────────
+function findLluiImport(sf) {
+    for (const stmt of sf.statements) {
+        if (ts.isImportDeclaration(stmt) &&
+            ts.isStringLiteral(stmt.moduleSpecifier) &&
+            stmt.moduleSpecifier.text === '@llui/dom') {
+            return stmt;
+        }
+    }
+    return null;
+}
+function getImportedHelpers(imp) {
+    const map = new Map();
+    const clause = imp.importClause;
+    if (!clause || !clause.namedBindings || !ts.isNamedImports(clause.namedBindings))
+        return map;
+    for (const spec of clause.namedBindings.elements) {
+        const original = (spec.propertyName ?? spec.name).text;
+        const local = spec.name.text;
+        if (ELEMENT_HELPERS.has(original)) {
+            map.set(local, original);
+        }
+    }
+    return map;
+}
+function hasComponentDef(sf, lluiImport) {
+    let found = false;
+    function visit(node) {
+        if (found)
+            return;
+        if (ts.isCallExpression(node) && isComponentCall(node, lluiImport)) {
+            found = true;
+            return;
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sf);
+    return found;
+}
+/**
+ * Scan for `component({ view: (h) => ... })` arrow functions and collect
+ * the identifier name used as the View-bundle parameter. When the user
+ * writes `h.show(...)` / `h.text(...)` inside the view, the compiler treats
+ * it the same as bare `show(...)` / `text(...)` for mask injection.
+ */
+function collectViewHelperNames(sf, lluiImport) {
+    const names = new Set();
+    function visit(node) {
+        if (ts.isCallExpression(node) && isComponentCall(node, lluiImport)) {
+            const arg = node.arguments[0];
+            if (arg && ts.isObjectLiteralExpression(arg)) {
+                for (const prop of arg.properties) {
+                    if (ts.isPropertyAssignment(prop) &&
+                        ts.isIdentifier(prop.name) &&
+                        prop.name.text === 'view' &&
+                        (ts.isArrowFunction(prop.initializer) || ts.isFunctionExpression(prop.initializer))) {
+                        const params = prop.initializer.parameters;
+                        if (params.length >= 1) {
+                            const first = params[0];
+                            if (ts.isIdentifier(first.name)) {
+                                names.add(first.name.text);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Also: any function parameter annotated as `View<...>` — covers extracted
+        // view-functions like `function repoPage(h: View<State, Msg>, ...)`.
+        if (ts.isParameter(node) &&
+            node.type &&
+            isViewTypeReference(node.type) &&
+            ts.isIdentifier(node.name)) {
+            names.add(node.name.text);
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sf);
+    return names;
+}
+function isViewTypeReference(t) {
+    return ts.isTypeReferenceNode(t) && ts.isIdentifier(t.typeName) && t.typeName.text === 'View';
+}
+/**
+ * Scan for `component({ view: ({ show, each, text, ... }) => ... })`
+ * destructured parameters and return a map from the locally-bound name to
+ * the primitive name it aliases. This lets users write the bare `show(...)` /
+ * `text(...)` forms without importing them, while the compiler still
+ * applies mask injection etc.
+ *
+ *     view: ({ show, text: t }) => [...]
+ *     // returns { show → "show", t → "text" }
+ */
+const VIEW_HELPER_PRIMITIVES = new Set([
+    'show',
+    'branch',
+    'scope',
+    'each',
+    'text',
+    'memo',
+    'sample',
+    'selector',
+    'ctx',
+    'slice',
+    'send',
+]);
+function collectViewHelperAliases(sf, lluiImport, helperNames) {
+    const aliases = new Map();
+    function addFromBindingPattern(pattern) {
+        for (const elem of pattern.elements) {
+            // { show } → propertyName=undefined, name=show
+            // { show: mySh } → propertyName=show, name=mySh
+            const sourceName = elem.propertyName && ts.isIdentifier(elem.propertyName)
+                ? elem.propertyName.text
+                : ts.isIdentifier(elem.name)
+                    ? elem.name.text
+                    : null;
+            const localName = ts.isIdentifier(elem.name) ? elem.name.text : null;
+            if (sourceName && localName && VIEW_HELPER_PRIMITIVES.has(sourceName)) {
+                aliases.set(localName, sourceName);
+            }
+        }
+    }
+    function visit(node) {
+        if (ts.isCallExpression(node) && isComponentCall(node, lluiImport)) {
+            const arg = node.arguments[0];
+            if (arg && ts.isObjectLiteralExpression(arg)) {
+                for (const prop of arg.properties) {
+                    if (ts.isPropertyAssignment(prop) &&
+                        ts.isIdentifier(prop.name) &&
+                        prop.name.text === 'view' &&
+                        (ts.isArrowFunction(prop.initializer) || ts.isFunctionExpression(prop.initializer))) {
+                        const params = prop.initializer.parameters;
+                        if (params.length >= 1) {
+                            const first = params[0];
+                            if (ts.isObjectBindingPattern(first.name)) {
+                                addFromBindingPattern(first.name);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Also: function parameters like `(…, { show, text }: View<State, Msg>) => …`
+        // on extracted helpers — allow the same destructuring ergonomics.
+        if (ts.isParameter(node) &&
+            node.type &&
+            isViewTypeReference(node.type) &&
+            ts.isObjectBindingPattern(node.name)) {
+            addFromBindingPattern(node.name);
+        }
+        // Also: `const { show, text } = h` assignments where `h` is a known
+        // helper binding — lets helpers destructure once at the top of the
+        // function body.
+        if (ts.isVariableDeclaration(node) &&
+            ts.isObjectBindingPattern(node.name) &&
+            node.initializer &&
+            ts.isIdentifier(node.initializer) &&
+            helperNames.has(node.initializer.text)) {
+            addFromBindingPattern(node.name);
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sf);
+    return aliases;
+}
+export function isComponentCall(node, lluiImport) {
+    if (!ts.isIdentifier(node.expression))
+        return false;
+    const name = node.expression.text;
+    if (name !== 'component')
+        return false;
+    // Verify it's from the llui import
+    const clause = lluiImport.importClause;
+    if (!clause?.namedBindings || !ts.isNamedImports(clause.namedBindings))
+        return false;
+    return clause.namedBindings.elements.some((s) => s.name.text === 'component' || (s.propertyName && s.propertyName.text === 'component'));
+}
+// ── Pass 2: Mask injection ───────────────────────────────────────
+/**
+ * Match a call expression against a primitive name across all three binding
+ * forms:
+ *   - bare imported identifier: `name(...)` where `name` was imported from @llui/dom
+ *   - destructured alias: `name(...)` where `name` is bound via
+ *     `view: (_, { name }) => ...` (or `{ name: alias }`)
+ *   - member call: `<h>.name(...)` where `<h>` is the 2nd view parameter
+ *
+ * The compiler treats all three identically for mask injection / each()
+ * optimization purposes.
+ */
+export function isHelperCall(expr, name, helperNames, aliases) {
+    if (ts.isIdentifier(expr)) {
+        if (expr.text === name)
+            return true;
+        if (aliases && aliases.get(expr.text) === name)
+            return true;
+        return false;
+    }
+    if (ts.isPropertyAccessExpression(expr) &&
+        ts.isIdentifier(expr.expression) &&
+        helperNames.has(expr.expression.text) &&
+        ts.isIdentifier(expr.name) &&
+        expr.name.text === name) {
+        return true;
+    }
+    return false;
+}
+// text() `__mask` injection — migrated to `textMaskModule`
+// (v2c/decomp-15). Module fires top-down (transformCallEnter); the
+// visitor sees the masked form.
+// `__mask` injection on each()/branch()/scope()/show() — migrated to
+// `structuralMaskModule` (v2c/decomp-14). Module fires top-down
+// (transformCallEnter) so the visitor sees the masked options literal.
+// ── Pass 3: Import cleanup ───────────────────────────────────────
+function cleanupImports(sf, lluiImport, _helpers, compiled, usesElSplit, usesElTemplate, usesMemo, usesApplyBinding, usesCloneStaticTemplate, usesRegisterScopeVariants, f) {
+    if (compiled.size === 0 &&
+        !usesElTemplate &&
+        !usesElSplit &&
+        !usesMemo &&
+        !usesApplyBinding &&
+        !usesCloneStaticTemplate &&
+        !usesRegisterScopeVariants)
+        return sf;
+    const clause = lluiImport.importClause;
+    if (!clause?.namedBindings || !ts.isNamedImports(clause.namedBindings))
+        return sf;
+    const remaining = clause.namedBindings.elements.filter((spec) => !compiled.has(spec.name.text));
+    const hasElSplit = clause.namedBindings.elements.some((s) => s.name.text === 'elSplit');
+    if (!hasElSplit && usesElSplit) {
+        remaining.push(f.createImportSpecifier(false, undefined, f.createIdentifier('elSplit')));
+    }
+    const hasElTemplate = clause.namedBindings.elements.some((s) => s.name.text === 'elTemplate');
+    if (!hasElTemplate && usesElTemplate) {
+        remaining.push(f.createImportSpecifier(false, undefined, f.createIdentifier('elTemplate')));
+    }
+    const hasCloneStaticTemplate = clause.namedBindings.elements.some((s) => s.name.text === '__cloneStaticTemplate');
+    if (!hasCloneStaticTemplate && usesCloneStaticTemplate) {
+        remaining.push(f.createImportSpecifier(false, undefined, f.createIdentifier('__cloneStaticTemplate')));
+    }
+    const hasMemo = clause.namedBindings.elements.some((s) => s.name.text === 'memo');
+    if (!hasMemo && usesMemo) {
+        remaining.push(f.createImportSpecifier(false, undefined, f.createIdentifier('memo')));
+    }
+    if (usesApplyBinding) {
+        if (!clause.namedBindings.elements.some((s) => s.name.text === '__runPhase2')) {
+            remaining.push(f.createImportSpecifier(false, undefined, f.createIdentifier('__runPhase2')));
+        }
+        if (!clause.namedBindings.elements.some((s) => s.name.text === '__handleMsg')) {
+            remaining.push(f.createImportSpecifier(false, undefined, f.createIdentifier('__handleMsg')));
+        }
+    }
+    // The connect-pattern injector (binding-descriptors.ts) emits
+    // `__registerScopeVariants([...])` calls; ensure the runtime
+    // helper is imported when at least one was inserted.
+    const hasRegisterScopeVariants = clause.namedBindings.elements.some((s) => s.name.text === '__registerScopeVariants');
+    if (!hasRegisterScopeVariants && usesRegisterScopeVariants) {
+        remaining.push(f.createImportSpecifier(false, undefined, f.createIdentifier('__registerScopeVariants')));
+    }
+    const newBindings = f.createNamedImports(remaining);
+    const newClause = f.createImportClause(false, undefined, newBindings);
+    const newImportDecl = f.createImportDeclaration(undefined, newClause, lluiImport.moduleSpecifier);
+    let replaced = false;
+    const statements = sf.statements.map((stmt) => {
+        if (!replaced &&
+            ts.isImportDeclaration(stmt) &&
+            ts.isStringLiteral(stmt.moduleSpecifier) &&
+            stmt.moduleSpecifier.text === '@llui/dom' &&
+            !stmt.importClause?.isTypeOnly) {
+            replaced = true;
+            return newImportDecl;
+        }
+        return stmt;
+    });
+    return f.updateSourceFile(sf, statements);
+}
+// ── __msgSchema injection ────────────────────────────────────────
+// `injectStateSchema` was the inline emitter for `__stateSchema`.
+// Migrated to `stateSchemaModule` + the registry bridge (v2c/decomp-3).
+// Behavior preserves end-to-end via the existing transform/HMR tests.
+// `stateTypeToLiteral` lives in `state-schema.ts` alongside `StateType`.
+// `injectComponentMeta` was the inline emitter for `__componentMeta`.
+// Migrated to `componentMetaModule` + the registry bridge in this
+// commit. Behavior preserves end-to-end via `registry-bridge.test.ts`.
+// `injectMsgSchema`, `injectEffectSchema`, `injectSchemaHash`,
+// `buildFieldDescriptorExpr`, `emitEnumValue` all migrated to
+// `msgSchemaModule` / `schemaHashModule` (v2c/decomp-5). The
+// literal builders live in `msg-schema.ts` alongside the schema
+// extraction logic.
+// `__lluiCompilerEmitted` + `__compilerVersion` integrity marker
+// migrated to `compilerStampModule` (v2c/decomp-10). Always-on through
+// the registry bridge — fires regardless of agent/dev mode.
+// ── Per-item accessor detection ──────────────────────────────────
+// Item selector deduplication — migrated to `itemDedupModule`
+// (v2c/decomp-16). Module fires top-down (transformCallEnter); the
+// visitor sees the post-dedup form.
+// Auto-memoize each() items accessor — migrated to `eachMemoModule`
+// (v2c/decomp-13). `tryWrapEachItemsWithMemo`, `accessorAllocatesArray`
+// + `ALLOCATING_METHODS` now live in `modules/each-memo.ts`.
+// ── Subtree collapse: nested elements → elTemplate ──────────────
+const NON_DELEGATION_HELPERS = new Set(['sample', 'item', 'memo', 'text', 'unsafeHtml']);
+export function computeAccessorMask(accessor, fieldBits, visited = new Set(), fieldBitsHi) {
+    if (visited.has(accessor))
+        return { mask: 0, maskHi: 0, readsState: false };
+    visited.add(accessor);
+    if (accessor.parameters.length === 0)
+        return { mask: 0xffffffff | 0, maskHi: 0, readsState: false };
+    const paramName = accessor.parameters[0].name;
+    if (!ts.isIdentifier(paramName))
+        return { mask: 0xffffffff | 0, maskHi: 0, readsState: false };
+    // FunctionDeclaration always has a body (we never resolve overloads here);
+    // ArrowFunction's body may be a single expression. Both shapes are walked
+    // identically by ts.forEachChild, so no special-casing is needed below.
+    if (!accessor.body)
+        return { mask: 0xffffffff | 0, maskHi: 0, readsState: false };
+    const stateParam = paramName.text;
+    let mask = 0;
+    let maskHi = 0;
+    let readsState = false;
+    // `inNestedFn` gates only the delegation-recursion. Property-access
+    // path extraction happens everywhere — inner-arrow callbacks like
+    // `s.items.filter((i) => i.includes(s.filter))` close over our
+    // state, and their `s.filter` reads contribute to the mask.
+    function walk(node, inNestedFn) {
+        // `node.parent` can be undefined for synthetic nodes produced by
+        // earlier AST-transform passes (the row-factory rewrite and the
+        // per-item heuristic both build new sub-trees whose inner nodes
+        // have no parent pointers). Guard every parent access below —
+        // crashing the whole build on a perfectly valid reactive accessor
+        // like `text((_s) => \`$${item.x.toLocaleString()}\`)` was how
+        // this bug first surfaced in the persistent-layout example work.
+        const parent = node.parent;
+        if (ts.isIdentifier(node) && node.text === stateParam && (!parent || !ts.isParameter(parent))) {
+            readsState = true;
+        }
+        if (ts.isPropertyAccessExpression(node)) {
+            // When there's no parent we can't tell if this is the top of a
+            // chain, so we resolve from here. That's still correct for mask
+            // accounting: `resolveChain` on an inner PAE produces a prefix
+            // of the outer chain, which maps to the same `fieldBits` bit
+            // via the prefix-match loop below. Worst case we resolve the
+            // same chain twice (`|=` is idempotent); best case we'd have
+            // resolved once from the real top. Correctness unchanged.
+            if (!parent || !ts.isPropertyAccessExpression(parent)) {
+                const chain = resolveChain(node, stateParam);
+                if (chain) {
+                    const bit = fieldBits.get(chain);
+                    const bitHi = fieldBitsHi?.get(chain);
+                    if (bit !== undefined) {
+                        mask |= bit;
+                    }
+                    else if (bitHi !== undefined) {
+                        maskHi |= bitHi;
+                    }
+                    else {
+                        // Match paths that overlap our chain in either direction:
+                        //   - `path` extends `chain` — fieldBits has finer-grained paths
+                        //     than we're reading (e.g. chain='user', fieldBits has
+                        //     'user.email').
+                        //   - `chain` extends `path` — we're reading deeper than what
+                        //     fieldBits tracks (e.g. chain='items.filter' from
+                        //     `s.items.filter(...)`, fieldBits has 'items'). Both ends
+                        //     must mask in: a change to `items` invalidates anything
+                        //     downstream of it.
+                        for (const [path, b] of fieldBits) {
+                            if (path === chain || path.startsWith(chain + '.') || chain.startsWith(path + '.')) {
+                                mask |= b;
+                            }
+                        }
+                        if (fieldBitsHi) {
+                            for (const [path, b] of fieldBitsHi) {
+                                if (path === chain ||
+                                    path.startsWith(chain + '.') ||
+                                    chain.startsWith(path + '.')) {
+                                    maskHi |= b;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Delegation: `helper(s)` where `s` matches our state param.
+        // Recurse into the helper's body so its state-path reads
+        // contribute to our mask. Only at top level — inside a nested
+        // function body, `s` may be shadowed and the call isn't
+        // unambiguously handing our state in.
+        if (!inNestedFn && ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+            const calleeName = node.expression.text;
+            if (!NON_DELEGATION_HELPERS.has(calleeName)) {
+                const arg0 = node.arguments[0];
+                if (arg0 && ts.isIdentifier(arg0) && arg0.text === stateParam) {
+                    const resolved = resolveAccessorBody(node.expression);
+                    if (resolved) {
+                        const inner = computeAccessorMask(resolved, fieldBits, visited, fieldBitsHi);
+                        mask |= inner.mask;
+                        maskHi |= inner.maskHi;
+                        if (inner.readsState)
+                            readsState = true;
+                    }
+                }
+            }
+        }
+        const enteringNested = ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node);
+        ts.forEachChild(node, (child) => walk(child, inNestedFn || enteringNested));
+    }
+    walk(accessor.body, false);
+    if (mask === 0 && maskHi === 0 && readsState) {
+        return { mask: 0xffffffff | 0, maskHi: 0, readsState: true };
+    }
+    return { mask, maskHi, readsState };
+}
+function resolveChain(node, paramName) {
+    const parts = [];
+    let current = node;
+    while (ts.isPropertyAccessExpression(current)) {
+        parts.unshift(current.name.text);
+        current = current.expression;
+    }
+    if (!ts.isIdentifier(current) || current.text !== paramName)
+        return null;
+    if (parts.length > 2)
+        return parts.slice(0, 2).join('.');
+    return parts.join('.');
+}
+// ── Compiler cache helpers ────────────────────────────────────────
+/**
+ * Extract the view function body (the value of the `view:` property) from
+ * a component() config object literal.  Uses a regex heuristic — good enough
+ * for round-tripping source for dev/agent tools.
+ */
+export function extractViewBody(code) {
+    const match = /\bview\s*:\s*([\s\S]*?)(?=,\s*(?:onEffect|update|init|name|onMsg)\s*:|}\s*\))/m.exec(code);
+    return match?.[1]?.trim() ?? null;
+}
+/**
+ * Extract the component `name:` string literal from a component() call's
+ * first argument object literal in the source text.
+ */
+export function extractComponentNameFromConfig(node) {
+    const configArg = node.arguments[0];
+    if (!configArg || !ts.isObjectLiteralExpression(configArg))
+        return null;
+    for (const prop of configArg.properties) {
+        if (ts.isPropertyAssignment(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === 'name' &&
+            ts.isStringLiteral(prop.initializer)) {
+            return prop.initializer.text;
+        }
+    }
+    return null;
+}
+/**
+ * Generate Object.defineProperty calls for __preSource, __postSource,
+ * __msgMaskMap, and __bindingSources on a component variable.  These are
+ * non-enumerable so they don't appear in JSON.stringify(componentDef) but are
+ * visible to devtools.
+ */
+export function generateCompilerCacheProps(varName, componentName) {
+    const entry = compilerCache.get(componentName);
+    if (!entry)
+        return '';
+    return (`\nObject.defineProperty(${varName}, '__preSource', { value: ${JSON.stringify(entry.preSource)}, enumerable: false, configurable: true })` +
+        `\nObject.defineProperty(${varName}, '__postSource', { value: ${JSON.stringify(entry.postSource)}, enumerable: false, configurable: true })` +
+        `\nObject.defineProperty(${varName}, '__msgMaskMap', { value: ${JSON.stringify(entry.msgMaskMap)}, enumerable: false, configurable: true })` +
+        `\nObject.defineProperty(${varName}, '__bindingSources', { value: ${JSON.stringify(entry.bindingSources)}, enumerable: false, configurable: true })`);
+}
+/**
+ * After the full output string is assembled, update each cached component's
+ * postSource (extract view body from the transformed output), then append
+ * Object.defineProperty calls for all four compiler-cache properties.
+ */
+export function appendCompilerCacheProps(output, componentDecls) {
+    let result = output;
+    for (const { varName, componentName } of componentDecls) {
+        const existing = compilerCache.get(componentName);
+        if (!existing)
+            continue;
+        // Update the cache entry with the post-transform view body
+        const postSource = extractViewBody(output) ?? '';
+        compilerCache.set(componentName, { ...existing, postSource });
+        // Append non-enumerable property definitions
+        result += generateCompilerCacheProps(varName, componentName);
+    }
+    return result;
+}
+//# sourceMappingURL=transform.js.map