graphddb 0.7.9 → 0.8.0

package/dist/internal/index.js

@@ -0,0 +1,701 @@
+import {
+  PREPARED_FORMAT_VERSION,
+  buildManifestEntity,
+  entityFingerprint
+} from "../chunk-LGHSZIEE.js";
+import {
+  LOGICAL_EFFECT_CATEGORIES,
+  PreparedReadStatement,
+  executeLogicalParallelWrites,
+  executeLogicalWriteOps,
+  serializeEffectParams
+} from "../chunk-I4LEJ4TF.js";
+import "../chunk-HNY2EJPV.js";
+import {
+  MARKER_ROW_ENTITY,
+  SPEC_VERSION,
+  SPEC_VERSION_SUPPORTED
+} from "../chunk-L4QRCHRQ.js";
+import {
+  MetadataRegistry,
+  buildConditionExpression,
+  execItemKeySignature,
+  resolveConditionTree
+} from "../chunk-L2NEDS7U.js";
+import {
+  TableMapping
+} from "../chunk-XTWXMOHD.js";
+
+// src/runtime/prepared-loader.ts
+import { validateEnvelope, EnvelopeFailure } from "behavior-contracts";
+
+// src/operations/declarative-transaction.ts
+import { renderTemplate, TemplateFailure } from "behavior-contracts";
+
+// src/runtime/behavior-contracts-adapter.ts
+function toSharedValue(v) {
+  if (v === null || v === void 0) return null;
+  switch (typeof v) {
+    case "string":
+    case "boolean":
+    case "bigint":
+      return v;
+    case "number":
+      return Number.isInteger(v) ? BigInt(v) : v;
+    default:
+      break;
+  }
+  if (v instanceof Date) return v.toJSON();
+  if (Array.isArray(v)) return v.map((e) => toSharedValue(e));
+  if (typeof v === "object") {
+    const out = {};
+    for (const [k, field] of Object.entries(v)) {
+      if (field === void 0) continue;
+      out[k] = toSharedValue(field);
+    }
+    return out;
+  }
+  return v;
+}
+function toSharedParams(params) {
+  const out = {};
+  for (const [name, value] of Object.entries(params)) {
+    if (value === void 0) continue;
+    out[name] = toSharedValue(value);
+  }
+  return out;
+}
+
+// src/runtime/guard-eval.ts
+import { evaluateExpression, ExprFailure } from "behavior-contracts";
+var GUARD_SCOPE_ROOTS = /* @__PURE__ */ new Set(["input", "item"]);
+function assertGuardScopes(node, context) {
+  if (node === null || typeof node !== "object") return;
+  const obj = node;
+  const ref = obj.ref ?? obj.refOpt;
+  if (Array.isArray(ref)) {
+    const root = ref[0];
+    if (typeof root === "string" && !GUARD_SCOPE_ROOTS.has(root)) {
+      throw new Error(
+        `${context}: this guard references '${root}', but a client-side guard may only reference the transaction 'input' / fan-out 'item' scopes. An expression that reads a DynamoDB attribute must lower to a ConditionExpression (write-condition class), not be evaluated client-side (issue #265). Refusing to evaluate a stale check.`
+      );
+    }
+    return;
+  }
+  for (const value of Object.values(obj)) {
+    if (Array.isArray(value)) {
+      for (const child of value) assertGuardScopes(child, context);
+    } else if (value !== null && typeof value === "object") {
+      for (const child of Object.values(value)) {
+        assertGuardScopes(child, context);
+      }
+    }
+  }
+}
+function evaluateGuard(guard, params, element, context) {
+  assertGuardScopes(guard.expr, context);
+  const scope = { input: toSharedParams(params) };
+  if (element !== void 0) {
+    scope.item = toSharedValue(element);
+  }
+  let result;
+  try {
+    result = evaluateExpression(guard.expr, scope);
+  } catch (exc) {
+    if (exc instanceof ExprFailure) {
+      throw new Error(`${context}: guard evaluation failed (${exc.code}): ${exc.message}`);
+    }
+    throw exc;
+  }
+  if (typeof result !== "boolean") {
+    throw new Error(
+      `${context}: a guard expression must evaluate to a boolean, got ${result === null ? "null" : typeof result} (issue #265).`
+    );
+  }
+  return result;
+}
+
+// src/operations/declarative-transaction.ts
+var PLACEHOLDER_RE = /\{[^{}]+\}/g;
+function hasNonCoreScope(template) {
+  return (template.match(PLACEHOLDER_RE) ?? []).some((m) => {
+    const name = m.slice(1, -1);
+    return name.startsWith("item.") || name.startsWith("result.");
+  });
+}
+function resolveTemplate(template, params, element) {
+  if (hasNonCoreScope(template)) {
+    return template.replace(PLACEHOLDER_RE, (match) => {
+      const name = match.slice(1, -1);
+      if (name.startsWith("item.")) {
+        const field = name.slice("item.".length);
+        if (!element || !(field in element)) {
+          throw new Error(
+            `declarative transaction: element field '${field}' is not bound; template '${template}' is only valid inside a forEach over the array param that supplies '${field}'.`
+          );
+        }
+        return String(element[field]);
+      }
+      if (!(name in params) || params[name] === void 0 || params[name] === null) {
+        throw new Error(
+          `declarative transaction: template '${template}' references unbound parameter '${name}'.`
+        );
+      }
+      return String(params[name]);
+    });
+  }
+  try {
+    return renderTemplate(template, toSharedParams(params));
+  } catch (exc) {
+    if (exc instanceof TemplateFailure && exc.code === "UNBOUND_PARAM") {
+      throw new Error(`declarative transaction: ${exc.message}.`);
+    }
+    throw exc;
+  }
+}
+function isWholePlaceholder(template) {
+  return /^\{[^{}]+\}$/.test(template);
+}
+function resolveValue(template, params, element) {
+  if (typeof template !== "string") return template;
+  if (isWholePlaceholder(template)) {
+    const name = template.slice(1, -1);
+    if (name.startsWith("item.")) {
+      const field = name.slice("item.".length);
+      if (element && field in element) return element[field];
+    } else if (name in params) {
+      return params[name];
+    }
+  }
+  return resolveTemplate(template, params, element);
+}
+function resolveRecord(record, params, element) {
+  const out = {};
+  for (const [field, tmpl] of Object.entries(record ?? {})) {
+    out[field] = resolveValue(tmpl, params, element);
+  }
+  return out;
+}
+function fillKeyTemplate(template, item) {
+  return template.replace(PLACEHOLDER_RE, (match) => {
+    const name = match.slice(1, -1);
+    return item[name] === void 0 ? "" : String(item[name]);
+  });
+}
+function keyTemplateFillable(template, item) {
+  const matches = template.match(PLACEHOLDER_RE) ?? [];
+  return matches.every((m) => m.slice(1, -1) in item);
+}
+function addKeyAttributes(entity, item) {
+  if (entity.key) {
+    item.PK = fillKeyTemplate(entity.key.pkTemplate, item);
+    if (entity.key.skTemplate !== null) {
+      item.SK = fillKeyTemplate(entity.key.skTemplate, item);
+    }
+  }
+  for (const gsi of entity.gsis) {
+    if (keyTemplateFillable(gsi.pkTemplate, item)) {
+      item[`${gsi.indexName}PK`] = fillKeyTemplate(gsi.pkTemplate, item);
+    }
+    if (gsi.skTemplate !== null && keyTemplateFillable(gsi.skTemplate, item)) {
+      item[`${gsi.indexName}SK`] = fillKeyTemplate(gsi.skTemplate, item);
+    }
+  }
+}
+function whenHolds(when, params, element) {
+  const left = resolveTemplate(when.left, params, element);
+  const right = resolveTemplate(when.right, params, element);
+  return when.op === "eq" ? left === right : left !== right;
+}
+function resolveRawConditionValue(val, params, element) {
+  if (val !== null && typeof val === "object" && typeof val.$param === "string") {
+    return resolveValue(`{${val.$param}}`, params, element);
+  }
+  return val;
+}
+function applyCondition(condition, target, params, element) {
+  if (!condition) return;
+  const names = target.ExpressionAttributeNames ??= {};
+  if (condition.kind === "notExists") {
+    names["#pk"] = "PK";
+    target.ConditionExpression = "attribute_not_exists(#pk)";
+    return;
+  }
+  if (condition.kind === "attributeExists" || condition.kind === "attributeNotExists") {
+    const fn = condition.kind === "attributeExists" ? "attribute_exists" : "attribute_not_exists";
+    names["#ce"] = condition.field;
+    target.ConditionExpression = `${fn}(#ce)`;
+    return;
+  }
+  const values = target.ExpressionAttributeValues ??= {};
+  if (condition.kind === "raw") {
+    Object.assign(names, condition.names);
+    for (const [alias, val] of Object.entries(condition.values)) {
+      values[alias] = resolveRawConditionValue(val, params, element);
+    }
+    target.ConditionExpression = condition.expression;
+    return;
+  }
+  if (condition.kind === "scpExpr") {
+    throw new Error(
+      "declarative transaction: this runtime does not evaluate scpExpr write conditions yet (spec 1.2 expression vocabulary, issue #261); evaluation lands with Phase 3 S5 (#265). Refusing to execute the write with its condition ignored."
+    );
+  }
+  if (condition.kind === "expr") {
+    const concrete = resolveConditionTree(
+      condition.declarative,
+      (name) => resolveValue(`{${name}}`, params, element)
+    );
+    const compiled = buildConditionExpression(concrete);
+    Object.assign(names, compiled.names);
+    Object.assign(values, compiled.values);
+    target.ConditionExpression = compiled.expression;
+    return;
+  }
+  const clauses = [];
+  let i = 0;
+  for (const [field, tmpl] of Object.entries(condition.fields)) {
+    const n = `#e${i}`;
+    const v = `:e${i}`;
+    names[n] = field;
+    values[v] = resolveValue(tmpl, params, element);
+    clauses.push(`${n} = ${v}`);
+    i++;
+  }
+  target.ConditionExpression = clauses.join(" AND ");
+}
+function entityByName(manifest, name) {
+  const entity = manifest.entities[name];
+  if (!entity) {
+    throw new Error(`declarative transaction: unknown entity '${name}' in manifest.`);
+  }
+  return entity;
+}
+function physicalTableName(manifest, logical) {
+  return manifest.tables[logical]?.physicalName ?? logical;
+}
+function applyMaintainTransform(op, args, value) {
+  if (op === "identity") return value;
+  if (op === "preview") {
+    const n = args[0];
+    if (typeof n !== "number" || !Number.isInteger(n) || n <= 0) {
+      throw new Error(
+        `declarative transaction: a maintenance \`preview\` projection has a non-positive-integer length bound (${JSON.stringify(n)}).`
+      );
+    }
+    if (value === null || value === void 0) return value;
+    return String(value).slice(0, n);
+  }
+  throw new Error(
+    `declarative transaction: unknown maintenance projection op '${String(op)}' (expected 'identity' / 'preview').`
+  );
+}
+function buildMaintainProjection(maintain, params, element) {
+  const out = {};
+  for (const [attr, transform] of Object.entries(maintain.projection)) {
+    const value = resolveValue(`{${transform.inputField}}`, params, element);
+    out[attr] = applyMaintainTransform(transform.op, transform.args, value);
+  }
+  return out;
+}
+function buildMaintainUpdateItem(spec, maintain, table, key, params, element) {
+  const update = { TableName: table, Key: key };
+  if (maintain.kind === "counter") {
+    const counter = maintain.counter;
+    if (counter === void 0) {
+      throw new Error(
+        `declarative transaction: a 'counter' maintenance write on '${spec.entity}' has no \`counter\` payload.`
+      );
+    }
+    update.UpdateExpression = "ADD #a0 :a0";
+    update.ExpressionAttributeNames = { "#a0": counter.attribute };
+    update.ExpressionAttributeValues = {
+      ":a0": typeof counter.delta === "string" ? Number(counter.delta) : counter.delta
+    };
+    return { Update: update };
+  }
+  const projection = buildMaintainProjection(maintain, params, element);
+  if (maintain.kind === "collection") {
+    const field = maintain.collection?.field;
+    if (field === void 0) {
+      throw new Error(
+        `declarative transaction: a 'collection' maintenance write on '${spec.entity}' has no \`collection.field\`.`
+      );
+    }
+    update.UpdateExpression = "SET #c = list_append(if_not_exists(#c, :empty), :item)";
+    update.ExpressionAttributeNames = { "#c": field };
+    update.ExpressionAttributeValues = { ":empty": [], ":item": [projection] };
+  } else {
+    const names = {};
+    const values = {};
+    const sets = [];
+    let i = 0;
+    for (const [attr, value] of Object.entries(projection)) {
+      names[`#m${i}`] = attr;
+      values[`:m${i}`] = value;
+      sets.push(`#m${i} = :m${i}`);
+      i++;
+    }
+    if (sets.length === 0) {
+      throw new Error(
+        `declarative transaction: a 'snapshot' maintenance write on '${spec.entity}' has an empty projection.`
+      );
+    }
+    update.UpdateExpression = `SET ${sets.join(", ")}`;
+    update.ExpressionAttributeNames = names;
+    update.ExpressionAttributeValues = values;
+  }
+  return { Update: update };
+}
+function buildTransactItem(spec, manifest, params, element) {
+  const literal = spec.literalKey === true;
+  const entity = literal ? void 0 : entityByName(manifest, spec.entity);
+  const table = literal ? physicalTableName(manifest, spec.tableName) : entity.physicalName;
+  if (spec.type === "Put") {
+    const item = resolveRecord(spec.item, params, element);
+    if (entity) addKeyAttributes(entity, item);
+    const put = { TableName: table, Item: item };
+    applyCondition(spec.condition, put, params, element);
+    return { Put: put };
+  }
+  const key = resolveRecord(spec.keyCondition, params, element);
+  if (spec.type === "Delete") {
+    const del = { TableName: table, Key: key };
+    applyCondition(spec.condition, del, params, element);
+    return { Delete: del };
+  }
+  if (spec.type === "ConditionCheck") {
+    if (!spec.condition) {
+      throw new Error(
+        `declarative transaction: ConditionCheck on '${spec.entity}' has no condition; a ConditionCheck must carry the assertion it makes.`
+      );
+    }
+    const check = { TableName: table, Key: key };
+    applyCondition(spec.condition, check, params, element);
+    return { ConditionCheck: check };
+  }
+  if (spec.maintain !== void 0) {
+    return buildMaintainUpdateItem(spec, spec.maintain, table, key, params, element);
+  }
+  const changes = resolveRecord(spec.changes, params, element);
+  const adds = resolveRecord(spec.add, params, element);
+  const names = {};
+  const values = {};
+  const sets = [];
+  const addClauses = [];
+  let i = 0;
+  for (const [field, value] of Object.entries(changes)) {
+    const n = `#c${i}`;
+    const v = `:c${i}`;
+    names[n] = field;
+    values[v] = value;
+    sets.push(`${n} = ${v}`);
+    i++;
+  }
+  let j = 0;
+  for (const [field, value] of Object.entries(adds)) {
+    const n = `#a${j}`;
+    const v = `:a${j}`;
+    names[n] = field;
+    values[v] = typeof value === "string" ? Number(value) : value;
+    addClauses.push(`${n} ${v}`);
+    j++;
+  }
+  const update = { TableName: table, Key: key };
+  const exprParts = [];
+  if (sets.length > 0) exprParts.push("SET " + sets.join(", "));
+  if (addClauses.length > 0) exprParts.push("ADD " + addClauses.join(", "));
+  if (exprParts.length > 0) {
+    update.UpdateExpression = exprParts.join(" ");
+    update.ExpressionAttributeNames = names;
+    update.ExpressionAttributeValues = values;
+  }
+  applyCondition(spec.condition, update, params, element);
+  return { Update: update };
+}
+function expandTransactionItems(spec, manifest, params) {
+  const expanded = [];
+  const emit = (item, element) => {
+    const model = item.literalKey === true || item.entity === MARKER_ROW_ENTITY ? void 0 : item.entity;
+    expanded.push({ item: buildTransactItem(item, manifest, params, element), model });
+  };
+  for (const item of spec.items) {
+    if (item.forEach) {
+      const source = params[item.forEach.source];
+      if (!Array.isArray(source)) {
+        throw new Error(
+          `declarative transaction: forEach source '${item.forEach.source}' must be an array param; got ${typeof source}.`
+        );
+      }
+      for (const element of source) {
+        if (item.when && !whenHolds(item.when, params, element)) continue;
+        if (item.guard !== void 0 && !evaluateGuard(item.guard, params, element, "declarative transaction guard"))
+          continue;
+        emit(item, element);
+      }
+    } else {
+      if (item.when && !whenHolds(item.when, params, void 0)) continue;
+      if (item.guard !== void 0 && !evaluateGuard(item.guard, params, void 0, "declarative transaction guard"))
+        continue;
+      emit(item, void 0);
+    }
+  }
+  return expanded;
+}
+
+// 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(map) {
+  const out = {};
+  for (const [field, bind] of Object.entries(map ?? {})) out[field] = slotOfBind(bind);
+  return out;
+}
+function bindValues(slots, params) {
+  const out = {};
+  for (const [field, slot] of Object.entries(slots)) {
+    out[field] = 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(plan, planId) {
+  const classes = /* @__PURE__ */ new Map();
+  const entities = {};
+  const tables = {};
+  for (const [name, expected] of Object.entries(plan.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}, live ${actual}). 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 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 = serializeEffectParams([op.modelClass], 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", upsert: "put" };
+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(plan, planId) {
+  const { classes } = bindEntities(plan, planId);
+  const routes = (plan.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(plan, planId) {
+  const { classes, manifest } = bindEntities(plan, planId);
+  const ops = (plan.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) {
+    if (doc.formatVersion === "1") {
+      throw new Error(
+        `${LOAD_LABEL}: this artifact uses prepared-plan format version '1' (generated by graphddb <= 0.7.2). This runtime speaks format '${PREPARED_FORMAT_VERSION}' (the entity fingerprints changed algorithm), so the artifact must be regenerated with the transform: \`graphddb transform prepared --aot <artifact> --write\`.`
+      );
+    }
+    throw new Error(
+      `${LOAD_LABEL}: unsupported artifact format version '${String(doc.formatVersion)}' (this runtime supports '${PREPARED_FORMAT_VERSION}'). Regenerate the artifact: \`graphddb transform prepared --aot <artifact> --write\`.`
+    );
+  }
+  try {
+    validateEnvelope(doc, SPEC_VERSION_SUPPORTED, { field: "specVersion", label: LOAD_LABEL });
+  } catch (exc) {
+    if (exc instanceof EnvelopeFailure) {
+      throw new Error(
+        `${LOAD_LABEL}: the artifact was compiled against operation-IR version '${String(doc.specVersion)}' but this runtime speaks '${SPEC_VERSION_SUPPORTED}'. A version-skewed static plan never executes \u2014 regenerate the artifact.`
+      );
+    }
+    throw exc;
+  }
+  const plan = doc.plans[planId];
+  if (plan === 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 plan.kind === "read" ? bindReadPlan(plan, planId) : bindWritePlan(plan, 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);
+}
+export {
+  AotPreparedWriteStatement,
+  loadPreparedPlan
+};