@memoized-dom/compiler 0.0.1

package/dist/emission/node-emitter.d.ts

@@ -0,0 +1,8 @@
+import type { NodePath } from '@babel/traverse';
+import type * as t from '@babel/types';
+import type { Ctx, RowCtx } from '../context';
+import type { JsxNode } from '../jsx/children';
+import type { EmitScope } from './scope';
+/** Shared callback shape used by structural-region emitters. */
+export type NodeEmitter = (ctx: Ctx, scope: EmitScope, node: JsxNode, componentName: string, componentPath: NodePath<t.FunctionDeclaration>, nestedIn?: 'row' | 'cond' | null, rowContext?: RowCtx, eventOriginId?: t.Expression, inSvg?: boolean, ownerId?: t.Expression) => string;
+//# sourceMappingURL=node-emitter.d.ts.map

package/dist/emission/node-emitter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-emitter.d.ts","sourceRoot":"","sources":["../../src/emission/node-emitter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,KAAK,CAAC,MAAM,cAAc,CAAC;AACvC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEzC,gEAAgE;AAChE,MAAM,MAAM,WAAW,GAAG,CACxB,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,OAAO,EACb,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,QAAQ,CAAC,CAAC,CAAC,mBAAmB,CAAC,EAC9C,QAAQ,CAAC,EAAE,KAAK,GAAG,MAAM,GAAG,IAAI,EAChC,UAAU,CAAC,EAAE,MAAM,EACnB,aAAa,CAAC,EAAE,CAAC,CAAC,UAAU,EAC5B,KAAK,CAAC,EAAE,OAAO,EACf,OAAO,CAAC,EAAE,CAAC,CAAC,UAAU,KACnB,MAAM,CAAC"}

package/dist/emission/render-callback.d.ts

@@ -0,0 +1,14 @@
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { type Ctx } from '../context';
+import { type EmitScope } from './scope';
+import type { NodeEmitter } from './node-emitter';
+/**
+ * Compile one caller-authored render callback into a row-factory adapter.
+ *
+ * The adapter is plain generated JavaScript, not a runtime JSX value. Its
+ * live row update closures remain indexed by the lexical caller so caller
+ * state can update rows mounted inside another component's list.
+ */
+export declare function buildRenderCallbackAdapter(ctx: Ctx, ownerScope: EmitScope, source: t.Expression, componentName: string, componentPath: NodePath<t.FunctionDeclaration>, emitNode: NodeEmitter, inSvg: boolean, ownerId: t.Expression): t.Identifier;
+//# sourceMappingURL=render-callback.d.ts.map

package/dist/emission/render-callback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-callback.d.ts","sourceRoot":"","sources":["../../src/emission/render-callback.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAElC,OAAO,EAGL,KAAK,GAAG,EAET,MAAM,YAAY,CAAC;AAEpB,OAAO,EAKL,KAAK,SAAS,EACf,MAAM,SAAS,CAAC;AACjB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAkBlD;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,GAAG,EACR,UAAU,EAAE,SAAS,EACrB,MAAM,EAAE,CAAC,CAAC,UAAU,EACpB,aAAa,EAAE,MAAM,EACrB,aAAa,EAAE,QAAQ,CAAC,CAAC,CAAC,mBAAmB,CAAC,EAC9C,QAAQ,EAAE,WAAW,EACrB,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,CAAC,CAAC,UAAU,GACpB,CAAC,CAAC,UAAU,CAiPd"}

package/dist/emission/scope.d.ts

@@ -0,0 +1,47 @@
+/**
+ * emission/scope.ts - generated bindings and statements shared by emitters.
+ *
+ * Owns per-factory slots, updater declarations, guarded writes, and entity
+ * registration so emit.ts can focus on component and JSX structure.
+ */
+import * as t from '@babel/types';
+import type { Ctx } from '../context';
+export interface EmitScope {
+    slots: string[];
+    tempVar: string;
+    updateVar: string;
+    /** Optional dependency reasons accepted by the owner updater. */
+    reasonVar: string | null;
+    /** Caller-owned root used for repeated-row delegated host events. */
+    delegatedEventRootVar: string | null;
+    creation: t.Statement[];
+    /** Lifecycle setup that runs only after this scope's full DOM is created. */
+    mounts: t.Statement[];
+    updaters: Array<() => t.Statement>;
+    tagCounters: Map<string, number>;
+    childCounts: Map<string, number>;
+    usedPrefixes: Map<string, number>;
+    usedConds: {
+        count: number;
+    };
+    textCounter: number;
+    regionCounter: number;
+    /** Structural regions whose retained entries drain with this scope. */
+    disposableRegions: string[];
+    /** Component entity ids created lexically inside this scope. */
+    disposableEntities: t.Expression[];
+    /** Lazy content-slot mounts disposed when this structural scope swaps. */
+    disposableCallbacks: t.Identifier[];
+    /** Source-order identity for forwarded slot mounts in this scope. */
+    forwardedSlotCounter: number;
+    /** Branch/slot scopes drain callbacks directly instead of by entity owner. */
+    manualDisposal: boolean;
+}
+export declare function newEmitScope(ctx: Ctx, manualDisposal?: boolean): EmitScope;
+export declare function cacheDecl(scope: EmitScope): t.Statement;
+export declare function freshSlot(ctx: Ctx, scope: EmitScope): string;
+export declare function freshNodeName(ctx: Ctx, scope: EmitScope, tag: string): string;
+export declare function slotGuard(scope: EmitScope, slot: string, expression: t.Expression, write: (value: t.Identifier) => t.Statement): t.Statement;
+export declare function updateDecl(scope: EmitScope): t.Statement;
+export declare function registerStmt(ctx: Ctx, id: t.Expression, parent: t.Expression, render: t.Expression): t.Statement;
+//# sourceMappingURL=scope.d.ts.map

package/dist/emission/scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope.d.ts","sourceRoot":"","sources":["../../src/emission/scope.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAGtC,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,iEAAiE;IACjE,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,qEAAqE;IACrE,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC;IACxB,6EAA6E;IAC7E,MAAM,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC;IACtB,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC;IACnC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,SAAS,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7B,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,uEAAuE;IACvE,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,gEAAgE;IAChE,kBAAkB,EAAE,CAAC,CAAC,UAAU,EAAE,CAAC;IACnC,0EAA0E;IAC1E,mBAAmB,EAAE,CAAC,CAAC,UAAU,EAAE,CAAC;IACpC,qEAAqE;IACrE,oBAAoB,EAAE,MAAM,CAAC;IAC7B,8EAA8E;IAC9E,cAAc,EAAE,OAAO,CAAC;CACzB;AAED,wBAAgB,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,cAAc,UAAQ,GAAG,SAAS,CAsBxE;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,GAAG,CAAC,CAAC,SAAS,CAKvD;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,SAAS,GAAG,MAAM,CAI5D;AAED,wBAAgB,aAAa,CAC3B,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,MAAM,GACV,MAAM,CAIR;AAED,wBAAgB,SAAS,CACvB,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,CAAC,CAAC,UAAU,EACxB,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,UAAU,KAAK,CAAC,CAAC,SAAS,GAC1C,CAAC,CAAC,SAAS,CAcb;AAED,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,CAAC,CAAC,SAAS,CAiBxD;AAED,wBAAgB,YAAY,CAC1B,GAAG,EAAE,GAAG,EACR,EAAE,EAAE,CAAC,CAAC,UAAU,EAChB,MAAM,EAAE,CAAC,CAAC,UAAU,EACpB,MAAM,EAAE,CAAC,CAAC,UAAU,GACnB,CAAC,CAAC,SAAS,CAUb"}

package/dist/emit.d.ts

@@ -0,0 +1,29 @@
+/**
+ * emit.ts - JSX DOM nodes and structural-region emission.
+ *
+ *   R2  JSX → creation branch with cached node variables (post-order)
+ *   R3  dynamic expressions → numbered slots with guarded setters
+ *   R4  creation runs the same guarded setters (null cache → first write)
+ *   R7  {items.map(item => …)} → createListRegion + row factories
+ *
+ * Component factory ABI and registration live in emission/component.ts.
+ * Emission state is explicit (EmitScope) rather than closure-local so that
+ * inline list rows can emit into a NESTED scope: an inline row is a small
+ * entity factory of its own (own slots, own update, register parent=id),
+ * created per item by the region.
+ */
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { type Ctx, type RowCtx } from './context';
+import { type EmitScope } from './emission/scope';
+import { type JsxNode } from './jsx/children';
+export declare function emitNode(ctx: Ctx, scope: EmitScope, node: JsxNode, compName: string, compPath: NodePath<t.FunctionDeclaration>, nestedIn?: 'row' | 'cond' | null, rowCtx?: RowCtx, eventOriginId?: t.Expression, inSvg?: boolean, ownerId?: t.Expression): string;
+/**
+ * A branch is a small factory: own slot cache, own guarded update closure,
+ * NO register (branches are not entities — a swap just removes their nodes).
+ * Emitted into a fresh EmitScope so variables and slots never collide.
+ */
+export declare function buildBranchCreate(ctx: Ctx, jsx: JsxNode, compName: string, compPath: NodePath<t.FunctionDeclaration>, regionId: t.Expression, inSvg?: boolean, ownerId?: t.Expression, allowConditions?: boolean, usedConds?: {
+    count: number;
+}): t.ArrowFunctionExpression;
+//# sourceMappingURL=emit.d.ts.map

package/dist/emit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emit.d.ts","sourceRoot":"","sources":["../src/emit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAIL,KAAK,GAAG,EACR,KAAK,MAAM,EACZ,MAAM,WAAW,CAAC;AAMnB,OAAO,EAIL,KAAK,SAAS,EACf,MAAM,kBAAkB,CAAC;AAc1B,OAAO,EAGL,KAAK,OAAO,EACb,MAAM,gBAAgB,CAAC;AAkIxB,wBAAgB,QAAQ,CACtB,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,OAAO,EACb,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,mBAAmB,CAAC,EACzC,QAAQ,GAAE,KAAK,GAAG,MAAM,GAAG,IAAW,EACtC,MAAM,CAAC,EAAE,MAAM,EACf,aAAa,CAAC,EAAE,CAAC,CAAC,UAAU,EAC5B,KAAK,UAAQ,EACb,OAAO,GAAE,CAAC,CAAC,UAAuC,GACjD,MAAM,CA0BR;AAm9BD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,OAAO,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,mBAAmB,CAAC,EACzC,QAAQ,EAAE,CAAC,CAAC,UAAU,EACtB,KAAK,UAAQ,EACb,OAAO,GAAE,CAAC,CAAC,UAAqB,EAChC,eAAe,UAAQ,EACvB,SAAS,CAAC,EAAE;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GAC5B,CAAC,CAAC,uBAAuB,CAa3B"}

package/dist/handler-commits.d.ts

@@ -0,0 +1,30 @@
+/**
+ * handler-commits.ts - write-scope commit construction and insertion.
+ *
+ * Converts analyzed scope effects into local, routed, or unbounded
+ * invalidation statements and inserts them on every normal function exit.
+ */
+import * as t from '@babel/types';
+import { type Ctx, type RowCtx } from './context';
+export interface ScopeWrites {
+    writes: Set<string>;
+    rootFallback: boolean;
+    /** This scope writes fields observed by one keyed row. */
+    rowLocal: boolean;
+    /** This scope may affect the instance-owned collection backing the row. */
+    rowOwnerLocal: boolean;
+    /** This scope writes state owned by one component instance. */
+    instanceLocal: boolean;
+    /** Exact instance or prop roots written by this scope. */
+    instanceWrites: Set<string>;
+    /** Scoped event fallback when a handler has no recognized write. */
+    eventOrigin: t.Statement | null;
+}
+export declare function createScopeWrites(): ScopeWrites;
+/** Record an exact write to state owned by one component instance. */
+export declare function recordInstanceWrite(scope: ScopeWrites, source: string): void;
+/** Build the static commit form for one analyzed function scope. */
+export declare function buildScopeCommit(ctx: Ctx, scope: ScopeWrites, compName: string | null, rowCtx?: RowCtx): t.Statement | null;
+/** Insert a commit on every normal exit while preserving arrow return values. */
+export declare function appendScopeCommit(ctx: Ctx, fn: t.ArrowFunctionExpression | t.FunctionExpression | t.FunctionDeclaration, commit: t.Statement): void;
+//# sourceMappingURL=handler-commits.d.ts.map

package/dist/handler-commits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler-commits.d.ts","sourceRoot":"","sources":["../src/handler-commits.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAGL,KAAK,GAAG,EACR,KAAK,MAAM,EACZ,MAAM,WAAW,CAAC;AAOnB,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACpB,YAAY,EAAE,OAAO,CAAC;IACtB,0DAA0D;IAC1D,QAAQ,EAAE,OAAO,CAAC;IAClB,2EAA2E;IAC3E,aAAa,EAAE,OAAO,CAAC;IACvB,+DAA+D;IAC/D,aAAa,EAAE,OAAO,CAAC;IACvB,0DAA0D;IAC1D,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC5B,oEAAoE;IACpE,WAAW,EAAE,CAAC,CAAC,SAAS,GAAG,IAAI,CAAC;CACjC;AAED,wBAAgB,iBAAiB,IAAI,WAAW,CAU/C;AAED,sEAAsE;AACtE,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,GACb,IAAI,CAGN;AAED,oEAAoE;AACpE,wBAAgB,gBAAgB,CAC9B,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,MAAM,GAAG,IAAI,EACvB,MAAM,CAAC,EAAE,MAAM,GACd,CAAC,CAAC,SAAS,GAAG,IAAI,CAyEpB;AAED,iFAAiF;AACjF,wBAAgB,iBAAiB,CAC/B,GAAG,EAAE,GAAG,EACR,EAAE,EAAE,CAAC,CAAC,uBAAuB,GAAG,CAAC,CAAC,kBAAkB,GAAG,CAAC,CAAC,mBAAmB,EAC5E,MAAM,EAAE,CAAC,CAAC,SAAS,GAClB,IAAI,CAcN"}

package/dist/handler-origin.d.ts

@@ -0,0 +1,13 @@
+/**
+ * handler-origin.ts - event-origin invalidation lowering.
+ *
+ * Produces the nearest entity refresh for write-free event handlers and wraps
+ * shared module handlers when their declaration cannot close over a site ID.
+ */
+import * as t from '@babel/types';
+import type { Ctx, RowCtx } from './context';
+/** The nearest update unit from which an event-triggered render starts. */
+export declare function buildEventOriginCommit(ctx: Ctx, compName: string | null, rowCtx?: RowCtx, eventOriginId?: t.Expression): t.Statement;
+/** A shared module handler needs a closure over its call site's entity ID. */
+export declare function wrapSharedHandlerWithOrigin(ctx: Ctx, handler: t.Expression, originCommit: t.Statement): t.ArrowFunctionExpression;
+//# sourceMappingURL=handler-origin.d.ts.map

package/dist/handler-origin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler-origin.d.ts","sourceRoot":"","sources":["../src/handler-origin.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAO7C,2EAA2E;AAC3E,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,MAAM,GAAG,IAAI,EACvB,MAAM,CAAC,EAAE,MAAM,EACf,aAAa,CAAC,EAAE,CAAC,CAAC,UAAU,GAC3B,CAAC,CAAC,SAAS,CAgBb;AAED,8EAA8E;AAC9E,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,GAAG,EACR,OAAO,EAAE,CAAC,CAAC,UAAU,EACrB,YAAY,EAAE,CAAC,CAAC,SAAS,GACxB,CAAC,CAAC,uBAAuB,CAgB3B"}

package/dist/handlers/analyze.d.ts

@@ -0,0 +1,4 @@
+import * as t from '@babel/types';
+import { type Ctx, type RowCtx } from '../context';
+export declare function analyzeHandler(ctx: Ctx, rootFn: t.ArrowFunctionExpression | t.FunctionExpression | t.FunctionDeclaration, compName: string | null, rowCtx?: RowCtx, eventBoundary?: boolean, eventOriginId?: t.Expression, executionAwareRoot?: boolean): void;
+//# sourceMappingURL=analyze.d.ts.map

package/dist/handlers/analyze.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../src/handlers/analyze.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAIL,KAAK,GAAG,EACR,KAAK,MAAM,EACZ,MAAM,YAAY,CAAC;AAsEpB,wBAAgB,cAAc,CAC5B,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,CAAC,CAAC,uBAAuB,GAAG,CAAC,CAAC,kBAAkB,GAAG,CAAC,CAAC,mBAAmB,EAChF,QAAQ,EAAE,MAAM,GAAG,IAAI,EACvB,MAAM,CAAC,EAAE,MAAM,EACf,aAAa,UAAQ,EACrB,aAAa,CAAC,EAAE,CAAC,CAAC,UAAU,EAC5B,kBAAkB,UAAQ,GACzB,IAAI,CAmwBN"}

package/dist/handlers/local-calls.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Direct-call classification for event handlers.
+ *
+ * A handler that only delegates to component-local helpers which already
+ * own a synchronous commit does not need a second event-origin invalidation.
+ * Calls inside nested callbacks are deliberately ignored: those callbacks
+ * have their own execution boundary and are instrumented separately.
+ */
+import type { HandlerFn } from '../handlers';
+export declare function callsOnlyCommittedLocalHelpers(root: HandlerFn, isCommittedHelper: (name: string) => boolean): boolean;
+//# sourceMappingURL=local-calls.d.ts.map

package/dist/handlers/local-calls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-calls.d.ts","sourceRoot":"","sources":["../../src/handlers/local-calls.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,SAAS,EACf,iBAAiB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GAC3C,OAAO,CAoCT"}

package/dist/handlers.d.ts

@@ -0,0 +1,40 @@
+/**
+ * handlers.ts — R5: event-handler write analysis and commit emission.
+ *
+ * Writes are grouped by their INNERMOST enclosing function scope, and each
+ * scope gets its own commit appended to its own body (M5.1):
+ *   - handler body            → commit at the end; async handlers commit in
+ *                               the continuation, after every `await`
+ *   - fire-and-forget nested callback (setTimeout / .then / subscription)
+ *                             → commit at the end of THAT callback
+ *
+ * Commit form per scope:
+ *   unbounded shared effect                → markDirtySubtree(rootId)
+ *   exact or receiver-bounded state effect → commitWrites(WRITES_n)
+ *   component instance / keyed-row effect  → direct local invalidation
+ *
+ * A method call on a reactive receiver is conservatively bounded to that
+ * receiver. The compiler does not maintain built-in method semantics:
+ * `items.push()` and `items.filter()` invalidate the same readers, whose
+ * memoized update guards absorb unchanged values.
+ */
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import { type Ctx, type RowCtx } from './context';
+export type HandlerFn = t.ArrowFunctionExpression | t.FunctionExpression | t.FunctionDeclaration;
+/** Resolve a component-local helper declared directly in the factory body. */
+export declare function resolveLocalHelper(compPath: NodePath<t.FunctionDeclaration>, name: string): HandlerFn | null;
+/**
+ * Instrument a callback that executes outside the component's synchronous
+ * factory call. The callback owns its normal-exit commit; no event boundary
+ * or exception wrapper is introduced.
+ */
+export declare function instrumentComponentCallback(ctx: Ctx, compPath: NodePath<t.FunctionDeclaration>, target: HandlerFn, compName: string, rowCtx?: RowCtx, executionAwareRoot?: boolean): void;
+/** Instrument a module-owned callback through canonical access-table writes. */
+export declare function instrumentSharedCallback(ctx: Ctx, target: HandlerFn, executionAwareRoot?: boolean): void;
+/**
+ * Resolve a JSX handler attribute to an analyzable function, augmenting
+ * named `const` handlers in place. Returns the expression to assign.
+ */
+export declare function buildHandler(ctx: Ctx, compPath: NodePath<t.FunctionDeclaration>, value: t.Expression, attrName: string, compName: string, rowCtx?: RowCtx, eventOriginId?: t.Expression): t.Expression;
+//# sourceMappingURL=handlers.d.ts.map

package/dist/handlers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlers.d.ts","sourceRoot":"","sources":["../src/handlers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAClC,OAAO,EAGL,KAAK,GAAG,EACR,KAAK,MAAM,EACZ,MAAM,WAAW,CAAC;AAiBnB,MAAM,MAAM,SAAS,GACjB,CAAC,CAAC,uBAAuB,GACzB,CAAC,CAAC,kBAAkB,GACpB,CAAC,CAAC,mBAAmB,CAAC;AAE1B,8EAA8E;AAC9E,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,mBAAmB,CAAC,EACzC,IAAI,EAAE,MAAM,GACX,SAAS,GAAG,IAAI,CAUlB;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,mBAAmB,CAAC,EACzC,MAAM,EAAE,SAAS,EACjB,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,MAAM,EACf,kBAAkB,UAAQ,GACzB,IAAI,CAaN;AAED,gFAAgF;AAChF,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,GAAG,EACR,MAAM,EAAE,SAAS,EACjB,kBAAkB,UAAQ,GACzB,IAAI,CAYN;AA8BD;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,mBAAmB,CAAC,EACzC,KAAK,EAAE,CAAC,CAAC,UAAU,EACnB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,MAAM,EACf,aAAa,CAAC,EAAE,CAAC,CAAC,UAAU,GAC3B,CAAC,CAAC,UAAU,CA2Jd"}

package/dist/helper-summaries.d.ts

@@ -0,0 +1,12 @@
+/**
+ * helper-summaries.ts - interprocedural effects for module-local helpers.
+ *
+ * Summaries distinguish exact writes from effects conservatively bounded to
+ * a receiver. Parameter receiver effects are retained by argument position,
+ * so callers can map them back to their own state. Only effects with no
+ * finite receiver/argument boundary are unbounded.
+ */
+import { type Ctx, type FnSummary } from './context';
+/** Read/write summary of a module-level helper, memoized and cycle-safe. */
+export declare function summarizeHelper(ctx: Ctx, name: string, visiting?: Set<string>): FnSummary;
+//# sourceMappingURL=helper-summaries.d.ts.map

package/dist/helper-summaries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helper-summaries.d.ts","sourceRoot":"","sources":["../src/helper-summaries.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,EAEL,KAAK,GAAG,EACR,KAAK,SAAS,EACf,MAAM,WAAW,CAAC;AAWnB,4EAA4E;AAC5E,wBAAgB,eAAe,CAC7B,GAAG,EAAE,GAAG,EACR,IAAI,EAAE,MAAM,EACZ,QAAQ,GAAE,GAAG,CAAC,MAAM,CAAa,GAChC,SAAS,CA2RX"}

package/dist/identifiers.d.ts

@@ -0,0 +1,29 @@
+/**
+ * identifiers.ts - compiler-wide lexical binding allocation.
+ *
+ * Every compiler-owned binding is reserved through one Babel Program scope.
+ * Source identifiers from descendant scopes are also reserved so generated
+ * outer bindings cannot be shadowed inside user callbacks.
+ */
+import type { NodePath, Scope } from '@babel/traverse';
+import * as t from '@babel/types';
+export declare class GeneratedIdentifiers {
+    private readonly scope;
+    readonly runtimeId: string;
+    private readonly reserved;
+    private readonly componentIds;
+    constructor(scope: Scope, programPath: NodePath<t.Program>);
+    generate(hint: string): t.Identifier;
+    registerComponentId(component: string, id: string): void;
+    componentId(component: string): t.Identifier;
+    runtimeMember(name: string): t.MemberExpression;
+}
+export interface IdentifierOwner {
+    identifiers: GeneratedIdentifiers | null;
+}
+export declare function initializeGeneratedIdentifiers(owner: IdentifierOwner, programPath: NodePath<t.Program>): GeneratedIdentifiers;
+export declare function generatedIdentifier(owner: IdentifierOwner, hint: string): t.Identifier;
+export declare function componentId(owner: IdentifierOwner, component: string): t.Identifier;
+export declare function md(owner: IdentifierOwner, name: string): t.MemberExpression;
+export declare function requireIdentifiers(owner: IdentifierOwner): GeneratedIdentifiers;
+//# sourceMappingURL=identifiers.d.ts.map

package/dist/identifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identifiers.d.ts","sourceRoot":"","sources":["../src/identifiers.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAElC,qBAAa,oBAAoB;IAKnB,OAAO,CAAC,QAAQ,CAAC,KAAK;IAJlC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqB;IAC9C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA6B;gBAE7B,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC;IAK3E,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,CAAC,UAAU;IASpC,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI;IAIxD,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,CAAC,CAAC,UAAU;IAQ5C,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,CAAC,gBAAgB;CAMhD;AAED,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,oBAAoB,GAAG,IAAI,CAAC;CAC1C;AAED,wBAAgB,8BAA8B,CAC5C,KAAK,EAAE,eAAe,EACtB,WAAW,EAAE,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,GAC/B,oBAAoB,CAItB;AAED,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,eAAe,EACtB,IAAI,EAAE,MAAM,GACX,CAAC,CAAC,UAAU,CAEd;AAED,wBAAgB,WAAW,CACzB,KAAK,EAAE,eAAe,EACtB,SAAS,EAAE,MAAM,GAChB,CAAC,CAAC,UAAU,CAEd;AAED,wBAAgB,EAAE,CAAC,KAAK,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,GAAG,CAAC,CAAC,gBAAgB,CAE3E;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,eAAe,GAAG,oBAAoB,CAK/E"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+/** Public compiler package entry. */
+export { compile, type MemoDomOptions } from './compile';
+export { compileModules, type CompileModulesOptions, } from './linker';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,qCAAqC;AAErC,OAAO,EAAE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,WAAW,CAAC;AACzD,OAAO,EACL,cAAc,EACd,KAAK,qBAAqB,GAC3B,MAAM,UAAU,CAAC"}