@llui/compiler 0.3.0 → 0.3.2

package/dist/transform.js

@@ -28,47 +28,7 @@ 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';
+import { createLintModules } from './lint-modules.js';
 export function createMaskLiteral(f, mask) {
     if (mask >= 0)
         return f.createNumericLiteral(mask);
@@ -227,6 +187,16 @@ export function transformLlui(source, _filename, devMode = false, emitAgentMetad
     let usesElSplit = false;
     let usesMemo = false;
     let usesApplyBinding = false;
+    // v0.4 size-cut: element-rewrite emits `__bindUncertain` for prop values
+    // it can't statically classify (e.g. function-parameter identifiers).
+    // The flag drives the cleanupImports pass to add the runtime import.
+    let usesBindUncertain = false;
+    // v0.4 size-cut (Tier 1.2): per-file set of primitive imports needed by
+    // the `__view` factories we synthesize alongside each `component()` call.
+    // The runtime calls `def.__view(send)` instead of `createView(send)`, so
+    // each component only pulls in the primitives it actually destructures —
+    // killing the view-bag tree-shaking leak that pulled all primitives.
+    const viewBagPrimitivesNeeded = new Set();
     let usesCloneStaticTemplate = false;
     const f = ts.factory;
     const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
@@ -320,55 +290,13 @@ export function transformLlui(source, _filename, devMode = false, emitAgentMetad
     // 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());
+    // Always-on lint rules. Single source of truth lives in
+    // `./lint-modules.ts` so adding/removing a rule propagates to both
+    // the transform pipeline and the rule-docs generator
+    // (`scripts/generate-rule-docs.ts`). LLM-first authoring requires
+    // non-bypassable correctness signals: every rule emits at
+    // `severity: error`.
+    activeModules.push(...createLintModules());
     // eachMemoModule wraps allocating each() items accessors in
     // `memo(...)` via `transformCallEnter`. Activated when the file
     // has any reactive paths (mirrors the inline call's gating).
@@ -455,7 +383,10 @@ export function transformLlui(source, _filename, devMode = false, emitAgentMetad
         lluiImport,
     }));
     const registry = new ModuleRegistry(activeModules);
-    const registryResult = registry.run(sourceFile);
+    // `typeSources` flows through to lint modules that need cross-file
+    // visibility (e.g. agent-emits-drift's imported-Msg case). Same
+    // shape as `ModuleExternalTypes`.
+    const registryResult = registry.run(sourceFile, undefined, typeSources);
     // 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,
@@ -496,6 +427,8 @@ export function transformLlui(source, _filename, devMode = false, emitAgentMetad
             usesElTemplate = true;
         if (erState.usesCloneStaticTemplate)
             usesCloneStaticTemplate = true;
+        if (erState.usesBindUncertain)
+            usesBindUncertain = true;
         if (erState.compiled.size > 0 ||
             erState.usesElSplit ||
             erState.usesElTemplate ||
@@ -716,6 +649,13 @@ export function transformLlui(source, _filename, devMode = false, emitAgentMetad
             // 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);
+            // v0.4 size-cut (Tier 1.2): synthesize __view = (send) => ({ send, ... })
+            // containing ONLY the primitives this component's view callback
+            // destructures. The runtime prefers __view over createView for compiled
+            // components, eliminating the all-primitives reference chain through
+            // view-helpers.ts. Each primitive becomes its own top-level import,
+            // tree-shaken by Rollup when no component destructures it.
+            result = injectViewBag(result ?? node, viewBagPrimitivesNeeded, f);
             // __schemaHash: migrated to schemaHashModule (v2c/decomp-5).
             // When shouldEmitAgentMetadata is true, schemaHashModule is in
             // the active module list and produces the emission via the
@@ -745,7 +685,7 @@ export function transformLlui(source, _filename, devMode = false, emitAgentMetad
     // 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);
+    transformed = cleanupImports(transformed, lluiImport, importedHelpers, safeToRemove, usesElSplit, usesElTemplate, usesMemo, usesApplyBinding, usesCloneStaticTemplate, scopeRegistrationsInjected, viewBagPrimitivesNeeded, usesBindUncertain, f);
     if (edits.length === 0) {
         // No element-helper rewrites — but registry may still have
         // collected diagnostics (e.g. agent-rule errors on Msg variants
@@ -1007,6 +947,141 @@ const VIEW_HELPER_PRIMITIVES = new Set([
     'slice',
     'send',
 ]);
+// v0.4 size-cut (Tier 1.2): bag-field → runtime-primitive map. `ctx` is
+// the only rename — every other destructured name maps 1:1 to its
+// primitive's exported identifier from `@llui/dom`. Fields not in this
+// map (e.g. `send`) are handled separately or omitted.
+const VIEW_BAG_FIELD_TO_PRIMITIVE = {
+    show: 'show',
+    branch: 'branch',
+    scope: 'scope',
+    each: 'each',
+    text: 'text',
+    unsafeHtml: 'unsafeHtml',
+    memo: 'memo',
+    selector: 'selector',
+    sample: 'sample',
+    clientOnly: 'clientOnly',
+    ctx: 'useContext',
+};
+/**
+ * Splice a `__view: (send) => ({ send, name1, name2, ... })` property into
+ * a `component({...})` call's config-arg literal. The synthesized factory
+ * lets the runtime build a minimal view bag that references only the
+ * primitives this component's view destructures — replacing the static
+ * `createView` call in mount.ts and eliminating its all-primitives import
+ * chain. Bag-field names other than `send` are added to `needed` so
+ * `cleanupImports` injects matching `@llui/dom` imports at the file level.
+ *
+ * Idempotent — returns `call` unchanged when:
+ *   • the config arg is not an object literal
+ *   • no `view:` property exists, or its value is not an arrow/function
+ *   • the config arg already has a `__view` property (re-run safety)
+ *
+ * Bag fields that aren't in `VIEW_BAG_FIELD_TO_PRIMITIVE` (e.g. unknown
+ * names from a user-typed View extension) are skipped — the runtime
+ * cannot fabricate them, so accessing them at runtime is the user's
+ * problem (matches dev-mode behavior).
+ *
+ * Identifier-style view params (`view: (h) => ...` or `view: (send) => ...`)
+ * can't be statically narrowed to a known subset of primitives — `h` may
+ * be passed to helpers, destructured later, or read dynamically. For
+ * those we emit `__view: ($send) => createView($send)` so the runtime
+ * gets the full bag. The instance-level `_viewBag` cache on
+ * `getInstanceViewBag` means this is still one allocation per mount.
+ */
+function injectViewBag(call, needed, f) {
+    const configArg = call.arguments[0];
+    if (!configArg || !ts.isObjectLiteralExpression(configArg))
+        return call;
+    // Skip if a `__view` is already present (idempotency for re-runs).
+    for (const prop of configArg.properties) {
+        if (ts.isPropertyAssignment(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === '__view') {
+            return call;
+        }
+    }
+    // Find view: arrow/function.
+    let viewFn = null;
+    for (const prop of configArg.properties) {
+        if (ts.isPropertyAssignment(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === 'view' &&
+            (ts.isArrowFunction(prop.initializer) || ts.isFunctionExpression(prop.initializer))) {
+            viewFn = prop.initializer;
+            break;
+        }
+    }
+    if (!viewFn)
+        return call;
+    const sendParamName = f.createIdentifier('$send');
+    // Build the __view factory body. Two shapes:
+    //
+    //   Destructured param — `view: ({ send, text, each }) => ...`
+    //     emit `__view: ($send) => ({ send: $send, text, each })`
+    //     (tree-shakes unused primitives — the Tier 1.2 size cut).
+    //
+    //   Identifier / no param — `view: (h) => ...`, `view: () => ...`,
+    //   `view: (send) => ...`, etc.
+    //     emit `__view: ($send) => createView($send)`
+    //     The compiler can't see which fields `h` is accessed on (it
+    //     may be passed to a helper, destructured later, read by
+    //     name dynamically). Full bag, instance-cached.
+    const firstParam = viewFn.parameters[0];
+    const isDestructured = !!firstParam && ts.isObjectBindingPattern(firstParam.name);
+    let factoryBody;
+    if (isDestructured) {
+        const entries = [];
+        for (const elem of firstParam.name.elements) {
+            const localName = ts.isIdentifier(elem.name) ? elem.name.text : null;
+            const sourceName = elem.propertyName && ts.isIdentifier(elem.propertyName) ? elem.propertyName.text : localName;
+            if (!localName || !sourceName)
+                continue;
+            if (sourceName === 'send') {
+                entries.push({ localName, primitive: null });
+                continue;
+            }
+            const primitive = VIEW_BAG_FIELD_TO_PRIMITIVE[sourceName];
+            if (!primitive)
+                continue; // unknown name — accessing it at runtime is the user's problem
+            entries.push({ localName, primitive });
+        }
+        const bagProps = [];
+        for (const e of entries) {
+            if (e.primitive === null) {
+                bagProps.push(e.localName === '$send'
+                    ? f.createShorthandPropertyAssignment(sendParamName)
+                    : f.createPropertyAssignment(f.createIdentifier(e.localName), sendParamName));
+            }
+            else if (e.localName === e.primitive) {
+                bagProps.push(f.createShorthandPropertyAssignment(f.createIdentifier(e.localName)));
+                needed.add(e.primitive);
+            }
+            else {
+                bagProps.push(f.createPropertyAssignment(f.createIdentifier(e.localName), f.createIdentifier(e.primitive)));
+                needed.add(e.primitive);
+            }
+        }
+        factoryBody = f.createParenthesizedExpression(f.createObjectLiteralExpression(bagProps, false));
+    }
+    else {
+        // Identifier-style or zero-arg view: emit `createView($send)` and
+        // pull `createView` into the file imports via cleanupImports.
+        needed.add('createView');
+        factoryBody = f.createCallExpression(f.createIdentifier('createView'), undefined, [
+            sendParamName,
+        ]);
+    }
+    const viewBagFactory = f.createArrowFunction(undefined, undefined, [
+        f.createParameterDeclaration(undefined, undefined, sendParamName, undefined, undefined, undefined),
+    ], undefined, f.createToken(ts.SyntaxKind.EqualsGreaterThanToken), factoryBody);
+    const newConfig = f.createObjectLiteralExpression([...configArg.properties, f.createPropertyAssignment('__view', viewBagFactory)], true);
+    return f.createCallExpression(call.expression, call.typeArguments, [
+        newConfig,
+        ...call.arguments.slice(1),
+    ]);
+}
 function collectViewHelperAliases(sf, lluiImport, helperNames) {
     const aliases = new Map();
     function addFromBindingPattern(pattern) {
@@ -1115,14 +1190,16 @@ export function isHelperCall(expr, name, helperNames, aliases) {
 // `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) {
+function cleanupImports(sf, lluiImport, _helpers, compiled, usesElSplit, usesElTemplate, usesMemo, usesApplyBinding, usesCloneStaticTemplate, usesRegisterScopeVariants, viewBagPrimitivesNeeded, usesBindUncertain, f) {
     if (compiled.size === 0 &&
         !usesElTemplate &&
         !usesElSplit &&
         !usesMemo &&
         !usesApplyBinding &&
         !usesCloneStaticTemplate &&
-        !usesRegisterScopeVariants)
+        !usesRegisterScopeVariants &&
+        viewBagPrimitivesNeeded.size === 0 &&
+        !usesBindUncertain)
         return sf;
     const clause = lluiImport.importClause;
     if (!clause?.namedBindings || !ts.isNamedImports(clause.namedBindings))
@@ -1132,6 +1209,10 @@ function cleanupImports(sf, lluiImport, _helpers, compiled, usesElSplit, usesElT
     if (!hasElSplit && usesElSplit) {
         remaining.push(f.createImportSpecifier(false, undefined, f.createIdentifier('elSplit')));
     }
+    const hasBindUncertain = clause.namedBindings.elements.some((s) => s.name.text === '__bindUncertain');
+    if (!hasBindUncertain && usesBindUncertain) {
+        remaining.push(f.createImportSpecifier(false, undefined, f.createIdentifier('__bindUncertain')));
+    }
     const hasElTemplate = clause.namedBindings.elements.some((s) => s.name.text === 'elTemplate');
     if (!hasElTemplate && usesElTemplate) {
         remaining.push(f.createImportSpecifier(false, undefined, f.createIdentifier('elTemplate')));
@@ -1159,8 +1240,19 @@ function cleanupImports(sf, lluiImport, _helpers, compiled, usesElSplit, usesElT
     if (!hasRegisterScopeVariants && usesRegisterScopeVariants) {
         remaining.push(f.createImportSpecifier(false, undefined, f.createIdentifier('__registerScopeVariants')));
     }
+    // v0.4 size-cut (Tier 1.2): add @llui/dom imports for each primitive
+    // referenced by synthesized __view factories. `ctx` is the destructured
+    // bag name; its primitive is `useContext` (the only rename pair).
+    for (const prim of viewBagPrimitivesNeeded) {
+        if (!clause.namedBindings.elements.some((s) => s.name.text === prim)) {
+            remaining.push(f.createImportSpecifier(false, undefined, f.createIdentifier(prim)));
+        }
+    }
     const newBindings = f.createNamedImports(remaining);
-    const newClause = f.createImportClause(false, undefined, newBindings);
+    // New TS 6 signature: first arg is `phaseModifier` (undefined =
+    // regular import; `ts.SyntaxKind.TypeKeyword` = `import type`).
+    // The legacy boolean overload is deprecated.
+    const newClause = f.createImportClause(undefined, undefined, newBindings);
     const newImportDecl = f.createImportDeclaration(undefined, newClause, lluiImport.moduleSpecifier);
     let replaced = false;
     const statements = sf.statements.map((stmt) => {
@@ -1168,7 +1260,10 @@ function cleanupImports(sf, lluiImport, _helpers, compiled, usesElSplit, usesElT
             ts.isImportDeclaration(stmt) &&
             ts.isStringLiteral(stmt.moduleSpecifier) &&
             stmt.moduleSpecifier.text === '@llui/dom' &&
-            !stmt.importClause?.isTypeOnly) {
+            // `phaseModifier === ts.SyntaxKind.TypeKeyword` is `import type
+            // …`; we only want to rewrite value imports. Replaces deprecated
+            // `isTypeOnly` from the TS<6 API.
+            stmt.importClause?.phaseModifier !== ts.SyntaxKind.TypeKeyword) {
             replaced = true;
             return newImportDecl;
         }