@llui/compiler 0.3.0

package/dist/manifest.js

@@ -0,0 +1,209 @@
+// __llui_deps.json — v2b library-boundary manifest (§4.2).
+//
+// Every published @llui/* package (and any third-party package that wants
+// compiler-level integration) emits a manifest declaring each exported
+// helper's reactive footprint: paths read directly, paths reached through
+// accessor parameters, and context-provider keys consumed.
+//
+// The schema is the result of validating against the real @llui/components
+// surface — every shape here is needed by some real helper. New shapes
+// require a schema-version bump + a worked example in §4.3.
+//
+// The substitution algorithm (`substituteHelperCall`) consumes a manifest
+// entry plus a call-site's argument expressions and computes the set of
+// host-state paths the call contributes to the consumer's __prefixes.
+import ts from 'typescript';
+const MAX_SUBSTITUTION_DEPTH = 8;
+/**
+ * Substitute a manifest helper call against its call-site arguments.
+ *
+ * Given a helper's manifest entry and the argument expressions at one call
+ * site, returns the set of host-state paths the call contributes to the
+ * consumer's __prefixes table.
+ *
+ * §4.4 substitution rules:
+ *   1. For each ViaParams entry, resolve the call-site argument.
+ *   2. `shape: 'accessor'` parameters are walked via `extractPaths`.
+ *   3. `shape: 'options-bag'` parameters are unpacked field-by-field
+ *      against the call site's object-literal argument.
+ *   4. `innerReads` are composed against the resolved accessors:
+ *      - rooted: helper-local, contributed verbatim
+ *      - param-result: paths from param N's body
+ *      - param-result-path: lift + sub-path composition
+ *   5. `readsThroughResultOf: N` — param's body operates on param N's
+ *      result; substitution composes through N's accessor.
+ *   6. `contextReads` — resolved against `providers`; provider.accessor +
+ *      subPaths compose to host-state paths.
+ *   7. Depth bounded at 8; cycles caught by `(helper-symbol, param-index)`
+ *      visited set.
+ */
+export function substituteHelperCall(entry, callArgs, ctx, helperKey = 'anonymous', visited = new Set(), depth = 0) {
+    const out = { paths: [], diagnostics: [], fullMask: false };
+    if (depth > MAX_SUBSTITUTION_DEPTH) {
+        out.diagnostics.push({
+            id: 'llui/substitution-depth-exceeded',
+            message: `Substitution depth exceeded 8 at helper "${helperKey}" (likely deep helper chain); contributing FULL_MASK at this call site.`,
+        });
+        out.fullMask = true;
+        return out;
+    }
+    // 1. Helper-local paths — rare; contributed verbatim. Reserved for the
+    //    case where the helper's "host state shape" equals the consumer's
+    //    (e.g. trivial passthrough helpers).
+    for (const p of entry.helperLocalPaths)
+        out.paths.push(p);
+    // 2. Per-parameter resolution.
+    for (const param of entry.viaParams) {
+        const arg = callArgs[param.index];
+        if (param.shape === 'send' || param.shape === 'opaque') {
+            // No path contribution — send is a Send<M> ref, opaque is intentional.
+            continue;
+        }
+        if (param.shape === 'thunk-returning-nodes') {
+            // The call site provides a `() => Node[]` thunk that closes over
+            // consumer-scope accessors. The substitution layer can't see inside
+            // the closure without re-walking the consumer's view source — that
+            // walk happens at the consumer's compile step, not here. We mark
+            // this param's contribution as "must be walked by consumer", which
+            // the cross-file walker handles by recursing into the thunk body
+            // directly. The manifest substitution itself contributes no paths.
+            continue;
+        }
+        if (param.shape === 'options-bag') {
+            if (!arg || !ts.isObjectLiteralExpression(arg)) {
+                // Non-literal options bag (variable reference, spread, etc.) is
+                // FULL_MASK at this call site. Real-world consumers do sometimes
+                // pre-build the options bag; we accept the cost and warn.
+                out.diagnostics.push({
+                    id: 'llui/opaque-options-bag',
+                    message: `Options-bag argument at index ${param.index} of "${helperKey}" is not an object literal; contributing FULL_MASK.`,
+                });
+                out.fullMask = true;
+                continue;
+            }
+            // Unpack: each field listed in `fields` is matched against the
+            // call-site object literal's property.
+            for (const [fieldName, fieldSpec] of Object.entries(param.fields)) {
+                const prop = arg.properties.find((p) => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === fieldName);
+                if (!prop || !ts.isPropertyAssignment(prop))
+                    continue;
+                const fieldExpr = prop.initializer;
+                substituteField(fieldSpec, fieldExpr, ctx, helperKey, visited, depth, out, entry);
+            }
+            continue;
+        }
+        // shape: 'accessor'
+        // Compose helper's innerReads. Each `kind: 'param-result*'` reads
+        // through `callArgs[from]`'s accessor — which may be a different
+        // parameter (the readsThroughResultOf case). Hence the resolver
+        // takes `from` per innerRead, not the enclosing `param.index`.
+        for (const ir of param.innerReads) {
+            if (ir.kind === 'rooted') {
+                out.paths.push(ir.path);
+                continue;
+            }
+            const liftPaths = liftPathsForArg(callArgs[ir.from], ctx);
+            if (ir.kind === 'param-result') {
+                for (const p of liftPaths)
+                    out.paths.push(p);
+            }
+            else if (ir.kind === 'param-result-path') {
+                for (const lift of liftPaths) {
+                    out.paths.push(lift ? `${lift}.${ir.path}` : ir.path);
+                }
+            }
+        }
+    }
+    // 6. Context-provider reads.
+    if (entry.contextReads) {
+        for (const cr of entry.contextReads) {
+            const provider = ctx.providers.get(cr.context);
+            if (!provider) {
+                out.diagnostics.push({
+                    id: 'llui/missing-context-provider',
+                    message: `Helper "${helperKey}" reads from context "${cr.context}" but no matching provide(${cr.context}, ...) call was found in the consumer. The reads will fall back to FULL_MASK; add a provider or wrap the helper's call site in one.`,
+                });
+                out.fullMask = true;
+                continue;
+            }
+            if (!provider.accessor)
+                continue;
+            const rootParamName = getFirstParamName(provider.accessor);
+            if (!rootParamName)
+                continue;
+            const liftPaths = ctx.extractPaths(provider.accessor, rootParamName);
+            for (const lift of liftPaths) {
+                for (const sub of cr.subPaths) {
+                    out.paths.push(lift ? `${lift}.${sub}` : sub);
+                }
+            }
+        }
+    }
+    // Dedup. Use a Set roundtrip — order is incidental for __prefixes.
+    out.paths = [...new Set(out.paths)];
+    return out;
+}
+function substituteField(fieldSpec, fieldExpr, ctx, helperKey, visited, depth, out, entry) {
+    if (fieldSpec.shape === 'send' || fieldSpec.shape === 'opaque')
+        return;
+    if (fieldSpec.shape === 'thunk-returning-nodes')
+        return; // consumer's view walker handles this
+    // shape: 'accessor' — field's innerReads compose against the field
+    // expression's accessor (depth-1 within the options bag).
+    const liftPaths = liftPathsForArg(fieldExpr, ctx);
+    for (const ir of fieldSpec.innerReads) {
+        if (ir.kind === 'rooted') {
+            out.paths.push(ir.path);
+        }
+        else if (ir.kind === 'param-result') {
+            for (const p of liftPaths)
+                out.paths.push(p);
+        }
+        else if (ir.kind === 'param-result-path') {
+            for (const lift of liftPaths) {
+                out.paths.push(lift ? `${lift}.${ir.path}` : ir.path);
+            }
+        }
+    }
+    // Silence the unused `entry`/`visited`/`helperKey`/`depth` — kept in
+    // the signature to mirror substituteHelperCall and ease the eventual
+    // recursive substitution Phase 3 lands.
+    void entry;
+    void visited;
+    void helperKey;
+    void depth;
+}
+/**
+ * Walk the call-site argument (or options-bag field) as an accessor and
+ * return its dotted path reads. Returns [] when the arg is not an arrow/
+ * function expression — substitution falls through to no contribution.
+ */
+function liftPathsForArg(arg, ctx) {
+    if (!arg)
+        return [];
+    const accessor = unwrapAccessorArg(arg);
+    if (!accessor)
+        return [];
+    const rootParamName = getFirstParamName(accessor);
+    if (!rootParamName)
+        return [];
+    return ctx.extractPaths(accessor, rootParamName);
+}
+/**
+ * Unwrap a call-site argument into the accessor function expression, if any.
+ * Accepts inline arrows, function expressions, and identifiers that
+ * resolve to a local const initializer (one level — Phase 3's walker
+ * generalizes this via the existing `resolveAccessorBody`).
+ */
+function unwrapAccessorArg(arg) {
+    if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg))
+        return arg;
+    return null;
+}
+function getFirstParamName(fn) {
+    const p0 = fn.parameters[0];
+    if (!p0 || !ts.isIdentifier(p0.name))
+        return undefined;
+    return p0.name.text;
+}
+//# sourceMappingURL=manifest.js.map

package/dist/manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.js","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"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","sourcesContent":["// __llui_deps.json — v2b library-boundary manifest (§4.2).\n//\n// Every published @llui/* package (and any third-party package that wants\n// compiler-level integration) emits a manifest declaring each exported\n// helper's reactive footprint: paths read directly, paths reached through\n// accessor parameters, and context-provider keys consumed.\n//\n// The schema is the result of validating against the real @llui/components\n// surface — every shape here is needed by some real helper. New shapes\n// require a schema-version bump + a worked example in §4.3.\n//\n// The substitution algorithm (`substituteHelperCall`) consumes a manifest\n// entry plus a call-site's argument expressions and computes the set of\n// host-state paths the call contributes to the consumer's __prefixes.\n\nimport ts from 'typescript'\n\n// ── Schema ──────────────────────────────────────────────────────────\n\nexport interface Manifest {\n  /** Schema version. Frozen at 1 in v2b. */\n  version: 1\n  /** Compiler version that emitted this manifest. */\n  compilerVersion: string\n  /** Exported helpers keyed by name. */\n  helpers: Record<string, HelperEntry>\n  /** Exported components keyed by name (for completeness; not used in v2b's substitution). */\n  components: Record<string, ComponentEntry>\n}\n\nexport interface HelperEntry {\n  /**\n   * `'view-helper'` — the call returns Node[]-like and is resolved once per\n   * call site.\n   * `'parts-helper'` — the call returns a *parts bag* (a record of accessor\n   * thunks). The bag is later spread into element calls by the consumer;\n   * every spread contributes the same read set.\n   */\n  kind: 'view-helper' | 'parts-helper'\n  /** Paths the helper reads from its OWN state shape (rare; usually empty). */\n  helperLocalPaths: string[]\n  /** Per-parameter substitution metadata. Index N corresponds to the helper's Nth declared parameter. */\n  viaParams: ParamSpec[]\n  /** Context-provider keys this helper consumes. Resolved against the consumer's provide() call sites. */\n  contextReads?: ContextRead[]\n}\n\nexport interface ComponentEntry {\n  /** Reserved for v2b's read-everything-the-component-reads escape hatch. Unused at v2b ship. */\n  name: string\n}\n\nexport type ParamSpec =\n  | { index: number; shape: 'accessor'; innerReads: InnerRead[] }\n  | {\n      index: number\n      shape: 'accessor'\n      /** This parameter's body operates on the result of parameter N. */\n      readsThroughResultOf: number\n      innerReads: InnerRead[]\n    }\n  | { index: number; shape: 'options-bag'; fields: Record<string, FieldSpec> }\n  | { index: number; shape: 'send' }\n  | { index: number; shape: 'thunk-returning-nodes' }\n  | { index: number; shape: 'opaque' }\n\nexport type FieldSpec =\n  | { shape: 'accessor'; innerReads: InnerRead[] }\n  | {\n      shape: 'accessor'\n      readsThroughResultOf: number\n      innerReads: InnerRead[]\n    }\n  | { shape: 'send' }\n  | { shape: 'thunk-returning-nodes' }\n  | { shape: 'opaque' }\n\nexport type InnerRead =\n  /** Helper-local read — rare; the helper sees state directly. */\n  | { kind: 'rooted'; path: string }\n  /** The entire result of parameter N. */\n  | { kind: 'param-result'; from: number }\n  /** A sub-path within parameter N's accessor result. The dominant kind across @llui/components. */\n  | { kind: 'param-result-path'; from: number; path: string }\n\nexport interface ContextRead {\n  /** Canonical id: `<package-name>#<export-name>`. */\n  context: string\n  /** Sub-paths within the context value the helper reads. */\n  subPaths: string[]\n}\n\n// ── Substitution algorithm (§4.4) ───────────────────────────────────\n\nexport interface ContextProvider {\n  context: string\n  /** Source AST for the consumer's `provide(LocaleContext, (s) => s.i18n, ...)` accessor. */\n  accessor: ts.ArrowFunction | ts.FunctionExpression | undefined\n}\n\nexport interface SubstitutionContext {\n  /** Maps canonical context ids to the consumer's matching provide(...) accessor. */\n  providers: Map<string, ContextProvider>\n  /**\n   * Path-extraction hook. Walks an arrow body and returns the dotted paths\n   * it reads. The cross-file walker injects its `extractAccessorPaths`\n   * here; tests can stub with a simpler walker.\n   */\n  extractPaths: (\n    accessor: ts.ArrowFunction | ts.FunctionExpression,\n    rootParamName: string,\n  ) => string[]\n}\n\nexport interface SubstitutionResult {\n  /** Host-state paths contributed by this call site, e.g. `['carousel.paused', 'carousel.current']`. */\n  paths: string[]\n  /** Diagnostics emitted by the substitution. */\n  diagnostics: SubstitutionDiagnostic[]\n  /** Whether the call site fell back to FULL_MASK (e.g. unrecognized options-bag shape). */\n  fullMask: boolean\n}\n\nexport interface SubstitutionDiagnostic {\n  id:\n    | 'llui/opaque-options-bag'\n    | 'llui/missing-context-provider'\n    | 'llui/substitution-depth-exceeded'\n    | 'llui/substitution-cycle'\n  message: string\n}\n\nconst MAX_SUBSTITUTION_DEPTH = 8\n\n/**\n * Substitute a manifest helper call against its call-site arguments.\n *\n * Given a helper's manifest entry and the argument expressions at one call\n * site, returns the set of host-state paths the call contributes to the\n * consumer's __prefixes table.\n *\n * §4.4 substitution rules:\n *   1. For each ViaParams entry, resolve the call-site argument.\n *   2. `shape: 'accessor'` parameters are walked via `extractPaths`.\n *   3. `shape: 'options-bag'` parameters are unpacked field-by-field\n *      against the call site's object-literal argument.\n *   4. `innerReads` are composed against the resolved accessors:\n *      - rooted: helper-local, contributed verbatim\n *      - param-result: paths from param N's body\n *      - param-result-path: lift + sub-path composition\n *   5. `readsThroughResultOf: N` — param's body operates on param N's\n *      result; substitution composes through N's accessor.\n *   6. `contextReads` — resolved against `providers`; provider.accessor +\n *      subPaths compose to host-state paths.\n *   7. Depth bounded at 8; cycles caught by `(helper-symbol, param-index)`\n *      visited set.\n */\nexport function substituteHelperCall(\n  entry: HelperEntry,\n  callArgs: ReadonlyArray<ts.Expression>,\n  ctx: SubstitutionContext,\n  helperKey = 'anonymous',\n  visited = new Set<string>(),\n  depth = 0,\n): SubstitutionResult {\n  const out: SubstitutionResult = { paths: [], diagnostics: [], fullMask: false }\n\n  if (depth > MAX_SUBSTITUTION_DEPTH) {\n    out.diagnostics.push({\n      id: 'llui/substitution-depth-exceeded',\n      message: `Substitution depth exceeded 8 at helper \"${helperKey}\" (likely deep helper chain); contributing FULL_MASK at this call site.`,\n    })\n    out.fullMask = true\n    return out\n  }\n\n  // 1. Helper-local paths — rare; contributed verbatim. Reserved for the\n  //    case where the helper's \"host state shape\" equals the consumer's\n  //    (e.g. trivial passthrough helpers).\n  for (const p of entry.helperLocalPaths) out.paths.push(p)\n\n  // 2. Per-parameter resolution.\n  for (const param of entry.viaParams) {\n    const arg = callArgs[param.index]\n\n    if (param.shape === 'send' || param.shape === 'opaque') {\n      // No path contribution — send is a Send<M> ref, opaque is intentional.\n      continue\n    }\n\n    if (param.shape === 'thunk-returning-nodes') {\n      // The call site provides a `() => Node[]` thunk that closes over\n      // consumer-scope accessors. The substitution layer can't see inside\n      // the closure without re-walking the consumer's view source — that\n      // walk happens at the consumer's compile step, not here. We mark\n      // this param's contribution as \"must be walked by consumer\", which\n      // the cross-file walker handles by recursing into the thunk body\n      // directly. The manifest substitution itself contributes no paths.\n      continue\n    }\n\n    if (param.shape === 'options-bag') {\n      if (!arg || !ts.isObjectLiteralExpression(arg)) {\n        // Non-literal options bag (variable reference, spread, etc.) is\n        // FULL_MASK at this call site. Real-world consumers do sometimes\n        // pre-build the options bag; we accept the cost and warn.\n        out.diagnostics.push({\n          id: 'llui/opaque-options-bag',\n          message: `Options-bag argument at index ${param.index} of \"${helperKey}\" is not an object literal; contributing FULL_MASK.`,\n        })\n        out.fullMask = true\n        continue\n      }\n      // Unpack: each field listed in `fields` is matched against the\n      // call-site object literal's property.\n      for (const [fieldName, fieldSpec] of Object.entries(param.fields)) {\n        const prop = arg.properties.find(\n          (p) => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === fieldName,\n        )\n        if (!prop || !ts.isPropertyAssignment(prop)) continue\n        const fieldExpr = prop.initializer\n        substituteField(fieldSpec, fieldExpr, ctx, helperKey, visited, depth, out, entry)\n      }\n      continue\n    }\n\n    // shape: 'accessor'\n    // Compose helper's innerReads. Each `kind: 'param-result*'` reads\n    // through `callArgs[from]`'s accessor — which may be a different\n    // parameter (the readsThroughResultOf case). Hence the resolver\n    // takes `from` per innerRead, not the enclosing `param.index`.\n    for (const ir of param.innerReads) {\n      if (ir.kind === 'rooted') {\n        out.paths.push(ir.path)\n        continue\n      }\n      const liftPaths = liftPathsForArg(callArgs[ir.from], ctx)\n      if (ir.kind === 'param-result') {\n        for (const p of liftPaths) out.paths.push(p)\n      } else if (ir.kind === 'param-result-path') {\n        for (const lift of liftPaths) {\n          out.paths.push(lift ? `${lift}.${ir.path}` : ir.path)\n        }\n      }\n    }\n  }\n\n  // 6. Context-provider reads.\n  if (entry.contextReads) {\n    for (const cr of entry.contextReads) {\n      const provider = ctx.providers.get(cr.context)\n      if (!provider) {\n        out.diagnostics.push({\n          id: 'llui/missing-context-provider',\n          message: `Helper \"${helperKey}\" reads from context \"${cr.context}\" but no matching provide(${cr.context}, ...) call was found in the consumer. The reads will fall back to FULL_MASK; add a provider or wrap the helper's call site in one.`,\n        })\n        out.fullMask = true\n        continue\n      }\n      if (!provider.accessor) continue\n      const rootParamName = getFirstParamName(provider.accessor)\n      if (!rootParamName) continue\n      const liftPaths = ctx.extractPaths(provider.accessor, rootParamName)\n      for (const lift of liftPaths) {\n        for (const sub of cr.subPaths) {\n          out.paths.push(lift ? `${lift}.${sub}` : sub)\n        }\n      }\n    }\n  }\n\n  // Dedup. Use a Set roundtrip — order is incidental for __prefixes.\n  out.paths = [...new Set(out.paths)]\n  return out\n}\n\nfunction substituteField(\n  fieldSpec: FieldSpec,\n  fieldExpr: ts.Expression,\n  ctx: SubstitutionContext,\n  helperKey: string,\n  visited: Set<string>,\n  depth: number,\n  out: SubstitutionResult,\n  entry: HelperEntry,\n): void {\n  if (fieldSpec.shape === 'send' || fieldSpec.shape === 'opaque') return\n  if (fieldSpec.shape === 'thunk-returning-nodes') return // consumer's view walker handles this\n\n  // shape: 'accessor' — field's innerReads compose against the field\n  // expression's accessor (depth-1 within the options bag).\n  const liftPaths = liftPathsForArg(fieldExpr, ctx)\n  for (const ir of fieldSpec.innerReads) {\n    if (ir.kind === 'rooted') {\n      out.paths.push(ir.path)\n    } else if (ir.kind === 'param-result') {\n      for (const p of liftPaths) out.paths.push(p)\n    } else if (ir.kind === 'param-result-path') {\n      for (const lift of liftPaths) {\n        out.paths.push(lift ? `${lift}.${ir.path}` : ir.path)\n      }\n    }\n  }\n  // Silence the unused `entry`/`visited`/`helperKey`/`depth` — kept in\n  // the signature to mirror substituteHelperCall and ease the eventual\n  // recursive substitution Phase 3 lands.\n  void entry\n  void visited\n  void helperKey\n  void depth\n}\n\n/**\n * Walk the call-site argument (or options-bag field) as an accessor and\n * return its dotted path reads. Returns [] when the arg is not an arrow/\n * function expression — substitution falls through to no contribution.\n */\nfunction liftPathsForArg(arg: ts.Expression | undefined, ctx: SubstitutionContext): string[] {\n  if (!arg) return []\n  const accessor = unwrapAccessorArg(arg)\n  if (!accessor) return []\n  const rootParamName = getFirstParamName(accessor)\n  if (!rootParamName) return []\n  return ctx.extractPaths(accessor, rootParamName)\n}\n\n/**\n * Unwrap a call-site argument into the accessor function expression, if any.\n * Accepts inline arrows, function expressions, and identifiers that\n * resolve to a local const initializer (one level — Phase 3's walker\n * generalizes this via the existing `resolveAccessorBody`).\n */\nfunction unwrapAccessorArg(arg: ts.Expression): ts.ArrowFunction | ts.FunctionExpression | null {\n  if (ts.isArrowFunction(arg) || ts.isFunctionExpression(arg)) return arg\n  return null\n}\n\nfunction getFirstParamName(fn: ts.ArrowFunction | ts.FunctionExpression): string | undefined {\n  const p0 = fn.parameters[0]\n  if (!p0 || !ts.isIdentifier(p0.name)) return undefined\n  return p0.name.text\n}\n"]}

package/dist/module.d.ts

@@ -0,0 +1,222 @@
+import ts from 'typescript';
+import type { Diagnostic } from './diagnostic.js';
+export interface DiagnosticDefinition {
+    /** Stable id, e.g. `llui/opaque-view-call`. Per v2c §3 §8.2. */
+    id: string;
+    /** One-line description; useful for adapter UIs that don't render the message. */
+    description: string;
+}
+/**
+ * Per-file analysis output. Modules accumulate findings here during
+ * visitor dispatch; emit consumes it. The shape is intentionally
+ * open-ended — modules name their own slots and the umbrella's
+ * orchestrator never inspects them, only forwards.
+ */
+export interface FileAnalysis {
+    /** Source file the analysis ran over. */
+    sourceFile: ts.SourceFile;
+    /** Per-module accumulator buckets, keyed by module name. */
+    perModule: Map<string, unknown>;
+    /** Diagnostics emitted during the walk. */
+    diagnostics: Diagnostic[];
+}
+/**
+ * Context passed to every visitor invocation. Modules use it to record
+ * findings, emit diagnostics, and consult shared state (the TS
+ * Compiler-API checker, the project root, sibling-module findings if
+ * dependencies allow).
+ */
+export interface AnalysisContext {
+    sourceFile: ts.SourceFile;
+    /** TS TypeChecker, when the host adapter has built a Program. May be undefined for AST-only paths. */
+    checker: ts.TypeChecker | undefined;
+    /**
+     * Get the named module's accumulator slot (creating it lazily). The
+     * slot is whatever shape the module wrote; type-safe access is the
+     * module author's responsibility — typically via a typed `get<T>()`
+     * wrapper exported alongside the module.
+     */
+    getSlot<T>(moduleName: string, init: () => T): T;
+    /** Record a diagnostic. The diagnostic's `id` should match one declared in `DiagnosticDefinition[]`. */
+    reportDiagnostic(d: Diagnostic): void;
+}
+export interface EmissionContribution {
+    /** Module emitting this contribution — used for conflict reporting. */
+    module: string;
+    /** Field name on the `ComponentDef` object literal (e.g. `__msgSchema`). */
+    field: string;
+    /** AST expression to assign. The umbrella merges into the component()'s config arg. */
+    value: ts.Expression;
+    /**
+     * Optional per-call target. When set, this contribution applies only
+     * to the named `component()` call expression; the umbrella's
+     * emission-merger writes the field into that call's config-arg
+     * object literal. When omitted, the contribution is *file-global*:
+     * the merger writes the field into every `component()` call in the
+     * file (the common case — `__msgSchema`, `__prefixes`, `__schemaHash`
+     * are file-shape-derived).
+     *
+     * Per-call target is needed for `__componentMeta` (file + line vary
+     * per call site) and any other field whose value depends on the
+     * specific `component()` call location.
+     *
+     * Conflict-detection runs per-(field, target) tuple — two modules
+     * may both contribute `__custom` if they target *different* call
+     * expressions; same target on the same field is still an error.
+     */
+    target?: ts.CallExpression;
+}
+export interface EmissionContext {
+    sourceFile: ts.SourceFile;
+    factory: ts.NodeFactory;
+}
+/**
+ * A compiler module declares:
+ *   - identification (name, compilerVersion semver against the umbrella);
+ *   - the diagnostics it can emit (stable IDs);
+ *   - per-`SyntaxKind` visitor handlers (the walker dispatches each AST
+ *     node once; every module with a handler for its kind sees it);
+ *   - optionally, an `emit` function that contributes ComponentDef fields
+ *     after the walk completes;
+ *   - optionally, `runtimeImports` declaring which `@llui/dom` symbols
+ *     its emissions reference.
+ */
+export interface CompilerModule {
+    name: string;
+    /** Semver range against the compiler API. v2c §5. */
+    compilerVersion: string;
+    /** Modules this one depends on. The registry verifies presence at activation. */
+    dependsOn?: string[];
+    diagnostics: DiagnosticDefinition[];
+    /**
+     * Optional AST pre-transform. Called once per file BEFORE the
+     * visitor walk and emission phase. Returns a (possibly rewritten)
+     * SourceFile; the result is threaded through subsequent modules'
+     * pre-transforms (in declaration order) and then becomes the file
+     * the visitor walks. Use for AST mutations the visitor model can't
+     * cleanly express — adjacent statement insertion, wrapping arrow
+     * expressions, etc. The agent's connect-pattern pass and the
+     * universal handler-tagger are the canonical examples (MODULE-MAPPING.md
+     * binding-descriptors entry).
+     *
+     * Most modules do NOT need this. Visitor + emit is the preferred
+     * shape because it composes deterministically across modules without
+     * threading a mutable SourceFile through each one. preTransform
+     * exists for the cases where AST mutation is unavoidable.
+     *
+     * The §2.1 "walker runs once per file" invariant is preserved: the
+     * VISITOR walk runs once. preTransform passes are additional, but
+     * they're typically cheap (targeted call-site rewrites, not deep
+     * recursive walks) and execute before the single visitor walk.
+     */
+    preTransform?(ctx: PreTransformContext, sf: ts.SourceFile): ts.SourceFile;
+    visitors: {
+        [K in ts.SyntaxKind]?: (ctx: AnalysisContext, node: ts.Node) => void;
+    };
+    /**
+     * Optional per-call AST rewrite, BOTTOM-UP (after children visited).
+     * Called once per `CallExpression` during the post-visitor transform
+     * phase, AFTER analysis has accumulated findings in
+     * `analysis.perModule` AND after `ts.visitEachChild` has recursively
+     * rewritten the node's children. Returns either:
+     *   - `null` — node unchanged; chain continues with the next module's
+     *     transformCall (if any).
+     *   - a new `ts.CallExpression` — node replaced; subsequent modules'
+     *     transformCall hooks see the new node (composes in declaration
+     *     order, just like preTransform).
+     *
+     * Use for rewrites that depend on the rewritten children — e.g.
+     * row-factory emission inspects the render body for an already-emitted
+     * `elTemplate(...)` call, so element rewrites that produce
+     * `elTemplate` MUST have fired first. Module authors should treat
+     * transformCall as a pure function of its inputs (the node + analysis
+     * findings).
+     */
+    transformCall?(ctx: TransformCallContext, node: ts.CallExpression): ts.CallExpression | null;
+    /**
+     * Optional per-call AST rewrite, TOP-DOWN (before children visited).
+     * Mirrors `transformCall` but fires BEFORE `ts.visitEachChild`
+     * recurses into the call's children. Use when the rewrite must happen
+     * before the children are visited — most commonly when the rewrite
+     * changes the call's argument shape and the children's visitor would
+     * misinterpret the original shape. Memo-wrapping the `items:`
+     * accessor of an `each()` call is the canonical example: the wrapped
+     * accessor is what subsequent passes (item-selector dedup, mask
+     * injection) read.
+     *
+     * Both `transformCallEnter` and `transformCall` may be declared by
+     * the same module; enter fires top-down before recursion, transformCall
+     * fires bottom-up after. Ordering within each direction is declaration
+     * order across modules; the two directions never interleave for a
+     * given node.
+     */
+    transformCallEnter?(ctx: TransformCallContext, node: ts.CallExpression): ts.CallExpression | null;
+    /** Called once per file after the visitor pass completes. Returns this module's emission contributions. */
+    emit?(ctx: EmissionContext, analysis: FileAnalysis): EmissionContribution[];
+    /** Runtime symbol names this module's emissions reference (from `@llui/dom`). */
+    runtimeImports?: string[];
+}
+export interface PreTransformContext {
+    factory: ts.NodeFactory;
+    /**
+     * Shared per-file findings accumulator. preTransform passes that
+     * need to communicate with their own emit step (e.g. "this file
+     * needed scope-variant registrations") use this slot map. The same
+     * `analysis.perModule` map is later passed to visitors and emit.
+     */
+    analysis: FileAnalysis;
+}
+/**
+ * Context passed to every `transformCall` invocation. Carries the
+ * factory for building new AST nodes and a read-only view of analysis
+ * findings (visitors have already completed and populated
+ * `analysis.perModule` by the time transformCall fires).
+ */
+export interface TransformCallContext {
+    factory: ts.NodeFactory;
+    /** Read-only access to visitor-phase findings. */
+    analysis: FileAnalysis;
+}
+export interface RegistryRunResult {
+    analysis: FileAnalysis;
+    emissions: EmissionContribution[];
+    /** Union of runtime imports from every active module. */
+    runtimeImports: string[];
+}
+/**
+ * The visitor registry. Built once per compiler boot from the user's
+ * `llui.config.ts` `modules: [...]` array; the umbrella's per-file
+ * pipeline calls `run(sourceFile, checker)` to drive a complete pass.
+ */
+export declare class ModuleRegistry {
+    private readonly modules;
+    /** Pre-indexed by SyntaxKind for O(1) dispatch. */
+    private readonly visitorsByKind;
+    constructor(modules: ReadonlyArray<CompilerModule>);
+    private verifyDependencies;
+    private buildVisitorIndex;
+    /**
+     * Run a full analysis + emission pass over `sourceFile`. Phases:
+     *   1. Pre-transform: each module's `preTransform?` fires in
+     *      declaration order; the (possibly rewritten) SourceFile flows
+     *      through subsequent passes.
+     *   2. Visitor walk: a single AST walk dispatches each node to every
+     *      module's matching SyntaxKind handler. Read-only — visitors
+     *      accumulate findings in `analysis.perModule` but cannot rewrite.
+     *   3. Transform: a `ts.transform`-style walk dispatches each
+     *      `CallExpression` to every module's `transformCallEnter?`
+     *      (top-down, before children recursion) and `transformCall?`
+     *      (bottom-up, after children recursion) hooks in declaration
+     *      order; each hook's return value (if non-null) feeds the next.
+     *      Composes call-site rewrites without each module paying a
+     *      whole-file walk cost.
+     *   4. Emission: each module's `emit?` fires; the registry merges
+     *      contributions, detecting (field, target) conflicts.
+     */
+    run(sourceFile: ts.SourceFile, checker?: ts.TypeChecker): RegistryRunResult;
+    /** Module names in declaration order. Adapters surface this for debug logs / config diagnostics. */
+    listModules(): string[];
+    /** All diagnostic definitions across active modules. Used by adapters to enumerate stable IDs. */
+    listDiagnostics(): DiagnosticDefinition[];
+}
+//# sourceMappingURL=module.d.ts.map

package/dist/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"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"}