graphddb 0.7.0 → 0.7.1

package/dist/index.js

@@ -5,8 +5,10 @@ import {
   BatchGetResult,
   DDBModel,
   EDGE_WRITES_MARKER,
+  LOGICAL_EFFECT_CATEGORIES,
   MARKER_ROW_ENTITY,
   OLD_VALUE_NAMESPACE,
+  PREPARED_FORMAT_VERSION,
   PREPARE_CACHE_MAX,
   PreparedReadStatement,
   PreparedWriteStatement,
@@ -21,6 +23,7 @@ import {
   buildContexts,
   buildContracts,
   buildManifest,
+  buildManifestEntity,
   buildOperations,
   buildProjection,
   buildQuerySpec,
@@ -44,6 +47,7 @@ import {
   deriveModelEdgeWriteItems,
   edgeWrites,
   encodeCursor,
+  entityFingerprint,
   evaluateFilter,
   execute,
   executeBatchGet,
@@ -52,6 +56,8 @@ import {
   executeExplain,
   executeList,
   executeListInternal,
+  executeLogicalParallelWrites,
+  executeLogicalWriteOps,
   executeQuery,
   from,
   getEdgeWrites,
@@ -83,7 +89,7 @@ import {
   validateDepth,
   when,
   wholeKeysSentinel
-} from "./chunk-GFGVDF4W.js";
+} from "./chunk-C5Q2NMRW.js";
 import {
   CdcEmulator,
   MAINT_OUTBOX_PK_PREFIX,
@@ -1282,6 +1288,256 @@ async function executeRangeFanout(op, keys, params = {}) {
   return out;
 }
 
+// src/runtime/prepared-loader.ts
+var LOAD_LABEL = "graphddb.loadPreparedPlan";
+function slotOfBind(bind) {
+  if ("param" in bind) return { kind: "param", name: bind.param };
+  if ("literal" in bind) return { kind: "literal", value: bind.literal };
+  if ("literalDate" in bind) return { kind: "literal", value: new Date(bind.literalDate) };
+  return { kind: "literal", value: BigInt(bind.literalBigInt) };
+}
+function slotsOfBindMap(map2) {
+  const out = {};
+  for (const [field2, bind] of Object.entries(map2 ?? {})) out[field2] = slotOfBind(bind);
+  return out;
+}
+function bindValues(slots, params) {
+  const out = {};
+  for (const [field2, slot] of Object.entries(slots)) {
+    out[field2] = slot.kind === "param" ? params[slot.name] : slot.value;
+  }
+  return out;
+}
+function resolveModelByName(name, planId) {
+  for (const modelClass of MetadataRegistry.getAll().keys()) {
+    if (modelClass.name === name) return modelClass;
+  }
+  throw new Error(
+    `${LOAD_LABEL}: static plan '${planId}' targets entity '${name}', which is not a registered model in this process. Ensure the model module is imported before the plan executes, or regenerate the artifact (graphddb transform prepared --aot).`
+  );
+}
+function bindEntities(plan2, planId) {
+  const classes = /* @__PURE__ */ new Map();
+  const entities = {};
+  const tables = {};
+  for (const [name, expected] of Object.entries(plan2.entities)) {
+    const modelClass = resolveModelByName(name, planId);
+    const metadata = MetadataRegistry.get(modelClass);
+    const actual = entityFingerprint(metadata);
+    if (actual !== expected) {
+      throw new Error(
+        `${LOAD_LABEL}: static plan '${planId}' is STALE \u2014 entity '${name}' has changed since the plan artifact was generated (declaration fingerprint mismatch: expected ${expected.slice(0, 12)}\u2026, live ${actual.slice(0, 12)}\u2026). A stale static plan never executes. Regenerate the artifact: \`graphddb transform prepared --aot <artifact> --write\` (CI: run the check mode to catch this at build time).`
+      );
+    }
+    classes.set(name, modelClass);
+    const entity = buildManifestEntity(metadata);
+    entities[name] = entity;
+    tables[metadata.tableName] = { physicalName: TableMapping.resolve(metadata.tableName) };
+  }
+  return { classes, manifest: { version: SPEC_VERSION, tables, entities } };
+}
+function templateParams(values) {
+  const out = {};
+  for (const [k2, v] of Object.entries(values)) {
+    out[k2] = v instanceof Date ? v.toISOString() : v;
+  }
+  return out;
+}
+function renderSpecItem(transaction, index, manifest, params) {
+  const single = {
+    params: transaction.params,
+    items: [transaction.items[index]]
+  };
+  return expandTransactionItems(single, manifest, params);
+}
+function renderEffectsForOp(op, boundParams) {
+  const rendered = templateParams(boundParams);
+  const effects = {};
+  const checks = [];
+  const modelBySignature = /* @__PURE__ */ new Map();
+  const { transaction, categories } = op.spec;
+  for (let i = 0; i < transaction.items.length; i++) {
+    const category = categories[i];
+    if (category === "base") continue;
+    for (const out of renderSpecItem(transaction, i, op.manifest, rendered)) {
+      const item = out.item;
+      if (category === "check") {
+        if (item.ConditionCheck !== void 0) checks.push(item.ConditionCheck);
+        continue;
+      }
+      const family = category;
+      if (!LOGICAL_EFFECT_CATEGORIES.includes(family)) {
+        throw new Error(
+          `${LOAD_LABEL}: unknown effect category '${String(category)}' in a static plan (artifact format skew \u2014 regenerate the artifact).`
+        );
+      }
+      (effects[family] ??= []).push(item);
+      if (out.model !== void 0) {
+        modelBySignature.set(execItemKeySignature(item), out.model);
+      }
+    }
+  }
+  return { effects, checks, modelBySignature };
+}
+var INTENT_TO_KIND = { create: "put", update: "update", remove: "delete" };
+var AotPreparedWriteStatement = class {
+  /** @internal */
+  constructor(ops) {
+    this.ops = ops;
+  }
+  ops;
+  async execute(params = {}, options = {}) {
+    const logical = this.ops.map((op) => {
+      const bound = {
+        ...bindValues(op.inputSlots, params),
+        ...bindValues(op.keySlots, params)
+      };
+      const condition = op.conditionSlots !== void 0 ? bindValues(op.conditionSlots, params) : void 0;
+      return {
+        kind: INTENT_TO_KIND[op.spec.intent],
+        modelClass: op.modelClass,
+        modelStatic: op.modelStatic,
+        keyFields: op.spec.keyFields,
+        params: bound,
+        // A `create` guards with attribute_not_exists — the same condition the
+        // compiled base op carries; an explicit gate on a create was rejected at
+        // BUILD time (mirroring the compiled core's `withCondition` reject).
+        ...op.spec.intent === "create" ? { condition: { notExists: true } } : condition !== void 0 ? { condition } : {},
+        ...op.spec.result !== void 0 ? { result: op.spec.result } : {},
+        renderEffects: (postW1) => renderEffectsForOp(op, postW1)
+      };
+    });
+    const mode = options.mode ?? "transaction";
+    const runOpts = {
+      label: LOAD_LABEL,
+      ...options.retry !== void 0 ? { retry: options.retry } : {},
+      ...options.context !== void 0 ? { context: options.context } : {}
+    };
+    if (mode === "transaction") {
+      const { readBacks } = await executeLogicalWriteOps(logical, runOpts);
+      const out2 = {};
+      this.ops.forEach((op, i) => {
+        if (op.spec.result !== void 0) out2[op.alias] = readBacks[i];
+      });
+      return out2;
+    }
+    const settled = await executeLogicalParallelWrites(logical, runOpts);
+    const out = {};
+    this.ops.forEach((op, i) => {
+      const res = settled[i];
+      out[op.alias] = res.ok ? { ok: true, value: op.spec.result !== void 0 ? res.value : void 0 } : { ok: false, error: res.error };
+    });
+    return out;
+  }
+};
+function bindReadPlan(plan2, planId) {
+  const { classes } = bindEntities(plan2, planId);
+  const routes = (plan2.reads ?? []).map((r) => {
+    const modelClass = classes.get(r.entity);
+    if (modelClass === void 0) {
+      throw new Error(
+        `${LOAD_LABEL}: static plan '${planId}' route '${r.alias}' targets entity '${r.entity}', which the plan does not fingerprint (artifact skew \u2014 regenerate).`
+      );
+    }
+    const consistentReadSlot = r.consistentRead !== void 0 ? slotOfBind(r.consistentRead) : void 0;
+    const limitSlot = r.limit !== void 0 ? slotOfBind(r.limit) : void 0;
+    const afterSlot = r.after !== void 0 ? slotOfBind(r.after) : void 0;
+    return {
+      alias: r.alias,
+      kind: r.op,
+      modelClass,
+      select: r.select,
+      keySlots: slotsOfBindMap(r.key),
+      ...r.maxDepth !== void 0 ? { maxDepth: r.maxDepth } : {},
+      ...r.order !== void 0 ? { order: r.order } : {},
+      ...r.filter !== void 0 ? { filter: r.filter } : {},
+      ...consistentReadSlot !== void 0 ? { consistentReadSlot } : {},
+      ...limitSlot !== void 0 ? { limitSlot } : {},
+      ...afterSlot !== void 0 ? { afterSlot } : {}
+    };
+  });
+  return new PreparedReadStatement(routes);
+}
+function bindWritePlan(plan2, planId) {
+  const { classes, manifest } = bindEntities(plan2, planId);
+  const ops = (plan2.writes ?? []).map((w) => {
+    const modelClass = classes.get(w.entity);
+    if (modelClass === void 0) {
+      throw new Error(
+        `${LOAD_LABEL}: static plan '${planId}' op '${w.alias}' targets entity '${w.entity}', which the plan does not fingerprint (artifact skew \u2014 regenerate).`
+      );
+    }
+    const modelStatic = modelClass.asModel();
+    return {
+      alias: w.alias,
+      spec: w,
+      modelClass,
+      modelStatic,
+      keySlots: slotsOfBindMap(w.key),
+      inputSlots: slotsOfBindMap(w.input),
+      ...w.condition !== void 0 ? { conditionSlots: slotsOfBindMap(w.condition) } : {},
+      manifest
+    };
+  });
+  return new AotPreparedWriteStatement(ops);
+}
+function bindPlan(doc, planId) {
+  if (doc === null || typeof doc !== "object" || doc.plans === void 0) {
+    throw new Error(`${LOAD_LABEL}: not a prepared-plan document.`);
+  }
+  if (doc.formatVersion !== PREPARED_FORMAT_VERSION) {
+    throw new Error(
+      `${LOAD_LABEL}: unsupported artifact format version '${String(doc.formatVersion)}' (this runtime supports '${PREPARED_FORMAT_VERSION}'). Regenerate the artifact with the installed graphddb version.`
+    );
+  }
+  if (doc.specVersion !== SPEC_VERSION) {
+    throw new Error(
+      `${LOAD_LABEL}: the artifact was compiled against operation-IR version '${String(doc.specVersion)}' but this runtime speaks '${SPEC_VERSION}'. A version-skewed static plan never executes \u2014 regenerate the artifact.`
+    );
+  }
+  const plan2 = doc.plans[planId];
+  if (plan2 === void 0) {
+    const available = Object.keys(doc.plans).sort().slice(0, 8).join(", ");
+    throw new Error(
+      `${LOAD_LABEL}: the artifact carries no plan '${planId}' (available: ${available}${Object.keys(doc.plans).length > 8 ? ", \u2026" : ""}). The source and the artifact have drifted \u2014 regenerate: \`graphddb transform prepared --aot <artifact> --write\`.`
+    );
+  }
+  return plan2.kind === "read" ? bindReadPlan(plan2, planId) : bindWritePlan(plan2, planId);
+}
+var BOUND = /* @__PURE__ */ new WeakMap();
+var LazyAotHandle = class {
+  constructor(doc, planId) {
+    this.doc = doc;
+    this.planId = planId;
+  }
+  doc;
+  planId;
+  bound;
+  resolve() {
+    if (this.bound !== void 0) return this.bound;
+    let perDoc = BOUND.get(this.doc);
+    if (perDoc === void 0) {
+      perDoc = /* @__PURE__ */ new Map();
+      BOUND.set(this.doc, perDoc);
+    }
+    let handle = perDoc.get(this.planId);
+    if (handle === void 0) {
+      handle = bindPlan(this.doc, this.planId);
+      perDoc.set(this.planId, handle);
+    }
+    this.bound = handle;
+    return handle;
+  }
+  async execute(params, options) {
+    const target = this.resolve();
+    return target.execute(params, options);
+  }
+};
+function loadPreparedPlan(doc, planId, body) {
+  void body;
+  return new LazyAotHandle(doc, planId);
+}
+
 // src/relation/maintenance-rebuild.ts
 function toClass(m) {
   try {
@@ -1858,6 +2114,7 @@ function assertDefinition(name, def) {
   }
 }
 export {
+  AotPreparedWriteStatement,
   BATCH_GET_MAX_KEYS,
   BATCH_WRITE_MAX_ITEMS,
   BatchGetResult,
@@ -2006,6 +2263,7 @@ export {
   lifecyclePhaseForIntent,
   list,
   literal,
+  loadPreparedPlan,
   maintainTrigger,
   maintainedFrom,
   map,

package/dist/linter/index.d.ts

@@ -1,7 +1,7 @@
-import { L as LintRule } from '../registry-Cv9nl_3i.js';
-export { a as LintResult, b as Linter } from '../registry-Cv9nl_3i.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';
-import '../maintenance-view-adapter-BP2CJDdz.js';
+import { L as LintRule } from '../registry-BndKbZbg.js';
+export { a as LintResult, b as Linter } from '../registry-BndKbZbg.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';
+import '../maintenance-view-adapter-NBTZbE8-.js';
 import '@aws-sdk/client-dynamodb';
 
 /**

package/dist/{maintenance-view-adapter-BP2CJDdz.d.ts → maintenance-view-adapter-NBTZbE8-.d.ts}

@@ -4135,8 +4135,17 @@ declare function buildMaintenanceGraph(registry?: ReadonlyMap<Function, EntityMe
  * `PROFILE`).
  */
 
-/** The schema version emitted in every manifest / operations document. */
-declare const SPEC_VERSION: "1.0";
+/**
+ * The schema version emitted in every manifest / operations document.
+ *
+ * `1.1` (issue #208, B案): the operation IR gained the **list fan-out binding
+ * form** ({@link SourceListSpec} on a `BatchGetItem` relation op), lifting the
+ * #197 `refs` loud-reject. The op vocabulary (the physical DynamoDB API surface)
+ * is unchanged — only the dataflow (source→key) binding grammar grew. Purely
+ * additive: every `1.0` document is a valid `1.1` document, and a document that
+ * uses no `refs` relation serializes byte-identically apart from this version.
+ */
+declare const SPEC_VERSION: "1.1";
 /** Field type as carried in the manifest (derived from the DynamoDB type). */
 type ManifestFieldType = 'string' | 'number' | 'boolean' | 'binary' | 'stringSet' | 'numberSet' | 'list' | 'map';
 interface ManifestField {
@@ -4306,6 +4315,45 @@ interface OperationSpec {
      * drive this operation's `{result.*}` placeholders. Absent on the root op.
      */
     readonly sourceField?: string;
+    /**
+     * The **list fan-out binding form** (issue #208, B案 — the shared-IR
+     * generalization that lifted the #197 `refs` loud-reject). Present only on a
+     * `BatchGetItem` relation operation that resolves a `refs` relation: instead of
+     * reading ONE scalar `parent[sourceField]`, the runtime reads the parent **list
+     * attribute** {@link SourceListSpec.from} and binds `{result.<sourceField>}`
+     * once per element — `element[key]` for an object element, the element itself
+     * for a bare scalar — skipping null/undefined refs. All element keys across all
+     * parents fan into ONE deduped `BatchGetItem` (the existing chunk/retry
+     * machinery), and the operation's `resultPath` (`…<prop>.items`) receives a
+     * connection `{ items, cursor: null }` whose items are the resolved child
+     * bodies in **first-seen element order**, deduped, with missing bodies dropped
+     * — byte-matching the TS in-process `fetchRefsList` semantics. Absent on every
+     * scalar-bound relation op (a pre-#208 document is byte-identical).
+     */
+    readonly sourceList?: SourceListSpec;
+}
+/**
+ * The list-valued source descriptor of a fan-out `BatchGetItem` operation (issue
+ * #208 B案; the operation-IR mirror of the manifest's `ManifestRelation.refs`).
+ */
+interface SourceListSpec {
+    /** The parent LIST attribute holding the inline reference elements (e.g. `tagRefs`). */
+    readonly from: string;
+    /**
+     * The field read off each element (e.g. `tagId`). Always equals the operation's
+     * `sourceField` (the `{result.<sourceField>}` token name); carried explicitly so
+     * the op is self-describing.
+     */
+    readonly key: string;
+    /**
+     * `true` when the parent list attribute was NOT selected by the query and was
+     * projected onto the parent operation **solely** to drive this fan-out. The
+     * runtime must then delete `from` from every parent node after ALL relation
+     * operations are applied — mirroring the TS hydrator, which projects implicit
+     * relation-source fields but strips them from the assembled result. Absent when
+     * the query's select projects the attribute itself (it stays in the result).
+     */
+    readonly implicit?: boolean;
 }
 /**
  * The **execution plan** for a multi-operation read (issue #70a). It is the
@@ -6368,7 +6416,9 @@ interface PreparedReadExecOptions {
 /**
  * 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`.
+ * `$` 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';
@@ -6386,6 +6436,9 @@ 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';
@@ -7316,4 +7369,4 @@ interface ViewDefinition {
  */
 declare function collectViewDefinitions(registry?: ReadonlyMap<Function, EntityMetadata>): ViewDefinition[];
 
-export { type BridgeBundle as $, type Param as A, type BatchResult as B, type CdcEmulatorOptions as C, type DynamoDBOperation as D, type EventLog as E, type FaultSpec as F, type QueryMethodSpec as G, type CommandModelContract as H, type CommandMethodSpec as I, type ContractSpec as J, type QuerySpec as K, type CommandSpec as L, type ModelStatic as M, type TransactionSpec as N, type ContextSpec 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 DefinitionMap as X, type OperationsDocument as Y, type AnyOperationDefinition as Z, type Manifest as _, type CdcMode as a, type DynamoType as a$, type ConditionSpec as a0, type CommandContractMethodSpec as a1, type CommandResolutionTarget as a2, type CompiledFragment as a3, type CompiledMutationPlan as a4, type ComposeSpec as a5, type CompositionPlanSpec as a6, type ContractCardinality as a7, type ContractCommandResult as a8, type ContractInputArity as a9, type ReadOperationType as aA, SPEC_VERSION as aB, type TransactionItemSpec as aC, type TransactionItemType as aD, type WhenSpec as aE, type WriteOperationType as aF, assertNoCrossFragmentMaintainCollision as aG, compileFragment as aH, compileMutationPlan as aI, compileSingleFragmentPlan as aJ, resetMaintenanceGraphCache as aK, resolveLifecycle as aL, resolveMaintainers as aM, type SelectableOf as aN, type PrimaryKeyOf as aO, type RequestContext as aP, type Middleware as aQ, type ReadRequestKind as aR, type CtxModel as aS, type ReadParams as aT, type ReadRequestCtx as aU, type Item as aV, type RetryPolicy as aW, type KeyDefinition as aX, type GsiDefinition as aY, type ModelKind as aZ, type FieldOptions as a_, type ContractKeySpec as aa, type ContractKind as ab, type ContractResolution as ac, type DerivedConditionCheck as ad, type DerivedEdgeWrite as ae, type DerivedIdempotencyGuard as af, type DerivedMaintainOutbox as ag, type DerivedMaintainWrite as ah, type DerivedOutboxEvent as ai, type DerivedUniqueGuard as aj, type DerivedUpdate as ak, type EntityRefResolver as al, type ExecutionPlanSpec as am, type FilterSpec as an, MAX_TRANSACT_COMPOSE_ITEMS as ao, type ManifestEntity as ap, type ManifestField as aq, type ManifestFieldType as ar, type ManifestGsi as as, type ManifestKey as at, type ManifestRelation as au, type ManifestTable as av, type OperationSpec as aw, type ParamSpec as ax, type QueryContractMethodSpec as ay, type RangeConditionSpec as az, type ChangeBatch as b, type DeleteOptions as b$, type ProjectionTransform as b0, type MaintainEvent as b1, type MembershipPredicate as b2, type MaintainConsistency as b3, type MaintainUpdateMode as b4, type MembershipPredicateOp as b5, type RelationOptions as b6, type AggregateOptions as b7, type AggregateValue as b8, type SelectBuilderSpec as b9, type CollectionOptions as bA, type Column as bB, type ColumnMap as bC, type CommandInputShape as bD, type CommandMethod as bE, type CommandPlan as bF, type CommandResultKind as bG, type CommandSelectShape as bH, type CondSlot as bI, type ConditionCheckInput as bJ, type Connection as bK, type ContractCallSignature as bL, type ContractCommandParams as bM, type ContractComposeNode as bN, type ContractFromRef as bO, type ContractItem as bP, type ContractKeyFieldRef as bQ, type ContractKeyInput as bR, type ContractKeyRef as bS, type ContractMethodOp as bT, type ContractParamRef as bU, type ContractQueryParams as bV, type CounterAggregate as bW, type CounterEffect as bX, type CtxBase as bY, DEFAULT_MAX_ATTEMPTS as bZ, DEFAULT_RETRY_POLICY as b_, type RawCondition as ba, type RetryOverride as bb, type ExecutionPlan as bc, type FieldMetadata as bd, type ResolvedKey as be, type RelationMetadata as bf, type MaintainEffect as bg, type OperationDefinition as bh, type WriteDefinitionOptions as bi, type PartialQueryKeyOf as bj, type StrictSelectSpec as bk, type ReadDefinitionOptions as bl, type EntityInput as bm, type UniqueQueryKeyOf as bn, type AggregateMetadata as bo, type BatchDeleteRequest as bp, type BatchGetOptions as bq, type BatchGetRequest as br, BatchGetResult as bs, type BatchPutRequest as bt, type BatchWriteRequest as bu, CONTRACT_RANGE_FANOUT_CONCURRENCY as bv, type CdcModelRegistry as bw, type CdcSubscribeHandlers as bx, type Change as by, type CollectionEffect as bz, type ChangeEvent as c, type ProjectionTransformOp as c$, type DeriveEffect as c0, type DescriptorBinding as c1, ENTITY_WRITES_MARKER as c2, type EdgeEffect as c3, type EffectPath as c4, type EmbeddedMetadata as c5, type EmitEffect as c6, type EntityWritesDefinition as c7, type EntityWritesShape as c8, type ExecutableCommandContract as c9, type MutateTransactionResult as cA, type MutationBody as cB, type MutationDescriptorMap as cC, type MutationFragment as cD, type MutationInputProxy as cE, type MutationInputRef as cF, type MutationIntent as cG, type NumberParam as cH, type OperationKind as cI, PREPARE_CACHE_MAX as cJ, type ParallelOpResult as cK, type ParamKind as cL, type ParamStructure as cM, type PersistCtx as cN, type PersistOrigin as cO, type PlannedCommandMethod as cP, type PreparedBody as cQ, type PreparedInputProxy as cR, type PreparedParamRef as cS, type PreparedReadExecOptions as cT, type PreparedReadRoute as cU, PreparedReadStatement as cV, type PreparedStatement as cW, type PreparedWriteExecOptions as cX, type PreparedWriteRoute as cY, PreparedWriteStatement as cZ, type ProjectionMap as c_, type ExecutableQueryContract as ca, type FilterInput as cb, type FragmentInput as cc, type GsiDefinitionMarker as cd, type GsiOptions as ce, type IdempotencyEffect as cf, type InProcessWriteDescriptor as cg, type InlineSnapshotSpec as ch, type InputArity as ci, type KeyDefinitionMarker as cj, type KeySegment as ck, type KeySlot as cl, type KeyStructure as cm, type KeyedResult as cn, LIFECYCLE_CONTRACT_MARKER as co, type LifecycleContract as cp, type LifecycleEffects as cq, type LiteralParam as cr, type MaintainItem as cs, type MaintainTrigger as ct, type MaintenanceGraph as cu, type MembershipEffect as cv, type ModelRef as cw, type MutateMode as cx, type MutateOptions as cy, type MutateParallelResult as cz, type ChangeEventName as d, executeQueryMethod as d$, type PutOptions as d0, type QueryEnvelopeResult as d1, type QueryKeyOf as d2, type QueryMethod as d3, type QueryResult as d4, type ReadEnvelope as d5, type ReadOpCtx as d6, type ReadOpKind as d7, type ReadRouteDescriptor as d8, type ReadRouteOptions as d9, type UpdateOptions as dA, type ViewSourceSlice as dB, type WriteCtx as dC, type WriteDescriptor as dD, type WriteEnvelope as dE, type WriteInput as dF, type WriteKind as dG, type WriteLifecyclePhase as dH, type WriteMiddleware as dI, type WriteRecorder as dJ, type WriteResultProjection as dK, attachModelClass as dL, buildDeleteInput as dM, buildMaintenanceGraph as dN, buildPutInput as dO, buildUpdateInput as dP, collectViewDefinitions as dQ, cond as dR, contractOfMethodSpec as dS, definePlan as dT, entityWrites as dU, executeBatchGet as dV, executeBatchWrite as dW, executeCommandMethod as dX, executeDelete as dY, executeKeyedBatchGet as dZ, executePut as d_, type ReadRouteResult as da, type RecordedCompose as db, type RelationBuilder as dc, type RelationConsistency as dd, type RelationLimitOptions as de, type RelationPattern as df, type RelationProjection as dg, type RelationReadOptions as dh, type RelationSelect as di, type RelationSpec as dj, type RelationUpdateMode as dk, type RelationWriteOptions as dl, type RequiresEffect as dm, type Resolution as dn, type RetryInfo as dp, type RetryOperationKind as dq, type SegmentSpec as dr, type SegmentedKey as ds, type SelectBuilder as dt, type SelectOf as du, type SnapshotEffect as dv, type StringParam as dw, TransactionContext as dx, type UniqueEffect as dy, type Updatable as dz, type ChangeHandler as e, executeRangeFanout as e0, executeTransaction as e1, executeUpdate as e2, from as e3, getEntityWrites as e4, gsi as e5, identity as e6, isColumn as e7, isCommandModelContract as e8, isCommandPlan as e9, preview as eA, publicCommandModel as eB, publicQueryModel as eC, query as eD, wholeKeysSentinel as eE, isContractComposeNode as ea, isContractFromRef as eb, isContractKeyFieldRef as ec, isContractKeyRef as ed, isContractParamRef as ee, isEntityWritesDefinition as ef, isKeySegment as eg, isLifecycleContract as eh, isMaintainTrigger as ei, isMutationFragment as ej, isMutationInputRef as ek, isParam as el, isPlannedCommandMethod as em, isPreparedParamRef as en, isQueryModelContract as eo, isRetryableError as ep, isRetryableTransactionCancellation as eq, k as er, key as es, lifecyclePhaseForIntent as et, maintainTrigger as eu, mintContractKeyFieldRef as ev, mintContractParamRef as ew, mutation as ex, param as ey, prepare 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 ParamDescriptor as x, type EntityRef as y, type ConditionInput as z };
+export { type OperationsDocument 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 PreparedBody as N, type ParamDescriptor 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 EntityRef as X, type ConditionInput as Y, type Param as Z, type DefinitionMap as _, type CdcMode as a, type FieldOptions as a$, type AnyOperationDefinition as a0, type Manifest as a1, type BridgeBundle as a2, type ConditionSpec 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 };

package/dist/{registry-Cv9nl_3i.d.ts → registry-BndKbZbg.d.ts}

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

package/dist/{relation-depth-BR0y7Q1i.d.ts → relation-depth-CCGHLTOv.d.ts}

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

package/dist/spec/index.d.ts

@@ -1,4 +1,4 @@
-export { $ as BridgeBundle, a1 as CommandContractMethodSpec, a2 as CommandResolutionTarget, L as CommandSpec, a3 as CompiledFragment, a4 as CompiledMutationPlan, a5 as ComposeSpec, a6 as CompositionPlanSpec, a0 as ConditionSpec, O as ContextSpec, a7 as ContractCardinality, a8 as ContractCommandResult, a9 as ContractInputArity, aa as ContractKeySpec, ab as ContractKind, ac as ContractResolution, J as ContractSpec, ad as DerivedConditionCheck, ae as DerivedEdgeWrite, af as DerivedIdempotencyGuard, ag as DerivedMaintainOutbox, ah as DerivedMaintainWrite, ai as DerivedOutboxEvent, aj as DerivedUniqueGuard, ak as DerivedUpdate, al as EntityRefResolver, am as ExecutionPlanSpec, an as FilterSpec, ao as MAX_TRANSACT_COMPOSE_ITEMS, _ as Manifest, ap as ManifestEntity, aq as ManifestField, ar as ManifestFieldType, as as ManifestGsi, at as ManifestKey, au as ManifestRelation, av as ManifestTable, aw as OperationSpec, Y as OperationsDocument, ax as ParamSpec, ay as QueryContractMethodSpec, K as QuerySpec, az as RangeConditionSpec, aA as ReadOperationType, aB as SPEC_VERSION, aC as TransactionItemSpec, aD as TransactionItemType, N as TransactionSpec, aE as WhenSpec, aF as WriteOperationType, aG as assertNoCrossFragmentMaintainCollision, aH as compileFragment, aI as compileMutationPlan, aJ as compileSingleFragmentPlan, aK as resetMaintenanceGraphCache, aL as resolveLifecycle, aM as resolveMaintainers } from '../maintenance-view-adapter-BP2CJDdz.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, 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 } from '../index-Eg94ChE1.js';
-import '../registry-Cv9nl_3i.js';
+export { a2 as BridgeBundle, a4 as CommandContractMethodSpec, a5 as CommandResolutionTarget, H as CommandSpec, a6 as CompiledFragment, a7 as CompiledMutationPlan, a8 as ComposeSpec, a9 as CompositionPlanSpec, a3 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, a1 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-NBTZbE8-.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-CvS9ATKB.js';
+import '../registry-BndKbZbg.js';
 import '@aws-sdk/client-dynamodb';

package/dist/spec/index.js

@@ -1,5 +1,6 @@
 import {
   MAX_TRANSACT_COMPOSE_ITEMS,
+  PREPARED_FORMAT_VERSION,
   SPEC_VERSION,
   assertBundleSerializable,
   assertContractBoundaries,
@@ -12,22 +13,28 @@ import {
   buildContracts,
   buildManifest,
   buildOperations,
+  buildPreparedPlanDocument,
   buildQuerySpec,
   buildTransactionSpec,
   buildTransactions,
+  canonicalJson,
   collectContractBoundaryViolations,
   collectContractN1Violations,
   compileFragment,
   compileMutationPlan,
+  compilePreparedPlan,
   compileSingleFragmentPlan,
+  entityFingerprint,
+  planFingerprint,
   resetMaintenanceGraphCache,
   resolveLifecycle,
   resolveMaintainers
-} from "../chunk-GFGVDF4W.js";
+} from "../chunk-C5Q2NMRW.js";
 import "../chunk-F2DI3GTI.js";
 import "../chunk-PDUVTYC5.js";
 export {
   MAX_TRANSACT_COMPOSE_ITEMS,
+  PREPARED_FORMAT_VERSION,
   SPEC_VERSION,
   assertBundleSerializable,
   assertContractBoundaries,
@@ -40,14 +47,19 @@ export {
   buildContracts,
   buildManifest,
   buildOperations,
+  buildPreparedPlanDocument,
   buildQuerySpec,
   buildTransactionSpec,
   buildTransactions,
+  canonicalJson,
   collectContractBoundaryViolations,
   collectContractN1Violations,
   compileFragment,
   compileMutationPlan,
+  compilePreparedPlan,
   compileSingleFragmentPlan,
+  entityFingerprint,
+  planFingerprint,
   resetMaintenanceGraphCache,
   resolveLifecycle,
   resolveMaintainers

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-BP2CJDdz.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-NBTZbE8-.js';
 import '@aws-sdk/client-dynamodb';
 
 /**

package/dist/transform/index.d.ts

@@ -115,7 +115,10 @@ type PreparedDiagnosticCode =
 /** The `prepare` argument is not a statically visible function body. */
  | 'unverifiable-body'
 /** Informational: an inline call site the transform hoists (check mode). */
- | 'hoistable';
+ | 'hoistable'
+/** Informational (#208 --aot check mode): a `DDBModel.prepare` call site not
+ * yet rewritten to the static-plan loader (`--aot … --write` rewrites it). */
+ | 'aot-pending';
 /** One lint / transform diagnostic, positioned in the original source. */
 interface PreparedDiagnostic {
     readonly code: PreparedDiagnosticCode;
@@ -163,5 +166,51 @@ declare function transformPreparedSource(fileName: string, sourceText: string, o
  * reported as `hoistable` notes so a build can surface silent-slow fallbacks.
  */
 declare function lintPreparedSource(fileName: string, sourceText: string): readonly PreparedDiagnostic[];
+/** The local identifier the rewrite binds `loadPreparedPlan` to. */
+declare const AOT_LOADER_LOCAL = "__gddbLoadPreparedPlan";
+/** The local identifier the rewrite binds the artifact document to. */
+declare const AOT_PLANS_LOCAL = "__gddbPreparedPlans";
+/** The named export of an evaluation shim: `{ <siteIndex>: <bodyFn> }`. */
+declare const AOT_SHIM_EXPORT = "__gddbAotBodies";
+/** One discovered prepared call site (either form), verified and numbered. */
+interface PreparedAotSite {
+    /** 1-based document-order index within the file. */
+    readonly index: number;
+    /** The stable plan id: `<planIdPrefix>#<index>`. */
+    readonly planId: string;
+    /** `prepare` (original form) or `aot` (already rewritten). */
+    readonly form: 'prepare' | 'aot';
+}
+/** The per-file result of the AOT pass. */
+interface PreparedAotFileResult {
+    readonly fileName: string;
+    /** The rewritten source (identical to the input in check mode / no change). */
+    readonly text: string;
+    readonly changed: boolean;
+    readonly sites: readonly PreparedAotSite[];
+    /**
+     * The evaluation-shim module source (present when the file has ≥1 verified
+     * site and no violations). Importing it yields `{ [AOT_SHIM_EXPORT]:
+     * Record<siteIndex, PreparedBody> }`.
+     */
+    readonly shimSource?: string;
+    readonly diagnostics: readonly PreparedDiagnostic[];
+    readonly errorCount: number;
+}
+interface PreparedAotOptions {
+    /** `transform` rewrites call sites; `check` only discovers + lints (drift mode). */
+    readonly mode: 'transform' | 'check';
+    /** The plan-id prefix — the project-relative source path (POSIX separators). */
+    readonly planIdPrefix: string;
+    /** The module specifier the rewrite imports the artifact document from. */
+    readonly artifactImport: string;
+}
+/**
+ * The #208 AOT pass over one source file: discover + verify every prepared call
+ * site (both forms), assign stable plan ids, build the evaluation shim, and (in
+ * `transform` mode) rewrite `DDBModel.prepare` sites to the static-plan loader.
+ * See the section header above for the full contract.
+ */
+declare function transformPreparedSourceAot(fileName: string, sourceText: string, options: PreparedAotOptions): PreparedAotFileResult;
 
-export { HOIST_SLOT_PREFIX, type PreparedDiagnostic, type PreparedDiagnosticCode, type PreparedTransformOptions, type PreparedTransformResult, lintPreparedSource, transformPreparedSource };
+export { AOT_LOADER_LOCAL, AOT_PLANS_LOCAL, AOT_SHIM_EXPORT, HOIST_SLOT_PREFIX, type PreparedAotFileResult, type PreparedAotOptions, type PreparedAotSite, type PreparedDiagnostic, type PreparedDiagnosticCode, type PreparedTransformOptions, type PreparedTransformResult, lintPreparedSource, transformPreparedSource, transformPreparedSourceAot };