graphddb 0.7.7 → 0.7.9

package/dist/{maintenance-view-adapter-C1HaBX4y.d.ts → maintenance-view-adapter-BATUh_I8.d.ts}

@@ -437,14 +437,14 @@ declare const RAW_COND: unique symbol;
  *   `FilterInput<M>` of the same model, so embedding a different model's column
  *   is a compile error.
  */
-interface RawCondition<M = unknown> {
+interface RawCondition<M = unknown, P extends readonly unknown[] = readonly unknown[]> {
     readonly [RAW_COND]: true;
     /** @internal phantom — owning-model brand. */
     readonly __model?: M;
     /** Expression fragment with `{name}` / `{value}` markers already inlined. */
     readonly template: TemplateStringsArray;
     /** The interpolated parts, each either a Column ref or an embedded value. */
-    readonly parts: unknown[];
+    readonly parts: P;
 }
 /**
  * The interpolation slot type accepted by {@link cond}. A column reference
@@ -469,7 +469,7 @@ type CondSlot<M> = Column<any, M> | string | number | boolean | Date | Param<unk
  * filter: cond`${User.col.age} > ${18} and attribute_exists(${User.col.email})`
  * ```
  */
-declare function cond<M = unknown>(template: TemplateStringsArray, ...parts: CondSlot<M>[]): RawCondition<M>;
+declare function cond<M = unknown, const P extends readonly CondSlot<M>[] = readonly CondSlot<M>[]>(template: TemplateStringsArray, ...parts: P): RawCondition<M, P>;
 
 /**
  * Type-safe attribute condition API (DynamoDB `FilterExpression`).
@@ -1385,10 +1385,12 @@ interface CtxBase {
 /**
  * The logical read kinds an {@link ReadRequestCtx} may carry (R1 / R4 / R5).
  *
- * Only the kinds the runtime actually emits are advertised. A `query` route in
- * the read envelope delegates to {@link import('../operations/query.js').executeQuery}
- * (kind `'query'`), a `list` route to {@link import('../operations/list.js').executeList}
- * (kind `'list'`), so there is no distinct `'envelopeRoute'` kind. `batchGet`
+ * Only the kinds the runtime actually emits are advertised. Every read surface
+ * (the ad-hoc `Model.query` / `Model.list`, a read-envelope route, a prepared
+ * read) lowers to the unified internal read plan and executes through
+ * {@link import('../runtime/read-plan.js').executeCompiledReadRoute} (issue
+ * #249), which runs the single-item core (kind `'query'`) or the partition core
+ * (kind `'list'`) — so there is no distinct `'envelopeRoute'` kind. `batchGet`
  * (`DDBModel.batchGet`, the public multi-key read primitive) fires request-level
  * hooks since issue #142 — its R1/R4/R5 carry kind `'batchGet'`; each underlying
  * physical `BatchGetItem` op fires R2/R3/R5 with op kind `'BatchGetItem'`.
@@ -1910,36 +1912,53 @@ type OperationKind = 'query' | 'list' | 'put' | 'update' | 'delete';
  * / `not` (single nested condition) keys express logical groups. Each operand
  * value may be a concrete literal or a {@link Param} placeholder.
  */
-type ConditionLeaf = Param<unknown> | string | number | boolean | Date;
+/**
+ * An operand leaf of a declarative condition.
+ *
+ * The optional type parameter `X` names an **extra** operand kind admitted only
+ * in a specific authoring context; it defaults to `never`, so the bare
+ * `ConditionLeaf` (the single-write / contract path) is exactly the original
+ * `Param<unknown> | string | number | boolean | Date` and is unaffected.
+ *
+ * The transaction path (issue #246) passes `X = TransactionRef`: inside
+ * `defineTransaction` a condition operand may be a `p.*` field reference (a
+ * {@link import('./transaction.js').TransactionRef}), which the serializer
+ * (`spec/transaction.ts` `conditionTreeLeaf`) already renders to a `{ $param }`
+ * marker. Widening the leaf here to include `TransactionRef` **only** in the tx
+ * context (via `ConditionInput<TransactionRef>`) aligns the type with that
+ * runtime behaviour without letting a `TransactionRef` leak into non-tx
+ * conditions (whose serializers do not accept it).
+ */
+type ConditionLeaf<X = never> = Param<unknown> | string | number | boolean | Date | X;
 /** A declarative operator object on one condition field (subset of FilterInput). */
-interface ConditionOperatorObject {
-    readonly eq?: ConditionLeaf;
-    readonly ne?: ConditionLeaf;
-    readonly gt?: ConditionLeaf;
-    readonly ge?: ConditionLeaf;
-    readonly lt?: ConditionLeaf;
-    readonly le?: ConditionLeaf;
-    readonly between?: readonly [ConditionLeaf, ConditionLeaf];
-    readonly in?: readonly ConditionLeaf[];
-    readonly beginsWith?: ConditionLeaf;
-    readonly contains?: ConditionLeaf;
-    readonly notContains?: ConditionLeaf;
+interface ConditionOperatorObject<X = never> {
+    readonly eq?: ConditionLeaf<X>;
+    readonly ne?: ConditionLeaf<X>;
+    readonly gt?: ConditionLeaf<X>;
+    readonly ge?: ConditionLeaf<X>;
+    readonly lt?: ConditionLeaf<X>;
+    readonly le?: ConditionLeaf<X>;
+    readonly between?: readonly [ConditionLeaf<X>, ConditionLeaf<X>];
+    readonly in?: readonly ConditionLeaf<X>[];
+    readonly beginsWith?: ConditionLeaf<X>;
+    readonly contains?: ConditionLeaf<X>;
+    readonly notContains?: ConditionLeaf<X>;
     readonly attributeExists?: boolean;
     readonly attributeType?: string;
 }
-type ConditionInput = {
+type ConditionInput<X = never> = {
     readonly notExists: true;
 } | {
     readonly attributeExists: string;
 } | {
     readonly attributeNotExists: string;
-} | RawCondition | ConditionTree;
+} | RawCondition | ConditionTree<X>;
 /** A recursive declarative condition tree (field clauses + logical groups). */
-interface ConditionTree {
-    readonly and?: readonly ConditionInput[];
-    readonly or?: readonly ConditionInput[];
-    readonly not?: ConditionInput;
-    readonly [field: string]: ConditionLeaf | ConditionOperatorObject | readonly ConditionInput[] | ConditionInput | undefined;
+interface ConditionTree<X = never> {
+    readonly and?: readonly ConditionInput<X>[];
+    readonly or?: readonly ConditionInput<X>[];
+    readonly not?: ConditionInput<X>;
+    readonly [field: string]: ConditionLeaf<X> | ConditionOperatorObject<X> | readonly ConditionInput<X>[] | ConditionInput<X> | undefined;
 }
 /** Options accepted by the write `define*` entry points (issue #46). */
 interface WriteDefinitionOptions {
@@ -2904,6 +2923,45 @@ type FragmentInput = Readonly<Record<string, MutationInputRef | string | number
  * assembler validates every leaf via {@link assertFaithfulInput}.
  */
 type DescriptorBinding = Readonly<Record<string, unknown>>;
+/** A concrete scalar admissible at a condition operand leaf. */
+type ConditionScalar = MutationInputRef | string | number | boolean | Date | null;
+/** A declarative operator object on one condition field (the #114-A subset). */
+interface FragmentConditionOperatorObject {
+    readonly eq?: ConditionScalar;
+    readonly ne?: ConditionScalar;
+    readonly gt?: ConditionScalar;
+    readonly ge?: ConditionScalar;
+    readonly lt?: ConditionScalar;
+    readonly le?: ConditionScalar;
+    readonly between?: readonly [ConditionScalar, ConditionScalar];
+    readonly in?: readonly ConditionScalar[];
+    readonly beginsWith?: ConditionScalar;
+    readonly contains?: ConditionScalar;
+    readonly notContains?: ConditionScalar;
+    readonly attributeExists?: boolean;
+}
+/**
+ * A declarative write **condition** authored on a {@link WriteDescriptor} (issue
+ * #242, Phase 2) — the same #114-A subset the #101 public write descriptor and
+ * `defineCommands` support, but with {@link MutationInputRef} (`$.field`) leaves
+ * (the mutation authoring form's placeholder) rather than `param.*` / concrete
+ * values. It is a recursive tree of field clauses (bare equality or an operator
+ * object) and `and` / `or` / `not` logical groups. The compiler translates each
+ * `$.field` leaf into a {@link import('./contract.js').ContractParamRef} so the
+ * existing serializer / runtime consume it unchanged.
+ *
+ * A cross-fragment reference (`$.alias.field`) is **not** admissible in a
+ * condition — a `TransactWriteItems` cannot read one item's value mid-transaction
+ * to gate another, and a condition on the fragment's own row can only reference
+ * that row's persisted attributes vs. the command input. Such a leaf is a loud
+ * build error ({@link assertFaithfulCondition}).
+ */
+interface FragmentCondition {
+    readonly and?: readonly FragmentCondition[];
+    readonly or?: readonly FragmentCondition[];
+    readonly not?: FragmentCondition;
+    readonly [field: string]: ConditionScalar | FragmentConditionOperatorObject | readonly FragmentCondition[] | FragmentCondition | undefined;
+}
 /**
  * One recorded write fragment (proposal §3): an **intent** + a target entity + an
  * optional adopted save contract (`use:`) + the input binding. It is a
@@ -2922,6 +2980,21 @@ interface MutationFragment {
     readonly entity: EntityRef;
     readonly input: FragmentInput;
     readonly use?: EntityWritesDefinition;
+    /**
+     * The declarative write **condition** (gate) authored on the descriptor (issue
+     * #242, Phase 2). It is the #114-A subset — bare field equality, an operator
+     * object (`{ gt }`, `{ between }`, `{ in }`, …), and the `and` / `or` / `not`
+     * logical groups — whose value leaves are {@link MutationInputRef} (`$.field`)
+     * references or concrete literals. It is carried **verbatim** here (the mutation
+     * assembler only validates the leaf shapes; see {@link assertFaithfulCondition});
+     * the compiler ({@link import('../spec/mutation-command.js').compileFragment})
+     * translates each `$.field` leaf into a {@link
+     * import('./contract.js').ContractParamRef} and attaches it to the compiled base
+     * op's `condition`, so the **existing** condition serializer / runtime consume it
+     * exactly as a #101 public write descriptor's condition does. `undefined` when
+     * the descriptor declared no `condition`.
+     */
+    readonly condition?: FragmentCondition;
 }
 /** Runtime guard: is `value` a {@link MutationFragment}? */
 declare function isMutationFragment(value: unknown): value is MutationFragment;
@@ -2944,10 +3017,17 @@ type ModelRef = ModelStatic<DDBModel> | (new (...args: unknown[]) => unknown) |
  *  - `key` — the target row's primary-key binding (identifies the row);
  *  - `input` — the non-key field binding (the body / changed fields). Optional for
  *    a `remove` (a delete writes no fields);
- *  - `condition` — an optional declarative write gate (accepted for authoring
- *    parity with the #101 descriptor; threaded by #101's in-process executor — the
- *    declaration-DSL compiler does not consume it, so the serialized IR is
- *    unchanged);
+ *  - `condition` — an optional declarative write gate (issue #242, Phase 2). It is
+ *    the #114-A condition subset (bare equality, operator objects `{ gt }` / `{ in }`
+ *    / `{ between }` / …, and `and` / `or` / `not` groups) whose operand leaves are
+ *    `$.field` input references or literals. The declaration-DSL compiler **consumes**
+ *    it: each `$.field` leaf becomes a {@link import('./contract.js').ContractParamRef}
+ *    and the tree is attached to the compiled base op's `condition`, so it is
+ *    serialized (into the operation spec) and evaluated at runtime exactly as a #101
+ *    public write descriptor's / `defineCommands` condition is (single-op, in-process
+ *    transaction, and the Python bridge). A conditioned `update` / `remove` therefore
+ *    fails a CAS-style write when the gate does not hold, rather than silently
+ *    committing;
  *  - `result` — an optional read-back projection `{ select, options? }` (likewise
  *    accepted for authoring parity; the public read-back projection of a
  *    `command(...).plan(...)` method is still declared on `command({ select })`).
@@ -2962,8 +3042,11 @@ interface WriteDescriptor {
     readonly key: DescriptorBinding;
     /** The non-key field binding; optional (a `remove` writes no fields). */
     readonly input?: DescriptorBinding;
-    /** Optional declarative write gate (accepted for #101 parity; see above). */
-    readonly condition?: DescriptorBinding;
+    /**
+     * Optional declarative write gate — the #114-A condition subset (issue #242,
+     * Phase 2). Compiled, serialized, and evaluated at runtime; see the interface doc.
+     */
+    readonly condition?: FragmentCondition;
     /** Optional read-back projection `{ select, options? }` (accepted for #101 parity). */
     readonly result?: {
         readonly select?: unknown;
@@ -3752,14 +3835,65 @@ type LeafValueOf<L> = L extends Param<infer V> ? V : L;
 type KeyOf<KeyRec> = {
     readonly [F in keyof KeyRec]: LeafValueOf<KeyRec[F]>;
 };
-/** The params a descriptor method accepts: the union of its `key` + `input` leaf value types. */
+/** The params a descriptor method accepts: the union of its `key` + `input` + `condition` leaf value types. */
 type DescriptorParamsOf<D> = (D extends {
     readonly key: infer K;
 } ? KeyOf<K> : Record<never, never>) & (D extends {
     readonly input: infer I;
 } ? {
     readonly [F in keyof I]: LeafValueOf<I[F]>;
-} : Record<never, never>);
+} : Record<never, never>) & (D extends {
+    readonly condition: infer C;
+} ? ConditionParamsOf<C> : Record<never, never>);
+/**
+ * The `param.*` bindings a descriptor `condition` contributes to the method's
+ * `params` argument (issue #243). Every `param.*` at a condition operand position
+ * is minted (at runtime, by `descriptorConditionRecord`) into a named binding using
+ * the shared {@link conditionParamName} / `condParamName` scheme; this type mirrors
+ * that naming so a caller must supply exactly those params:
+ *  - a bare-equality clause / single-operand operator → keyed by the field name;
+ *  - `between` → `{field}_lo` / `{field}_hi`; `in` → `{field}_0`, `{field}_1`, …;
+ *  - `size` → `{field}_size`;
+ *  - `and` / `or` / `not` groups recurse; a raw `cond` → positional `cond_p0`, ….
+ */
+type ConditionParamsOf<C> = C extends {
+    readonly [RAW_COND]: true;
+    readonly parts: infer P;
+} ? RawCondParamsOf<P> : C extends readonly unknown[] ? never : C extends object ? UnionToIntersection<ConditionEntryParamsOf<C, keyof C>> extends infer R ? R : Record<never, never> : Record<never, never>;
+/** Per-key expansion of a condition object's param bindings (distributes over `K`). */
+type ConditionEntryParamsOf<C, K extends keyof C> = K extends 'and' | 'or' ? C[K] extends readonly (infer Sub)[] ? ConditionParamsOf<Sub> : Record<never, never> : K extends 'not' ? ConditionParamsOf<C[K]> : K extends string ? FieldClauseParamsOf<K & string, C[K]> : Record<never, never>;
+/** The param bindings a single field clause (`{ field: leaf | operatorObject }`) contributes. */
+type FieldClauseParamsOf<Field extends string, V> = V extends Param<infer PV> ? {
+    readonly [P in Field]: PV;
+} : V extends object ? UnionToIntersection<OperatorParamsOf<Field, V, keyof V>> : Record<never, never>;
+/** Per-operator expansion of an operator object's param bindings. */
+type OperatorParamsOf<Field extends string, V, Op extends keyof V> = Op extends 'between' ? V[Op] extends readonly [infer Lo, infer Hi] ? (Lo extends Param<infer LV> ? {
+    readonly [P in `${Field}_lo`]: LV;
+} : Record<never, never>) & (Hi extends Param<infer HV> ? {
+    readonly [P in `${Field}_hi`]: HV;
+} : Record<never, never>) : Record<never, never> : Op extends 'in' ? V[Op] extends readonly unknown[] ? InParamsOf<Field, V[Op]> : Record<never, never> : Op extends 'size' ? V[Op] extends Param<infer SV> ? {
+    readonly [P in `${Field}_size`]: SV;
+} : Record<never, never> : Op extends 'attributeExists' | 'attributeType' ? Record<never, never> : V[Op] extends Param<infer OV> ? {
+    readonly [P in Field]: OV;
+} : Record<never, never>;
+/** Positional `{field}_0`, `{field}_1`, … bindings for an `in` operand tuple. */
+type InParamsOf<Field extends string, T extends readonly unknown[], Acc extends unknown[] = []> = T extends readonly [
+    infer Head,
+    ...infer Tail
+] ? (Head extends Param<infer HV> ? {
+    readonly [P in `${Field}_${Acc['length']}`]: HV;
+} : Record<never, never>) & InParamsOf<Field, Tail, [...Acc, unknown]> : Record<never, never>;
+/**
+ * Positional `cond_p0`, `cond_p1`, … bindings for a raw `cond` fragment's `param.*`
+ * value slots. The index counts ONLY `param.*` slots (matching `condParamName` /
+ * `collectRawConditionParams`, where a column ref and an embedded literal never
+ * advance the counter), so `cond_pN` names the N-th param slot in occurrence order.
+ */
+type RawCondParamsOf<P, Acc extends unknown[] = []> = P extends readonly [infer Head, ...infer Tail] ? Head extends Param<infer HV> ? {
+    readonly [K in `cond_p${Acc['length']}`]: HV;
+} & RawCondParamsOf<Tail, [...Acc, unknown]> : RawCondParamsOf<Tail, Acc> : Record<never, never>;
+/** Collapse a union of records into their intersection (all bindings required together). */
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 /** The result of a read descriptor: a projected item (`query` → item | null, `list` → connection). */
 type ReadDescriptorResultOf<D> = D extends {
     readonly query: infer M;
@@ -3916,7 +4050,7 @@ interface PublicWriteDescriptor {
     readonly remove?: ModelRef;
     readonly key: Readonly<Record<string, unknown>>;
     readonly input?: Readonly<Record<string, unknown>>;
-    readonly condition?: Readonly<Record<string, unknown>>;
+    readonly condition?: Readonly<Record<string, unknown>> | RawCondition<any, any>;
     readonly result?: {
         readonly select?: Readonly<Record<string, boolean>>;
         readonly options?: unknown;
@@ -4537,6 +4671,21 @@ interface WhenSpec {
  * `attribute_exists`).
  */
 type TransactionItemType = 'Put' | 'Update' | 'Delete' | 'ConditionCheck';
+/**
+ * A value leaf of a transaction `item` / `changes` / `add` map (issue #245).
+ *
+ * - a **string** carries a template: a `{param}` / `{item.field}` placeholder, a
+ *   composite (`PREFIX#{param}`), or a plain string literal — resolved by the
+ *   runtimes' template machinery (a whole-placeholder string keeps the bound
+ *   param's *type*, a composite / plain string resolves to a string);
+ * - a **number** / **boolean** carries a *typed literal* verbatim, so a numeric
+ *   literal in a `put` item / `update` changes (`version: 0`) survives to DynamoDB
+ *   as an `N` / `BOOL` instead of being stringified to an `S` (the pre-#245 bug).
+ *
+ * A `Date` literal is serialized to its ISO-8601 **string** at build time (a
+ * `@datetime` / `@date` field is stored as `S`), so it stays a string leaf.
+ */
+type TransactionValueLeaf = string | number | boolean;
 /**
  * A single templated item in a transaction. When `forEach` is present, the item
  * is expanded **once per element** of the named array param, with each element's
@@ -4562,19 +4711,27 @@ interface TransactionItemSpec {
     readonly type: TransactionItemType;
     readonly tableName: string;
     readonly entity: string;
-    /** Put: the full item template (field → template / literal). */
-    readonly item?: Readonly<Record<string, string>>;
+    /**
+     * Put: the full item template (field → template / typed literal). A string
+     * value is a template ({@link TransactionValueLeaf}); a `number` / `boolean` is
+     * a typed literal carried verbatim (issue #245).
+     */
+    readonly item?: Readonly<Record<string, TransactionValueLeaf>>;
     /** Update / Delete / ConditionCheck: the key template (attribute → template). */
     readonly keyCondition?: Readonly<Record<string, string>>;
-    /** Update: field-level `SET` change templates (overwrite). */
-    readonly changes?: Readonly<Record<string, string>>;
+    /**
+     * Update: field-level `SET` change templates (overwrite). A string value is a
+     * template; a `number` / `boolean` is a typed literal carried verbatim (#245).
+     */
+    readonly changes?: Readonly<Record<string, TransactionValueLeaf>>;
     /**
      * Update: field-level atomic `ADD` deltas (issue #85, derived counters). Each
-     * value is a numeric template (`{param}` / a literal number string); the runtime
-     * applies `ADD #field :delta`, an atomic increment that needs no prior read and
-     * is safe under concurrency. A negative delta decrements (e.g. `-1` on a remove).
+     * value is a numeric template (`{param}` / a literal number string) or a typed
+     * numeric literal (issue #245); the runtime applies `ADD #field :delta`, an
+     * atomic increment that needs no prior read and is safe under concurrency. A
+     * negative delta decrements (e.g. `-1` on a remove).
      */
-    readonly add?: Readonly<Record<string, string>>;
+    readonly add?: Readonly<Record<string, TransactionValueLeaf>>;
     /**
      * The write / assertion condition (subset). Optional on `Put` / `Update` /
      * `Delete`; **required** on a `ConditionCheck` (the assertion it makes).
@@ -6096,7 +6253,9 @@ declare function executeCommandMethod(contract: ExecutableCommandContract, metho
  *
  * - **READ** — `{ alias: { query | list: Model, key, select, options? } }`. Each
  *   route runs **independently and in parallel** (`Promise.all`): a `query` route
- *   delegates to {@link executeQuery}, a `list` route to {@link executeList}. The
+ *   delegates to {@link executeAdHocQuery}, a `list` route to
+ *   {@link executeAdHocList} — the unified read-plan lowering (issue #249), the
+ *   same path `Model.query` / `Model.list` and `prepare` execute through. The
  *   nested selection / relation resolution / optimisation under a route is the
  *   existing read path, reused verbatim. Cross-route consistency is NOT guaranteed
  *   (each route is its own read).
@@ -6276,6 +6435,96 @@ type MutateParallelResult<E extends WriteEnvelope> = {
     readonly [K in keyof E]: BulkWrap<E[K], ParallelResultOf<E[K]>>;
 };
 
+/**
+ * The unified internal READ plan (issue #249) — every read surface lowers to ONE
+ * internal route representation ({@link CompiledReadRoute}) and executes through
+ * ONE executor ({@link executeCompiledReadRoute}).
+ *
+ * Before #249, reads had two paths: the prepared / AOT path lowered a declarative
+ * route to a {@link CompiledReadRoute} (param-slot IR) and executed it, while the
+ * ad-hoc surfaces (`Model.query` / `Model.list` / the `DDBModel.query` envelope)
+ * called `executeQuery` / `executeList` DIRECTLY — the same surface-dependent
+ * divergence that let #242/#243-class silent drops happen on the write side. This
+ * module closes the read side:
+ *
+ * - {@link executeCompiledReadRoute} is the SINGLE funnel from a lowered route to
+ *   the physical read cores (`executeQuery` / `executeList`). The prepared
+ *   statement ({@link import('./prepared.js').PreparedReadStatement}), the AOT
+ *   loader, and the ad-hoc surfaces all execute through it — no read surface
+ *   calls the cores directly anymore.
+ * - {@link executeAdHocQuery} / {@link executeAdHocList} lower an ad-hoc call to a
+ *   {@link CompiledReadRoute} first (each key FIELD becomes a same-named param
+ *   slot; the concrete values bind as params at execution — exactly the prepared
+ *   path's shape), then run the shared executor.
+ *
+ * ## Ad-hoc semantics are preserved EXACTLY
+ *
+ * The lowering adds a plan representation, never a behavior change: the caller's
+ * option bag is threaded through verbatim (a shallow copy — including fields the
+ * plan layer does not know about, so read middleware R1 hooks observe the same
+ * bag), the select spec is passed through untouched (the physical cores own
+ * `project(...)`-builder normalization / validation, as before), and per-call
+ * host-side options (`updatable` / `hydrate` / `retry` / `context`) flow through
+ * unchanged. A prepared route's slot-bound options take precedence over the
+ * per-call bag — the prepared surface only ever passes `retry` / `context`
+ * per-call, so both surfaces keep their existing semantics through the one
+ * executor.
+ *
+ * ## Structural memoization (the #206-style hot-path guarantee)
+ *
+ * The ad-hoc lowering is memoized in a bounded LRU keyed by the query's
+ * **structure** — model OBJECT identity (never a class name), route kind, key
+ * field NAMES (values are params, not part of the key), and the select shape
+ * (builder-aware; literal filter/option values inside a select are part of the
+ * shape) — so the plan is compiled once per `(model, shape)`, not per call. A
+ * select shape the serializer cannot prove stable (a function / symbol / class
+ * instance at a leaf) is compiled fresh per call instead of risking a cache
+ * collision — correctness over reuse.
+ */
+
+/**
+ * A recorded binding: a value is either a param slot (bind from `params[name]`)
+ * or a static literal (used verbatim). Discovered ONCE at lowering, replayed per
+ * execution. Exported (@internal) for the prepared runtime
+ * (`src/runtime/prepared.ts`), the #208 AOT emitter (`src/spec/prepared.ts`) and
+ * loader (`src/runtime/prepared-loader.ts`), which serialize / rebind exactly
+ * this structure.
+ */
+type Slot = {
+    readonly kind: 'param';
+    readonly name: string;
+} | {
+    readonly kind: 'literal';
+    readonly value: unknown;
+};
+/**
+ * The unified internal read plan — one `query` / `list` route lowered to its
+ * params-independent products (resolved model class, select spec, key param
+ * slots, static / slot-bound options). EVERY read surface produces one of these
+ * before execution: the prepared runtime (`compileReadRoute`), the #208 AOT
+ * loader (which reconstructs routes from the static plan artifact), and — since
+ * #249 — the ad-hoc surfaces (`Model.query` / `Model.list` / the `DDBModel.query`
+ * envelope) via {@link executeAdHocQuery} / {@link executeAdHocList}.
+ * @internal
+ */
+interface CompiledReadRoute {
+    readonly alias: string;
+    readonly kind: 'query' | 'list';
+    readonly modelClass: Function;
+    /** The static select spec (params-independent; may be a `project(...)` builder
+     * on the ad-hoc surface — the physical cores own its normalization). */
+    readonly select: Record<string, unknown>;
+    readonly keySlots: Readonly<Record<string, Slot>>;
+    /** Static option literals decided at lowering (maxDepth / order / filter). */
+    readonly maxDepth?: number;
+    readonly order?: 'ASC' | 'DESC';
+    readonly filter?: Record<string, unknown>;
+    /** Dynamic option slots (may bind a param or a literal). */
+    readonly consistentReadSlot?: Slot;
+    readonly limitSlot?: Slot;
+    readonly afterSlot?: Slot;
+}
+
 /**
  * Prepared statements — `DDBModel.prepare($ => ({...}))` → `.execute(params)`
  * (issue #205, design #203). The **runtime, fallback-B** implementation of the
@@ -6302,8 +6551,9 @@ type MutateParallelResult<E extends WriteEnvelope> = {
  * - **read** — the params-independent products (resolved model class, normalized
  *   select + static filter, key-field NAMES, validated relation structure) are
  *   computed once. `execute` binds the concrete key VALUES + per-call pagination /
- *   consistency and calls {@link executeQuery} / {@link executeListInternal} — the
- *   identical core `Model.query` / `Model.list` and `publicQueryModel` use. (The
+ *   consistency and runs the unified read-plan executor
+ *   (`executeCompiledReadRoute`, issue #249) — the identical core `Model.query` /
+ *   `Model.list` and `publicQueryModel` use. (The
  *   `ExecutionPlan` bakes concrete key values into its `keyCondition`, so a single
  *   compiled operation object is NOT reusable across param sets; the precompiled
  *   product is the resolved model + normalized projection — exactly what the public
@@ -6413,20 +6663,6 @@ interface PreparedReadExecOptions {
     readonly retry?: RetryOverride;
     readonly context?: RequestContext;
 }
-/**
- * A recorded binding: a value is either a param slot (bind from `params[name]`) or
- * a static literal (used verbatim). Discovered ONCE at prepare from the recording
- * `$` proxy, replayed per `execute`. Exported (@internal) for the #208 AOT
- * emitter (`src/spec/prepared.ts`) and loader (`src/runtime/prepared-loader.ts`),
- * which serialize / rebind exactly this structure.
- */
-type Slot = {
-    readonly kind: 'param';
-    readonly name: string;
-} | {
-    readonly kind: 'literal';
-    readonly value: unknown;
-};
 interface CompiledWriteOp {
     readonly alias: string;
     readonly intent: Intent;
@@ -6436,25 +6672,6 @@ interface CompiledWriteOp {
     readonly conditionSlots?: Readonly<Record<string, Slot>>;
     readonly result?: PreparedWriteRoute['result'];
 }
-/** @internal — exported for the #208 AOT loader, which reconstructs these
- * routes from the static plan artifact and executes them through the SAME
- * {@link PreparedReadStatement}. */
-interface CompiledReadRoute {
-    readonly alias: string;
-    readonly kind: 'query' | 'list';
-    readonly modelClass: Function;
-    /** The normalized static select spec (params-independent). */
-    readonly select: Record<string, unknown>;
-    readonly keySlots: Readonly<Record<string, Slot>>;
-    /** Static option literals decided at prepare (maxDepth / order / filter). */
-    readonly maxDepth?: number;
-    readonly order?: 'ASC' | 'DESC';
-    readonly filter?: Record<string, unknown>;
-    /** Dynamic option slots (may bind a param or a literal). */
-    readonly consistentReadSlot?: Slot;
-    readonly limitSlot?: Slot;
-    readonly afterSlot?: Slot;
-}
 /** A prepared **write** handle. `execute(params)` binds + runs the shared write core. */
 declare class PreparedWriteStatement {
     private readonly ops;
@@ -7380,4 +7597,4 @@ interface ViewDefinition {
  */
 declare function collectViewDefinitions(registry?: ReadonlyMap<Function, EntityMetadata>): ViewDefinition[];
 
-export { type AnyOperationDefinition as $, type ContractSpec as A, type BatchResult as B, type CdcEmulatorOptions as C, type DynamoDBOperation as D, type EventLog as E, type FaultSpec as F, type QuerySpec as G, type CommandSpec as H, type TransactionSpec as I, type ContextSpec as J, SPEC_VERSION as K, type ParamSpec as L, type ModelStatic as M, type ParamDescriptor as N, type EntityRef as O, type PutInput as P, type QueryModelContract as Q, type ReplayOptions as R, type ShardId as S, type TransactWriteExecItem as T, type Unsubscribe as U, type ViewDefinition as V, type WriteExecOptions as W, type ConditionInput as X, type Param as Y, type DefinitionMap as Z, type OperationsDocument as _, type CdcMode as a, type FieldOptions as a$, type Manifest as a0, type BridgeBundle as a1, type ConditionSpec as a2, type PreparedBody as a3, type CommandContractMethodSpec as a4, type CommandResolutionTarget as a5, type CompiledFragment as a6, type CompiledMutationPlan as a7, type ComposeSpec as a8, type CompositionPlanSpec as a9, type QueryContractMethodSpec as aA, type RangeConditionSpec as aB, type ReadOperationType as aC, type TransactionItemSpec as aD, type TransactionItemType as aE, type WhenSpec as aF, type WriteOperationType as aG, assertNoCrossFragmentMaintainCollision as aH, compileFragment as aI, compileMutationPlan as aJ, compileSingleFragmentPlan as aK, resetMaintenanceGraphCache as aL, resolveLifecycle as aM, resolveMaintainers as aN, type SelectableOf as aO, type PrimaryKeyOf as aP, type RequestContext as aQ, type Middleware as aR, type ReadRequestKind as aS, type CtxModel as aT, type ReadParams as aU, type ReadRequestCtx as aV, type Item as aW, type RetryPolicy as aX, type KeyDefinition as aY, type GsiDefinition as aZ, type ModelKind as a_, type ContractCardinality as aa, type ContractCommandResult as ab, type ContractInputArity as ac, type ContractKeySpec as ad, type ContractKind as ae, type ContractResolution as af, type DerivedConditionCheck as ag, type DerivedEdgeWrite as ah, type DerivedIdempotencyGuard as ai, type DerivedMaintainOutbox as aj, type DerivedMaintainWrite as ak, type DerivedOutboxEvent as al, type DerivedUniqueGuard as am, type DerivedUpdate as an, type EntityRefResolver as ao, type ExecutionPlanSpec as ap, type FilterSpec as aq, MAX_TRANSACT_COMPOSE_ITEMS as ar, type ManifestEntity as as, type ManifestField as at, type ManifestFieldType as au, type ManifestGsi as av, type ManifestKey as aw, type ManifestRelation as ax, type ManifestTable as ay, type OperationSpec as az, type ChangeBatch as b, type ContractQueryParams as b$, type DynamoType as b0, type ProjectionTransform as b1, type MaintainEvent as b2, type MembershipPredicate as b3, type MaintainConsistency as b4, type MaintainUpdateMode as b5, type MembershipPredicateOp as b6, type RelationOptions as b7, type AggregateOptions as b8, type AggregateValue as b9, type BatchWriteRequest as bA, CONTRACT_RANGE_FANOUT_CONCURRENCY as bB, type CdcModelRegistry as bC, type CdcSubscribeHandlers as bD, type Change as bE, type CollectionEffect as bF, type CollectionOptions as bG, type Column as bH, type ColumnMap as bI, type CommandInputShape as bJ, type CommandMethod as bK, type CommandPlan as bL, type CommandResultKind as bM, type CommandSelectShape as bN, type CondSlot as bO, type ConditionCheckInput as bP, type Connection as bQ, type ContractCallSignature as bR, type ContractCommandParams as bS, type ContractComposeNode as bT, type ContractFromRef as bU, type ContractItem as bV, type ContractKeyFieldRef as bW, type ContractKeyInput as bX, type ContractKeyRef as bY, type ContractMethodOp as bZ, type ContractParamRef as b_, type SelectBuilderSpec as ba, type RawCondition as bb, type RetryOverride as bc, type ExecutionPlan as bd, type FieldMetadata as be, type ResolvedKey as bf, type Slot as bg, type PreparedWriteExecOptions as bh, type CommandReturn as bi, type ParallelOpResult as bj, type PreparedStatement as bk, type RelationMetadata as bl, type MaintainEffect as bm, type OperationDefinition as bn, type WriteDefinitionOptions as bo, type PartialQueryKeyOf as bp, type StrictSelectSpec as bq, type ReadDefinitionOptions as br, type EntityInput as bs, type UniqueQueryKeyOf as bt, type AggregateMetadata as bu, type BatchDeleteRequest as bv, type BatchGetOptions as bw, type BatchGetRequest as bx, BatchGetResult as by, type BatchPutRequest as bz, type ChangeEvent as c, PreparedWriteStatement as c$, type CounterAggregate as c0, type CounterEffect as c1, type CtxBase as c2, DEFAULT_MAX_ATTEMPTS as c3, DEFAULT_RETRY_POLICY as c4, type DeleteOptions as c5, type DeriveEffect as c6, type DescriptorBinding as c7, ENTITY_WRITES_MARKER as c8, type EdgeEffect as c9, type MaintenanceGraph as cA, type MembershipEffect as cB, type ModelRef as cC, type MutateMode as cD, type MutateOptions as cE, type MutateParallelResult as cF, type MutateTransactionResult as cG, type MutationBody as cH, type MutationDescriptorMap as cI, type MutationFragment as cJ, type MutationInputProxy as cK, type MutationInputRef as cL, type MutationIntent as cM, type NumberParam as cN, type OperationKind as cO, PREPARE_CACHE_MAX as cP, type ParamKind as cQ, type ParamStructure as cR, type PersistCtx as cS, type PersistOrigin as cT, type PlannedCommandMethod as cU, type PreparedInputProxy as cV, type PreparedParamRef as cW, type PreparedReadExecOptions as cX, type PreparedReadRoute as cY, PreparedReadStatement as cZ, type PreparedWriteRoute as c_, type EffectPath as ca, type EmbeddedMetadata as cb, type EmitEffect as cc, type EntityWritesDefinition as cd, type EntityWritesShape as ce, type ExecutableCommandContract as cf, type ExecutableQueryContract as cg, type FilterInput as ch, type FragmentInput as ci, type GsiDefinitionMarker as cj, type GsiOptions as ck, type IdempotencyEffect as cl, type InProcessWriteDescriptor as cm, type InlineSnapshotSpec as cn, type InputArity as co, type KeyDefinitionMarker as cp, type KeySegment as cq, type KeySlot as cr, type KeyStructure as cs, type KeyedResult as ct, LIFECYCLE_CONTRACT_MARKER as cu, type LifecycleContract as cv, type LifecycleEffects as cw, type LiteralParam as cx, type MaintainItem as cy, type MaintainTrigger as cz, type ChangeEventName as d, executeKeyedBatchGet as d$, type ProjectionMap as d0, type ProjectionTransformOp as d1, type PutOptions as d2, type QueryEnvelopeResult as d3, type QueryKeyOf as d4, type QueryMethod as d5, type QueryResult as d6, type ReadEnvelope as d7, type ReadOpCtx as d8, type ReadOpKind as d9, type UniqueEffect as dA, type Updatable as dB, type UpdateOptions as dC, type ViewSourceSlice as dD, type WriteCtx as dE, type WriteDescriptor as dF, type WriteEnvelope as dG, type WriteInput as dH, type WriteKind as dI, type WriteLifecyclePhase as dJ, type WriteMiddleware as dK, type WriteRecorder as dL, type WriteResultProjection as dM, attachModelClass as dN, buildDeleteInput as dO, buildMaintenanceGraph as dP, buildPutInput as dQ, buildUpdateInput as dR, collectViewDefinitions as dS, cond as dT, contractOfMethodSpec as dU, definePlan as dV, entityWrites as dW, executeBatchGet as dX, executeBatchWrite as dY, executeCommandMethod as dZ, executeDelete as d_, type ReadRouteDescriptor as da, type ReadRouteOptions as db, type ReadRouteResult as dc, type RecordedCompose as dd, type RelationBuilder as de, type RelationConsistency as df, type RelationLimitOptions as dg, type RelationPattern as dh, type RelationProjection as di, type RelationReadOptions as dj, type RelationSelect as dk, type RelationSpec as dl, type RelationUpdateMode as dm, type RelationWriteOptions as dn, type RequiresEffect as dp, type Resolution as dq, type RetryInfo as dr, type RetryOperationKind as ds, type SegmentSpec as dt, type SegmentedKey as du, type SelectBuilder as dv, type SelectOf as dw, type SnapshotEffect as dx, type StringParam as dy, TransactionContext as dz, type ChangeHandler as e, executePut as e0, executeQueryMethod as e1, executeRangeFanout as e2, executeTransaction as e3, executeUpdate as e4, from as e5, getEntityWrites as e6, gsi as e7, identity as e8, isColumn as e9, param as eA, prepare as eB, preview as eC, publicCommandModel as eD, publicQueryModel as eE, query as eF, wholeKeysSentinel as eG, isCommandModelContract as ea, isCommandPlan as eb, isContractComposeNode as ec, isContractFromRef as ed, isContractKeyFieldRef as ee, isContractKeyRef as ef, isContractParamRef as eg, isEntityWritesDefinition as eh, isKeySegment as ei, isLifecycleContract as ej, isMaintainTrigger as ek, isMutationFragment as el, isMutationInputRef as em, isParam as en, isPlannedCommandMethod as eo, isPreparedParamRef as ep, isQueryModelContract as eq, isRetryableError as er, isRetryableTransactionCancellation as es, k as et, key as eu, lifecyclePhaseForIntent as ev, maintainTrigger as ew, mintContractKeyFieldRef as ex, mintContractParamRef as ey, mutation as ez, type ClockMode as f, type ConcurrentRecomputeRef as g, type StartingPosition as h, type StreamViewType as i, type SubscribeHandler as j, type SubscribeHandlers as k, buildSubscribeHandler as l, type EntityMetadata as m, type Executor as n, type ReadExecOptions as o, type ExecutorResult as p, type BatchGetExecInput as q, type WriteResult as r, type UpdateInput as s, type DeleteInput as t, type BatchWriteExecItem as u, type BatchExecOptions as v, DDBModel as w, type QueryMethodSpec as x, type CommandModelContract as y, type CommandMethodSpec as z };
+export { type AnyOperationDefinition as $, type ContractSpec as A, type BatchResult as B, type CdcEmulatorOptions as C, type DynamoDBOperation as D, type EventLog as E, type FaultSpec as F, type QuerySpec as G, type CommandSpec as H, type TransactionSpec as I, type ContextSpec as J, SPEC_VERSION as K, type ParamSpec as L, type ModelStatic as M, type ParamDescriptor as N, type EntityRef as O, type PutInput as P, type QueryModelContract as Q, type ReplayOptions as R, type ShardId as S, type TransactWriteExecItem as T, type Unsubscribe as U, type ViewDefinition as V, type WriteExecOptions as W, type ConditionInput as X, type Param as Y, type DefinitionMap as Z, type OperationsDocument as _, type CdcMode as a, type ModelKind as a$, type Manifest as a0, type BridgeBundle as a1, type ConditionSpec as a2, type PreparedBody as a3, type CommandContractMethodSpec as a4, type CommandResolutionTarget as a5, type CompiledFragment as a6, type CompiledMutationPlan as a7, type ComposeSpec as a8, type CompositionPlanSpec as a9, type QueryContractMethodSpec as aA, type RangeConditionSpec as aB, type ReadOperationType as aC, type TransactionItemSpec as aD, type TransactionItemType as aE, type WhenSpec as aF, type WriteOperationType as aG, assertNoCrossFragmentMaintainCollision as aH, compileFragment as aI, compileMutationPlan as aJ, compileSingleFragmentPlan as aK, resetMaintenanceGraphCache as aL, resolveLifecycle as aM, resolveMaintainers as aN, type SelectableOf as aO, type PrimaryKeyOf as aP, type RequestContext as aQ, type Middleware as aR, type ReadRequestKind as aS, type CtxModel as aT, type ReadParams as aU, type ReadRequestCtx as aV, type Item as aW, type RetryPolicy as aX, type RetryOverride as aY, type KeyDefinition as aZ, type GsiDefinition as a_, type ContractCardinality as aa, type ContractCommandResult as ab, type ContractInputArity as ac, type ContractKeySpec as ad, type ContractKind as ae, type ContractResolution as af, type DerivedConditionCheck as ag, type DerivedEdgeWrite as ah, type DerivedIdempotencyGuard as ai, type DerivedMaintainOutbox as aj, type DerivedMaintainWrite as ak, type DerivedOutboxEvent as al, type DerivedUniqueGuard as am, type DerivedUpdate as an, type EntityRefResolver as ao, type ExecutionPlanSpec as ap, type FilterSpec as aq, MAX_TRANSACT_COMPOSE_ITEMS as ar, type ManifestEntity as as, type ManifestField as at, type ManifestFieldType as au, type ManifestGsi as av, type ManifestKey as aw, type ManifestRelation as ax, type ManifestTable as ay, type OperationSpec as az, type ChangeBatch as b, type ContractQueryParams as b$, type FieldOptions as b0, type DynamoType as b1, type ProjectionTransform as b2, type MaintainEvent as b3, type MembershipPredicate as b4, type MaintainConsistency as b5, type MaintainUpdateMode as b6, type MembershipPredicateOp as b7, type RelationOptions as b8, type AggregateOptions as b9, type BatchWriteRequest as bA, CONTRACT_RANGE_FANOUT_CONCURRENCY as bB, type CdcModelRegistry as bC, type CdcSubscribeHandlers as bD, type Change as bE, type CollectionEffect as bF, type CollectionOptions as bG, type Column as bH, type ColumnMap as bI, type CommandInputShape as bJ, type CommandMethod as bK, type CommandPlan as bL, type CommandResultKind as bM, type CommandSelectShape as bN, type CondSlot as bO, type ConditionCheckInput as bP, type Connection as bQ, type ContractCallSignature as bR, type ContractCommandParams as bS, type ContractComposeNode as bT, type ContractFromRef as bU, type ContractItem as bV, type ContractKeyFieldRef as bW, type ContractKeyInput as bX, type ContractKeyRef as bY, type ContractMethodOp as bZ, type ContractParamRef as b_, type AggregateValue as ba, type SelectBuilderSpec as bb, type RawCondition as bc, type ExecutionPlan as bd, type FieldMetadata as be, type ResolvedKey as bf, type Slot as bg, type PreparedWriteExecOptions as bh, type CommandReturn as bi, type ParallelOpResult as bj, type PreparedStatement as bk, type RelationMetadata as bl, type MaintainEffect as bm, type OperationDefinition as bn, type WriteDefinitionOptions as bo, type PartialQueryKeyOf as bp, type StrictSelectSpec as bq, type ReadDefinitionOptions as br, type EntityInput as bs, type UniqueQueryKeyOf as bt, type AggregateMetadata as bu, type BatchDeleteRequest as bv, type BatchGetOptions as bw, type BatchGetRequest as bx, BatchGetResult as by, type BatchPutRequest as bz, type ChangeEvent as c, PreparedReadStatement as c$, type CounterAggregate as c0, type CounterEffect as c1, type CtxBase as c2, DEFAULT_MAX_ATTEMPTS as c3, DEFAULT_RETRY_POLICY as c4, type DeleteOptions as c5, type DeriveEffect as c6, type DescriptorBinding as c7, ENTITY_WRITES_MARKER as c8, type EdgeEffect as c9, type MaintainItem as cA, type MaintainTrigger as cB, type MaintenanceGraph as cC, type MembershipEffect as cD, type ModelRef as cE, type MutateMode as cF, type MutateOptions as cG, type MutateParallelResult as cH, type MutateTransactionResult as cI, type MutationBody as cJ, type MutationDescriptorMap as cK, type MutationFragment as cL, type MutationInputProxy as cM, type MutationInputRef as cN, type MutationIntent as cO, type NumberParam as cP, type OperationKind as cQ, PREPARE_CACHE_MAX as cR, type ParamKind as cS, type ParamStructure as cT, type PersistCtx as cU, type PersistOrigin as cV, type PlannedCommandMethod as cW, type PreparedInputProxy as cX, type PreparedParamRef as cY, type PreparedReadExecOptions as cZ, type PreparedReadRoute as c_, type EffectPath as ca, type EmbeddedMetadata as cb, type EmitEffect as cc, type EntityWritesDefinition as cd, type EntityWritesShape as ce, type ExecutableCommandContract as cf, type ExecutableQueryContract as cg, type FilterInput as ch, type FragmentCondition as ci, type FragmentConditionOperatorObject as cj, type FragmentInput as ck, type GsiDefinitionMarker as cl, type GsiOptions as cm, type IdempotencyEffect as cn, type InProcessWriteDescriptor as co, type InlineSnapshotSpec as cp, type InputArity as cq, type KeyDefinitionMarker as cr, type KeySegment as cs, type KeySlot as ct, type KeyStructure as cu, type KeyedResult as cv, LIFECYCLE_CONTRACT_MARKER as cw, type LifecycleContract as cx, type LifecycleEffects as cy, type LiteralParam as cz, type ChangeEventName as d, executeCommandMethod as d$, type PreparedWriteRoute as d0, PreparedWriteStatement as d1, type ProjectionMap as d2, type ProjectionTransformOp as d3, type PutOptions as d4, type QueryEnvelopeResult as d5, type QueryKeyOf as d6, type QueryMethod as d7, type QueryResult as d8, type ReadEnvelope as d9, type StringParam as dA, TransactionContext as dB, type UniqueEffect as dC, type Updatable as dD, type UpdateOptions as dE, type ViewSourceSlice as dF, type WriteCtx as dG, type WriteDescriptor as dH, type WriteEnvelope as dI, type WriteInput as dJ, type WriteKind as dK, type WriteLifecyclePhase as dL, type WriteMiddleware as dM, type WriteRecorder as dN, type WriteResultProjection as dO, attachModelClass as dP, buildDeleteInput as dQ, buildMaintenanceGraph as dR, buildPutInput as dS, buildUpdateInput as dT, collectViewDefinitions as dU, cond as dV, contractOfMethodSpec as dW, definePlan as dX, entityWrites as dY, executeBatchGet as dZ, executeBatchWrite as d_, type ReadOpCtx as da, type ReadOpKind as db, type ReadRouteDescriptor as dc, type ReadRouteOptions as dd, type ReadRouteResult as de, type RecordedCompose as df, type RelationBuilder as dg, type RelationConsistency as dh, type RelationLimitOptions as di, type RelationPattern as dj, type RelationProjection as dk, type RelationReadOptions as dl, type RelationSelect as dm, type RelationSpec as dn, type RelationUpdateMode as dp, type RelationWriteOptions as dq, type RequiresEffect as dr, type Resolution as ds, type RetryInfo as dt, type RetryOperationKind as du, type SegmentSpec as dv, type SegmentedKey as dw, type SelectBuilder as dx, type SelectOf as dy, type SnapshotEffect as dz, type ChangeHandler as e, executeDelete as e0, executeKeyedBatchGet as e1, executePut as e2, executeQueryMethod as e3, executeRangeFanout as e4, executeTransaction as e5, executeUpdate as e6, from as e7, getEntityWrites as e8, gsi as e9, mintContractParamRef as eA, mutation as eB, param as eC, prepare as eD, preview as eE, publicCommandModel as eF, publicQueryModel as eG, query as eH, wholeKeysSentinel as eI, identity as ea, isColumn as eb, isCommandModelContract as ec, isCommandPlan as ed, isContractComposeNode as ee, isContractFromRef as ef, isContractKeyFieldRef as eg, isContractKeyRef as eh, isContractParamRef as ei, isEntityWritesDefinition as ej, isKeySegment as ek, isLifecycleContract as el, isMaintainTrigger as em, isMutationFragment as en, isMutationInputRef as eo, isParam as ep, isPlannedCommandMethod as eq, isPreparedParamRef as er, isQueryModelContract as es, isRetryableError as et, isRetryableTransactionCancellation as eu, k as ev, key as ew, lifecyclePhaseForIntent as ex, maintainTrigger as ey, mintContractKeyFieldRef as ez, type ClockMode as f, type ConcurrentRecomputeRef as g, type StartingPosition as h, type StreamViewType as i, type SubscribeHandler as j, type SubscribeHandlers as k, buildSubscribeHandler as l, type EntityMetadata as m, type Executor as n, type ReadExecOptions as o, type ExecutorResult as p, type BatchGetExecInput as q, type WriteResult as r, type UpdateInput as s, type DeleteInput as t, type BatchWriteExecItem as u, type BatchExecOptions as v, DDBModel as w, type QueryMethodSpec as x, type CommandModelContract as y, type CommandMethodSpec as z };

package/dist/{registry-DWhq5wiA.d.ts → registry-CXhP4TaE.d.ts}

@@ -1,4 +1,4 @@
-import { m as EntityMetadata } from './maintenance-view-adapter-C1HaBX4y.js';
+import { m as EntityMetadata } from './maintenance-view-adapter-BATUh_I8.js';
 
 interface LintRule {
     id: string;

package/dist/{relation-depth-BnqfKkZB.d.ts → relation-depth-Dg3yhl7S.d.ts}

@@ -1,4 +1,4 @@
-import { b as Linter, L as LintRule } from './registry-DWhq5wiA.js';
+import { b as Linter, L as LintRule } from './registry-CXhP4TaE.js';
 
 /**
  * Creates a Linter pre-loaded with rules safe for Entity registration.

package/dist/spec/index.d.ts

@@ -1,4 +1,4 @@
-export { a1 as BridgeBundle, a4 as CommandContractMethodSpec, a5 as CommandResolutionTarget, H as CommandSpec, a6 as CompiledFragment, a7 as CompiledMutationPlan, a8 as ComposeSpec, a9 as CompositionPlanSpec, a2 as ConditionSpec, J as ContextSpec, aa as ContractCardinality, ab as ContractCommandResult, ac as ContractInputArity, ad as ContractKeySpec, ae as ContractKind, af as ContractResolution, A as ContractSpec, ag as DerivedConditionCheck, ah as DerivedEdgeWrite, ai as DerivedIdempotencyGuard, aj as DerivedMaintainOutbox, ak as DerivedMaintainWrite, al as DerivedOutboxEvent, am as DerivedUniqueGuard, an as DerivedUpdate, ao as EntityRefResolver, ap as ExecutionPlanSpec, aq as FilterSpec, ar as MAX_TRANSACT_COMPOSE_ITEMS, a0 as Manifest, as as ManifestEntity, at as ManifestField, au as ManifestFieldType, av as ManifestGsi, aw as ManifestKey, ax as ManifestRelation, ay as ManifestTable, az as OperationSpec, _ as OperationsDocument, L as ParamSpec, aA as QueryContractMethodSpec, G as QuerySpec, aB as RangeConditionSpec, aC as ReadOperationType, K as SPEC_VERSION, aD as TransactionItemSpec, aE as TransactionItemType, I as TransactionSpec, aF as WhenSpec, aG as WriteOperationType, aH as assertNoCrossFragmentMaintainCollision, aI as compileFragment, aJ as compileMutationPlan, aK as compileSingleFragmentPlan, aL as resetMaintenanceGraphCache, aM as resolveLifecycle, aN as resolveMaintainers } from '../maintenance-view-adapter-C1HaBX4y.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, O as PREPARED_FORMAT_VERSION, Q as PreparedBindMap, g as PreparedBindSpec, a as PreparedPlanDocument, h as PreparedPlanSpec, i as PreparedReadRouteSpec, P as PreparedWriteOpSpec, 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, R as buildPreparedPlanDocument, F as buildQuerySpec, G as buildTransactionSpec, H as buildTransactions, S as canonicalJson, I as collectContractBoundaryViolations, J as collectContractN1Violations, U as compilePreparedPlan, V as entityFingerprint, X as planFingerprint } from '../index-BnTZQ_IG.js';
-import '../registry-DWhq5wiA.js';
+export { a1 as BridgeBundle, a4 as CommandContractMethodSpec, a5 as CommandResolutionTarget, H as CommandSpec, a6 as CompiledFragment, a7 as CompiledMutationPlan, a8 as ComposeSpec, a9 as CompositionPlanSpec, a2 as ConditionSpec, J as ContextSpec, aa as ContractCardinality, ab as ContractCommandResult, ac as ContractInputArity, ad as ContractKeySpec, ae as ContractKind, af as ContractResolution, A as ContractSpec, ag as DerivedConditionCheck, ah as DerivedEdgeWrite, ai as DerivedIdempotencyGuard, aj as DerivedMaintainOutbox, ak as DerivedMaintainWrite, al as DerivedOutboxEvent, am as DerivedUniqueGuard, an as DerivedUpdate, ao as EntityRefResolver, ap as ExecutionPlanSpec, aq as FilterSpec, ar as MAX_TRANSACT_COMPOSE_ITEMS, a0 as Manifest, as as ManifestEntity, at as ManifestField, au as ManifestFieldType, av as ManifestGsi, aw as ManifestKey, ax as ManifestRelation, ay as ManifestTable, az as OperationSpec, _ as OperationsDocument, L as ParamSpec, aA as QueryContractMethodSpec, G as QuerySpec, aB as RangeConditionSpec, aC as ReadOperationType, K as SPEC_VERSION, aD as TransactionItemSpec, aE as TransactionItemType, I as TransactionSpec, aF as WhenSpec, aG as WriteOperationType, aH as assertNoCrossFragmentMaintainCollision, aI as compileFragment, aJ as compileMutationPlan, aK as compileSingleFragmentPlan, aL as resetMaintenanceGraphCache, aM as resolveLifecycle, aN as resolveMaintainers } from '../maintenance-view-adapter-BATUh_I8.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, O as PREPARED_FORMAT_VERSION, Q as PreparedBindMap, g as PreparedBindSpec, a as PreparedPlanDocument, h as PreparedPlanSpec, i as PreparedReadRouteSpec, P as PreparedWriteOpSpec, 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, R as buildPreparedPlanDocument, F as buildQuerySpec, G as buildTransactionSpec, H as buildTransactions, S as canonicalJson, I as collectContractBoundaryViolations, J as collectContractN1Violations, U as compilePreparedPlan, V as entityFingerprint, X as planFingerprint } from '../index-CtPJSMrc.js';
+import '../registry-CXhP4TaE.js';
 import '@aws-sdk/client-dynamodb';

package/dist/spec/index.js

@@ -29,8 +29,8 @@ import {
   resetMaintenanceGraphCache,
   resolveLifecycle,
   resolveMaintainers
-} from "../chunk-WPABX7WG.js";
-import "../chunk-F2DI3GTI.js";
+} from "../chunk-NYM7K2ST.js";
+import "../chunk-PFFPLD4B.js";
 import "../chunk-PDUVTYC5.js";
 export {
   MAX_TRANSACT_COMPOSE_ITEMS,

package/dist/testing/index.d.ts

@@ -1,4 +1,4 @@
-import { n as Executor, D as DynamoDBOperation, 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, c as ChangeEvent } from '../maintenance-view-adapter-C1HaBX4y.js';
+import { n as Executor, D as DynamoDBOperation, 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, c as ChangeEvent } from '../maintenance-view-adapter-BATUh_I8.js';
 import '@aws-sdk/client-dynamodb';
 
 /**

package/dist/testing/index.js

@@ -1,11 +1,11 @@
 import {
   createCdcEmulator
-} from "../chunk-5NXNEW43.js";
+} from "../chunk-ZPNRLOKA.js";
 import {
   ClientManager,
   MetadataRegistry,
   resolveModelClass
-} from "../chunk-F2DI3GTI.js";
+} from "../chunk-PFFPLD4B.js";
 import {
   TableMapping
 } from "../chunk-PDUVTYC5.js";