graphddb 0.7.0 → 0.7.2

package/dist/{index-Eg94ChE1.d.ts → index-CvS9ATKB.d.ts}

@@ -1,5 +1,291 @@
-import { x as ParamDescriptor, y as EntityRef, z as ConditionInput, A as Param, M as ModelStatic, w as DDBModel, Q as QueryModelContract, G as QueryMethodSpec, H as CommandModelContract, I as CommandMethodSpec, J as ContractSpec, K as QuerySpec, L as CommandSpec, N as TransactionSpec, O as ContextSpec, X as DefinitionMap, Y as OperationsDocument, Z as AnyOperationDefinition, _ as Manifest, $ as BridgeBundle, a0 as ConditionSpec } from './maintenance-view-adapter-BP2CJDdz.js';
-import { M as MetadataRegistry } from './registry-Cv9nl_3i.js';
+import { Q as QueryModelContract, x as QueryMethodSpec, y as CommandModelContract, z as CommandMethodSpec, A as ContractSpec, G as QuerySpec, H as CommandSpec, I as TransactionSpec, J as ContextSpec, K as SPEC_VERSION, L as ParamSpec, N as PreparedBody, m as EntityMetadata, O as ParamDescriptor, X as EntityRef, Y as ConditionInput, Z as Param, M as ModelStatic, w as DDBModel, _ as DefinitionMap, $ as OperationsDocument, a0 as AnyOperationDefinition, a1 as Manifest, a2 as BridgeBundle, a3 as ConditionSpec } from './maintenance-view-adapter-NBTZbE8-.js';
+import { M as MetadataRegistry } from './registry-BndKbZbg.js';
+
+/**
+ * Contract-layer serialization (issue #59, CQRS Contract layer, Epic #57;
+ * spec `docs/cqrs-contract.md`, "SSoT Schema").
+ *
+ * The Contract IR (#58, `src/define/contract.ts`) holds, per contract method, a
+ * resolved declarative {@link ContractMethodOp} plus the **decided facts** the
+ * planner derived (`resolution` / `inputArity` / `result`). This module
+ * **serializes** those facts into the JSON SSoT — it does **not** re-derive them:
+ *
+ * - The `contracts` map (contract name → {@link ContractSpec}) is layered **on
+ *   top of** the existing `queries` / `commands` / `transactions`. Each method
+ *   references one of them by name (`ContractName__methodName`), so the existing
+ *   operation-spec shapes are unchanged and the current runtime keeps working.
+ * - The referenced operation spec is produced by **reusing** the proven
+ *   {@link buildQuerySpec} / {@link buildCommandSpec} planners: a
+ *   {@link ContractMethodOp} is translated back into the {@link AnyOperationDefinition}
+ *   shape those planners consume (the contract's sentinel references become the
+ *   `Param` placeholders the planner already understands), so the symbolic key
+ *   evaluation, projection, relation chaining, and condition handling are shared
+ *   — never re-implemented, never drifting.
+ *
+ * Everything emitted is **JSON-serializable** by construction (only strings /
+ * numbers / booleans / arrays / plain objects). A contract-free input emits no
+ * `contracts` / `contexts` keys, so the pre-#59 operations document is reproduced
+ * byte-for-byte (backward compatibility).
+ *
+ * ## What this issue serializes vs. defers
+ *
+ * The #58 IR captures a single declarative op per method with a boolean `select`
+ * projection; it does **not** model External Query / Query Composition (no
+ * `query(Contract.method, { from(...) })` primitive exists yet). So no #58
+ * contract produces a `compose`. The serializer nonetheless **supports** it: when
+ * a method op carries composition (a forward-compatible {@link ContractMethodOp}
+ * extension), it is emitted per the proposal's `compose` shape. The N+1 checker
+ * (#60), boundary lint (#61), and runtime execution (#62) are out of scope here —
+ * this is serialization + generator only.
+ */
+
+/**
+ * A contract as accepted by the serializer: either a resolved
+ * {@link QueryModelContract} or a {@link CommandModelContract} (the #58 factory
+ * output). The Key type is erased — the serializer reads the key **fields** off
+ * the resolved op / model metadata, not the phantom type.
+ */
+type AnyModelContract = QueryModelContract<unknown, Record<string, QueryMethodSpec<unknown, unknown, unknown>>> | CommandModelContract<unknown, Record<string, CommandMethodSpec<unknown, unknown, unknown>>>;
+/** A map of contract name → resolved contract IR (as passed to the generator). */
+type ContractMap = Record<string, AnyModelContract>;
+/**
+ * A context-ownership declaration as authored by the producer: context name →
+ * the Model (entity) and Contract names that belong to it. The serializer sorts
+ * the member lists deterministically; see {@link ContextSpec}.
+ */
+interface ContextOwnership {
+    readonly models?: readonly string[];
+    readonly contracts?: readonly string[];
+}
+/** A map of context name → its membership (as passed to the generator). */
+type ContextOwnershipMap = Record<string, ContextOwnership>;
+/**
+ * The output of {@link buildContracts}: the `contracts` map and the
+ * **synthesized** operation specs each method references. The caller merges the
+ * synthesized `queries` / `commands` / `transactions` into the document's
+ * existing maps (a contract method's referenced op lives alongside hand-written
+ * definitions, addressed by name).
+ */
+interface BuiltContracts {
+    readonly contracts: Record<string, ContractSpec>;
+    /** Synthesized read ops referenced by query contract methods. */
+    readonly queries: Record<string, QuerySpec>;
+    /** Synthesized write ops referenced by command contract methods (single form). */
+    readonly commands: Record<string, CommandSpec>;
+    /**
+     * Synthesized transactions referenced by command contract methods whose array
+     * form resolves to a `'transact'` batched write (issue #64). One transaction per
+     * such method, named `<Contract>__<method>__batch`: a single `forEach`-over-keys
+     * write item that the runtime expands once per key (≤25, atomic), reusing the
+     * proven declarative-transaction machinery (#46). Empty when no command method
+     * declares a `'transact'` batch.
+     */
+    readonly transactions: Record<string, TransactionSpec>;
+}
+/**
+ * The derived-effect family of one serialized prepared-write transaction item
+ * (issue #208). Index-aligned to `TransactionSpec.items`; the AOT loader groups
+ * rendered items by category ACROSS the plan's ops so the composed
+ * `TransactWriteItems` matches the in-process execution core's order
+ * (writes, then all edges, then all derived updates, …) byte-for-byte.
+ */
+type PreparedWriteItemCategory = 'base' | 'edge' | 'derive' | 'unique' | 'outbox' | 'idempotency' | 'maintain' | 'maintainOutbox' | 'check';
+/**
+ * Serialize a map of resolved contracts into the `contracts` SSoT map plus the
+ * synthesized operation specs each method references. Deterministic: contracts
+ * and methods are emitted in sorted-key order.
+ *
+ * @param contracts Contract name → resolved {@link QueryModelContract} /
+ *   {@link CommandModelContract} (the #58 factory output). Empty → empty output.
+ * @throws if a contract method op cannot be serialized (a non-boolean projection
+ *   slot, an unsupported write condition); or if a contract violates an N+1
+ *   safety rule (#60, {@link assertContractN1Safe}) — an array into a `range`
+ *   method, a "list under a list", or a `range` composed child.
+ */
+declare function buildContracts(contracts?: ContractMap): BuiltContracts;
+/**
+ * Serialize the context-ownership declarations into the SSoT `contexts` map.
+ * Member lists are sorted for determinism. An empty input yields an empty map
+ * (the caller then omits the key for backward compatibility).
+ */
+declare function buildContexts(contexts?: ContextOwnershipMap): Record<string, ContextSpec>;
+
+/**
+ * Static prepared-plan artifact — the **build-time** (AOT) compilation of
+ * `DDBModel.prepare` bodies (issue #208; design #203 phase 4, on top of the #205
+ * runtime and the #206 compile-time hoist).
+ *
+ * `graphddb transform prepared --aot` evaluates each no-capture-verified prepare
+ * body at BUILD time (the #206 lint proves build-time evaluability) and this
+ * module compiles the evaluated routes into a JSON-serializable
+ * {@link PreparedPlanDocument}:
+ *
+ * - a **write** plan runs the SAME mutation compiler the runtime `prepare` uses
+ *   (`compileWriteFragment` → lifecycle resolution → derived-effect derivation)
+ *   and serializes the result through the SAME contract-SSoT path a
+ *   `.plan(mutation)` command method uses
+ *   ({@link serializePreparedWriteFragment} → one declarative
+ *   {@link TransactionSpec} per op: base write + edges / counters / uniqueness
+ *   guards / outbox / idempotency / maintenance / ConditionChecks) — so the
+ *   runtime never invokes the mutation compiler again, **including the first
+ *   call** (the #206 audit's cold-start gap);
+ * - a **read** plan serializes the analyzed route products (entity name, select
+ *   template, per-field param binds, static/dynamic options) plus the
+ *   {@link QuerySpec} the spec planner derives for it — the same
+ *   `operations.json` vocabulary the Python runtime consumes (templated
+ *   `{param}` key conditions, physical ops, execution plan), so a broken read
+ *   plan fails the BUILD, not the first request.
+ *
+ * ## Model references are entity NAMES
+ *
+ * The artifact never carries a class: each plan records the entity names it
+ * touches plus a **fingerprint** of each entity's canonical manifest entry
+ * ({@link entityFingerprint}). The TS loader (`src/runtime/prepared-loader.ts`)
+ * re-binds names against the live {@link MetadataRegistry} and recomputes the
+ * fingerprints — a mismatch (model declaration / TableMapping drift since the
+ * artifact was generated) is a LOUD reject, never a stale-plan execution.
+ *
+ * Everything emitted is JSON-serializable by construction (the #206 no-capture
+ * lint guarantees the body's templates are static data; the only non-JSON
+ * scalars a template may carry — `Date` / `bigint` literals — are encoded
+ * explicitly in {@link PreparedBindSpec}).
+ */
+
+/** The prepared-plan artifact format version (independent of {@link SPEC_VERSION}). */
+declare const PREPARED_FORMAT_VERSION: "1";
+/**
+ * One serialized value bind: a `$`-param slot (bound from the caller's
+ * `execute(params)` by name) or a static literal recorded at build time. `Date`
+ * and `bigint` literals — which JSON cannot carry natively — are encoded
+ * explicitly and revived by the loader, so the bound value is the SAME typed
+ * value the runtime `prepare` would have captured.
+ */
+type PreparedBindSpec = {
+    readonly param: string;
+} | {
+    readonly literal: string | number | boolean | null;
+} | {
+    readonly literalDate: string;
+} | {
+    readonly literalBigInt: string;
+};
+/** A `{ field: bind }` map (a serialized slot map). */
+type PreparedBindMap = Readonly<Record<string, PreparedBindSpec>>;
+/** One serialized read route of a prepared READ plan. */
+interface PreparedReadRouteSpec {
+    readonly alias: string;
+    readonly op: 'query' | 'list';
+    /** The target entity name (re-bound via the registry at load). */
+    readonly entity: string;
+    /** The static, params-independent select template (JSON-safe by the #206 lint). */
+    readonly select: Record<string, unknown>;
+    /** Key-field binds (`{ field: { param | literal } }`). */
+    readonly key: PreparedBindMap;
+    /** Static option literals decided at build time. */
+    readonly maxDepth?: number;
+    readonly order?: 'ASC' | 'DESC';
+    readonly filter?: Record<string, unknown>;
+    /** Dynamic option binds (a `$` param or a literal, decided per call). */
+    readonly consistentRead?: PreparedBindSpec;
+    readonly limit?: PreparedBindSpec;
+    readonly after?: PreparedBindSpec;
+    /**
+     * The spec-IR read plan (`operations.json` vocabulary: physical ops, templated
+     * `{<field>}` key conditions, relation fan-outs, execution plan) derived from
+     * this route at build time. Key-condition tokens are the entity's key FIELD
+     * names; the per-call param→field mapping is {@link key}. Deriving it at build
+     * time surfaces a broken route as a BUILD failure and freezes the physical
+     * plan for drift comparison.
+     */
+    readonly query: QuerySpec;
+}
+/** One serialized write op of a prepared WRITE plan. */
+interface PreparedWriteOpSpec {
+    readonly alias: string;
+    readonly entity: string;
+    readonly intent: 'create' | 'update' | 'remove';
+    /** The target model's primary-key input fields (W1 key/changes split + read-back key). */
+    readonly keyFields: readonly string[];
+    /** Key-field binds. */
+    readonly key: PreparedBindMap;
+    /** Input-field binds. */
+    readonly input: PreparedBindMap;
+    /** In-process write-gate binds (flat equality / existence template), if declared. */
+    readonly condition?: PreparedBindMap;
+    /** The read-back projection + options, verbatim (JSON-safe by the #206 lint). */
+    readonly result?: {
+        readonly select?: Record<string, unknown>;
+        readonly options?: {
+            readonly consistentRead?: boolean;
+            readonly maxDepth?: number;
+        };
+    };
+    /**
+     * The consistent read-back's spec-IR plan (derived from `result.select` at
+     * build time — a broken read-back projection fails the BUILD). Present iff
+     * {@link result} declares a non-empty select.
+     */
+    readonly readback?: QuerySpec;
+    /**
+     * The op's full declarative {@link TransactionSpec}: `items[0]` is the base
+     * write, followed by every derived effect the mutation compiler resolved at
+     * build time. Templates bind `{<field>}` tokens — the op's key/input FIELD
+     * names — which the loader renders from the per-call bound field values.
+     */
+    readonly transaction: TransactionSpec;
+    /** Per-item derived-effect categories, index-aligned to `transaction.items`. */
+    readonly categories: readonly PreparedWriteItemCategory[];
+}
+/** One compiled prepared plan (all routes of one `DDBModel.prepare` body). */
+interface PreparedPlanSpec {
+    readonly kind: 'read' | 'write';
+    /**
+     * The `$` params the plan binds (union across routes), with kinds recovered
+     * from the bound entity fields where determinable.
+     */
+    readonly params: Readonly<Record<string, ParamSpec>>;
+    /**
+     * Entity name → fingerprint of its canonical manifest entry at build time.
+     * The loader recomputes these from the live registry and LOUDLY rejects a
+     * mismatch (stale plan / model drift).
+     */
+    readonly entities: Readonly<Record<string, string>>;
+    /** Read routes, in body declaration order (read plans only). */
+    readonly reads?: readonly PreparedReadRouteSpec[];
+    /** Write ops, in body declaration order (write plans only). */
+    readonly writes?: readonly PreparedWriteOpSpec[];
+}
+/** The full static prepared-plan artifact. */
+interface PreparedPlanDocument {
+    readonly formatVersion: typeof PREPARED_FORMAT_VERSION;
+    /** The shared operation-IR version the plans were compiled against. */
+    readonly specVersion: typeof SPEC_VERSION;
+    /** Plan id (the transform's stable call-site id) → compiled plan. */
+    readonly plans: Readonly<Record<string, PreparedPlanSpec>>;
+}
+/** Deterministic JSON: object keys sorted at every level (arrays keep order). */
+declare function canonicalJson(value: unknown): string;
+/**
+ * The fingerprint of one entity's canonical manifest entry — every plan-relevant
+ * declaration fact (table, physical name, prefix, fields + formats, key / GSI
+ * templates, relations incl. `refs` bindings, TTL). Computed identically at
+ * build (emit) and at load (live registry), so any drift is caught.
+ */
+declare function entityFingerprint(metadata: EntityMetadata): string;
+/** Stable content hash of a compiled plan (drift-check convenience). */
+declare function planFingerprint(plan: PreparedPlanSpec): string;
+/**
+ * Compile ONE `DDBModel.prepare` body into its static {@link PreparedPlanSpec}
+ * (build-time). The body is evaluated once with the recording `$` proxy — the
+ * #206 no-capture lint has already proven this is side-effect-free and
+ * params-independent — then each route is analyzed and serialized.
+ *
+ * @param body      The prepare body function (as extracted by the transform).
+ * @param planLabel A human-readable label woven into build errors (the plan id).
+ */
+declare function compilePreparedPlan(body: PreparedBody, planLabel?: string): PreparedPlanSpec;
+/** Assemble the full artifact document from compiled plans. */
+declare function buildPreparedPlanDocument(plans: Readonly<Record<string, PreparedPlanSpec>>): PreparedPlanDocument;
 
 /**
  * Declarative transaction definition DSL (issue #46, Python-bridge Phase 4).
@@ -218,107 +504,6 @@ declare function defineTransaction<const P extends TransactionParamShape>(params
  */
 declare function defineTransactions<const D extends Record<string, TransactionDefinition>>(definitions: D): D;
 
-/**
- * Contract-layer serialization (issue #59, CQRS Contract layer, Epic #57;
- * spec `docs/cqrs-contract.md`, "SSoT Schema").
- *
- * The Contract IR (#58, `src/define/contract.ts`) holds, per contract method, a
- * resolved declarative {@link ContractMethodOp} plus the **decided facts** the
- * planner derived (`resolution` / `inputArity` / `result`). This module
- * **serializes** those facts into the JSON SSoT — it does **not** re-derive them:
- *
- * - The `contracts` map (contract name → {@link ContractSpec}) is layered **on
- *   top of** the existing `queries` / `commands` / `transactions`. Each method
- *   references one of them by name (`ContractName__methodName`), so the existing
- *   operation-spec shapes are unchanged and the current runtime keeps working.
- * - The referenced operation spec is produced by **reusing** the proven
- *   {@link buildQuerySpec} / {@link buildCommandSpec} planners: a
- *   {@link ContractMethodOp} is translated back into the {@link AnyOperationDefinition}
- *   shape those planners consume (the contract's sentinel references become the
- *   `Param` placeholders the planner already understands), so the symbolic key
- *   evaluation, projection, relation chaining, and condition handling are shared
- *   — never re-implemented, never drifting.
- *
- * Everything emitted is **JSON-serializable** by construction (only strings /
- * numbers / booleans / arrays / plain objects). A contract-free input emits no
- * `contracts` / `contexts` keys, so the pre-#59 operations document is reproduced
- * byte-for-byte (backward compatibility).
- *
- * ## What this issue serializes vs. defers
- *
- * The #58 IR captures a single declarative op per method with a boolean `select`
- * projection; it does **not** model External Query / Query Composition (no
- * `query(Contract.method, { from(...) })` primitive exists yet). So no #58
- * contract produces a `compose`. The serializer nonetheless **supports** it: when
- * a method op carries composition (a forward-compatible {@link ContractMethodOp}
- * extension), it is emitted per the proposal's `compose` shape. The N+1 checker
- * (#60), boundary lint (#61), and runtime execution (#62) are out of scope here —
- * this is serialization + generator only.
- */
-
-/**
- * A contract as accepted by the serializer: either a resolved
- * {@link QueryModelContract} or a {@link CommandModelContract} (the #58 factory
- * output). The Key type is erased — the serializer reads the key **fields** off
- * the resolved op / model metadata, not the phantom type.
- */
-type AnyModelContract = QueryModelContract<unknown, Record<string, QueryMethodSpec<unknown, unknown, unknown>>> | CommandModelContract<unknown, Record<string, CommandMethodSpec<unknown, unknown, unknown>>>;
-/** A map of contract name → resolved contract IR (as passed to the generator). */
-type ContractMap = Record<string, AnyModelContract>;
-/**
- * A context-ownership declaration as authored by the producer: context name →
- * the Model (entity) and Contract names that belong to it. The serializer sorts
- * the member lists deterministically; see {@link ContextSpec}.
- */
-interface ContextOwnership {
-    readonly models?: readonly string[];
-    readonly contracts?: readonly string[];
-}
-/** A map of context name → its membership (as passed to the generator). */
-type ContextOwnershipMap = Record<string, ContextOwnership>;
-/**
- * The output of {@link buildContracts}: the `contracts` map and the
- * **synthesized** operation specs each method references. The caller merges the
- * synthesized `queries` / `commands` / `transactions` into the document's
- * existing maps (a contract method's referenced op lives alongside hand-written
- * definitions, addressed by name).
- */
-interface BuiltContracts {
-    readonly contracts: Record<string, ContractSpec>;
-    /** Synthesized read ops referenced by query contract methods. */
-    readonly queries: Record<string, QuerySpec>;
-    /** Synthesized write ops referenced by command contract methods (single form). */
-    readonly commands: Record<string, CommandSpec>;
-    /**
-     * Synthesized transactions referenced by command contract methods whose array
-     * form resolves to a `'transact'` batched write (issue #64). One transaction per
-     * such method, named `<Contract>__<method>__batch`: a single `forEach`-over-keys
-     * write item that the runtime expands once per key (≤25, atomic), reusing the
-     * proven declarative-transaction machinery (#46). Empty when no command method
-     * declares a `'transact'` batch.
-     */
-    readonly transactions: Record<string, TransactionSpec>;
-}
-/**
- * Serialize a map of resolved contracts into the `contracts` SSoT map plus the
- * synthesized operation specs each method references. Deterministic: contracts
- * and methods are emitted in sorted-key order.
- *
- * @param contracts Contract name → resolved {@link QueryModelContract} /
- *   {@link CommandModelContract} (the #58 factory output). Empty → empty output.
- * @throws if a contract method op cannot be serialized (a non-boolean projection
- *   slot, an unsupported write condition); or if a contract violates an N+1
- *   safety rule (#60, {@link assertContractN1Safe}) — an array into a `range`
- *   method, a "list under a list", or a `range` composed child.
- */
-declare function buildContracts(contracts?: ContractMap): BuiltContracts;
-/**
- * Serialize the context-ownership declarations into the SSoT `contexts` map.
- * Member lists are sorted for determinism. An empty input yields an empty map
- * (the caller then omits the key for backward compatibility).
- */
-declare function buildContexts(contexts?: ContextOwnershipMap): Record<string, ContextSpec>;
-
 /**
  * Static parameterized operation-spec generation (issue #42, Phase 0b).
  *
@@ -687,4 +872,4 @@ declare function assertBundleSerializable(bundle: BridgeBundle): void;
  */
 declare function buildBridgeBundle(queries?: DefinitionMap, commands?: DefinitionMap, registry?: typeof MetadataRegistry, transactions?: Record<string, TransactionDefinition>, contractInputs?: ContractInputs): BridgeBundle;
 
-export { type AnyModelContract as A, type BuiltContracts as B, type ContextOwnership as C, buildTransactions as D, collectContractBoundaryViolations as E, collectContractN1Violations as F, defineTransaction as G, defineTransactions as H, isTransactionRef as I, when as J, type TransactionDefinition as T, type WhenComparison as W, type ContextOwnershipMap as a, type ContractBoundaryViolation as b, type ContractInputs as c, type ContractMap as d, type ContractN1Violation as e, type TransactionParamShape as f, type TransactionRef as g, type TxConditionCheckOptions as h, type TxForEachInstruction as i, type TxForEachOptions as j, type TxInstruction as k, type TxRecorder as l, type TxWriteInstruction as m, type TxWriteOptions as n, assertBundleSerializable as o, assertContractBoundaries as p, assertContractN1Safe as q, assertJsonSerializable as r, assertSupportedCondition as s, buildBridgeBundle as t, buildContexts as u, buildContracts as v, buildManifest as w, buildOperations as x, buildQuerySpec as y, buildTransactionSpec as z };
+export { type AnyModelContract as A, type BuiltContracts as B, type ContextOwnership as C, buildManifest as D, buildOperations as E, buildQuerySpec as F, buildTransactionSpec as G, buildTransactions as H, collectContractBoundaryViolations as I, collectContractN1Violations as J, defineTransaction as K, defineTransactions as L, isTransactionRef as M, when as N, PREPARED_FORMAT_VERSION as O, type PreparedWriteOpSpec as P, type PreparedBindMap as Q, buildPreparedPlanDocument as R, canonicalJson as S, type TransactionDefinition as T, compilePreparedPlan as U, entityFingerprint as V, type WhenComparison as W, planFingerprint as X, type PreparedPlanDocument as a, type ContextOwnershipMap as b, type ContractBoundaryViolation as c, type ContractInputs as d, type ContractMap as e, type ContractN1Violation as f, type PreparedBindSpec as g, type PreparedPlanSpec as h, type PreparedReadRouteSpec as i, type TransactionParamShape as j, type TransactionRef as k, type TxConditionCheckOptions as l, type TxForEachInstruction as m, type TxForEachOptions as n, type TxInstruction as o, type TxRecorder as p, type TxWriteInstruction as q, type TxWriteOptions as r, assertBundleSerializable as s, assertContractBoundaries as t, assertContractN1Safe as u, assertJsonSerializable as v, assertSupportedCondition as w, buildBridgeBundle as x, buildContexts as y, buildContracts as z };

package/dist/index.d.ts

@@ -1,11 +1,12 @@
-export { a as LintResult, L as LintRule, b as Linter, M as MetadataRegistry } from './registry-Cv9nl_3i.js';
-import { aN as SelectableOf, aO as PrimaryKeyOf, aP as RequestContext, aQ as Middleware, aR as ReadRequestKind, aS as CtxModel, aT as ReadParams, aU as ReadRequestCtx, D as DynamoDBOperation, aV as Item, n as Executor, aW as RetryPolicy, am as ExecutionPlanSpec, aX as KeyDefinition, aY as GsiDefinition, aZ as ModelKind, a_ as FieldOptions, a$ as DynamoType, b0 as ProjectionTransform, b1 as MaintainEvent, b2 as MembershipPredicate, b3 as MaintainConsistency, b4 as MaintainUpdateMode, b5 as MembershipPredicateOp, b6 as RelationOptions, b7 as AggregateOptions, b8 as AggregateValue, b9 as SelectBuilderSpec, ba as RawCondition, m as EntityMetadata, N as TransactionSpec, _ as Manifest, bb as RetryOverride, bc as ExecutionPlan, bd as FieldMetadata, be as ResolvedKey, o as ReadExecOptions, p as ExecutorResult, q as BatchGetExecInput, P as PutInput, W as WriteExecOptions, r as WriteResult, s as UpdateInput, t as DeleteInput, u as BatchWriteExecItem, v as BatchExecOptions, T as TransactWriteExecItem, bf as RelationMetadata, aC as TransactionItemSpec, bg as MaintainEffect, M as ModelStatic, w as DDBModel, V as ViewDefinition, A as Param, x as ParamDescriptor, X as DefinitionMap, bh as OperationDefinition, bi as WriteDefinitionOptions, bj as PartialQueryKeyOf, bk as StrictSelectSpec, bl as ReadDefinitionOptions, bm as EntityInput, bn as UniqueQueryKeyOf } from './maintenance-view-adapter-BP2CJDdz.js';
-export { bo as AggregateMetadata, Z as AnyOperationDefinition, bp as BatchDeleteRequest, bq as BatchGetOptions, br as BatchGetRequest, bs as BatchGetResult, bt as BatchPutRequest, B as BatchResult, bu as BatchWriteRequest, $ as BridgeBundle, bv as CONTRACT_RANGE_FANOUT_CONCURRENCY, C as CdcEmulatorOptions, a as CdcMode, bw as CdcModelRegistry, bx as CdcSubscribeHandlers, by as Change, b as ChangeBatch, c as ChangeEvent, d as ChangeEventName, e as ChangeHandler, f as ClockMode, bz as CollectionEffect, bA as CollectionOptions, bB as Column, bC as ColumnMap, a1 as CommandContractMethodSpec, bD as CommandInputShape, bE as CommandMethod, I as CommandMethodSpec, H as CommandModelContract, bF as CommandPlan, a2 as CommandResolutionTarget, bG as CommandResultKind, bH as CommandSelectShape, L as CommandSpec, a3 as CompiledFragment, a5 as ComposeSpec, g as ConcurrentRecomputeRef, bI as CondSlot, bJ as ConditionCheckInput, z as ConditionInput, a0 as ConditionSpec, bK as Connection, O as ContextSpec, bL as ContractCallSignature, a7 as ContractCardinality, bM as ContractCommandParams, a8 as ContractCommandResult, bN as ContractComposeNode, bO as ContractFromRef, a9 as ContractInputArity, bP as ContractItem, bQ as ContractKeyFieldRef, bR as ContractKeyInput, bS as ContractKeyRef, aa as ContractKeySpec, ab as ContractKind, bT as ContractMethodOp, bU as ContractParamRef, bV as ContractQueryParams, ac as ContractResolution, J as ContractSpec, bW as CounterAggregate, bX as CounterEffect, bY as CtxBase, bZ as DEFAULT_MAX_ATTEMPTS, b_ as DEFAULT_RETRY_POLICY, b$ as DeleteOptions, c0 as DeriveEffect, ae as DerivedEdgeWrite, ak as DerivedUpdate, c1 as DescriptorBinding, c2 as ENTITY_WRITES_MARKER, c3 as EdgeEffect, c4 as EffectPath, c5 as EmbeddedMetadata, c6 as EmitEffect, y as EntityRef, c7 as EntityWritesDefinition, c8 as EntityWritesShape, E as EventLog, c9 as ExecutableCommandContract, ca as ExecutableQueryContract, F as FaultSpec, cb as FilterInput, an as FilterSpec, cc as FragmentInput, cd as GsiDefinitionMarker, ce as GsiOptions, cf as IdempotencyEffect, cg as InProcessWriteDescriptor, ch as InlineSnapshotSpec, ci as InputArity, cj as KeyDefinitionMarker, ck as KeySegment, cl as KeySlot, cm as KeyStructure, cn as KeyedResult, co as LIFECYCLE_CONTRACT_MARKER, cp as LifecycleContract, cq as LifecycleEffects, cr as LiteralParam, cs as MaintainItem, ct as MaintainTrigger, cu as MaintenanceGraph, ap as ManifestEntity, aq as ManifestField, ar as ManifestFieldType, as as ManifestGsi, at as ManifestKey, au as ManifestRelation, av as ManifestTable, cv as MembershipEffect, cw as ModelRef, cx as MutateMode, cy as MutateOptions, cz as MutateParallelResult, cA as MutateTransactionResult, cB as MutationBody, cC as MutationDescriptorMap, cD as MutationFragment, cE as MutationInputProxy, cF as MutationInputRef, cG as MutationIntent, cH as NumberParam, cI as OperationKind, aw as OperationSpec, Y as OperationsDocument, cJ as PREPARE_CACHE_MAX, cK as ParallelOpResult, cL as ParamKind, ax as ParamSpec, cM as ParamStructure, cN as PersistCtx, cO as PersistOrigin, cP as PlannedCommandMethod, cQ as PreparedBody, cR as PreparedInputProxy, cS as PreparedParamRef, cT as PreparedReadExecOptions, cU as PreparedReadRoute, cV as PreparedReadStatement, cW as PreparedStatement, cX as PreparedWriteExecOptions, cY as PreparedWriteRoute, cZ as PreparedWriteStatement, c_ as ProjectionMap, c$ as ProjectionTransformOp, d0 as PutOptions, ay as QueryContractMethodSpec, d1 as QueryEnvelopeResult, d2 as QueryKeyOf, d3 as QueryMethod, G as QueryMethodSpec, Q as QueryModelContract, d4 as QueryResult, K as QuerySpec, az as RangeConditionSpec, d5 as ReadEnvelope, d6 as ReadOpCtx, d7 as ReadOpKind, aA as ReadOperationType, d8 as ReadRouteDescriptor, d9 as ReadRouteOptions, da as ReadRouteResult, db as RecordedCompose, dc as RelationBuilder, dd as RelationConsistency, de as RelationLimitOptions, df as RelationPattern, dg as RelationProjection, dh as RelationReadOptions, di as RelationSelect, dj as RelationSpec, dk as RelationUpdateMode, dl as RelationWriteOptions, R as ReplayOptions, dm as RequiresEffect, dn as Resolution, dp as RetryInfo, dq as RetryOperationKind, aB as SPEC_VERSION, dr as SegmentSpec, ds as SegmentedKey, dt as SelectBuilder, du as SelectOf, S as ShardId, dv as SnapshotEffect, h as StartingPosition, i as StreamViewType, dw as StringParam, j as SubscribeHandler, k as SubscribeHandlers, dx as TransactionContext, aD as TransactionItemType, dy as UniqueEffect, dz as Updatable, dA as UpdateOptions, dB as ViewSourceSlice, aE as WhenSpec, dC as WriteCtx, dD as WriteDescriptor, dE as WriteEnvelope, dF as WriteInput, dG as WriteKind, dH as WriteLifecyclePhase, dI as WriteMiddleware, aF as WriteOperationType, dJ as WriteRecorder, dK as WriteResultProjection, dL as attachModelClass, dM as buildDeleteInput, dN as buildMaintenanceGraph, dO as buildPutInput, l as buildSubscribeHandler, dP as buildUpdateInput, dQ as collectViewDefinitions, aH as compileFragment, aI as compileMutationPlan, aJ as compileSingleFragmentPlan, dR as cond, dS as contractOfMethodSpec, dT as definePlan, dU as entityWrites, dV as executeBatchGet, dW as executeBatchWrite, dX as executeCommandMethod, dY as executeDelete, dZ as executeKeyedBatchGet, d_ as executePut, d$ as executeQueryMethod, e0 as executeRangeFanout, e1 as executeTransaction, e2 as executeUpdate, e3 as from, e4 as getEntityWrites, e5 as gsi, e6 as identity, e7 as isColumn, e8 as isCommandModelContract, e9 as isCommandPlan, ea as isContractComposeNode, eb as isContractFromRef, ec as isContractKeyFieldRef, ed as isContractKeyRef, ee as isContractParamRef, ef as isEntityWritesDefinition, eg as isKeySegment, eh as isLifecycleContract, ei as isMaintainTrigger, ej as isMutationFragment, ek as isMutationInputRef, el as isParam, em as isPlannedCommandMethod, en as isPreparedParamRef, eo as isQueryModelContract, ep as isRetryableError, eq as isRetryableTransactionCancellation, er as k, es as key, et as lifecyclePhaseForIntent, eu as maintainTrigger, ev as mintContractKeyFieldRef, ew as mintContractParamRef, ex as mutation, ey as param, ez as prepare, eA as preview, eB as publicCommandModel, eC as publicQueryModel, eD as query, aL as resolveLifecycle, eE as wholeKeysSentinel } from './maintenance-view-adapter-BP2CJDdz.js';
+export { a as LintResult, L as LintRule, b as Linter, M as MetadataRegistry } from './registry-BndKbZbg.js';
+import { aO as SelectableOf, aP as PrimaryKeyOf, aQ as RequestContext, aR as Middleware, aS as ReadRequestKind, aT as CtxModel, aU as ReadParams, aV as ReadRequestCtx, D as DynamoDBOperation, aW as Item, n as Executor, aX as RetryPolicy, ap as ExecutionPlanSpec, aY as KeyDefinition, aZ as GsiDefinition, a_ as ModelKind, a$ as FieldOptions, b0 as DynamoType, b1 as ProjectionTransform, b2 as MaintainEvent, b3 as MembershipPredicate, b4 as MaintainConsistency, b5 as MaintainUpdateMode, b6 as MembershipPredicateOp, b7 as RelationOptions, b8 as AggregateOptions, b9 as AggregateValue, ba as SelectBuilderSpec, bb as RawCondition, m as EntityMetadata, I as TransactionSpec, a1 as Manifest, bc as RetryOverride, bd as ExecutionPlan, be as FieldMetadata, bf as ResolvedKey, o as ReadExecOptions, p as ExecutorResult, q as BatchGetExecInput, P as PutInput, W as WriteExecOptions, r as WriteResult, s as UpdateInput, t as DeleteInput, u as BatchWriteExecItem, v as BatchExecOptions, T as TransactWriteExecItem, M as ModelStatic, w as DDBModel, bg as Slot, bh as PreparedWriteExecOptions, bi as CommandReturn, bj as ParallelOpResult, N as PreparedBody, bk as PreparedStatement, bl as RelationMetadata, aD as TransactionItemSpec, bm as MaintainEffect, V as ViewDefinition, Z as Param, O as ParamDescriptor, _ as DefinitionMap, bn as OperationDefinition, bo as WriteDefinitionOptions, bp as PartialQueryKeyOf, bq as StrictSelectSpec, br as ReadDefinitionOptions, bs as EntityInput, bt as UniqueQueryKeyOf } from './maintenance-view-adapter-NBTZbE8-.js';
+export { bu as AggregateMetadata, a0 as AnyOperationDefinition, bv as BatchDeleteRequest, bw as BatchGetOptions, bx as BatchGetRequest, by as BatchGetResult, bz as BatchPutRequest, B as BatchResult, bA as BatchWriteRequest, a2 as BridgeBundle, bB as CONTRACT_RANGE_FANOUT_CONCURRENCY, C as CdcEmulatorOptions, a as CdcMode, bC as CdcModelRegistry, bD as CdcSubscribeHandlers, bE as Change, b as ChangeBatch, c as ChangeEvent, d as ChangeEventName, e as ChangeHandler, f as ClockMode, bF as CollectionEffect, bG as CollectionOptions, bH as Column, bI as ColumnMap, a4 as CommandContractMethodSpec, bJ as CommandInputShape, bK as CommandMethod, z as CommandMethodSpec, y as CommandModelContract, bL as CommandPlan, a5 as CommandResolutionTarget, bM as CommandResultKind, bN as CommandSelectShape, H as CommandSpec, a6 as CompiledFragment, a8 as ComposeSpec, g as ConcurrentRecomputeRef, bO as CondSlot, bP as ConditionCheckInput, Y as ConditionInput, a3 as ConditionSpec, bQ as Connection, J as ContextSpec, bR as ContractCallSignature, aa as ContractCardinality, bS as ContractCommandParams, ab as ContractCommandResult, bT as ContractComposeNode, bU as ContractFromRef, ac as ContractInputArity, bV as ContractItem, bW as ContractKeyFieldRef, bX as ContractKeyInput, bY as ContractKeyRef, ad as ContractKeySpec, ae as ContractKind, bZ as ContractMethodOp, b_ as ContractParamRef, b$ as ContractQueryParams, af as ContractResolution, A as ContractSpec, c0 as CounterAggregate, c1 as CounterEffect, c2 as CtxBase, c3 as DEFAULT_MAX_ATTEMPTS, c4 as DEFAULT_RETRY_POLICY, c5 as DeleteOptions, c6 as DeriveEffect, ah as DerivedEdgeWrite, an as DerivedUpdate, c7 as DescriptorBinding, c8 as ENTITY_WRITES_MARKER, c9 as EdgeEffect, ca as EffectPath, cb as EmbeddedMetadata, cc as EmitEffect, X as EntityRef, cd as EntityWritesDefinition, ce as EntityWritesShape, E as EventLog, cf as ExecutableCommandContract, cg as ExecutableQueryContract, F as FaultSpec, ch as FilterInput, aq as FilterSpec, ci as FragmentInput, cj as GsiDefinitionMarker, ck as GsiOptions, cl as IdempotencyEffect, cm as InProcessWriteDescriptor, cn as InlineSnapshotSpec, co as InputArity, cp as KeyDefinitionMarker, cq as KeySegment, cr as KeySlot, cs as KeyStructure, ct as KeyedResult, cu as LIFECYCLE_CONTRACT_MARKER, cv as LifecycleContract, cw as LifecycleEffects, cx as LiteralParam, cy as MaintainItem, cz as MaintainTrigger, cA as MaintenanceGraph, as as ManifestEntity, at as ManifestField, au as ManifestFieldType, av as ManifestGsi, aw as ManifestKey, ax as ManifestRelation, ay as ManifestTable, cB as MembershipEffect, cC as ModelRef, cD as MutateMode, cE as MutateOptions, cF as MutateParallelResult, cG as MutateTransactionResult, cH as MutationBody, cI as MutationDescriptorMap, cJ as MutationFragment, cK as MutationInputProxy, cL as MutationInputRef, cM as MutationIntent, cN as NumberParam, cO as OperationKind, az as OperationSpec, $ as OperationsDocument, cP as PREPARE_CACHE_MAX, cQ as ParamKind, L as ParamSpec, cR as ParamStructure, cS as PersistCtx, cT as PersistOrigin, cU as PlannedCommandMethod, cV as PreparedInputProxy, cW as PreparedParamRef, cX as PreparedReadExecOptions, cY as PreparedReadRoute, cZ as PreparedReadStatement, c_ as PreparedWriteRoute, c$ as PreparedWriteStatement, d0 as ProjectionMap, d1 as ProjectionTransformOp, d2 as PutOptions, aA as QueryContractMethodSpec, d3 as QueryEnvelopeResult, d4 as QueryKeyOf, d5 as QueryMethod, x as QueryMethodSpec, Q as QueryModelContract, d6 as QueryResult, G as QuerySpec, aB as RangeConditionSpec, d7 as ReadEnvelope, d8 as ReadOpCtx, d9 as ReadOpKind, aC as ReadOperationType, da as ReadRouteDescriptor, db as ReadRouteOptions, dc as ReadRouteResult, dd as RecordedCompose, de as RelationBuilder, df as RelationConsistency, dg as RelationLimitOptions, dh as RelationPattern, di as RelationProjection, dj as RelationReadOptions, dk as RelationSelect, dl as RelationSpec, dm as RelationUpdateMode, dn as RelationWriteOptions, R as ReplayOptions, dp as RequiresEffect, dq as Resolution, dr as RetryInfo, ds as RetryOperationKind, K as SPEC_VERSION, dt as SegmentSpec, du as SegmentedKey, dv as SelectBuilder, dw as SelectOf, S as ShardId, dx as SnapshotEffect, h as StartingPosition, i as StreamViewType, dy as StringParam, j as SubscribeHandler, k as SubscribeHandlers, dz as TransactionContext, aE as TransactionItemType, dA as UniqueEffect, dB as Updatable, dC as UpdateOptions, dD as ViewSourceSlice, aF as WhenSpec, dE as WriteCtx, dF as WriteDescriptor, dG as WriteEnvelope, dH as WriteInput, dI as WriteKind, dJ as WriteLifecyclePhase, dK as WriteMiddleware, aG as WriteOperationType, dL as WriteRecorder, dM as WriteResultProjection, dN as attachModelClass, dO as buildDeleteInput, dP as buildMaintenanceGraph, dQ as buildPutInput, l as buildSubscribeHandler, dR as buildUpdateInput, dS as collectViewDefinitions, aI as compileFragment, aJ as compileMutationPlan, aK as compileSingleFragmentPlan, dT as cond, dU as contractOfMethodSpec, dV as definePlan, dW as entityWrites, dX as executeBatchGet, dY as executeBatchWrite, dZ as executeCommandMethod, d_ as executeDelete, d$ as executeKeyedBatchGet, e0 as executePut, e1 as executeQueryMethod, e2 as executeRangeFanout, e3 as executeTransaction, e4 as executeUpdate, e5 as from, e6 as getEntityWrites, e7 as gsi, e8 as identity, e9 as isColumn, ea as isCommandModelContract, eb as isCommandPlan, ec as isContractComposeNode, ed as isContractFromRef, ee as isContractKeyFieldRef, ef as isContractKeyRef, eg as isContractParamRef, eh as isEntityWritesDefinition, ei as isKeySegment, ej as isLifecycleContract, ek as isMaintainTrigger, el as isMutationFragment, em as isMutationInputRef, en as isParam, eo as isPlannedCommandMethod, ep as isPreparedParamRef, eq as isQueryModelContract, er as isRetryableError, es as isRetryableTransactionCancellation, et as k, eu as key, ev as lifecyclePhaseForIntent, ew as maintainTrigger, ex as mintContractKeyFieldRef, ey as mintContractParamRef, ez as mutation, eA as param, eB as prepare, eC as preview, eD as publicCommandModel, eE as publicQueryModel, eF as query, aM as resolveLifecycle, eG as wholeKeysSentinel } from './maintenance-view-adapter-NBTZbE8-.js';
 import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
 import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
-export { C as CdcEmulator, M as MAINT_OUTBOX_PK_PREFIX, a as MaintenanceDrain, b as MaintenanceDrainOptions, c as createCdcEmulator, d as createMaintenanceDrain, e as createMaintenanceDrainHandler, p as parseChange } from './from-change-pnURY-cV.js';
-export { c as createDefaultLinter, g as gsiAmbiguityRule, m as missingGsiRule, n as noScanRule, q as queryBoundaryRule, r as relationDepthRule, a as requireLimitRule } from './relation-depth-BR0y7Q1i.js';
-export { A as AnyModelContract, B as BuiltContracts, C as ContextOwnership, a as ContextOwnershipMap, b as ContractBoundaryViolation, c as ContractInputs, d as ContractMap, e as ContractN1Violation, T as TransactionDefinition, f as TransactionParamShape, g as TransactionRef, h as TxConditionCheckOptions, i as TxForEachInstruction, j as TxForEachOptions, k as TxInstruction, l as TxRecorder, m as TxWriteInstruction, n as TxWriteOptions, W as WhenComparison, o as assertBundleSerializable, p as assertContractBoundaries, q as assertContractN1Safe, r as assertJsonSerializable, s as assertSupportedCondition, t as buildBridgeBundle, u as buildContexts, v as buildContracts, w as buildManifest, x as buildOperations, y as buildQuerySpec, z as buildTransactionSpec, D as buildTransactions, E as collectContractBoundaryViolations, F as collectContractN1Violations, G as defineTransaction, H as defineTransactions, I as isTransactionRef, J as when } from './index-Eg94ChE1.js';
+export { C as CdcEmulator, M as MAINT_OUTBOX_PK_PREFIX, a as MaintenanceDrain, b as MaintenanceDrainOptions, c as createCdcEmulator, d as createMaintenanceDrain, e as createMaintenanceDrainHandler, p as parseChange } from './from-change-CWiXBcgi.js';
+import { P as PreparedWriteOpSpec, a as PreparedPlanDocument } from './index-CvS9ATKB.js';
+export { A as AnyModelContract, B as BuiltContracts, C as ContextOwnership, b as ContextOwnershipMap, c as ContractBoundaryViolation, d as ContractInputs, e as ContractMap, f as ContractN1Violation, g as PreparedBindSpec, h as PreparedPlanSpec, i as PreparedReadRouteSpec, T as TransactionDefinition, j as TransactionParamShape, k as TransactionRef, l as TxConditionCheckOptions, m as TxForEachInstruction, n as TxForEachOptions, o as TxInstruction, p as TxRecorder, q as TxWriteInstruction, r as TxWriteOptions, W as WhenComparison, s as assertBundleSerializable, t as assertContractBoundaries, u as assertContractN1Safe, v as assertJsonSerializable, w as assertSupportedCondition, x as buildBridgeBundle, y as buildContexts, z as buildContracts, D as buildManifest, E as buildOperations, F as buildQuerySpec, G as buildTransactionSpec, H as buildTransactions, I as collectContractBoundaryViolations, J as collectContractN1Violations, K as defineTransaction, L as defineTransactions, M as isTransactionRef, N as when } from './index-CvS9ATKB.js';
+export { c as createDefaultLinter, g as gsiAmbiguityRule, m as missingGsiRule, n as noScanRule, q as queryBoundaryRule, r as relationDepthRule, a as requireLimitRule } from './relation-depth-CCGHLTOv.js';
 
 /**
  * Query options with conditional `consistentRead` availability.
@@ -1406,6 +1407,83 @@ declare function encodePerKeyCursor(key: Record<string, unknown>, inner: string
  */
 declare function decodePerKeyCursor(cursor: string, expectedKey: Record<string, unknown>): string;
 
+/**
+ * Static prepared-plan LOADER (issue #208) — the runtime half of the AOT
+ * pipeline. `graphddb transform prepared --aot` compiles every verified
+ * `DDBModel.prepare` body at BUILD time into a {@link PreparedPlanDocument}
+ * (`src/spec/prepared.ts`) and rewrites the call site to
+ *
+ * ```ts
+ * (__gddbPrepared1 ??= loadPreparedPlan(__gddbPreparedPlans, '<id>', ($) => ({…})))
+ * ```
+ *
+ * This module loads that artifact: it re-binds each plan's entity NAMES against
+ * the live {@link MetadataRegistry}, verifies the plan is not stale, and returns
+ * a handle whose `execute` runs the very same execution cores the runtime
+ * `prepare` uses — with **zero plan construction / compilation per op, including
+ * the first call**:
+ *
+ * - a **read** plan binds into the SAME {@link PreparedReadStatement} the
+ *   runtime `prepare` returns (identical semantics by construction — reads never
+ *   had an expensive compile; what `prepare` computes once, the artifact
+ *   carries);
+ * - a **write** plan's mutation compile (lifecycle resolution + derived-effect
+ *   derivation — the expensive half) happened at BUILD time; `execute` renders
+ *   the serialized templates and runs {@link executeLogicalWriteOps} /
+ *   {@link executeLogicalParallelWrites} — the same W1–W5 / fast-path / atomic
+ *   commit / read-back pipeline as the compiled core, so effects are identical.
+ *
+ * ## Stale plans are a LOUD reject
+ *
+ * Each plan records a fingerprint of every entity's canonical manifest entry at
+ * build time. On first use the loader recomputes the fingerprints from the live
+ * registry: a mismatch (the model declarations — key/GSI templates, fields,
+ * relations, table mapping — changed since the artifact was generated) throws
+ * with a regeneration hint. A stale static plan NEVER executes. Version-skewed
+ * artifacts (format / spec IR version) reject the same way.
+ *
+ * ## Laziness
+ *
+ * Binding is deferred to the FIRST `execute` (not the `loadPreparedPlan` call):
+ * a module-scope `const p = loadPreparedPlan(…)` must not touch the registry at
+ * module-init time (the target models may be declared later in the same module —
+ * the same TDZ hazard the #206 lazy slot solves). Binding is memoized per
+ * `(document, planId)`; it performs registry lookups + fingerprint hashing only,
+ * never plan compilation.
+ */
+
+interface BoundWriteOp {
+    readonly alias: string;
+    readonly spec: PreparedWriteOpSpec;
+    readonly modelClass: Function;
+    readonly modelStatic: ModelStatic<DDBModel>;
+    readonly keySlots: Readonly<Record<string, Slot>>;
+    readonly inputSlots: Readonly<Record<string, Slot>>;
+    readonly conditionSlots?: Readonly<Record<string, Slot>>;
+    readonly manifest: Manifest;
+}
+/** A prepared WRITE handle bound from a static plan (#208). `execute(params)`
+ * mirrors {@link import('./prepared.js').PreparedWriteStatement.execute}. */
+declare class AotPreparedWriteStatement {
+    private readonly ops;
+    /** @internal */
+    constructor(ops: readonly BoundWriteOp[]);
+    execute(params?: Record<string, unknown>, options?: PreparedWriteExecOptions): Promise<Record<string, CommandReturn | undefined> | Record<string, ParallelOpResult | ParallelOpResult[]>>;
+}
+/**
+ * Load one statically-compiled prepared plan (issue #208). The rewritten call
+ * site passes the artifact document, the stable plan id, and the ORIGINAL
+ * prepare body — the body is retained in source as the plan's compile source
+ * (drift regeneration + type inference + the untransformed-build fallback) and
+ * is NEVER evaluated here: execution consumes the static artifact only.
+ *
+ * Per-op plan construction / compilation is ZERO, including the first call —
+ * the first `execute` performs registry binding + stale-fingerprint
+ * verification only (memoized per `(document, planId)`), then every call binds
+ * params into the frozen plan and runs the shared execution cores.
+ */
+declare function loadPreparedPlan(doc: PreparedPlanDocument, planId: string, body?: PreparedBody): PreparedStatement;
+
 declare function detectRelationFields(select: Record<string, unknown>, metadata: EntityMetadata): RelationMetadata[];
 declare function getImplicitKeyFields(select: Record<string, unknown>, metadata: EntityMetadata): string[];
 
@@ -2100,4 +2178,4 @@ type WriteOnlyDefinitions<D extends DefinitionMap> = {
     [K in keyof D]: D[K] extends OperationDefinition<infer _T, infer Op, infer _K, infer _S, infer _Ch, infer _P> ? Op extends 'put' | 'update' | 'delete' ? D[K] : OperationDefinition<DDBModel, 'put' | 'update' | 'delete', unknown, unknown, unknown, Record<string, ParamDescriptor>> : never;
 };
 
-export { AggregateOptions, AggregateValue, BATCH_GET_MAX_KEYS, BATCH_WRITE_MAX_ITEMS, BatchExecOptions, BatchGetExecInput, BatchWriteExecItem, ClientManager, type CollectParams, type ConditionExpressionResult, CtxModel, DDBModel, DefinitionMap, DeleteInput, type DriftReport, DynamoDBOperation, DynamoExecutor, DynamoType, EDGE_WRITES_MARKER, type EdgeLifecycle, type EdgeWriteDeclaration, type EdgeWriteRecorder, type EdgeWritesDefinition, EntityMetadata, ExecutionPlan, Executor, ExecutorResult, type ExplainInput, FieldMetadata, FieldOptions, type FilterExpressionResult, GsiDefinition, type HasManyVersionedCallback, type HasManyVersionedOptions, type HasOneVersionedCallback, type HasOneVersionedOptions, Item, KeyDefinition, type ListInput, type ListOptions, MAX_TRANSACT_ITEMS, MaintainConsistency, MaintainEffect, MaintainEvent, MaintainUpdateMode, type MaintainedFromCallback, type MaintainedFromOptions, type MaintenanceRebuildOptions, MaintenanceRebuilder, Manifest, MembershipPredicate, MembershipPredicateOp, Middleware, type ModelOptions, ModelStatic, OLD_VALUE_NAMESPACE, OperationDefinition, Param, ParamDescriptor, type Parameterize, PartialQueryKeyOf, type PerKeyCursorEnvelope, type PlanInput, PrimaryKeyOf, type ProjectionResult, ProjectionTransform, type ProjectionValue, PutInput, type QueryOptions$1 as QueryOptions, RawCondition, ReadExecOptions, ReadParams, ReadRequestCtx, ReadRequestKind, type RebuildResult, type RefsOptions, RelationMetadata, RelationOptions, type RelationTraversalOptions, RequestContext, ResolvedKey, RetryOverride, RetryPolicy, RetryingExecutor, SelectableOf, type SelfProxy, type SelfRef, type SourceProxy, type SourceRef, TableMapping, TransactWriteExecItem, TransactionItemSpec, TransactionSpec, UniqueQueryKeyOf, type UpdateExpressionResult, UpdateInput, type VersionedHistoryOptions, type VersionedLatestOptions, ViewDefinition, WriteDefinitionOptions, WriteExecOptions, WriteResult, aggregate, belongsTo, binary, boolean, buildConditionExpression, buildProjection, buildUpdateExpression, cdcProjected, compileFilterExpression, count, createMaintenanceRebuilder, datetime, decodeCursor, decodePerKeyCursor, defineCommands, defineDelete, defineList, definePut, defineQueries, defineQuery, defineUpdate, deriveEdgeWriteItems, deriveEdgeWriteItemsFor, deriveModelEdgeWriteItems, derivePrefix, detectRelationFields, edgeWrites, embedded, encodeCursor, encodePerKeyCursor, evaluateFilter, execute, executeDeclarativeTransaction, executeExplain, executeList, executeQuery, expandTransaction, field, getEdgeWrites, getImplicitKeyFields, hasMany, hasOne, hydrate, isEdgeWritesDefinition, isSelectBuilder, list, literal, maintainedFrom, map, max, model, number, numberSet, plan, refs, resolveKey, resolveRelations, serializeContractKey, serializeFieldValue, string, stringSet, ttl, validateDepth, validateGsiAmbiguity, whenMember };
+export { AggregateOptions, AggregateValue, AotPreparedWriteStatement, BATCH_GET_MAX_KEYS, BATCH_WRITE_MAX_ITEMS, BatchExecOptions, BatchGetExecInput, BatchWriteExecItem, ClientManager, type CollectParams, type ConditionExpressionResult, CtxModel, DDBModel, DefinitionMap, DeleteInput, type DriftReport, DynamoDBOperation, DynamoExecutor, DynamoType, EDGE_WRITES_MARKER, type EdgeLifecycle, type EdgeWriteDeclaration, type EdgeWriteRecorder, type EdgeWritesDefinition, EntityMetadata, ExecutionPlan, Executor, ExecutorResult, type ExplainInput, FieldMetadata, FieldOptions, type FilterExpressionResult, GsiDefinition, type HasManyVersionedCallback, type HasManyVersionedOptions, type HasOneVersionedCallback, type HasOneVersionedOptions, Item, KeyDefinition, type ListInput, type ListOptions, MAX_TRANSACT_ITEMS, MaintainConsistency, MaintainEffect, MaintainEvent, MaintainUpdateMode, type MaintainedFromCallback, type MaintainedFromOptions, type MaintenanceRebuildOptions, MaintenanceRebuilder, Manifest, MembershipPredicate, MembershipPredicateOp, Middleware, type ModelOptions, ModelStatic, OLD_VALUE_NAMESPACE, OperationDefinition, ParallelOpResult, Param, ParamDescriptor, type Parameterize, PartialQueryKeyOf, type PerKeyCursorEnvelope, type PlanInput, PreparedBody, PreparedPlanDocument, PreparedStatement, PreparedWriteExecOptions, PreparedWriteOpSpec, PrimaryKeyOf, type ProjectionResult, ProjectionTransform, type ProjectionValue, PutInput, type QueryOptions$1 as QueryOptions, RawCondition, ReadExecOptions, ReadParams, ReadRequestCtx, ReadRequestKind, type RebuildResult, type RefsOptions, RelationMetadata, RelationOptions, type RelationTraversalOptions, RequestContext, ResolvedKey, RetryOverride, RetryPolicy, RetryingExecutor, SelectableOf, type SelfProxy, type SelfRef, type SourceProxy, type SourceRef, TableMapping, TransactWriteExecItem, TransactionItemSpec, TransactionSpec, UniqueQueryKeyOf, type UpdateExpressionResult, UpdateInput, type VersionedHistoryOptions, type VersionedLatestOptions, ViewDefinition, WriteDefinitionOptions, WriteExecOptions, WriteResult, aggregate, belongsTo, binary, boolean, buildConditionExpression, buildProjection, buildUpdateExpression, cdcProjected, compileFilterExpression, count, createMaintenanceRebuilder, datetime, decodeCursor, decodePerKeyCursor, defineCommands, defineDelete, defineList, definePut, defineQueries, defineQuery, defineUpdate, deriveEdgeWriteItems, deriveEdgeWriteItemsFor, deriveModelEdgeWriteItems, derivePrefix, detectRelationFields, edgeWrites, embedded, encodeCursor, encodePerKeyCursor, evaluateFilter, execute, executeDeclarativeTransaction, executeExplain, executeList, executeQuery, expandTransaction, field, getEdgeWrites, getImplicitKeyFields, hasMany, hasOne, hydrate, isEdgeWritesDefinition, isSelectBuilder, list, literal, loadPreparedPlan, maintainedFrom, map, max, model, number, numberSet, plan, refs, resolveKey, resolveRelations, serializeContractKey, serializeFieldValue, string, stringSet, ttl, validateDepth, validateGsiAmbiguity, whenMember };