@memoized-dom/compiler 0.0.1

package/README.md

@@ -0,0 +1,28 @@
+# Compiler
+
+The top-level files are orchestration and whole-program passes:
+
+| Path | Responsibility |
+|---|---|
+| `src/analysis.ts` | Analysis orchestration, JSX validation, and read attribution |
+| `src/context.ts` | Stable facade for shared context types and AST utilities |
+| `src/emit.ts` | Host JSX DOM emission and structural-region dispatch |
+| `src/handlers.ts` | Handler resolution and callback instrumentation |
+| `src/linker.ts` | Connected module-graph compilation |
+| `src/module-control-flow.ts` | Pure module if/switch computed classification |
+| `src/plugin.ts` | Babel pass ordering and final module rewrite |
+
+Domain folders keep related implementation details discoverable:
+
+| Folder | Responsibility |
+|---|---|
+| `src/analysis/` | Computeds, component paths, instance preludes, and access tables |
+| `src/components/` | Prop contracts, content/ref slots, and linker manifests |
+| `src/context/` | Compiler data model/context construction and raw AST helpers |
+| `src/emission/` | Component factories, generated scopes, and list/conditional regions |
+| `src/handlers/` | Mutation traversal and commit-routing analysis |
+| `src/jsx/` | Ordered attributes, child classification, refs, and namespaces |
+
+The top-level analysis, context, emitter, and handler modules intentionally
+remain stable facades. Cross-domain callers use those facades; implementation
+modules within a domain import their siblings directly.

package/dist/analysis/access-table.d.ts

@@ -0,0 +1,5 @@
+import * as t from '@babel/types';
+import { type Ctx } from '../context';
+/** Build and install the module's state-reader access table. */
+export declare function buildAccessTable(ctx: Ctx): t.Statement | null;
+//# sourceMappingURL=access-table.d.ts.map

package/dist/analysis/access-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"access-table.d.ts","sourceRoot":"","sources":["../../src/analysis/access-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAqB,KAAK,GAAG,EAAE,MAAM,YAAY,CAAC;AAKzD,gEAAgE;AAChE,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,GAAG,GAAG,CAAC,CAAC,SAAS,GAAG,IAAI,CAyF7D"}

package/dist/analysis/component-graph.d.ts

@@ -0,0 +1,10 @@
+import type { Ctx } from '../context';
+/** Resolve every static runtime path at which a component may be mounted. */
+export declare function pathVariants(ctx: Ctx, name: string, visiting?: Set<string>): string[];
+/** Runtime reader patterns for static, conditional, and listed components. */
+export declare function componentPatterns(ctx: Ctx, name: string): string[];
+/** Whether a listed component can use the allocation-free row ABI. */
+export declare function isLightweightListedComponent(ctx: Ctx, name: string): boolean;
+/** Intrinsic row shape used before graph linking marks a component listed. */
+export declare function isListLightweightCandidate(ctx: Ctx, name: string): boolean;
+//# sourceMappingURL=component-graph.d.ts.map

package/dist/analysis/component-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-graph.d.ts","sourceRoot":"","sources":["../../src/analysis/component-graph.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAItC,6EAA6E;AAC7E,wBAAgB,YAAY,CAC1B,GAAG,EAAE,GAAG,EACR,IAAI,EAAE,MAAM,EACZ,QAAQ,GAAE,GAAG,CAAC,MAAM,CAAa,GAChC,MAAM,EAAE,CAuDV;AAED,8EAA8E;AAC9E,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAuClE;AAED,sEAAsE;AACtE,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,GAAG,EACR,IAAI,EAAE,MAAM,GACX,OAAO,CAoBT;AAED,8EAA8E;AAC9E,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAgC1E"}

package/dist/analysis/component-reads.d.ts

@@ -0,0 +1,10 @@
+import { type Ctx } from '../context';
+/** Module dependencies read anywhere in an already-analyzed component tree. */
+export declare function componentSubtreeReads(ctx: Ctx, componentName: string, visiting?: Set<string>): Set<string>;
+/**
+ * Render-callback component trees live under callee-owned row identities, but
+ * their dependencies and refresh manager remain caller-owned. Fold those
+ * static dependencies into the caller access-table entry.
+ */
+export declare function foldRenderCallbackSubtreeReads(ctx: Ctx): void;
+//# sourceMappingURL=component-reads.d.ts.map

package/dist/analysis/component-reads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-reads.d.ts","sourceRoot":"","sources":["../../src/analysis/component-reads.ts"],"names":[],"mappings":"AACA,OAAO,EAAa,KAAK,GAAG,EAAE,MAAM,YAAY,CAAC;AAGjD,+EAA+E;AAC/E,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,GAAG,EACR,aAAa,EAAE,MAAM,EACrB,QAAQ,GAAE,GAAG,CAAC,MAAM,CAAa,GAChC,GAAG,CAAC,MAAM,CAAC,CA0Bb;AAED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CA0C7D"}

package/dist/analysis/computed.d.ts

@@ -0,0 +1,11 @@
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { type ComputedAnalysis, type Ctx } from '../context';
+/**
+ * Analyze a candidate module-level computed initializer. Detection is by
+ * reactive-state reference rather than by a whitelist of expression forms.
+ */
+export declare function analyzeComputed(ctx: Ctx, expr: t.Node): ComputedAnalysis;
+/** Discover ordered module-level const derivations after module state exists. */
+export declare function scanComputeds(ctx: Ctx, programPath: NodePath<t.Program>): void;
+//# sourceMappingURL=computed.d.ts.map

package/dist/analysis/computed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computed.d.ts","sourceRoot":"","sources":["../../src/analysis/computed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAKL,KAAK,gBAAgB,EACrB,KAAK,GAAG,EACT,MAAM,YAAY,CAAC;AAGpB;;;GAGG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,GAAG,gBAAgB,CAqGxE;AAED,iFAAiF;AACjF,wBAAgB,aAAa,CAC3B,GAAG,EAAE,GAAG,EACR,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,GAC/B,IAAI,CAgCN"}

package/dist/analysis/instance-control-flow.d.ts

@@ -0,0 +1,9 @@
+import type { Ctx } from '../context';
+/**
+ * Classify pure top-level if/switch calculations for reactive replay.
+ * Side-effectful control flow remains one-time authored setup.
+ */
+export declare function scanInstanceControlFlow(ctx: Ctx): void;
+/** Resolve transitive sources and allocate selective invalidation reasons. */
+export declare function finalizeInstancePreludes(ctx: Ctx): void;
+//# sourceMappingURL=instance-control-flow.d.ts.map

package/dist/analysis/instance-control-flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-control-flow.d.ts","sourceRoot":"","sources":["../../src/analysis/instance-control-flow.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAwJtC;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CA4HtD;AAED,8EAA8E;AAC9E,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAuEvD"}

package/dist/analysis/instance.d.ts

@@ -0,0 +1,9 @@
+import { type Ctx } from '../context';
+/** Collect mutable or store-like bindings owned by each component instance. */
+export declare function scanInstanceState(ctx: Ctx): void;
+/**
+ * Discover ordered component-local const derivations. These replay in the
+ * owning component update before guarded DOM setters.
+ */
+export declare function scanInstanceDerivations(ctx: Ctx): void;
+//# sourceMappingURL=instance.d.ts.map

package/dist/analysis/instance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance.d.ts","sourceRoot":"","sources":["../../src/analysis/instance.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,GAAG,EACT,MAAM,YAAY,CAAC;AAMpB,+EAA+E;AAC/E,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CA0BhD;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CA8LtD"}

package/dist/analysis/runtime-pattern.d.ts

@@ -0,0 +1,9 @@
+import * as t from '@babel/types';
+export type RuntimeBindingPattern = t.Identifier | t.ObjectPattern | t.ArrayPattern;
+/**
+ * Clone an authored TypeScript binding pattern for generated JavaScript.
+ * Babel stores annotations on nested pattern nodes, so clear every supported
+ * binding shape rather than only the root.
+ */
+export declare function cloneRuntimeBindingPattern(pattern: RuntimeBindingPattern): RuntimeBindingPattern;
+//# sourceMappingURL=runtime-pattern.d.ts.map

package/dist/analysis/runtime-pattern.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-pattern.d.ts","sourceRoot":"","sources":["../../src/analysis/runtime-pattern.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAElC,MAAM,MAAM,qBAAqB,GAC7B,CAAC,CAAC,UAAU,GACZ,CAAC,CAAC,aAAa,GACf,CAAC,CAAC,YAAY,CAAC;AAEnB;;;;GAIG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,qBAAqB,GAC7B,qBAAqB,CAcvB"}

package/dist/analysis/slot-paths.d.ts

@@ -0,0 +1,11 @@
+import type { Ctx } from '../context';
+/**
+ * Add the runtime identity alternatives created by deferred render slots.
+ *
+ * The first mount deliberately retains the lexical path. Later live mounts
+ * insert `$slot[n]` immediately below the component that authored the slot.
+ * Expanding static access paths here keeps state routing precise without
+ * runtime JSX values or dynamic dependency registration.
+ */
+export declare function expandRenderSlotPaths(ctx: Ctx, paths: readonly string[]): string[];
+//# sourceMappingURL=slot-paths.d.ts.map

package/dist/analysis/slot-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot-paths.d.ts","sourceRoot":"","sources":["../../src/analysis/slot-paths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAOtC;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,SAAS,MAAM,EAAE,GACvB,MAAM,EAAE,CAqBV"}

package/dist/analysis/type-candidates.d.ts

@@ -0,0 +1,14 @@
+import * as t from '@babel/types';
+/**
+ * Module state whose declared TypeScript type is a finite string-literal set.
+ * The annotation is the contract: an initializer alone cannot prove every
+ * value that later assignments or imported helper calls may produce.
+ */
+export declare function moduleStateStringCandidates(program: t.Program): Map<string, string[]>;
+/**
+ * Functions whose declared return type is a finite string-literal set.
+ * This is exported through linked function metadata so a caller can safely
+ * lower `const Tag = chooseTag(...); <Tag />` without seeing the helper body.
+ */
+export declare function moduleFunctionStringCandidates(program: t.Program): Map<string, string[]>;
+//# sourceMappingURL=type-candidates.d.ts.map

package/dist/analysis/type-candidates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-candidates.d.ts","sourceRoot":"","sources":["../../src/analysis/type-candidates.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AA8FlC;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,CAAC,CAAC,OAAO,GACjB,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAyBvB;AAED;;;;GAIG;AACH,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,CAAC,CAAC,OAAO,GACjB,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAwCvB"}

package/dist/analysis.d.ts

@@ -0,0 +1,52 @@
+/**
+ * analysis.ts — compiler pass 1: module analysis and access-table build.
+ *
+ * Runs at Program.enter, before any transform:
+ *   1. scan module-level reactive state (`let` vars, `const` store objects)
+ *   2. scan top-level functions: JSX-bearing ones are COMPONENTS, the rest
+ *      are HELPERS (summarized for interprocedural read/write attribution)
+ *   3. per component: wire the composition graph (ALL parents), count host
+ *      elements, validate every construct L1 does/doesn't support
+ *   4. collect reads per component — with list-row attribution and helper
+ *      summaries folded in
+ *
+ * Specialized analysis lives under analysis/: computed state, instance
+ * derivations, control-flow replay, component paths, and access-table build.
+ *
+ * M5.3 fixes living here:
+ *   - helpers are no longer mistaken for components (and vice versa)
+ *   - multi-parent components route to every instance
+ *   - row patterns expand repeated ancestors ('App/Tag[*]/items/Row[*]')
+ *   - key={...} outside list rows and state-reading props on static
+ *     children are compile errors (were silent miscompiles)
+ */
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { type Ctx } from './context';
+export { isLightweightListedComponent, isListLightweightCandidate, } from './analysis/component-graph';
+export { buildAccessTable } from './analysis/access-table';
+/**
+ * R13: analyze a candidate computed initializer — collect the state keys it
+ * reads and decide whether it is a legal derivation.
+ *
+ * Detection is BY REFERENCE (R13.1, replacing the PURE_METHODS whitelist):
+ * any expression that mentions an already-declared state variable is a
+ * derivation — arbitrary method calls, unknown/imported/global functions,
+ * `new`, tagged templates, and local-mutating callbacks are all fine. A
+ * derivation recomputes on every write to its sources and computedChanged
+ * gates what propagates downstream; keeping it a pure function of state is
+ * the author's responsibility (same contract as Vue computed / Svelte $:).
+ *
+ * Rejected syntax covers only what would corrupt the state model itself:
+ *   - assignments / updates to non-locals (writes belong in handlers)
+ *   - calls to module helpers KNOWN to write state (reuses the same write
+ *     analysis handlers rely on — a precise negative, not a whitelist)
+ *   - await / yield (derivations must be synchronous)
+ * Locals (nested function params, declarators) are collected conservatively
+ * (name-wide), so `reduce((acc, t) => { acc.push(t); return acc; }, [])`
+ * and `(s, t) => (s += t.n, s)` are fine. The walk never early-exits on
+ * impure: read collection continues so a state-touching impure const is
+ * always an ERROR, never a silent plain const.
+ */
+export declare function runAnalysis(ctx: Ctx, programPath: NodePath<t.Program>): void;
+//# sourceMappingURL=analysis.d.ts.map

package/dist/analysis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analysis.d.ts","sourceRoot":"","sources":["../src/analysis.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EASL,KAAK,GAAG,EACT,MAAM,WAAW,CAAC;AAsCnB,OAAO,EACL,4BAA4B,EAC5B,0BAA0B,GAC3B,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAonC3D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,IAAI,CA6C5E"}

package/dist/compile.d.ts

@@ -0,0 +1,17 @@
+/**
+ * compile.ts — compiler entry point.
+ *
+ * One function: component source (.tsx) in, compiled JavaScript out.
+ *
+ * Plugin pipeline:
+ *   1. @babel/plugin-syntax-jsx           — parse JSX (no transform)
+ *   2. memoDomPlugin                      — the paradigm transform (R1–R6, L1)
+ *   3. @babel/plugin-transform-typescript — strip types from emitted code
+ *
+ * The transform is written against standard ESTree nodes via @babel/types so
+ * frontend #2 (oxc) can reuse the emission logic later.
+ */
+import { type MemoDomOptions } from './plugin';
+export type { MemoDomOptions };
+export declare function compile(source: string, opts?: MemoDomOptions): string;
+//# sourceMappingURL=compile.d.ts.map

package/dist/compile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compile.d.ts","sourceRoot":"","sources":["../src/compile.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH,OAAsB,EAAE,KAAK,cAAc,EAAE,MAAM,UAAU,CAAC;AAE9D,YAAY,EAAE,cAAc,EAAE,CAAC;AAE/B,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,GAAE,cAAmB,GAAG,MAAM,CAezE"}

package/dist/component-linker.d.ts

@@ -0,0 +1,32 @@
+/**
+ * component-linker.ts - graph-level component placement and row-mode linking.
+ *
+ * Component factories are analyzed in their defining module but receive
+ * runtime ids from callers. This pass turns cross-module call edges into the
+ * concrete/wildcard paths used by defining-module access-table emission.
+ */
+import type { LinkedComponentPropSource, LinkedComponentRowUse } from './context';
+import type { ComponentPropSourceRefs } from './components/prop-origins';
+export interface ComponentGraphEdge {
+    target: string;
+    suffix: string;
+    mode: 'static' | 'row';
+    keyPath?: string[] | null;
+    sourceKey?: string;
+    sourceLocal?: boolean;
+    propSources?: ComponentPropSourceRefs;
+}
+export interface ComponentGraphNode {
+    key: string;
+    moduleId: string;
+    local: string;
+    edges: ComponentGraphEdge[];
+}
+export interface LinkedComponentGraph {
+    paths: Map<string, string[]>;
+    rows: Map<string, LinkedComponentRowUse[]>;
+    propSources: Map<string, Map<string, LinkedComponentPropSource>>;
+}
+/** Compute every declaration's caller-derived paths and keyed-row metadata. */
+export declare function linkComponentGraph(declarations: readonly ComponentGraphNode[], rootId: string): LinkedComponentGraph;
+//# sourceMappingURL=component-linker.d.ts.map

package/dist/component-linker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-linker.d.ts","sourceRoot":"","sources":["../src/component-linker.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EACV,yBAAyB,EACzB,qBAAqB,EACtB,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EACV,uBAAuB,EACxB,MAAM,2BAA2B,CAAC;AAGnC,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,QAAQ,GAAG,KAAK,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,IAAI,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,WAAW,CAAC,EAAE,uBAAuB,CAAC;CACvC;AAED,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,kBAAkB,EAAE,CAAC;CAC7B;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC7B,IAAI,EAAE,GAAG,CAAC,MAAM,EAAE,qBAAqB,EAAE,CAAC,CAAC;IAC3C,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAAC,CAAC;CAClE;AAoBD,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAChC,YAAY,EAAE,SAAS,kBAAkB,EAAE,EAC3C,MAAM,EAAE,MAAM,GACb,oBAAoB,CAiEtB"}

package/dist/components/callback-props.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Stable scalar callback props.
+ *
+ * Inline callback expressions are factory values, not reactive values. Their
+ * closures observe the component's live bindings, so recreating them in every
+ * prop replay only causes identity churn and needless child invalidation.
+ */
+import * as t from '@babel/types';
+import type { Ctx } from '../context';
+import type { EmitScope } from '../emission/scope';
+export declare function isInlineScalarCallback(value: t.Expression): value is t.ArrowFunctionExpression | t.FunctionExpression;
+export declare function stabilizeInlineCallbackProp(ctx: Ctx, scope: EmitScope, value: t.ArrowFunctionExpression | t.FunctionExpression, hint?: string): t.Identifier;
+export declare function stabilizeInlineCallbackStatement(ctx: Ctx, statements: t.Statement[], value: t.ArrowFunctionExpression | t.FunctionExpression, hint?: string): t.Identifier;
+//# sourceMappingURL=callback-props.d.ts.map

package/dist/components/callback-props.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callback-props.d.ts","sourceRoot":"","sources":["../../src/components/callback-props.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAEtC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEnD,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,CAAC,CAAC,UAAU,GAClB,KAAK,IAAI,CAAC,CAAC,uBAAuB,GAAG,CAAC,CAAC,kBAAkB,CAK3D;AAED,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,CAAC,CAAC,uBAAuB,GAAG,CAAC,CAAC,kBAAkB,EACvD,IAAI,SAAa,GAChB,CAAC,CAAC,UAAU,CAQd;AAED,wBAAgB,gCAAgC,CAC9C,GAAG,EAAE,GAAG,EACR,UAAU,EAAE,CAAC,CAAC,SAAS,EAAE,EACzB,KAAK,EAAE,CAAC,CAAC,uBAAuB,GAAG,CAAC,CAAC,kBAAkB,EACvD,IAAI,SAAa,GAChB,CAAC,CAAC,UAAU,CAQd"}

package/dist/components/calls.d.ts

@@ -0,0 +1,17 @@
+/**
+ * components/calls.ts - named JSX props to component factory arguments.
+ *
+ * Call sites use names while component factories may use positional slots or
+ * one object envelope. These builders are shared by static and keyed-row
+ * component emission so prop order and spread projection cannot drift.
+ */
+import * as t from '@babel/types';
+import type { Ctx } from '../context';
+export interface ComponentPropEntry {
+    name: string;
+    value: t.Expression;
+}
+export declare function orderCallProps(ctx: Ctx, tag: string, entries: ComponentPropEntry[]): t.Expression[];
+export declare function callPropsFromObject(ctx: Ctx, tag: string, object: t.Expression): t.Expression[];
+export declare function buildSpreadComponentPropUpdate(ctx: Ctx, tag: string, ownerId: t.Expression, idSuffix: string, expression: t.ObjectExpression): t.Statement;
+//# sourceMappingURL=calls.d.ts.map

package/dist/components/calls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calls.d.ts","sourceRoot":"","sources":["../../src/components/calls.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAGtC,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,CAAC,CAAC,UAAU,CAAC;CACrB;AAED,wBAAgB,cAAc,CAC5B,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,kBAAkB,EAAE,GAC5B,CAAC,CAAC,UAAU,EAAE,CAgDhB;AAED,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,CAAC,CAAC,UAAU,GACnB,CAAC,CAAC,UAAU,EAAE,CAYhB;AAED,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,CAAC,CAAC,UAAU,EACrB,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,CAAC,CAAC,gBAAgB,GAC7B,CAAC,CAAC,SAAS,CAoBb"}

package/dist/components/children.d.ts

@@ -0,0 +1,43 @@
+/**
+ * components/children.ts - compiler-owned content slots for component children.
+ *
+ * A slot defers child creation until the callee mounts it into a real host
+ * node. Its update closure remains attached to the lexical owner's update so
+ * ordinary state routing and guarded DOM writes keep their existing shape.
+ */
+import * as t from '@babel/types';
+import { type Ctx } from '../context';
+import { type EmitScope } from '../emission/scope';
+export type EmitChildSlot = (scope: EmitScope, parentNode: t.Identifier, ownerId: t.Identifier) => void;
+export type JsxChild = t.JSXElement['children'][number];
+export interface ChildContentEmitters {
+    emitText(expression: t.Expression): string;
+    emitNode(node: t.JSXElement | t.JSXFragment): string;
+    emitList(call: t.CallExpression, parentVar: string): void;
+    emitCondition(expression: t.ConditionalExpression | t.LogicalExpression, parentVar: string): void;
+    isForwarded(expression: t.Expression): boolean;
+    emitForwarded(expression: t.Expression, parentVar: string): void;
+    fail(message: string): never;
+}
+/**
+ * React-compatible JSX text normalization shared by host and slot content.
+ * Edge spaces are removed only when they come from source line breaks.
+ */
+export declare function normalizeJsxText(raw: string): string;
+/** Does a component element contain authored, non-whitespace children? */
+export declare function hasComponentChildren(children: readonly JsxChild[]): boolean;
+/** Declared render-prop name referenced by one interpolation/forwarding site. */
+export declare function renderPropReferenceName(ctx: Ctx, compName: string, expression: t.Expression): string | null;
+/** Is this expression one of the component's compiler-owned mount slots? */
+export declare function isRenderPropReference(ctx: Ctx, compName: string, expression: t.Expression): boolean;
+/**
+ * Build a stable mount function and link its guarded update to `ownerScope`.
+ * Child entity/list/conditional counters are shared with the lexical owner so
+ * generated ids follow the same source-order analysis as direct JSX.
+ */
+export declare function buildChildrenSlot(ctx: Ctx, ownerScope: EmitScope, identityOwner: t.Expression, emit: EmitChildSlot): t.Identifier;
+/** Mount one forwarded slot with a structural owner and track branch teardown. */
+export declare function emitForwardedSlotMount(ctx: Ctx, scope: EmitScope, expression: t.Expression, parentVar: string, ownerId: t.Expression): void;
+/** Emit lazy slot content into a callee-provided host in source order. */
+export declare function emitChildrenIntoParent(scope: EmitScope, children: readonly JsxChild[], parentVar: string, emitters: ChildContentEmitters): void;
+//# sourceMappingURL=children.d.ts.map

package/dist/components/children.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"children.d.ts","sourceRoot":"","sources":["../../src/components/children.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAAc,KAAK,GAAG,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,EAIL,KAAK,SAAS,EACf,MAAM,mBAAmB,CAAC;AAS3B,MAAM,MAAM,aAAa,GAAG,CAC1B,KAAK,EAAE,SAAS,EAChB,UAAU,EAAE,CAAC,CAAC,UAAU,EACxB,OAAO,EAAE,CAAC,CAAC,UAAU,KAClB,IAAI,CAAC;AACV,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC;AAExD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,UAAU,EAAE,CAAC,CAAC,UAAU,GAAG,MAAM,CAAC;IAC3C,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,WAAW,GAAG,MAAM,CAAC;IACrD,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,cAAc,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1D,aAAa,CACX,UAAU,EAAE,CAAC,CAAC,qBAAqB,GAAG,CAAC,CAAC,iBAAiB,EACzD,SAAS,EAAE,MAAM,GAChB,IAAI,CAAC;IACR,WAAW,CAAC,UAAU,EAAE,CAAC,CAAC,UAAU,GAAG,OAAO,CAAC;IAC/C,aAAa,CAAC,UAAU,EAAE,CAAC,CAAC,UAAU,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACjE,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,CAAC;CAC9B;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAKpD;AAED,0EAA0E;AAC1E,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,SAAS,QAAQ,EAAE,GAAG,OAAO,CAI3E;AAED,iFAAiF;AACjF,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,CAAC,CAAC,UAAU,GACvB,MAAM,GAAG,IAAI,CAwBf;AAED,4EAA4E;AAC5E,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,CAAC,CAAC,UAAU,GACvB,OAAO,CAMT;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,GAAG,EACR,UAAU,EAAE,SAAS,EACrB,aAAa,EAAE,CAAC,CAAC,UAAU,EAC3B,IAAI,EAAE,aAAa,GAClB,CAAC,CAAC,UAAU,CAuOd;AAED,kFAAkF;AAClF,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,SAAS,EAChB,UAAU,EAAE,CAAC,CAAC,UAAU,EACxB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,CAAC,CAAC,UAAU,GACpB,IAAI,CAwBN;AAED,0EAA0E;AAC1E,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,SAAS,QAAQ,EAAE,EAC7B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,oBAAoB,GAC7B,IAAI,CAyDN"}

package/dist/components/declarations.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Canonicalize supported component declaration spellings.
+ *
+ * The rest of the compiler intentionally operates on one component shape:
+ * top-level function declarations. Normalizing uppercase const arrows and
+ * function expressions before analysis keeps component/linker/emitter logic
+ * unified instead of adding expression-path branches to every pass.
+ */
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+/**
+ * Rewrite top-level uppercase const function values containing JSX into the
+ * canonical declaration shape consumed by all later passes.
+ */
+export declare function normalizeComponentDeclarations(programPath: NodePath<t.Program>): void;
+//# sourceMappingURL=declarations.d.ts.map

package/dist/components/declarations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declarations.d.ts","sourceRoot":"","sources":["../../src/components/declarations.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAuGlC;;;GAGG;AACH,wBAAgB,8BAA8B,CAC5C,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,GAC/B,IAAI,CAuCN"}

package/dist/components/jsx-values.d.ts

@@ -0,0 +1,7 @@
+import { type Ctx } from '../context';
+/**
+ * Expand top-level component `const view = <JSX />` aliases at each render
+ * use. Aliases may chain and may hold JSX-bearing conditional expressions.
+ */
+export declare function normalizeComponentJsxValues(ctx: Ctx): void;
+//# sourceMappingURL=jsx-values.d.ts.map

package/dist/components/jsx-values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-values.d.ts","sourceRoot":"","sources":["../../src/components/jsx-values.ts"],"names":[],"mappings":"AAQA,OAAO,EAAc,KAAK,GAAG,EAAE,MAAM,YAAY,CAAC;AA+PlD;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,CAoJ1D"}

package/dist/components/local-derived.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Emits dependency-selected replay for component-local derivations.
+ */
+import * as t from '@babel/types';
+export declare function reasonCondition(reasonVar: string, reasons: number[]): t.Expression;
+//# sourceMappingURL=local-derived.d.ts.map

package/dist/components/local-derived.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-derived.d.ts","sourceRoot":"","sources":["../../src/components/local-derived.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAQlC,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EAAE,GAChB,CAAC,CAAC,UAAU,CA4Bd"}

package/dist/components/manifest.d.ts

@@ -0,0 +1,31 @@
+/**
+ * components/manifest.ts - component facts serialized by the module linker.
+ *
+ * This module owns AST-level component discovery and converts analyzed local
+ * composition/list sites into canonical graph edges. Graph traversal itself
+ * remains in component-linker.ts.
+ */
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { type Ctx } from '../context';
+import { type ComponentGraphNode } from '../component-linker';
+export interface ComponentExportInfo {
+    key: string;
+    props: string[];
+    objectProps: boolean;
+    acceptsUnknownProps: boolean;
+    hasWholeDefault: boolean;
+    listLightweight: boolean;
+    delegatedEvents: boolean;
+    renderProps: string[];
+    renderCallbacks: string[];
+    refProps: string[];
+    subtreeReads: string[];
+}
+/** Discover enough component shape to bootstrap the first import-link pass. */
+export declare function discoverComponentExports(programPath: NodePath<t.Program>, moduleId: string): Map<string, ComponentExportInfo>;
+/** Export metadata after full binding-aware module analysis. */
+export declare function analyzedComponentExport(ctx: Ctx, moduleId: string, local: string): ComponentExportInfo;
+/** Convert analyzed local calls and list sites into graph placement edges. */
+export declare function analyzedComponentDeclarations(moduleId: string, ctx: Ctx): ComponentGraphNode[];
+//# sourceMappingURL=manifest.d.ts.map

package/dist/components/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../../src/components/manifest.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAElC,OAAO,EAGL,KAAK,GAAG,EACT,MAAM,YAAY,CAAC;AACpB,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,qBAAqB,CAAC;AAS7B,MAAM,WAAW,mBAAmB;IAClC,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,mBAAmB,EAAE,OAAO,CAAC;IAC7B,eAAe,EAAE,OAAO,CAAC;IACzB,eAAe,EAAE,OAAO,CAAC;IACzB,eAAe,EAAE,OAAO,CAAC;IACzB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB;AAED,+EAA+E;AAC/E,wBAAgB,wBAAwB,CACtC,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,EAChC,QAAQ,EAAE,MAAM,GACf,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CA8BlC;AAED,gEAAgE;AAChE,wBAAgB,uBAAuB,CACrC,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,GACZ,mBAAmB,CAiBrB;AAMD,8EAA8E;AAC9E,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,GAAG,GACP,kBAAkB,EAAE,CA0EtB"}

package/dist/components/prop-effects.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Maps defining-module prop mutations to caller-resolved state boundaries.
+ */
+import type { Ctx, RowCtx } from '../context';
+import { type ScopeWrites } from '../handler-commits';
+import type { ReactiveOrigin } from '../mutation-analysis';
+/**
+ * Applies one prop effect and returns whether the origin is a named prop.
+ */
+export declare function applyLinkedPropEffect(ctx: Ctx, component: string, rowCtx: RowCtx | undefined, origin: ReactiveOrigin, scope: ScopeWrites): boolean;
+//# sourceMappingURL=prop-effects.d.ts.map

package/dist/components/prop-effects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prop-effects.d.ts","sourceRoot":"","sources":["../../src/components/prop-effects.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAEL,KAAK,WAAW,EACjB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAmC3D;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,GAAG,EAAE,GAAG,EACR,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,WAAW,GACjB,OAAO,CAqBT"}

package/dist/components/prop-linker.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Propagates canonical prop origins through the acyclic component graph.
+ */
+import type { ComponentGraphNode } from '../component-linker';
+import type { LinkedComponentPropSource } from '../context';
+/** Caller-resolved source boundaries for every named component prop. */
+export declare function linkComponentPropSources(nodes: Map<string, ComponentGraphNode>, roots: string[]): Map<string, Map<string, LinkedComponentPropSource>>;
+//# sourceMappingURL=prop-linker.d.ts.map

package/dist/components/prop-linker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prop-linker.d.ts","sourceRoot":"","sources":["../../src/components/prop-linker.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EACV,kBAAkB,EACnB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EACV,yBAAyB,EAC1B,MAAM,YAAY,CAAC;AAsDpB,wEAAwE;AACxE,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,EACtC,KAAK,EAAE,MAAM,EAAE,GACd,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,yBAAyB,CAAC,CAAC,CAyCrD"}

package/dist/components/prop-origins.d.ts

@@ -0,0 +1,17 @@
+import { type Ctx } from '../context';
+export type ComponentPropSourceRef = {
+    type: 'state';
+    key: string;
+} | {
+    type: 'prop';
+    name: string;
+    path: string[];
+} | {
+    type: 'root';
+} | {
+    type: 'local';
+};
+export type ComponentPropSourceRefs = Record<string, ComponentPropSourceRef[]>;
+/** Prop-source references grouped by component tag used inside one owner. */
+export declare function collectComponentPropSources(ctx: Ctx, owner: string): Map<string, ComponentPropSourceRefs>;
+//# sourceMappingURL=prop-origins.d.ts.map

package/dist/components/prop-origins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prop-origins.d.ts","sourceRoot":"","sources":["../../src/components/prop-origins.ts"],"names":[],"mappings":"AAKA,OAAO,EAML,KAAK,GAAG,EACT,MAAM,YAAY,CAAC;AAOpB,MAAM,MAAM,sBAAsB,GAC9B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAC9B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAA;CAAE,GAC9C;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAEtB,MAAM,MAAM,uBAAuB,GAAG,MAAM,CAC1C,MAAM,EACN,sBAAsB,EAAE,CACzB,CAAC;AA6JF,6EAA6E;AAC7E,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,MAAM,GACZ,GAAG,CAAC,MAAM,EAAE,uBAAuB,CAAC,CA4CtC"}

package/dist/components/prop-projections.d.ts

@@ -0,0 +1,5 @@
+import { type Ctx } from '../context';
+import { type ReactiveOrigin } from '../mutation-analysis';
+/** Body-projected bindings whose values still represent component props. */
+export declare function componentPropProjectionOrigins(ctx: Ctx, component: string): Map<string, ReactiveOrigin>;
+//# sourceMappingURL=prop-projections.d.ts.map

package/dist/components/prop-projections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prop-projections.d.ts","sourceRoot":"","sources":["../../src/components/prop-projections.ts"],"names":[],"mappings":"AAIA,OAAO,EAGL,KAAK,GAAG,EACT,MAAM,YAAY,CAAC;AACpB,OAAO,EAEL,KAAK,cAAc,EACpB,MAAM,sBAAsB,CAAC;AA8I9B,4EAA4E;AAC5E,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,GAAG,EACR,SAAS,EAAE,MAAM,GAChB,GAAG,CAAC,MAAM,EAAE,cAAc,CAAC,CAY7B"}

package/dist/components/props.d.ts

@@ -0,0 +1,73 @@
+/**
+ * components/props.ts - component prop patterns and reactive replay builders.
+ *
+ * JSX always supplies named properties. This module normalizes supported
+ * function parameters into either positional slots or one object envelope,
+ * then emits assignments that replay defaults and destructuring after a prop
+ * box update. It contains no runtime or component-placement policy.
+ */
+import * as t from '@babel/types';
+export type ComponentParam = Exclude<t.FunctionDeclaration['params'][number], t.TSParameterProperty>;
+export interface ComponentPropsPlan {
+    mode: 'positional' | 'object';
+    /** JSX attribute names accepted by a closed declaration. */
+    names: string[];
+    /** Generic object bindings and object rest accept undeclared attributes. */
+    acceptsUnknown: boolean;
+    /** Source bindings introduced by the original parameter patterns. */
+    bindings: string[];
+    /** Original parameters retained by lightweight factories. */
+    params: ComponentParam[];
+    /** The sole object envelope has a whole-parameter default. */
+    hasWholeDefault: boolean;
+    /** Props consumed as compiler-owned mount slots rather than scalar values. */
+    renderProps: string[];
+    /** Props invoked by structural list sites as caller-owned row factories. */
+    renderCallbacks: string[];
+    /** Props consumed as DOM ref adapters and forwarded without reading a sink. */
+    refProps: string[];
+}
+export interface LocalDerivation {
+    /** Declaration converted from const to let by component emission. */
+    declaration: t.VariableDeclaration;
+    /** Binding or destructuring pattern refreshed during update. */
+    target: t.Identifier | t.ObjectPattern | t.ArrayPattern;
+    /** Reactive expression evaluated again in source order. */
+    source: t.Expression;
+    /** Every binding introduced by target. */
+    bindings: string[];
+    /** Transitive non-derived roots that can change this value. */
+    sources: string[];
+}
+export interface ControlFlowDerivation {
+    /** Pure authored control flow retained for initial factory evaluation. */
+    statement: t.IfStatement | t.SwitchStatement;
+    /** Mutable locals assigned by the control-flow calculation. */
+    bindings: string[];
+    /** Initializers restored before replay when the control flow is partial. */
+    resets: Array<{
+        binding: string;
+        source: t.Expression;
+    }>;
+    /** Transitive non-derived roots that can change the calculation. */
+    sources: string[];
+}
+/** Normalize a component's source parameters into its JSX call contract. */
+export declare function analyzeComponentProps(params: t.FunctionDeclaration['params']): ComponentPropsPlan;
+/** Initial locals for an entity factory whose inputs live in a props box. */
+export declare function buildPropDeclaration(plan: ComponentPropsPlan, sources: t.Expression[]): t.VariableDeclaration | null;
+/** Replay original parameter semantics from new slot values. */
+export declare function buildPropReplay(plan: ComponentPropsPlan, sources: t.Expression[]): t.Statement[];
+/** Assignment used by ordered body derivations such as `{ value } = props`. */
+export declare function buildDerivationReplay(derivation: LocalDerivation): t.Statement;
+/** All lexical bindings introduced by an identifier or destructuring pattern. */
+export declare function bindingNames(node: t.LVal): string[];
+/** Generic object parameter binding, or null for an object pattern. */
+export declare function objectBindingName(plan: ComponentPropsPlan): string | null;
+/** Local identifier bound from one top-level object property. */
+export declare function localBindingForProp(plan: ComponentPropsPlan, name: string): string | null;
+/** Declared prop name that introduced one local binding. */
+export declare function propNameForBinding(plan: ComponentPropsPlan, binding: string): string | null;
+/** Clone an authored parameter for emitted JavaScript factory syntax. */
+export declare function runtimeParameter(param: ComponentParam): ComponentParam;
+//# sourceMappingURL=props.d.ts.map

package/dist/components/props.d.ts.map

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