graphddb 0.7.9 → 0.8.0

package/dist/{chunk-PFFPLD4B.js → chunk-L2NEDS7U.js}

@@ -4,10 +4,8 @@ import {
   createColumnMap,
   createDefaultLinter,
   isColumn,
-  isKeyDefinition,
-  resolveKey,
-  segmentFieldNames
-} from "./chunk-PDUVTYC5.js";
+  isKeyDefinition
+} from "./chunk-XTWXMOHD.js";
 
 // src/decorators/gsi.ts
 var GSI_MARKER = /* @__PURE__ */ Symbol("graphddb:gsi");
@@ -172,146 +170,6 @@ ${messages}`);
   }
 };
 
-// src/types/select-builder.ts
-var SELECT_BUILDER = /* @__PURE__ */ Symbol.for("graphddb.selectBuilder");
-var SELECT_SPEC = /* @__PURE__ */ Symbol.for("graphddb.selectSpec");
-
-// src/select/builder.ts
-var BuilderImpl = class _BuilderImpl {
-  [SELECT_BUILDER] = true;
-  /** The resolved spec, exposed (non-method) so normalizers can read it. */
-  [SELECT_SPEC];
-  constructor(spec) {
-    this[SELECT_SPEC] = spec;
-  }
-  clone(patch) {
-    return new _BuilderImpl({ ...this[SELECT_SPEC], ...patch });
-  }
-  filter(filter) {
-    return this.clone({ filter });
-  }
-  limit(limit) {
-    return this.clone({ limit });
-  }
-  after(cursor) {
-    return this.clone({ after: cursor });
-  }
-  order(order) {
-    return this.clone({ order });
-  }
-};
-function isSelectBuilder(value) {
-  return typeof value === "object" && value !== null && value[SELECT_BUILDER] === true;
-}
-function fromBuilder(value) {
-  const spec = value[SELECT_SPEC];
-  return {
-    select: spec.select,
-    filter: spec.filter,
-    limit: spec.limit,
-    after: spec.after,
-    order: spec.order
-  };
-}
-function normalizeSelectSpec(value) {
-  if (isSelectBuilder(value)) {
-    return fromBuilder(value);
-  }
-  const obj = value;
-  return {
-    select: obj.select,
-    filter: obj.filter,
-    limit: obj.limit,
-    after: obj.after,
-    order: obj.order
-  };
-}
-function normalizeTopLevelSelect(value) {
-  if (isSelectBuilder(value)) {
-    return fromBuilder(value);
-  }
-  return { select: value ?? {} };
-}
-function buildProject(select) {
-  return new BuilderImpl({
-    [SELECT_BUILDER]: true,
-    select
-  });
-}
-function buildRelation(select) {
-  return new BuilderImpl({
-    [SELECT_BUILDER]: true,
-    select
-  });
-}
-
-// src/relation/detect.ts
-function isRelationSpec(value) {
-  if (typeof value !== "object" || value === null) return false;
-  return "select" in value || isSelectBuilder(value);
-}
-function isInlineSnapshotSpec(value) {
-  return typeof value === "object" && value !== null && !isSelectBuilder(value) && value.inline === true && !("select" in value);
-}
-function detectRelationFields(select, metadata) {
-  const result = [];
-  for (const [fieldName, value] of Object.entries(select)) {
-    if (isRelationSpec(value)) {
-      const rel = metadata.relations.find((r) => r.propertyName === fieldName);
-      if (rel) {
-        result.push(rel);
-      }
-    }
-  }
-  return result;
-}
-function validateInlineSnapshotSelect(select, metadata, resolveTargetMeta) {
-  for (const [fieldName, value] of Object.entries(select)) {
-    if (isInlineSnapshotSpec(value)) {
-      const rel = metadata.relations.find((r) => r.propertyName === fieldName);
-      if (!rel) {
-        throw new Error(
-          `Inline read '{ ${fieldName}: { inline: true } }' is only valid on an embeddedSnapshot relation, but '${fieldName}' is not a relation on '${metadata.prefix}'. Use '${fieldName}: true' for a scalar / embedded field.`
-        );
-      }
-      if (rel.options?.pattern !== "embeddedSnapshot") {
-        throw new Error(
-          `Inline read '{ ${fieldName}: { inline: true } }' is only valid on an embeddedSnapshot relation. '${fieldName}' is a plain '${rel.type}' relation (no 'pattern: embeddedSnapshot'); use '{ ${fieldName}: { select: \u2026 } }' to traverse to its child rows instead.`
-        );
-      }
-      continue;
-    }
-    if (typeof value === "object" && value !== null && isRelationSpec(value)) {
-      const rel = metadata.relations.find((r) => r.propertyName === fieldName);
-      if (!rel) continue;
-      const targetMeta = resolveTargetMeta(rel);
-      const nested = normalizeSelectSpec(value).select;
-      if (nested) {
-        validateInlineSnapshotSelect(nested, targetMeta, resolveTargetMeta);
-      }
-    }
-  }
-}
-function getImplicitKeyFields(select, metadata) {
-  const relations = detectRelationFields(select, metadata);
-  const needed = /* @__PURE__ */ new Set();
-  for (const rel of relations) {
-    if (rel.type === "refs" && rel.refs) {
-      const listField = rel.refs.from;
-      if (!(listField in select) || select[listField] !== true) {
-        needed.add(listField);
-      }
-      continue;
-    }
-    for (const sourceField of Object.values(rel.keyBinding)) {
-      if (!(sourceField in select) || select[sourceField] !== true) {
-        needed.add(sourceField);
-      }
-    }
-  }
-  return [...needed];
-}
-
 // src/define/param.ts
 function isParamOptions(value) {
   return typeof value === "object" && value !== null;
@@ -456,6 +314,194 @@ async function batchWriteChunkWithRetry(docClient, tableName, entries, toCommand
   }
 }
 
+// src/executor/batch-executor.ts
+async function executeBatchGet(docClient, operation) {
+  if (operation.keys.length === 0) {
+    return { items: [] };
+  }
+  const chunks = chunkArray(operation.keys, BATCH_GET_MAX_KEYS);
+  const chunkResults = await Promise.all(
+    chunks.map(
+      (chunk) => batchGetChunkWithRetry(docClient, operation.tableName, {
+        Keys: chunk,
+        ...operation.projectionExpression ? { ProjectionExpression: operation.projectionExpression } : {},
+        ...operation.expressionAttributeNames ? { ExpressionAttributeNames: operation.expressionAttributeNames } : {},
+        ...operation.consistentRead ? { ConsistentRead: true } : {}
+      })
+    )
+  );
+  const allItems = [];
+  for (const chunkItems of chunkResults) {
+    allItems.push(...chunkItems);
+  }
+  return { items: allItems };
+}
+
+// src/executor/dynamo-executor.ts
+var DynamoExecutor = class {
+  async execute(operation, _options) {
+    const docClient = await ClientManager.getDocumentClient();
+    if (operation.type === "GetItem") {
+      return executeGetItem(docClient, operation);
+    }
+    if (operation.type === "BatchGetItem") {
+      return this.batchGet(operation);
+    }
+    return executeQuery(docClient, operation);
+  }
+  async batchGet(input, _options) {
+    const docClient = await ClientManager.getDocumentClient();
+    return executeBatchGet(docClient, { type: "BatchGetItem", ...input });
+  }
+  async put(input, options) {
+    const docClient = await ClientManager.getDocumentClient();
+    const { PutCommand } = await loadLibDynamoDB();
+    const result = await docClient.send(
+      new PutCommand(
+        options?.returnOldImage ? { ...input, ReturnValues: "ALL_OLD" } : input
+      )
+    );
+    return toWriteResult(result);
+  }
+  async update(input, options) {
+    const docClient = await ClientManager.getDocumentClient();
+    const { UpdateCommand } = await loadLibDynamoDB();
+    const result = await docClient.send(
+      new UpdateCommand(
+        options?.returnOldImage ? { ...input, ReturnValues: "ALL_OLD" } : input
+      )
+    );
+    return toWriteResult(result);
+  }
+  async delete(input, options) {
+    const docClient = await ClientManager.getDocumentClient();
+    const { DeleteCommand } = await loadLibDynamoDB();
+    const result = await docClient.send(
+      new DeleteCommand(
+        options?.returnOldImage ? { ...input, ReturnValues: "ALL_OLD" } : input
+      )
+    );
+    return toWriteResult(result);
+  }
+  async batchWrite(tableName, items, _options) {
+    const docClient = await ClientManager.getDocumentClient();
+    for (const chunk of chunkArray(items, BATCH_WRITE_MAX_ITEMS)) {
+      await batchWriteChunkWithRetry(
+        docClient,
+        tableName,
+        chunk,
+        toBatchWriteCommandItem,
+        matchUnprocessed
+      );
+    }
+  }
+  async transactWrite(items, _options) {
+    if (items.length === 0) return;
+    const docClient = await ClientManager.getDocumentClient();
+    const { TransactWriteCommand } = await loadLibDynamoDB();
+    await docClient.send(
+      new TransactWriteCommand({ TransactItems: items })
+    );
+  }
+};
+function toWriteResult(result) {
+  const oldItem = result.Attributes;
+  return oldItem ? { oldItem } : {};
+}
+function toBatchWriteCommandItem(item) {
+  if (item.type === "put") {
+    return { PutRequest: { Item: item.item } };
+  }
+  return { DeleteRequest: { Key: item.key } };
+}
+function matchUnprocessed(unprocessed, items) {
+  return unprocessed.map((u) => {
+    if (u.PutRequest?.Item) {
+      const { PK, SK } = u.PutRequest.Item;
+      const match = items.find(
+        (it) => it.type === "put" && it.item.PK === PK && it.item.SK === SK
+      );
+      if (!match) {
+        throw new Error("Unable to match unprocessed BatchWrite put request");
+      }
+      return match;
+    }
+    if (u.DeleteRequest?.Key) {
+      const { PK, SK } = u.DeleteRequest.Key;
+      const match = items.find(
+        (it) => it.type === "delete" && it.key.PK === PK && it.key.SK === SK
+      );
+      if (!match) {
+        throw new Error("Unable to match unprocessed BatchWrite delete request");
+      }
+      return match;
+    }
+    throw new Error("Unsupported unprocessed BatchWrite request shape");
+  });
+}
+async function executeGetItem(docClient, operation) {
+  const { GetCommand } = await loadLibDynamoDB();
+  const cmd = new GetCommand({
+    TableName: operation.tableName,
+    Key: operation.keyCondition,
+    ...operation.projectionExpression ? { ProjectionExpression: operation.projectionExpression } : {},
+    ...operation.expressionAttributeNames ? { ExpressionAttributeNames: operation.expressionAttributeNames } : {},
+    ...operation.consistentRead ? { ConsistentRead: true } : {}
+  });
+  const result = await docClient.send(cmd);
+  if (result.Item) {
+    return { items: [result.Item] };
+  }
+  return { items: [] };
+}
+async function executeQuery(docClient, operation) {
+  const { QueryCommand } = await loadLibDynamoDB();
+  const keyEntries = Object.entries(operation.keyCondition);
+  const conditionParts = [];
+  const exprAttrNames = {
+    ...operation.expressionAttributeNames ?? {},
+    ...operation.filterExpressionAttributeNames ?? {}
+  };
+  const exprAttrValues = {
+    ...operation.filterExpressionAttributeValues ?? {}
+  };
+  for (let i = 0; i < keyEntries.length; i++) {
+    const [attrName, value] = keyEntries[i];
+    const nameAlias2 = `#k${i}`;
+    const valueAlias2 = `:k${i}`;
+    exprAttrNames[nameAlias2] = attrName;
+    exprAttrValues[valueAlias2] = value;
+    conditionParts.push(`${nameAlias2} = ${valueAlias2}`);
+  }
+  if (operation.rangeCondition) {
+    const rc = operation.rangeCondition;
+    const idx = keyEntries.length;
+    const nameAlias2 = `#k${idx}`;
+    const valueAlias2 = `:k${idx}`;
+    exprAttrNames[nameAlias2] = rc.key;
+    exprAttrValues[valueAlias2] = rc.value;
+    conditionParts.push(`begins_with(${nameAlias2}, ${valueAlias2})`);
+  }
+  const cmd = new QueryCommand({
+    TableName: operation.tableName,
+    KeyConditionExpression: conditionParts.join(" AND "),
+    ExpressionAttributeNames: exprAttrNames,
+    ExpressionAttributeValues: exprAttrValues,
+    ...operation.indexName ? { IndexName: operation.indexName } : {},
+    ...operation.filterExpression ? { FilterExpression: operation.filterExpression } : {},
+    ...operation.projectionExpression ? { ProjectionExpression: operation.projectionExpression } : {},
+    ...operation.scanIndexForward != null ? { ScanIndexForward: operation.scanIndexForward } : {},
+    ...operation.limit != null ? { Limit: operation.limit } : {},
+    ...operation.exclusiveStartKey ? { ExclusiveStartKey: operation.exclusiveStartKey } : {},
+    ...operation.consistentRead ? { ConsistentRead: true } : {}
+  });
+  const result = await docClient.send(cmd);
+  return {
+    items: result.Items ?? [],
+    lastEvaluatedKey: result.LastEvaluatedKey
+  };
+}
+
 // src/executor/retry-policy.ts
 var DEFAULT_MAX_ATTEMPTS = 10;
 var DEFAULT_RETRY_POLICY = {
@@ -595,7 +641,7 @@ var RetryingExecutor = class {
   /**
    * @param inner the wrapped executor (the real {@link DynamoExecutor}).
    * @param getGlobalPolicy reads the globally-configured policy (or `null` for the
-   *   built-in default) at CALL time, so a `DDBModel.setRetryPolicy(...)` after the
+   *   built-in default) at CALL time, so a `graphddb.config.retry(...)` after the
    *   executor is constructed still takes effect.
    */
   constructor(inner, getGlobalPolicy) {
@@ -675,7 +721,7 @@ var ClientManager = class {
   /**
    * The globally-configured single-op retry policy (issue #111). `null` ⇒ the
    * always-on built-in {@link DEFAULT_RETRY_POLICY} applies (retry is enabled out
-   * of the box). Set via {@link DDBModel.setRetryPolicy} / {@link setRetryPolicy};
+   * of the box). Set via `graphddb.config.retry` / {@link setRetryPolicy};
    * read at call time by the default {@link RetryingExecutor}.
    */
   static retryPolicy = null;
@@ -683,7 +729,7 @@ var ClientManager = class {
    * The host-runtime read-middleware registry (issue #50 / #138) — a process-wide
    * ordered list of {@link Middleware}, the same global-config + injectable-seam
    * pattern as {@link retryPolicy} / {@link executor}. Registered via
-   * {@link DDBModel.use} / {@link use}, snapshotted per read, and NEVER serialized
+   * `graphddb.config.use` / {@link use}, snapshotted per read, and NEVER serialized
    * (it never touches the planner / spec / `operations.json`, so the bridge #48 is
    * unaffected). {@link reset} clears it.
    */
@@ -695,7 +741,7 @@ var ClientManager = class {
   static getClient() {
     if (!this.client) {
       throw new Error(
-        "DynamoDB client is not configured. Call DDBModel.setClient(new DynamoDBClient({...})) first."
+        "DynamoDB client is not configured. Call graphddb.config.client(new DynamoDBClient({...})) first."
       );
     }
     return this.client;
@@ -757,12 +803,12 @@ var ClientManager = class {
   /**
    * Register a read {@link Middleware} (issue #50 / #138). Appended last, so its
    * `before*` hooks run last (FIFO) and its `afterFetch` / `onError` hooks run
-   * first (LIFO). Mirrors {@link setRetryPolicy}; backs {@link DDBModel.use}.
+   * first (LIFO). Mirrors {@link setRetryPolicy}; backs `graphddb.config.use`.
    */
   static use(mw) {
     this.middleware.use(mw);
   }
-  /** Remove every registered read middleware (teardown / tests). Backs {@link DDBModel.clearMiddleware}. */
+  /** Remove every registered read middleware (teardown / tests). Backs `graphddb.config.clearMiddleware`. */
   static clearMiddleware() {
     this.middleware.clear();
   }
@@ -785,194 +831,6 @@ var ClientManager = class {
   }
 };
 
-// src/executor/batch-executor.ts
-async function executeBatchGet(docClient, operation) {
-  if (operation.keys.length === 0) {
-    return { items: [] };
-  }
-  const chunks = chunkArray(operation.keys, BATCH_GET_MAX_KEYS);
-  const chunkResults = await Promise.all(
-    chunks.map(
-      (chunk) => batchGetChunkWithRetry(docClient, operation.tableName, {
-        Keys: chunk,
-        ...operation.projectionExpression ? { ProjectionExpression: operation.projectionExpression } : {},
-        ...operation.expressionAttributeNames ? { ExpressionAttributeNames: operation.expressionAttributeNames } : {},
-        ...operation.consistentRead ? { ConsistentRead: true } : {}
-      })
-    )
-  );
-  const allItems = [];
-  for (const chunkItems of chunkResults) {
-    allItems.push(...chunkItems);
-  }
-  return { items: allItems };
-}
-
-// src/executor/dynamo-executor.ts
-var DynamoExecutor = class {
-  async execute(operation, _options) {
-    const docClient = await ClientManager.getDocumentClient();
-    if (operation.type === "GetItem") {
-      return executeGetItem(docClient, operation);
-    }
-    if (operation.type === "BatchGetItem") {
-      return this.batchGet(operation);
-    }
-    return executeQuery(docClient, operation);
-  }
-  async batchGet(input, _options) {
-    const docClient = await ClientManager.getDocumentClient();
-    return executeBatchGet(docClient, { type: "BatchGetItem", ...input });
-  }
-  async put(input, options) {
-    const docClient = await ClientManager.getDocumentClient();
-    const { PutCommand } = await loadLibDynamoDB();
-    const result = await docClient.send(
-      new PutCommand(
-        options?.returnOldImage ? { ...input, ReturnValues: "ALL_OLD" } : input
-      )
-    );
-    return toWriteResult(result);
-  }
-  async update(input, options) {
-    const docClient = await ClientManager.getDocumentClient();
-    const { UpdateCommand } = await loadLibDynamoDB();
-    const result = await docClient.send(
-      new UpdateCommand(
-        options?.returnOldImage ? { ...input, ReturnValues: "ALL_OLD" } : input
-      )
-    );
-    return toWriteResult(result);
-  }
-  async delete(input, options) {
-    const docClient = await ClientManager.getDocumentClient();
-    const { DeleteCommand } = await loadLibDynamoDB();
-    const result = await docClient.send(
-      new DeleteCommand(
-        options?.returnOldImage ? { ...input, ReturnValues: "ALL_OLD" } : input
-      )
-    );
-    return toWriteResult(result);
-  }
-  async batchWrite(tableName, items, _options) {
-    const docClient = await ClientManager.getDocumentClient();
-    for (const chunk of chunkArray(items, BATCH_WRITE_MAX_ITEMS)) {
-      await batchWriteChunkWithRetry(
-        docClient,
-        tableName,
-        chunk,
-        toBatchWriteCommandItem,
-        matchUnprocessed
-      );
-    }
-  }
-  async transactWrite(items, _options) {
-    if (items.length === 0) return;
-    const docClient = await ClientManager.getDocumentClient();
-    const { TransactWriteCommand } = await loadLibDynamoDB();
-    await docClient.send(
-      new TransactWriteCommand({ TransactItems: items })
-    );
-  }
-};
-function toWriteResult(result) {
-  const oldItem = result.Attributes;
-  return oldItem ? { oldItem } : {};
-}
-function toBatchWriteCommandItem(item) {
-  if (item.type === "put") {
-    return { PutRequest: { Item: item.item } };
-  }
-  return { DeleteRequest: { Key: item.key } };
-}
-function matchUnprocessed(unprocessed, items) {
-  return unprocessed.map((u) => {
-    if (u.PutRequest?.Item) {
-      const { PK, SK } = u.PutRequest.Item;
-      const match = items.find(
-        (it) => it.type === "put" && it.item.PK === PK && it.item.SK === SK
-      );
-      if (!match) {
-        throw new Error("Unable to match unprocessed BatchWrite put request");
-      }
-      return match;
-    }
-    if (u.DeleteRequest?.Key) {
-      const { PK, SK } = u.DeleteRequest.Key;
-      const match = items.find(
-        (it) => it.type === "delete" && it.key.PK === PK && it.key.SK === SK
-      );
-      if (!match) {
-        throw new Error("Unable to match unprocessed BatchWrite delete request");
-      }
-      return match;
-    }
-    throw new Error("Unsupported unprocessed BatchWrite request shape");
-  });
-}
-async function executeGetItem(docClient, operation) {
-  const { GetCommand } = await loadLibDynamoDB();
-  const cmd = new GetCommand({
-    TableName: operation.tableName,
-    Key: operation.keyCondition,
-    ...operation.projectionExpression ? { ProjectionExpression: operation.projectionExpression } : {},
-    ...operation.expressionAttributeNames ? { ExpressionAttributeNames: operation.expressionAttributeNames } : {},
-    ...operation.consistentRead ? { ConsistentRead: true } : {}
-  });
-  const result = await docClient.send(cmd);
-  if (result.Item) {
-    return { items: [result.Item] };
-  }
-  return { items: [] };
-}
-async function executeQuery(docClient, operation) {
-  const { QueryCommand } = await loadLibDynamoDB();
-  const keyEntries = Object.entries(operation.keyCondition);
-  const conditionParts = [];
-  const exprAttrNames = {
-    ...operation.expressionAttributeNames ?? {},
-    ...operation.filterExpressionAttributeNames ?? {}
-  };
-  const exprAttrValues = {
-    ...operation.filterExpressionAttributeValues ?? {}
-  };
-  for (let i = 0; i < keyEntries.length; i++) {
-    const [attrName, value] = keyEntries[i];
-    const nameAlias2 = `#k${i}`;
-    const valueAlias2 = `:k${i}`;
-    exprAttrNames[nameAlias2] = attrName;
-    exprAttrValues[valueAlias2] = value;
-    conditionParts.push(`${nameAlias2} = ${valueAlias2}`);
-  }
-  if (operation.rangeCondition) {
-    const rc = operation.rangeCondition;
-    const idx = keyEntries.length;
-    const nameAlias2 = `#k${idx}`;
-    const valueAlias2 = `:k${idx}`;
-    exprAttrNames[nameAlias2] = rc.key;
-    exprAttrValues[valueAlias2] = rc.value;
-    conditionParts.push(`begins_with(${nameAlias2}, ${valueAlias2})`);
-  }
-  const cmd = new QueryCommand({
-    TableName: operation.tableName,
-    KeyConditionExpression: conditionParts.join(" AND "),
-    ExpressionAttributeNames: exprAttrNames,
-    ExpressionAttributeValues: exprAttrValues,
-    ...operation.indexName ? { IndexName: operation.indexName } : {},
-    ...operation.filterExpression ? { FilterExpression: operation.filterExpression } : {},
-    ...operation.projectionExpression ? { ProjectionExpression: operation.projectionExpression } : {},
-    ...operation.scanIndexForward != null ? { ScanIndexForward: operation.scanIndexForward } : {},
-    ...operation.limit != null ? { Limit: operation.limit } : {},
-    ...operation.exclusiveStartKey ? { ExclusiveStartKey: operation.exclusiveStartKey } : {},
-    ...operation.consistentRead ? { ConsistentRead: true } : {}
-  });
-  const result = await docClient.send(cmd);
-  return {
-    items: result.Items ?? [],
-    lastEvaluatedKey: result.LastEvaluatedKey
-  };
-}
-
 // src/select/cond.ts
 var RAW_COND = /* @__PURE__ */ Symbol.for("graphddb.rawCond");
 function isRawCondition(value) {
@@ -1038,17 +896,6 @@ function serializeRawCondition(raw, renderSlot) {
   }
   return { expression: out, names, values };
 }
-function collectRawConditionParams(raw) {
-  const out = [];
-  let paramIndex = 0;
-  for (const part of raw.parts) {
-    if (isColumn(part)) continue;
-    if (isParam(part)) {
-      out.push({ name: condParamName(paramIndex++), param: part });
-    }
-  }
-  return out;
-}
 
 // src/expression/condition-expression.ts
 var CONDITION_OPERATOR_KEYS = /* @__PURE__ */ new Set([
@@ -1298,69 +1145,6 @@ function serializeFieldValue(value, fieldMeta) {
   return value;
 }
 
-// src/expression/update-expression.ts
-function isPlainObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
-}
-function flattenChanges(obj, parentPath, embeddedFieldNames) {
-  const sets = [];
-  const removes = [];
-  for (const [fieldName, value] of Object.entries(obj)) {
-    const currentPath = [...parentPath, fieldName];
-    if (value === void 0) {
-      removes.push({ path: currentPath });
-    } else if (embeddedFieldNames.has(currentPath[0]) && isPlainObject(value)) {
-      const nested = flattenChanges(value, currentPath, embeddedFieldNames);
-      sets.push(...nested.sets);
-      removes.push(...nested.removes);
-    } else {
-      sets.push({ path: currentPath, value });
-    }
-  }
-  return { sets, removes };
-}
-function buildUpdateExpression(changes, embeddedFieldNames) {
-  const { sets, removes } = flattenChanges(changes, [], embeddedFieldNames);
-  if (sets.length === 0 && removes.length === 0) {
-    throw new Error("No changes provided for update.");
-  }
-  const names = {};
-  const values = {};
-  let valueCounter = 0;
-  const setClauses = [];
-  for (const op of sets) {
-    const pathExpr = op.path.map((segment) => {
-      const nameKey = `#${segment}`;
-      names[nameKey] = segment;
-      return nameKey;
-    }).join(".");
-    const valueKey = `:val${valueCounter++}`;
-    values[valueKey] = op.value;
-    setClauses.push(`${pathExpr} = ${valueKey}`);
-  }
-  const removeClauses = [];
-  for (const op of removes) {
-    const pathExpr = op.path.map((segment) => {
-      const nameKey = `#${segment}`;
-      names[nameKey] = segment;
-      return nameKey;
-    }).join(".");
-    removeClauses.push(pathExpr);
-  }
-  const parts = [];
-  if (setClauses.length > 0) {
-    parts.push(`SET ${setClauses.join(", ")}`);
-  }
-  if (removeClauses.length > 0) {
-    parts.push(`REMOVE ${removeClauses.join(", ")}`);
-  }
-  return {
-    expression: parts.join(" "),
-    names,
-    values
-  };
-}
-
 // src/metadata/segments.ts
 var SEGMENT_DELIMITER = "#";
 function segmentComplete(segment, values) {
@@ -1500,34 +1284,6 @@ function missingGsiFields(gsi2, available) {
   return gsi2.inputFieldNames.filter((f) => available[f] === void 0);
 }
 
-// src/hydrator/hidden-key.ts
-var GRAPHDDB_KEY = /* @__PURE__ */ Symbol("graphddb:key");
-function attachHiddenKey(result, raw) {
-  const pk = raw.PK;
-  if (typeof pk !== "string") {
-    throw new Error(
-      "Cannot attach updatable key: raw item is missing a string `PK` attribute."
-    );
-  }
-  const sk = raw.SK;
-  const value = {
-    PK: pk,
-    SK: typeof sk === "string" ? sk : ""
-  };
-  Object.defineProperty(result, GRAPHDDB_KEY, {
-    value,
-    enumerable: false,
-    writable: false,
-    configurable: false
-  });
-  return result;
-}
-function readHiddenKey(entity) {
-  const value = entity[GRAPHDDB_KEY];
-  if (value === void 0) return void 0;
-  return value;
-}
-
 // src/capture/registry.ts
 var ChangeCaptureRegistryImpl = class {
   subscribers = /* @__PURE__ */ new Set();
@@ -1869,102 +1625,187 @@ function ctxModelFor(modelClass) {
   return resolved;
 }
 
-// src/operations/put.ts
-function buildPutInput(modelClass, item, options) {
-  const meta = MetadataRegistry.get(modelClass);
-  if (!meta.primaryKey) {
+// src/expression/update-expression.ts
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date);
+}
+function flattenChanges(obj, parentPath, embeddedFieldNames) {
+  const sets = [];
+  const removes = [];
+  for (const [fieldName, value] of Object.entries(obj)) {
+    const currentPath = [...parentPath, fieldName];
+    if (value === void 0) {
+      removes.push({ path: currentPath });
+    } else if (embeddedFieldNames.has(currentPath[0]) && isPlainObject(value)) {
+      const nested = flattenChanges(value, currentPath, embeddedFieldNames);
+      sets.push(...nested.sets);
+      removes.push(...nested.removes);
+    } else {
+      sets.push({ path: currentPath, value });
+    }
+  }
+  return { sets, removes };
+}
+function buildUpdateExpression(changes, embeddedFieldNames) {
+  const { sets, removes } = flattenChanges(changes, [], embeddedFieldNames);
+  if (sets.length === 0 && removes.length === 0) {
+    throw new Error("No changes provided for update.");
+  }
+  const names = {};
+  const values = {};
+  let valueCounter = 0;
+  const setClauses = [];
+  for (const op of sets) {
+    const pathExpr = op.path.map((segment) => {
+      const nameKey = `#${segment}`;
+      names[nameKey] = segment;
+      return nameKey;
+    }).join(".");
+    const valueKey = `:val${valueCounter++}`;
+    values[valueKey] = op.value;
+    setClauses.push(`${pathExpr} = ${valueKey}`);
+  }
+  const removeClauses = [];
+  for (const op of removes) {
+    const pathExpr = op.path.map((segment) => {
+      const nameKey = `#${segment}`;
+      names[nameKey] = segment;
+      return nameKey;
+    }).join(".");
+    removeClauses.push(pathExpr);
+  }
+  const parts = [];
+  if (setClauses.length > 0) {
+    parts.push(`SET ${setClauses.join(", ")}`);
+  }
+  if (removeClauses.length > 0) {
+    parts.push(`REMOVE ${removeClauses.join(", ")}`);
+  }
+  return {
+    expression: parts.join(" "),
+    names,
+    values
+  };
+}
+
+// src/hydrator/hidden-key.ts
+var GRAPHDDB_KEY = /* @__PURE__ */ Symbol("graphddb:key");
+function attachHiddenKey(result, raw) {
+  const pk = raw.PK;
+  if (typeof pk !== "string") {
     throw new Error(
-      `No primary key defined for '${modelClass.name}'. Ensure the model has a static \`keys = key(...)\` definition.`
+      "Cannot attach updatable key: raw item is missing a string `PK` attribute."
     );
   }
-  const tableName = TableMapping.resolve(meta.tableName);
-  const serialized = {};
-  for (const fieldMeta of meta.fields) {
-    const value = item[fieldMeta.propertyName];
-    if (value !== void 0) {
-      serialized[fieldMeta.propertyName] = serializeFieldValue(value, fieldMeta);
-    }
+  const sk = raw.SK;
+  const value = {
+    PK: pk,
+    SK: typeof sk === "string" ? sk : ""
+  };
+  Object.defineProperty(result, GRAPHDDB_KEY, {
+    value,
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+  return result;
+}
+function readHiddenKey(entity) {
+  const value = entity[GRAPHDDB_KEY];
+  if (value === void 0) return void 0;
+  return value;
+}
+
+// src/operations/update.ts
+function resolveUpdateKey(modelClass, primaryKey, entity, fieldMap) {
+  const hidden = readHiddenKey(entity);
+  if (hidden) {
+    return { pk: hidden.PK, sk: hidden.SK };
+  }
+  const missing = primaryKey.inputFieldNames.filter(
+    (f) => entity[f] === void 0
+  );
+  if (missing.length > 0) {
+    const fieldList = missing.join(", ");
+    throw new Error(
+      `Cannot resolve update key for '${modelClass.name}': missing key field(s) [${fieldList}]. Provide an explicit key (update({ ${fieldList} }, changes)), select all key fields, or query with { updatable: true }.`
+    );
   }
   const keyInput = {};
-  for (const fieldName of meta.primaryKey.inputFieldNames) {
-    keyInput[fieldName] = serialized[fieldName] ?? item[fieldName];
+  for (const fieldName of primaryKey.inputFieldNames) {
+    let value = entity[fieldName];
+    const fieldMeta = fieldMap.get(fieldName);
+    if (fieldMeta && value !== void 0) {
+      value = serializeFieldValue(value, fieldMeta);
+    }
+    keyInput[fieldName] = value;
   }
   const { pk, sk } = resolveSegmentedKey(
-    meta.primaryKey.segmented,
+    primaryKey.segmented,
     keyInput,
     `${modelClass.name} primary key`
   );
-  const dynamoItem = {
-    PK: pk,
-    SK: sk ?? "",
-    ...serialized
-  };
-  for (const emb of meta.embeddedFields) {
-    const value = item[emb.propertyName];
-    if (value !== void 0) {
-      dynamoItem[emb.propertyName] = value;
-    }
-  }
+  return { pk, sk: sk ?? "" };
+}
+function buildGsiRederiveSets(modelClass, meta, entity, serializedChanges, fieldMap, names, values, options) {
+  const changedFields = new Set(Object.keys(serializedChanges));
+  const affected = affectedGsis(meta, changedFields);
+  if (affected.length === 0) return [];
   const available = {};
-  for (const fieldName of meta.fields.map((f) => f.propertyName)) {
-    available[fieldName] = serialized[fieldName] ?? item[fieldName];
+  for (const [fieldName, raw] of Object.entries(entity)) {
+    if (raw === void 0) continue;
+    const fm = fieldMap.get(fieldName);
+    available[fieldName] = fm ? serializeFieldValue(raw, fm) : raw;
   }
-  for (const gsi2 of meta.gsiDefinitions) {
-    const { pkAttr, pk: gsiPk, skAttr, sk: gsiSk } = deriveGsiKey(
+  Object.assign(available, serializedChanges);
+  const clauses = [];
+  let i = 0;
+  for (const gsi2 of affected) {
+    const missing = missingGsiFields(gsi2, available);
+    if (missing.length > 0) {
+      if (options?.rederive === "read-modify-write") continue;
+      const changed = gsi2.inputFieldNames.filter((f) => changedFields.has(f));
+      throw new Error(
+        `Cannot update '${modelClass.name}': updating ${fmtFields(changed)} affects index '${gsi2.indexName}' (also depends on ${fmtFields(missing)}); provide ${missing.length > 1 ? "them" : "it"}, or use { rederive: 'read-modify-write' }.`
+      );
+    }
+    const { pkAttr, pk, skAttr, sk } = deriveGsiKey(
       gsi2,
       available,
       `${modelClass.name} GSI '${gsi2.indexName}'`
     );
-    dynamoItem[pkAttr] = gsiPk;
-    dynamoItem[skAttr] = gsiSk;
-  }
-  const putInput = {
-    TableName: tableName,
-    Item: dynamoItem
-  };
-  if (options?.condition) {
-    const condResult = buildConditionExpression(options.condition);
-    putInput.ConditionExpression = condResult.expression;
-    if (Object.keys(condResult.names).length > 0) {
-      putInput.ExpressionAttributeNames = condResult.names;
-    }
-    if (Object.keys(condResult.values).length > 0) {
-      putInput.ExpressionAttributeValues = condResult.values;
-    }
+    const pkN = `#gsi${i}pk`;
+    const pkV = `:gsi${i}pk`;
+    names[pkN] = pkAttr;
+    values[pkV] = pk;
+    clauses.push(`${pkN} = ${pkV}`);
+    const skN = `#gsi${i}sk`;
+    const skV = `:gsi${i}sk`;
+    names[skN] = skAttr;
+    values[skV] = sk;
+    clauses.push(`${skN} = ${skV}`);
+    i++;
   }
-  return putInput;
+  return clauses;
 }
-async function executePut(modelClass, item, options) {
-  const mw = writeRuntimeFor(options);
-  if (mw) {
-    await executeSingleWriteWithHooks({ kind: "put", modelClass, item, options }, mw);
-    return;
-  }
-  await executePutCore(modelClass, item, options);
+function fmtFields(fields) {
+  return fields.map((f) => `'${f}'`).join(", ");
 }
-async function executePutCore(modelClass, item, options, persistVia, forceOldImage) {
-  const putInput = buildPutInput(modelClass, item, options);
-  const wantsOld = ChangeCaptureRegistry.wantsOldImage(modelClass) || forceOldImage === true;
-  const send = (input) => ClientManager.getExecutor().put(input, {
-    ...wantsOld ? { returnOldImage: true } : {},
-    ...options?.retry !== void 0 ? { retry: options.retry } : {}
-  });
-  const result = persistVia ? await persistVia(putInput, send) : await send(putInput);
-  if (ChangeCaptureRegistry.hasSubscribers()) {
-    const oldItem = result.oldItem;
-    captureWrite({
-      table: putInput.TableName,
-      model: modelClass.name,
-      op: "put",
-      keys: { pk: String(putInput.Item.PK), sk: String(putInput.Item.SK ?? "") },
-      newItem: putInput.Item,
-      ...oldItem ? { oldItem } : {}
-    });
+function appendSetClauses(expression, clauses) {
+  if (clauses.length === 0) return expression;
+  const extra = clauses.join(", ");
+  if (/(^|\s)SET\s/.test(expression)) {
+    const removeIdx = expression.indexOf(" REMOVE ");
+    if (removeIdx === -1) {
+      return `${expression}, ${extra}`;
+    }
+    const setPart = expression.slice(0, removeIdx);
+    const rest = expression.slice(removeIdx);
+    return `${setPart}, ${extra}${rest}`;
   }
+  return `SET ${extra} ${expression}`.trimEnd();
 }
-
-// src/operations/delete.ts
-function buildDeleteInput(modelClass, keyObj, options) {
+function buildUpdateInput(modelClass, entity, changes, options) {
   const meta = MetadataRegistry.get(modelClass);
   if (!meta.primaryKey) {
     throw new Error(
@@ -1975,259 +1816,12 @@ function buildDeleteInput(modelClass, keyObj, options) {
   const fieldMap = new Map(
     meta.fields.map((f) => [f.propertyName, f])
   );
-  const keyInput = {};
-  for (const fieldName of meta.primaryKey.inputFieldNames) {
-    let value = keyObj[fieldName];
+  for (const fieldName of Object.keys(changes)) {
     const fieldMeta = fieldMap.get(fieldName);
-    if (fieldMeta && value !== void 0) {
-      value = serializeFieldValue(value, fieldMeta);
-    }
-    keyInput[fieldName] = value;
-  }
-  const { pk, sk } = resolveSegmentedKey(
-    meta.primaryKey.segmented,
-    keyInput,
-    `${modelClass.name} primary key`
-  );
-  const deleteInput = {
-    TableName: tableName,
-    Key: {
-      PK: pk,
-      SK: sk ?? ""
-    }
-  };
-  if (options?.condition) {
-    const condResult = buildConditionExpression(options.condition);
-    deleteInput.ConditionExpression = condResult.expression;
-    if (Object.keys(condResult.names).length > 0) {
-      deleteInput.ExpressionAttributeNames = condResult.names;
-    }
-    if (Object.keys(condResult.values).length > 0) {
-      deleteInput.ExpressionAttributeValues = condResult.values;
-    }
-  }
-  return deleteInput;
-}
-async function executeDelete(modelClass, keyObj, options) {
-  const mw = writeRuntimeFor(options);
-  if (mw) {
-    await executeSingleWriteWithHooks({ kind: "delete", modelClass, key: keyObj, options }, mw);
-    return;
-  }
-  await executeDeleteCore(modelClass, keyObj, options);
-}
-async function executeDeleteCore(modelClass, keyObj, options, persistVia, forceOldImage) {
-  const deleteInput = buildDeleteInput(modelClass, keyObj, options);
-  const wantsOld = ChangeCaptureRegistry.wantsOldImage(modelClass) || forceOldImage === true;
-  const send = (input) => ClientManager.getExecutor().delete(input, {
-    ...wantsOld ? { returnOldImage: true } : {},
-    ...options?.retry !== void 0 ? { retry: options.retry } : {}
-  });
-  const result = persistVia ? await persistVia(deleteInput, send) : await send(deleteInput);
-  if (ChangeCaptureRegistry.hasSubscribers()) {
-    const oldItem = result.oldItem;
-    captureWrite({
-      table: deleteInput.TableName,
-      model: modelClass.name,
-      op: "delete",
-      keys: { pk: String(deleteInput.Key.PK), sk: String(deleteInput.Key.SK ?? "") },
-      ...oldItem ? { oldItem } : {}
-    });
-  }
-}
-
-// src/operations/write-hooks.ts
-function writeRuntimeFor(options) {
-  const mw = buildWriteRuntime(options?.context);
-  return mw.active ? mw : void 0;
-}
-async function executeSingleWriteWithHooks(req, mw) {
-  const input = {};
-  if (req.item !== void 0) input.item = { ...req.item };
-  if (req.key !== void 0) input.key = { ...req.key };
-  if (req.changes !== void 0) input.changes = { ...req.changes };
-  if (req.options !== void 0) input.options = { ...req.options };
-  const ctx = mw.writeCtx(req.kind, ctxModelFor(req.modelClass), input);
-  try {
-    await mw.runWriteBefore(ctx);
-    const change2 = await persistRewrittenWrite(req.modelClass, ctx, mw);
-    await mw.runWriteAfter(ctx, change2);
-  } catch (err) {
-    await mw.runWriteError(ctx, err);
-  }
-}
-async function persistRewrittenWrite(modelClass, ctx, mw) {
-  const opts = ctx.input.options;
-  const origin = { model: ctx.model, kind: ctx.kind };
-  const forceOldImage = mw.hasWriteAfter;
-  const cap = {};
-  if (ctx.kind === "put") {
-    await executePutCore(
-      modelClass,
-      ctx.input.item ?? {},
-      opts,
-      (input, send) => runPersist(mw, { Put: input }, origin, cap, (it) => {
-        const put = it.Put;
-        cap.newImage = put.Item;
-        return send(put);
-      }),
-      forceOldImage
-    );
-    return change(cap, true);
-  }
-  if (ctx.kind === "update") {
-    await executeUpdateCore(
-      modelClass,
-      ctx.input.key ?? {},
-      ctx.input.changes ?? {},
-      opts,
-      (input, send) => runPersist(mw, { Update: input }, origin, cap, (it) => {
-        const upd = it.Update;
-        const old = cap.result?.oldItem;
-        cap.newImage = { ...old ?? upd.Key, ...ctx.input.changes ?? {} };
-        return send(upd);
-      }),
-      forceOldImage
-    );
-    return change(cap, true);
-  }
-  await executeDeleteCore(
-    modelClass,
-    ctx.input.key ?? {},
-    opts,
-    (input, send) => runPersist(
-      mw,
-      { Delete: input },
-      origin,
-      cap,
-      (it) => send(it.Delete)
-    ),
-    forceOldImage
-  );
-  return change(cap, false);
-}
-function change(cap, withNew) {
-  const out = {};
-  const oldImage = cap.result?.oldItem;
-  if (oldImage !== void 0) out.oldImage = oldImage;
-  if (withNew && cap.newImage !== void 0) {
-    out.newImage = cap.newImage;
-  }
-  return out;
-}
-async function runPersist(mw, item, origin, cap, send) {
-  const ctx = mw.persistCtx([item], [origin]);
-  const result = await mw.runPersist(ctx, async (items) => send(items[0]));
-  cap.result = result;
-  return result;
-}
-
-// src/operations/update.ts
-function resolveUpdateKey(modelClass, primaryKey, entity, fieldMap) {
-  const hidden = readHiddenKey(entity);
-  if (hidden) {
-    return { pk: hidden.PK, sk: hidden.SK };
-  }
-  const missing = primaryKey.inputFieldNames.filter(
-    (f) => entity[f] === void 0
-  );
-  if (missing.length > 0) {
-    const fieldList = missing.join(", ");
-    throw new Error(
-      `Cannot resolve update key for '${modelClass.name}': missing key field(s) [${fieldList}]. Provide an explicit key (update({ ${fieldList} }, changes)), select all key fields, or query with { updatable: true }.`
-    );
-  }
-  const keyInput = {};
-  for (const fieldName of primaryKey.inputFieldNames) {
-    let value = entity[fieldName];
-    const fieldMeta = fieldMap.get(fieldName);
-    if (fieldMeta && value !== void 0) {
-      value = serializeFieldValue(value, fieldMeta);
-    }
-    keyInput[fieldName] = value;
-  }
-  const { pk, sk } = resolveSegmentedKey(
-    primaryKey.segmented,
-    keyInput,
-    `${modelClass.name} primary key`
-  );
-  return { pk, sk: sk ?? "" };
-}
-function buildGsiRederiveSets(modelClass, meta, entity, serializedChanges, fieldMap, names, values, options) {
-  const changedFields = new Set(Object.keys(serializedChanges));
-  const affected = affectedGsis(meta, changedFields);
-  if (affected.length === 0) return [];
-  const available = {};
-  for (const [fieldName, raw] of Object.entries(entity)) {
-    if (raw === void 0) continue;
-    const fm = fieldMap.get(fieldName);
-    available[fieldName] = fm ? serializeFieldValue(raw, fm) : raw;
-  }
-  Object.assign(available, serializedChanges);
-  const clauses = [];
-  let i = 0;
-  for (const gsi2 of affected) {
-    const missing = missingGsiFields(gsi2, available);
-    if (missing.length > 0) {
-      if (options?.rederive === "read-modify-write") continue;
-      const changed = gsi2.inputFieldNames.filter((f) => changedFields.has(f));
-      throw new Error(
-        `Cannot update '${modelClass.name}': updating ${fmtFields(changed)} affects index '${gsi2.indexName}' (also depends on ${fmtFields(missing)}); provide ${missing.length > 1 ? "them" : "it"}, or use { rederive: 'read-modify-write' }.`
-      );
-    }
-    const { pkAttr, pk, skAttr, sk } = deriveGsiKey(
-      gsi2,
-      available,
-      `${modelClass.name} GSI '${gsi2.indexName}'`
-    );
-    const pkN = `#gsi${i}pk`;
-    const pkV = `:gsi${i}pk`;
-    names[pkN] = pkAttr;
-    values[pkV] = pk;
-    clauses.push(`${pkN} = ${pkV}`);
-    const skN = `#gsi${i}sk`;
-    const skV = `:gsi${i}sk`;
-    names[skN] = skAttr;
-    values[skV] = sk;
-    clauses.push(`${skN} = ${skV}`);
-    i++;
-  }
-  return clauses;
-}
-function fmtFields(fields) {
-  return fields.map((f) => `'${f}'`).join(", ");
-}
-function appendSetClauses(expression, clauses) {
-  if (clauses.length === 0) return expression;
-  const extra = clauses.join(", ");
-  if (/(^|\s)SET\s/.test(expression)) {
-    const removeIdx = expression.indexOf(" REMOVE ");
-    if (removeIdx === -1) {
-      return `${expression}, ${extra}`;
-    }
-    const setPart = expression.slice(0, removeIdx);
-    const rest = expression.slice(removeIdx);
-    return `${setPart}, ${extra}${rest}`;
-  }
-  return `SET ${extra} ${expression}`.trimEnd();
-}
-function buildUpdateInput(modelClass, entity, changes, options) {
-  const meta = MetadataRegistry.get(modelClass);
-  if (!meta.primaryKey) {
-    throw new Error(
-      `No primary key defined for '${modelClass.name}'. Ensure the model has a static \`keys = key(...)\` definition.`
-    );
-  }
-  const tableName = TableMapping.resolve(meta.tableName);
-  const fieldMap = new Map(
-    meta.fields.map((f) => [f.propertyName, f])
-  );
-  for (const fieldName of Object.keys(changes)) {
-    const fieldMeta = fieldMap.get(fieldName);
-    if (fieldMeta?.options?.readonly) {
-      throw new Error(
-        `Cannot update readonly field '${fieldName}' on '${modelClass.name}'. Readonly fields can only be set during put.`
-      );
+    if (fieldMeta?.options?.readonly) {
+      throw new Error(
+        `Cannot update readonly field '${fieldName}' on '${modelClass.name}'. Readonly fields can only be set during put.`
+      );
     }
   }
   const { pk, sk } = resolveUpdateKey(
@@ -2400,1391 +1994,448 @@ async function executeUpdateCore(modelClass, entity, changes, options, persistVi
   }
 }
 
-// src/runtime/same-key-collapse.ts
-function collapseSameKey(items, view) {
-  const groups = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    const sig = view.keySignature(item);
-    const bucket = groups.get(sig);
-    if (bucket === void 0) groups.set(sig, [item]);
-    else bucket.push(item);
-  }
-  const replacement = /* @__PURE__ */ new Map();
-  const dropped = /* @__PURE__ */ new Set();
-  for (const bucket of groups.values()) {
-    if (bucket.length === 1) continue;
-    const kinds = new Set(bucket.map((it) => view.kind(it)));
-    if (kinds.size === 2 && kinds.has("Delete") && kinds.has("Put")) {
-      for (const it of bucket) dropped.add(it);
-      continue;
-    }
-    if (kinds.size === 2 && kinds.has("Put") && kinds.has("Update")) {
-      throw new Error(
-        `Contract runtime: a derived counter (\`increment\`) resolves to the SAME item as the entity write at runtime (the call-time key values made an aliased target coincide with the written row). A Put+Update on one transaction item is unsupported \u2014 DynamoDB rejects touching one key twice, and collapsing it would silently drop the increment. A \`w.increment(...)\` must target a DIFFERENT row (e.g. a parent aggregate's counter); to maintain a counter ON the written entity, write the field as part of the entity itself, not via a derived counter onto its own row.`
-      );
-    }
-    if (kinds.size === 1 && kinds.has("Update")) {
-      replacement.set(bucket[0], view.mergeAdds(bucket));
-      for (const it of bucket.slice(1)) dropped.add(it);
-      continue;
-    }
-    if (kinds.size === 1 && (kinds.has("Put") || kinds.has("Delete"))) {
-      for (const it of bucket.slice(1)) dropped.add(it);
-      continue;
-    }
+// src/operations/delete.ts
+function buildDeleteInput(modelClass, keyObj, options) {
+  const meta = MetadataRegistry.get(modelClass);
+  if (!meta.primaryKey) {
     throw new Error(
-      `Contract runtime: ${bucket.length} transaction items resolve to the same physical row with an unsupported op combination (${[...kinds].sort().join("+")}). A TransactWriteItems may not touch one key twice; this collision is not a known collapse shape (self-row Put/Delete de-dup, swap no-op, or symmetric counter ADDs), so it is rejected rather than silently collapsed.`
-    );
-  }
-  const out = [];
-  for (const item of items) {
-    if (dropped.has(item)) continue;
-    out.push(replacement.get(item) ?? item);
-  }
-  return out;
-}
-
-// src/runtime/transaction-commit.ts
-var MAX_TRANSACT_ITEMS = 25;
-var execItemCollapseView = {
-  kind: execItemKind,
-  keySignature: execItemKeySignature,
-  mergeAdds: mergeAddUpdates
-};
-function collapseSameKeyItems(items) {
-  return collapseSameKey(items, execItemCollapseView);
-}
-async function commitTransaction(items, options = {}) {
-  const collapsed = collapseSameKeyItems(items);
-  if (collapsed.length === 0) return collapsed;
-  if (collapsed.length > MAX_TRANSACT_ITEMS) {
-    throw options.limitError ? options.limitError(collapsed.length) : new Error(
-      `Transaction exceeds DynamoDB limit of ${MAX_TRANSACT_ITEMS} items`
+      `No primary key defined for '${modelClass.name}'. Ensure the model has a static \`keys = key(...)\` definition.`
     );
   }
-  const sendBatch = (items2) => ClientManager.getExecutor().transactWrite(
-    items2,
-    options.retry !== void 0 ? { retry: options.retry } : void 0
+  const tableName = TableMapping.resolve(meta.tableName);
+  const fieldMap = new Map(
+    meta.fields.map((f) => [f.propertyName, f])
   );
-  let committed = collapsed;
-  if (options.middleware) {
-    const { runtime, origins, transaction } = options.middleware;
-    const persistCtx = runtime.persistCtx(collapsed, origins, transaction);
-    await runtime.runPersist(persistCtx, async (items2) => sendBatch(items2));
-    committed = persistCtx.items;
-  } else {
-    await sendBatch(collapsed);
-  }
-  captureTransactItems(committed, options.modelBySignature ?? EMPTY_MODEL_MAP);
-  return committed;
-}
-var EMPTY_MODEL_MAP = /* @__PURE__ */ new Map();
-function captureTransactItems(items, modelBySignature) {
-  if (!ChangeCaptureRegistry.hasSubscribers()) return;
-  for (const item of items) {
-    if ("ConditionCheck" in item) continue;
-    captureWrite(captureMetaForItem(item, modelBySignature));
-  }
-}
-function captureMetaForItem(item, modelBySignature) {
-  const model = modelBySignature.get(execItemKeySignature(item));
-  const labelled = model !== void 0 ? { model } : {};
-  if ("Put" in item) {
-    const Item = item.Put.Item;
-    return {
-      table: item.Put.TableName,
-      ...labelled,
-      op: "put",
-      keys: { pk: String(Item.PK), sk: String(Item.SK ?? "") },
-      newItem: Item
-    };
-  }
-  if ("Update" in item) {
-    return {
-      table: item.Update.TableName,
-      ...labelled,
-      op: "update",
-      keys: { pk: String(item.Update.Key.PK), sk: String(item.Update.Key.SK ?? "") }
-    };
+  const keyInput = {};
+  for (const fieldName of meta.primaryKey.inputFieldNames) {
+    let value = keyObj[fieldName];
+    const fieldMeta = fieldMap.get(fieldName);
+    if (fieldMeta && value !== void 0) {
+      value = serializeFieldValue(value, fieldMeta);
+    }
+    keyInput[fieldName] = value;
   }
-  return {
-    table: item.Delete.TableName,
-    ...labelled,
-    op: "delete",
-    keys: { pk: String(item.Delete.Key.PK), sk: String(item.Delete.Key.SK ?? "") }
+  const { pk, sk } = resolveSegmentedKey(
+    meta.primaryKey.segmented,
+    keyInput,
+    `${modelClass.name} primary key`
+  );
+  const deleteInput = {
+    TableName: tableName,
+    Key: {
+      PK: pk,
+      SK: sk ?? ""
+    }
   };
-}
-function execItemKeySignature(item) {
-  const part = (rec) => `${String(rec?.PK ?? "")}#${String(rec?.SK ?? "")}`;
-  if ("Put" in item) return `${item.Put.TableName}#${part(item.Put.Item)}`;
-  if ("Update" in item) return `${item.Update.TableName}#${part(item.Update.Key)}`;
-  if ("Delete" in item) return `${item.Delete.TableName}#${part(item.Delete.Key)}`;
-  return `${item.ConditionCheck.TableName}#${part(item.ConditionCheck.Key)}`;
-}
-function execItemKind(item) {
-  if ("Put" in item) return "Put";
-  if ("Update" in item) return "Update";
-  if ("Delete" in item) return "Delete";
-  return "ConditionCheck";
-}
-function mergeAddUpdates(updates) {
-  const first = updates[0];
-  if (!("Update" in first)) {
-    throw new Error("Contract runtime: mergeAddUpdates received a non-Update item.");
-  }
-  const deltas = /* @__PURE__ */ new Map();
-  for (const it of updates) {
-    if (!("Update" in it)) {
-      throw new Error("Contract runtime: cannot merge a non-Update item into an ADD.");
+  if (options?.condition) {
+    const condResult = buildConditionExpression(options.condition);
+    deleteInput.ConditionExpression = condResult.expression;
+    if (Object.keys(condResult.names).length > 0) {
+      deleteInput.ExpressionAttributeNames = condResult.names;
     }
-    const names2 = it.Update.ExpressionAttributeNames ?? {};
-    const values2 = it.Update.ExpressionAttributeValues ?? {};
-    for (const [namePlaceholder, attr] of Object.entries(names2)) {
-      const valuePlaceholder = `:${namePlaceholder.slice(1)}`;
-      const delta = values2[valuePlaceholder];
-      if (typeof delta !== "number") {
-        throw new Error(
-          `Contract runtime: cannot merge same-key counter updates \u2014 an ADD delta on '${attr}' is not numeric.`
-        );
-      }
-      deltas.set(attr, (deltas.get(attr) ?? 0) + delta);
+    if (Object.keys(condResult.values).length > 0) {
+      deleteInput.ExpressionAttributeValues = condResult.values;
     }
   }
-  const names = {};
-  const values = {};
-  const clauses = [];
-  let i = 0;
-  for (const [attr, delta] of deltas) {
-    names[`#a${i}`] = attr;
-    values[`:a${i}`] = delta;
-    clauses.push(`#a${i} :a${i}`);
-    i++;
-  }
-  const merged = {
-    TableName: first.Update.TableName,
-    Key: first.Update.Key,
-    UpdateExpression: `ADD ${clauses.join(", ")}`,
-    ExpressionAttributeNames: names,
-    ExpressionAttributeValues: values
-  };
-  return { Update: merged };
-}
-
-// src/operations/transaction.ts
-var MODEL_CLASS_KEY = /* @__PURE__ */ Symbol.for("graphddb.modelClass");
-function attachModelClass(modelStatic, modelClass) {
-  Object.defineProperty(modelStatic, MODEL_CLASS_KEY, {
-    value: modelClass,
-    enumerable: false,
-    configurable: false,
-    writable: false
-  });
-  return modelStatic;
+  return deleteInput;
 }
-function resolveModelClass(model) {
-  const modelClass = model[MODEL_CLASS_KEY];
-  if (!modelClass) {
-    throw new Error(
-      "Invalid model reference. Use ModelStatic from DDBModel.asModel()."
-    );
+async function executeDelete(modelClass, keyObj, options) {
+  const mw = writeRuntimeFor(options);
+  if (mw) {
+    await executeSingleWriteWithHooks({ kind: "delete", modelClass, key: keyObj, options }, mw);
+    return;
   }
-  return modelClass;
+  await executeDeleteCore(modelClass, keyObj, options);
 }
-var TransactionContext = class {
-  items = [];
-  captureMeta = [];
-  /**
-   * The logical write ops, parallel to {@link items} but EXCLUDING `conditionCheck`
-   * entries (those are read-only assertions, recorded only in `items`). Used by the
-   * write-hook path (#139) to run W1 on each logical op and recompose the batch.
-   * A `null` entry marks an `items` slot that has no logical op (a ConditionCheck),
-   * so the eager and logical arrays can be re-aligned at commit.
-   */
-  logicalOps = [];
-  get itemCount() {
-    return this.items.length;
-  }
-  put(model, item, options) {
-    this.assertWithinLimit();
-    const modelClass = resolveModelClass(model);
-    const putInput = buildPutInput(modelClass, item, options);
-    this.items.push({ Put: putInput });
-    this.logicalOps.push({ kind: "put", modelClass, item, options });
-    this.captureMeta.push({
-      modelName: modelClass.name,
-      op: "put",
-      table: putInput.TableName,
-      keys: { pk: String(putInput.Item.PK), sk: String(putInput.Item.SK ?? "") },
-      newItem: putInput.Item
-    });
-  }
-  update(model, entity, changes, options) {
-    this.assertWithinLimit();
-    const modelClass = resolveModelClass(model);
-    const updateInput = buildUpdateInput(modelClass, entity, changes, options);
-    this.items.push({ Update: updateInput });
-    this.logicalOps.push({ kind: "update", modelClass, key: entity, changes, options });
-    this.captureMeta.push({
-      modelName: modelClass.name,
-      op: "update",
-      table: updateInput.TableName,
-      keys: { pk: String(updateInput.Key.PK), sk: String(updateInput.Key.SK ?? "") }
-    });
-  }
-  delete(model, key, options) {
-    this.assertWithinLimit();
-    const modelClass = resolveModelClass(model);
-    const deleteInput = buildDeleteInput(modelClass, key, options);
-    this.items.push({ Delete: deleteInput });
-    this.logicalOps.push({ kind: "delete", modelClass, key, options });
-    this.captureMeta.push({
-      modelName: modelClass.name,
-      op: "delete",
+async function executeDeleteCore(modelClass, keyObj, options, persistVia, forceOldImage) {
+  const deleteInput = buildDeleteInput(modelClass, keyObj, options);
+  const wantsOld = ChangeCaptureRegistry.wantsOldImage(modelClass) || forceOldImage === true;
+  const send = (input) => ClientManager.getExecutor().delete(input, {
+    ...wantsOld ? { returnOldImage: true } : {},
+    ...options?.retry !== void 0 ? { retry: options.retry } : {}
+  });
+  const result = persistVia ? await persistVia(deleteInput, send) : await send(deleteInput);
+  if (ChangeCaptureRegistry.hasSubscribers()) {
+    const oldItem = result.oldItem;
+    captureWrite({
       table: deleteInput.TableName,
-      keys: { pk: String(deleteInput.Key.PK), sk: String(deleteInput.Key.SK ?? "") }
-    });
-  }
-  /**
-   * Add a read-only `ConditionCheck` assertion on a keyed item (issue #81). The
-   * item is **not** mutated; the `options.condition` (e.g.
-   * `{ attributeExists: 'PK' }` to require the row exists) is asserted, and a
-   * failed assertion cancels the **whole** `TransactWriteItems` atomically. This
-   * is the foundation for referential-integrity derivation (proposal: `requires
-   * <Entity> exists`). A ConditionCheck emits no change-capture record (it writes
-   * nothing).
-   *
-   * @throws if `options.condition` is missing — a ConditionCheck without an
-   *   assertion is meaningless.
-   */
-  conditionCheck(model, key, options) {
-    if (!options || !options.condition) {
-      throw new Error(
-        "TransactionContext.conditionCheck requires a `condition` (the read-only assertion it makes); e.g. `{ condition: { attributeExists: 'PK' } }`."
-      );
-    }
-    this.assertWithinLimit();
-    const modelClass = resolveModelClass(model);
-    const { TableName, Key } = buildDeleteInput(modelClass, key);
-    const cond2 = buildConditionExpression(options.condition);
-    const check = {
-      TableName,
-      Key,
-      ConditionExpression: cond2.expression
-    };
-    if (Object.keys(cond2.names).length > 0) {
-      check.ExpressionAttributeNames = cond2.names;
-    }
-    if (Object.keys(cond2.values).length > 0) {
-      check.ExpressionAttributeValues = cond2.values;
-    }
-    this.items.push({ ConditionCheck: check });
-    this.logicalOps.push(null);
-  }
-  /** @internal */
-  getTransactItems() {
-    return this.items;
-  }
-  /** @internal — the recorded logical write ops (issue #139 W1), `null` per ConditionCheck slot. */
-  getLogicalOps() {
-    return this.logicalOps;
-  }
-  /** @internal — capture descriptors for the write-capture seam (issue #72). */
-  getCaptureMeta() {
-    return this.captureMeta;
-  }
-  assertWithinLimit() {
-    if (this.items.length >= MAX_TRANSACT_ITEMS) {
-      throw new Error(
-        `Transaction exceeds DynamoDB limit of ${MAX_TRANSACT_ITEMS} items`
-      );
-    }
-  }
-};
-async function executeTransaction(fn, options) {
-  const tx = new TransactionContext();
-  await fn(tx);
-  let transactItems = tx.getTransactItems();
-  if (transactItems.length === 0) {
-    return;
-  }
-  const writeMw = buildWriteRuntime(options?.context);
-  if (writeMw.active) {
-    const txId = { id: /* @__PURE__ */ Symbol("graphddb.transaction") };
-    const logical = tx.getLogicalOps();
-    const items = [...transactItems];
-    const origins = [];
-    const writeCtxs = [];
-    const modelBySignature2 = /* @__PURE__ */ new Map();
-    for (let i = 0; i < logical.length; i++) {
-      const op = logical[i];
-      if (op === null) continue;
-      const input = {};
-      if (op.item !== void 0) input.item = { ...op.item };
-      if (op.key !== void 0) input.key = { ...op.key };
-      if (op.changes !== void 0) input.changes = { ...op.changes };
-      if (op.options !== void 0) input.options = { ...op.options };
-      const ctx = writeMw.writeCtx(op.kind, ctxModelFor(op.modelClass), input, txId);
-      await writeMw.runWriteBefore(ctx);
-      const built = buildLogicalItem(op.modelClass, ctx);
-      items[i] = built;
-      modelBySignature2.set(execItemKeySignature(built), op.modelClass.name);
-      origins.push({ model: ctx.model, kind: ctx.kind });
-      writeCtxs.push(ctx);
-    }
-    transactItems = items;
-    await commitTransaction(transactItems, {
-      modelBySignature: modelBySignature2,
-      middleware: { runtime: writeMw, origins, transaction: txId }
+      model: modelClass.name,
+      op: "delete",
+      keys: { pk: String(deleteInput.Key.PK), sk: String(deleteInput.Key.SK ?? "") },
+      ...oldItem ? { oldItem } : {}
     });
-    for (let j = writeCtxs.length - 1; j >= 0; j--) {
-      await writeMw.runWriteAfter(writeCtxs[j], {});
-    }
-    return;
   }
-  const modelBySignature = /* @__PURE__ */ new Map();
-  for (const meta of tx.getCaptureMeta()) {
-    if (meta.modelName) {
-      modelBySignature.set(
-        `${meta.table}#${meta.keys.pk}#${meta.keys.sk}`,
-        meta.modelName
-      );
-    }
-  }
-  await commitTransaction(transactItems, {
-    modelBySignature
-  });
-}
-function buildLogicalItem(modelClass, ctx) {
-  const opts = ctx.input.options;
-  if (ctx.kind === "put") {
-    return { Put: buildPutInput(modelClass, ctx.input.item ?? {}, opts) };
-  }
-  if (ctx.kind === "update") {
-    return {
-      Update: buildUpdateInput(modelClass, ctx.input.key ?? {}, ctx.input.changes ?? {}, opts)
-    };
-  }
-  return { Delete: buildDeleteInput(modelClass, ctx.input.key ?? {}, opts) };
 }
 
-// src/hydrator/hydrator.ts
-function hydrate(rawItems, select, metadata, updatable = false) {
-  return rawItems.map((item) => hydrateItem(item, select, metadata, updatable));
-}
-function hydrateItem(raw, select, metadata, updatable = false) {
-  const fieldMap = new Map(
-    metadata.fields.map((f) => [f.propertyName, f])
-  );
-  const embeddedMap = new Map(
-    metadata.embeddedFields.map((e) => [e.propertyName, e])
-  );
-  const result = {};
-  for (const [fieldName, selectValue] of Object.entries(select)) {
-    if (selectValue === true) {
-      const value = raw[fieldName];
-      if (value !== void 0) {
-        const fieldMeta = fieldMap.get(fieldName);
-        result[fieldName] = deserializeValue(value, fieldMeta);
-      }
-    } else if (isInlineSnapshotSpec(selectValue)) {
-      const value = raw[fieldName];
-      if (value !== void 0) {
-        result[fieldName] = value;
-      }
-    } else if (typeof selectValue === "object" && selectValue !== null) {
-      if ("select" in selectValue || isSelectBuilder(selectValue)) {
-        continue;
-      }
-      const rawEmb = raw[fieldName];
-      if (rawEmb && typeof rawEmb === "object") {
-        result[fieldName] = hydrateEmbedded(
-          rawEmb,
-          selectValue,
-          metadata,
-          fieldName
-        );
-      }
-    }
-  }
-  if (updatable) {
-    attachHiddenKey(result, raw);
-  }
-  return result;
-}
-function hydrateEmbedded(raw, select, _metadata, _fieldName) {
-  const result = {};
-  for (const [key, selectValue] of Object.entries(select)) {
-    if (selectValue === true) {
-      if (raw[key] !== void 0) {
-        result[key] = raw[key];
-      }
-    } else if (typeof selectValue === "object" && selectValue !== null && !("select" in selectValue)) {
-      const nested = raw[key];
-      if (nested && typeof nested === "object") {
-        result[key] = hydrateEmbedded(
-          nested,
-          selectValue,
-          _metadata,
-          key
-        );
-      }
-    }
-  }
-  return result;
-}
-function deserializeValue(value, fieldMeta) {
-  if (!fieldMeta) return value;
-  if (fieldMeta.options?.deserialize) {
-    return fieldMeta.options.deserialize(value);
-  }
-  if (fieldMeta.options?.format === "datetime" && typeof value === "string") {
-    return new Date(value);
-  }
-  if (fieldMeta.options?.format === "date" && typeof value === "string") {
-    return /* @__PURE__ */ new Date(value + "T00:00:00.000Z");
-  }
-  return value;
+// src/operations/write-hooks.ts
+function writeRuntimeFor(options) {
+  const mw = buildWriteRuntime(options?.context);
+  return mw.active ? mw : void 0;
 }
-
-// src/define/entity-writes.ts
-var MAINTAIN_TRIGGER_RE = /^[^.\s$[\]*]+\.(?:created|updated|removed)$/;
-function maintainTrigger(value) {
-  if (typeof value !== "string" || !MAINTAIN_TRIGGER_RE.test(value)) {
-    throw new Error(
-      `maintainTrigger: a maintenance trigger must be an \`Entity.event\` string where event is one of \`created\` / \`updated\` / \`removed\` (e.g. \`"Post.created"\`), but received ${JSON.stringify(value)}.`
-    );
+async function executeSingleWriteWithHooks(req, mw) {
+  const input = {};
+  if (req.item !== void 0) input.item = { ...req.item };
+  if (req.key !== void 0) input.key = { ...req.key };
+  if (req.changes !== void 0) input.changes = { ...req.changes };
+  if (req.options !== void 0) input.options = { ...req.options };
+  const ctx = mw.writeCtx(req.kind, ctxModelFor(req.modelClass), input);
+  try {
+    await mw.runWriteBefore(ctx);
+    const change2 = await persistRewrittenWrite(req.modelClass, ctx, mw);
+    await mw.runWriteAfter(ctx, change2);
+  } catch (err) {
+    await mw.runWriteError(ctx, err);
   }
-  return value;
 }
-function isMaintainTrigger(value) {
-  return typeof value === "string" && MAINTAIN_TRIGGER_RE.test(value);
-}
-function makeProjectionTransform(path, op, args) {
-  if (op === "preview") {
-    const [n] = args;
-    if (typeof n !== "number" || !Number.isInteger(n) || n <= 0) {
-      throw new Error(
-        `transform: the \`preview\` op requires a positive integer length bound (e.g. \`preview('$.body', 200)\`), but received ${JSON.stringify(n)}.`
-      );
-    }
-    return { kind: "transform", path, op, args: [n] };
+async function persistRewrittenWrite(modelClass, ctx, mw) {
+  const opts = ctx.input.options;
+  const origin = { model: ctx.model, kind: ctx.kind };
+  const forceOldImage = mw.hasWriteAfter;
+  const cap = {};
+  if (ctx.kind === "put") {
+    await executePutCore(
+      modelClass,
+      ctx.input.item ?? {},
+      opts,
+      (input, send) => runPersist(mw, { Put: input }, origin, cap, (it) => {
+        const put = it.Put;
+        cap.newImage = put.Item;
+        return send(put);
+      }),
+      forceOldImage
+    );
+    return change(cap, true);
   }
-  if (op === "identity") {
-    if (args.length > 0) {
-      throw new Error(
-        `transform: the \`identity\` op takes no arguments, but received ${JSON.stringify(args)}.`
-      );
-    }
-    return { kind: "transform", path, op, args: [] };
+  if (ctx.kind === "update") {
+    await executeUpdateCore(
+      modelClass,
+      ctx.input.key ?? {},
+      ctx.input.changes ?? {},
+      opts,
+      (input, send) => runPersist(mw, { Update: input }, origin, cap, (it) => {
+        const upd = it.Update;
+        const old = cap.result?.oldItem;
+        cap.newImage = { ...old ?? upd.Key, ...ctx.input.changes ?? {} };
+        return send(upd);
+      }),
+      forceOldImage
+    );
+    return change(cap, true);
   }
-  throw new Error(
-    `transform: unknown projection op ${JSON.stringify(op)} (expected \`identity\` or \`preview\`).`
+  await executeDeleteCore(
+    modelClass,
+    ctx.input.key ?? {},
+    opts,
+    (input, send) => runPersist(
+      mw,
+      { Delete: input },
+      origin,
+      cap,
+      (it) => send(it.Delete)
+    ),
+    forceOldImage
   );
+  return change(cap, false);
 }
-function pathOf(value) {
-  return typeof value === "string" ? value : value.path;
-}
-function preview(path, n) {
-  return makeProjectionTransform(pathOf(path), "preview", [n]);
-}
-function identity(path) {
-  return makeProjectionTransform(pathOf(path), "identity", []);
-}
-var LIFECYCLE_CONTRACT_MARKER = /* @__PURE__ */ Symbol(
-  "graphddb:lifecycleContract"
-);
-function isLifecycleContract(value) {
-  return typeof value === "object" && value !== null && value[LIFECYCLE_CONTRACT_MARKER] === true;
-}
-var ENTITY_WRITES_MARKER = /* @__PURE__ */ Symbol("graphddb:entityWrites");
-function isEntityWritesDefinition(value) {
-  return typeof value === "object" && value !== null && value[ENTITY_WRITES_MARKER] === true;
-}
-function freezeEffects(effects) {
+function change(cap, withNew) {
   const out = {};
-  if (effects.requires !== void 0) out.requires = effects.requires;
-  if (effects.unique !== void 0) out.unique = effects.unique;
-  if (effects.edges !== void 0) out.edges = effects.edges;
-  if (effects.derive !== void 0) out.derive = effects.derive;
-  if (effects.emits !== void 0) out.emits = effects.emits;
-  if (effects.idempotency !== void 0) out.idempotency = effects.idempotency;
+  const oldImage = cap.result?.oldItem;
+  if (oldImage !== void 0) out.oldImage = oldImage;
+  if (withNew && cap.newImage !== void 0) {
+    out.newImage = cap.newImage;
+  }
   return out;
 }
-var recorder = {
-  lifecycle(effects = {}) {
-    return {
-      [LIFECYCLE_CONTRACT_MARKER]: true,
-      effects: freezeEffects(effects)
-    };
-  },
-  exists(targetFactory, keys) {
-    return { kind: "requires", targetFactory, keys };
-  },
-  unique(spec) {
-    return { kind: "unique", name: spec.name, scope: spec.scope, fields: spec.fields };
-  },
-  putEdge(targetFactory, relationProperty) {
-    return { kind: "putEdge", targetFactory, relationProperty };
-  },
-  deleteEdge(targetFactory, relationProperty) {
-    return { kind: "deleteEdge", targetFactory, relationProperty };
-  },
-  dualEdge(forward, inverse) {
-    return {
-      kind: "putEdge",
-      targetFactory: forward.target,
-      relationProperty: forward.relationProperty,
-      inverse: {
-        adjacencyFactory: inverse.adjacency,
-        targetFactory: inverse.target,
-        relationProperty: inverse.relationProperty
-      }
-    };
-  },
-  increment(targetFactory, keys, attribute, amount) {
-    return { kind: "derive", targetFactory, keys, attribute, amount };
-  },
-  transform(path, op, ...args) {
-    return makeProjectionTransform(path, op, args);
-  },
-  event(name, payload) {
-    return { kind: "event", name, payload };
-  },
-  idempotentBy(token) {
-    return { kind: "idempotency", token };
-  }
-};
-function entityWrites(builder) {
-  const shape = builder(recorder);
-  for (const phase of ["create", "update", "remove"]) {
-    const contract = shape[phase];
-    if (contract !== void 0 && !isLifecycleContract(contract)) {
-      throw new Error(
-        `entityWrites: the '${phase}' lifecycle must be built with \`w.lifecycle({...})\` (it carries the \xA72 effect arrays), but received ${JSON.stringify(contract)}.`
-      );
-    }
-  }
-  if (shape.create === void 0 && shape.update === void 0 && shape.remove === void 0) {
+async function runPersist(mw, item, origin, cap, send) {
+  const ctx = mw.persistCtx([item], [origin]);
+  const result = await mw.runPersist(ctx, async (items) => send(items[0]));
+  cap.result = result;
+  return result;
+}
+
+// src/operations/put.ts
+function buildPutInput(modelClass, item, options) {
+  const meta = MetadataRegistry.get(modelClass);
+  if (!meta.primaryKey) {
     throw new Error(
-      "entityWrites(...) must declare at least one lifecycle (`create` / `update` / `remove`); an empty save contract declares nothing."
+      `No primary key defined for '${modelClass.name}'. Ensure the model has a static \`keys = key(...)\` definition.`
     );
   }
-  return {
-    [ENTITY_WRITES_MARKER]: true,
-    ...shape.create !== void 0 ? { create: shape.create } : {},
-    ...shape.update !== void 0 ? { update: shape.update } : {},
-    ...shape.remove !== void 0 ? { remove: shape.remove } : {}
-  };
-}
-function getEntityWrites(modelClass) {
-  for (const name of Object.getOwnPropertyNames(modelClass)) {
-    let value;
-    try {
-      value = modelClass[name];
-    } catch {
-      continue;
+  const tableName = TableMapping.resolve(meta.tableName);
+  const serialized = {};
+  for (const fieldMeta of meta.fields) {
+    const value = item[fieldMeta.propertyName];
+    if (value !== void 0) {
+      serialized[fieldMeta.propertyName] = serializeFieldValue(value, fieldMeta);
     }
-    if (isEntityWritesDefinition(value)) return value;
   }
-  return void 0;
-}
-function lifecyclePhaseForIntent(intent) {
-  return intent;
-}
-
-// src/relation/maintenance-view-adapter.ts
-function logicalNameOf(meta) {
-  return meta.prefix.endsWith("#") ? meta.prefix.slice(0, -1) : meta.prefix;
-}
-function resolveClass(factory) {
-  return factory();
-}
-function sourceLogicalName(sourceClass) {
-  const meta = MetadataRegistry.get(sourceClass);
-  return logicalNameOf(meta);
-}
-function triggersFor(sourceLogical, on) {
-  return on.map((ev) => `${sourceLogical}.${ev}`);
-}
-function assertNoCrossSliceCollision(viewName, decls) {
-  const projectionOwner = /* @__PURE__ */ new Map();
-  const collectionOwner = /* @__PURE__ */ new Map();
-  let keyFieldShape;
-  decls.forEach((d, idx) => {
-    for (const attr of Object.keys(d.project)) {
-      const prev = projectionOwner.get(attr);
-      if (prev !== void 0 && prev !== idx) {
-        throw new Error(
-          `View '${viewName}': projection target '${attr}' is maintained by more than one \`@maintainedFrom\` declaration. A view field must be filled by exactly one source \u2014 the declaration order carries no meaning, so this is ambiguous. Remove '${attr}' from one of the declarations (or split it onto a distinct view field).`
-        );
-      }
-      projectionOwner.set(attr, idx);
-    }
-    if (d.collectionField !== void 0) {
-      const prev = collectionOwner.get(d.collectionField);
-      if (prev !== void 0 && prev !== idx) {
-        throw new Error(
-          `View '${viewName}': collection field '${d.collectionField}' is maintained by more than one \`@maintainedFrom\` declaration. A maintained collection has exactly one source \u2014 split the second source onto a distinct collection field.`
-        );
-      }
-      collectionOwner.set(d.collectionField, idx);
-    }
-    const shape = Object.keys(d.keyBind).slice().sort().join(",");
-    if (keyFieldShape === void 0) {
-      keyFieldShape = shape;
-    } else if (keyFieldShape !== shape) {
-      throw new Error(
-        `View '${viewName}': \`@maintainedFrom\` declarations bind different view-key field SETS ([${keyFieldShape}] vs [${shape}]). All sources must resolve the SAME view row identity \u2014 they must bind the same set of view-key fields (the source field a given key reads from may differ per source, but the key SHAPE may not). A divergent key shape would split the row.`
-      );
-    }
-  });
-}
-function viewFromMaintainedFrom(viewClass, meta, kind) {
-  const viewName = viewClass.name ?? logicalNameOf(meta);
-  const decls = meta.maintainedFrom ?? [];
-  const pattern = kind === "sparseView" ? "sparseView" : "materializedView";
-  for (const d of decls) {
-    if (kind === "sparseView" && !d.when) {
-      throw new Error(
-        `View '${viewName}': \`kind: 'sparseView'\` requires every \`@maintainedFrom\` to declare a \`when\` membership predicate (e.g. \`whenMember(source.status, 'eq', 'active')\`) \u2014 the predicate decides PUT (holds) vs DELETE (flips false).`
-      );
-    }
-    if (kind !== "sparseView" && d.when) {
-      throw new Error(
-        `View '${viewName}': a \`@maintainedFrom\` declares a \`when\` membership predicate but the view \`kind\` is '${kind}'. Declare \`kind: 'sparseView'\` to maintain a predicate-gated put/delete row.`
-      );
-    }
+  const keyInput = {};
+  for (const fieldName of meta.primaryKey.inputFieldNames) {
+    keyInput[fieldName] = serialized[fieldName] ?? item[fieldName];
   }
-  assertNoCrossSliceCollision(
-    viewName,
-    decls.map((d) => ({
-      keyBind: d.keyBind,
-      project: d.project,
-      collectionField: d.collection?.field
-    }))
+  const { pk, sk } = resolveSegmentedKey(
+    meta.primaryKey.segmented,
+    keyInput,
+    `${modelClass.name} primary key`
   );
-  let updateMode;
-  let consistency;
-  for (const d of decls) {
-    if (d.updateMode !== void 0) {
-      if (updateMode !== void 0 && updateMode !== d.updateMode) {
-        throw new Error(
-          `View '${viewName}': conflicting \`updateMode\` across \`@maintainedFrom\` declarations ('${updateMode}' vs '${d.updateMode}'). A view row has a single write path \u2014 declare the same \`updateMode\` on every source.`
-        );
-      }
-      updateMode = d.updateMode;
-    }
-    if (d.consistency !== void 0) {
-      if (consistency !== void 0 && consistency !== d.consistency) {
-        throw new Error(
-          `View '${viewName}': conflicting \`consistency\` across \`@maintainedFrom\` declarations ('${consistency}' vs '${d.consistency}').`
-        );
-      }
-      consistency = d.consistency;
-    }
-  }
-  const slices = decls.map((d) => sliceFromDeclaration(d));
-  return {
-    name: viewName,
-    viewClass,
-    pattern,
-    slices,
-    ...updateMode !== void 0 ? { updateMode } : {},
-    ...consistency !== void 0 ? { consistency } : {}
-  };
-}
-function sliceFromDeclaration(d) {
-  const sourceClass = resolveClass(d.sourceFactory);
-  const sourceLogical = sourceLogicalName(sourceClass);
-  const collection = d.collection ? {
-    field: d.collection.field,
-    ...d.collection.maxItems !== void 0 ? { maxItems: d.collection.maxItems } : {},
-    ...d.collection.orderBy !== void 0 ? { orderBy: d.collection.orderBy, orderDir: d.collection.order ?? "DESC" } : {}
-  } : void 0;
-  return {
-    sourceClass,
-    maintainedOn: triggersFor(sourceLogical, d.on),
-    keys: d.keyBind,
-    project: d.project,
-    ...collection ? { collection } : {},
-    ...d.when ? { predicate: d.when } : {}
+  const dynamoItem = {
+    PK: pk,
+    SK: sk ?? "",
+    ...serialized
   };
-}
-function versionedViews(ownerClass, ownerMeta) {
-  const ownerLogical = logicalNameOf(ownerMeta);
-  const rels = [];
-  for (const rel of ownerMeta.relations) {
-    const v = rel.options?.versioned;
-    if (!v) continue;
-    const targetClass = resolveClass(rel.targetFactory);
-    const targetMeta = MetadataRegistry.get(targetClass);
-    if (!targetMeta.primaryKey) {
-      throw new Error(
-        `Versioned relation '${rel.propertyName}' on '${ownerLogical}': the target model '${targetClass.name}' has no \`key\` \u2014 a versioned latest/history row needs a key to resolve which row to overwrite / append.`
-      );
+  for (const emb of meta.embeddedFields) {
+    const value = item[emb.propertyName];
+    if (value !== void 0) {
+      dynamoItem[emb.propertyName] = value;
     }
-    const keyFields = [
-      ...segmentFieldNames(targetMeta.primaryKey.segmented.pkSegments),
-      ...segmentFieldNames(targetMeta.primaryKey.segmented.skSegments)
-    ];
-    rels.push({
-      propertyName: rel.propertyName,
-      mode: v.mode,
-      on: v.on,
-      project: v.project,
-      ...v.updateMode !== void 0 ? { updateMode: v.updateMode } : {},
-      ...v.consistency !== void 0 ? { consistency: v.consistency } : {},
-      targetClass,
-      targetMeta,
-      keyFields
-    });
   }
-  assertVersionedDiscriminator(ownerLogical, rels);
-  const out = [];
-  for (const rel of rels) {
-    const keys = {};
-    for (const f of rel.keyFields) keys[f] = `$.entity.${f}`;
-    const targetName = rel.targetClass.name ?? logicalNameOf(rel.targetMeta);
-    out.push({
-      name: targetName,
-      viewClass: rel.targetClass,
-      pattern: "materializedView",
-      slices: [
-        {
-          sourceClass: ownerClass,
-          maintainedOn: triggersFor(ownerLogical, rel.on),
-          keys,
-          project: rel.project
-        }
-      ],
-      ...rel.updateMode !== void 0 ? { updateMode: rel.updateMode } : {},
-      ...rel.consistency !== void 0 ? { consistency: rel.consistency } : {}
-    });
+  const available = {};
+  for (const fieldName of meta.fields.map((f) => f.propertyName)) {
+    available[fieldName] = serialized[fieldName] ?? item[fieldName];
   }
-  return out;
-}
-function assertVersionedDiscriminator(ownerLogical, rels) {
-  const latests = rels.filter((r) => r.mode === "latest");
-  const histories = rels.filter((r) => r.mode === "history");
-  if (latests.length === 0 || histories.length === 0) return;
-  for (const latest of latests) {
-    const latestKeyFields = new Set(latest.keyFields);
-    for (const history of histories) {
-      const discriminators = history.keyFields.filter((f) => !latestKeyFields.has(f));
-      if (discriminators.length === 0) {
-        const latestName = latest.targetClass.name ?? "<latest>";
-        const historyName = history.targetClass.name ?? "<history>";
-        throw new Error(
-          `Versioned relation pair on '${ownerLogical}': the \`versionedHistory\` target '${historyName}' (\`${history.propertyName}\`) is keyed by [${history.keyFields.map((f) => `'${f}'`).join(", ")}], which carries NO version discriminator beyond the \`versionedLatest\` target '${latestName}' (\`${latest.propertyName}\`) keyed by [${[...latestKeyFields].map((f) => `'${f}'`).join(", ")}]. The history row must be keyed by a per-version field (e.g. add a \`version\` segment to '${historyName}'s \`@key\`) so each revision is a NEW row; otherwise every revision overwrites one row (a latest pointer, not an append-only history).`
-        );
-      }
-    }
+  for (const gsi2 of meta.gsiDefinitions) {
+    const { pkAttr, pk: gsiPk, skAttr, sk: gsiSk } = deriveGsiKey(
+      gsi2,
+      available,
+      `${modelClass.name} GSI '${gsi2.indexName}'`
+    );
+    dynamoItem[pkAttr] = gsiPk;
+    dynamoItem[skAttr] = gsiSk;
   }
-}
-function collectViewDefinitions(registry) {
-  const resolved = registry ?? MetadataRegistry.getAll();
-  const out = [];
-  for (const [klass, meta] of resolved) {
-    const kind = meta.kind ?? "entity";
-    if (kind === "materializedView" || kind === "sparseView") {
-      out.push(viewFromMaintainedFrom(klass, meta, kind));
+  const putInput = {
+    TableName: tableName,
+    Item: dynamoItem
+  };
+  if (options?.condition) {
+    const condResult = buildConditionExpression(options.condition);
+    putInput.ConditionExpression = condResult.expression;
+    if (Object.keys(condResult.names).length > 0) {
+      putInput.ExpressionAttributeNames = condResult.names;
     }
-    if (meta.relations?.some((r) => r.options?.versioned)) {
-      out.push(...versionedViews(klass, meta));
+    if (Object.keys(condResult.values).length > 0) {
+      putInput.ExpressionAttributeValues = condResult.values;
     }
   }
-  return out;
-}
-
-// src/relation/maintenance-graph.ts
-var COUNT_DELTA_FOR_EVENT = {
-  created: 1,
-  removed: -1,
-  updated: 0
-};
-var MAINTAIN_EVENTS = ["created", "updated", "removed"];
-function isPathRooted(value) {
-  return value.startsWith("$.input.") || value.startsWith("$.entity.");
-}
-function sourceAttributeOf(path) {
-  const stripped = path.replace(/^\$\.(input|entity)\./, "");
-  return stripped.split(".")[0] ?? stripped;
-}
-function normalizeProjectionEntry(value) {
-  if (typeof value === "string") {
-    const path = isPathRooted(value) ? value : `$.entity.${value}`;
-    return identity(path);
-  }
-  return value;
-}
-function buildProjectionMap(projection, ownerEntity, relationProperty) {
-  const entries = projection ? Object.entries(projection) : [];
-  if (entries.length === 0) {
-    throw new Error(
-      `Relation '${relationProperty}' on '${ownerEntity}' declares maintenance (\`write.maintainedOn\`) but no \`projection\`: a maintained snapshot / collection with no captured attributes projects nothing. Declare a \`projection\` map (e.g. \`{ postId: 'postId', textPreview: preview('body', 120) }\`).`
-    );
-  }
-  const out = {};
-  for (const [attr, value] of entries) {
-    out[attr] = normalizeProjectionEntry(value);
-  }
-  return out;
+  return putInput;
 }
-function buildDestinationKeys(keyBinding) {
-  const keys = {};
-  const sourceFields = [];
-  for (const [sourceField, ownerField] of Object.entries(keyBinding)) {
-    keys[ownerField] = `$.entity.${sourceField}`;
-    sourceFields.push(sourceField);
+async function executePut(modelClass, item, options) {
+  const mw = writeRuntimeFor(options);
+  if (mw) {
+    await executeSingleWriteWithHooks({ kind: "put", modelClass, item, options }, mw);
+    return;
   }
-  return { keys, sourceFields };
+  await executePutCore(modelClass, item, options);
 }
-function sourcePayloadAttributes(meta) {
-  const attrs = /* @__PURE__ */ new Set();
-  for (const f of meta.fields) attrs.add(f.propertyName);
-  if (meta.primaryKey) {
-    for (const f of segmentFieldNames(meta.primaryKey.segmented.pkSegments)) attrs.add(f);
-    for (const f of segmentFieldNames(meta.primaryKey.segmented.skSegments)) attrs.add(f);
-  }
-  for (const gsi2 of meta.gsiDefinitions) {
-    for (const f of segmentFieldNames(gsi2.segmented.pkSegments)) attrs.add(f);
-    for (const f of segmentFieldNames(gsi2.segmented.skSegments)) attrs.add(f);
-  }
-  return attrs;
-}
-function assertMaintenanceRoundTrips(args) {
-  const {
-    ownerEntity,
-    relationProperty,
-    ownerMeta,
-    sourceEntity,
-    sourceMeta,
-    destinationKeyFields,
-    keyBindingSourceFields,
-    projection
-  } = args;
-  const sourceAttrs = sourcePayloadAttributes(sourceMeta);
-  try {
-    resolveKey([...destinationKeyFields], ownerMeta);
-  } catch (cause) {
-    throw new Error(
-      `Maintenance declaration for relation '${relationProperty}' on '${ownerEntity}' binds destination-key fields [${destinationKeyFields.map((f) => `'${f}'`).join(", ")}], which cover no access-pattern partition of the maintained entity '${ownerEntity}'. The maintained snapshot / collection row could not be resolved, so the snapshot key would not point at a real target row \u2014 bind the partition-key field(s) of the index the maintained row lives on. (${cause.message})`
-    );
+async function executePutCore(modelClass, item, options, persistVia, forceOldImage) {
+  const putInput = buildPutInput(modelClass, item, options);
+  const wantsOld = ChangeCaptureRegistry.wantsOldImage(modelClass) || forceOldImage === true;
+  const send = (input) => ClientManager.getExecutor().put(input, {
+    ...wantsOld ? { returnOldImage: true } : {},
+    ...options?.retry !== void 0 ? { retry: options.retry } : {}
+  });
+  const result = persistVia ? await persistVia(putInput, send) : await send(putInput);
+  if (ChangeCaptureRegistry.hasSubscribers()) {
+    const oldItem = result.oldItem;
+    captureWrite({
+      table: putInput.TableName,
+      model: modelClass.name,
+      op: "put",
+      keys: { pk: String(putInput.Item.PK), sk: String(putInput.Item.SK ?? "") },
+      newItem: putInput.Item,
+      ...oldItem ? { oldItem } : {}
+    });
   }
-  for (const field of keyBindingSourceFields) {
-    if (!sourceAttrs.has(field)) {
-      throw new Error(
-        `Maintenance key binding for relation '${relationProperty}' on '${ownerEntity}' reads source field '${field}' to resolve the destination row, but the source entity '${sourceEntity}' carries no attribute '${field}' on its payload (available: ${[...sourceAttrs].sort().map((f) => `'${f}'`).join(", ")}). The destination key could not be built from the source payload \u2014 reject.`
-      );
-    }
+}
+
+// src/runtime/same-key-collapse.ts
+function collapseSameKey(items, view) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const sig = view.keySignature(item);
+    const bucket = groups.get(sig);
+    if (bucket === void 0) groups.set(sig, [item]);
+    else bucket.push(item);
   }
-  for (const [attr, transform] of Object.entries(projection)) {
-    if (!isPathRooted(transform.path)) {
-      throw new Error(
-        `Maintenance projection for relation '${relationProperty}' on '${ownerEntity}' captures attribute '${attr}' from '${transform.path}', which is not a payload-rooted source path (\`$.input.*\` / \`$.entity.*\`). The maintenance graph projects only from the source payload (payload \u540C\u68B1) \u2014 there is no fetch / re-projection.`
-      );
+  const replacement = /* @__PURE__ */ new Map();
+  const dropped = /* @__PURE__ */ new Set();
+  for (const bucket of groups.values()) {
+    if (bucket.length === 1) continue;
+    const kinds = new Set(bucket.map((it) => view.kind(it)));
+    if (kinds.size === 2 && kinds.has("Delete") && kinds.has("Put")) {
+      for (const it of bucket) dropped.add(it);
+      continue;
     }
-    const srcAttr = sourceAttributeOf(transform.path);
-    if (!sourceAttrs.has(srcAttr)) {
+    if (kinds.size === 2 && kinds.has("Put") && kinds.has("Update")) {
       throw new Error(
-        `Maintenance projection for relation '${relationProperty}' on '${ownerEntity}' captures '${attr}' from '${transform.path}', but the source entity '${sourceEntity}' carries no attribute '${srcAttr}' on its payload (available: ${[...sourceAttrs].sort().map((f) => `'${f}'`).join(", ")}). Projection is payload \u540C\u68B1 only (no fetch / re-projection): an attribute the source row does not carry cannot be projected \u2014 reject.`
+        `Contract runtime: a derived counter (\`increment\`) resolves to the SAME item as the entity write at runtime (the call-time key values made an aliased target coincide with the written row). A Put+Update on one transaction item is unsupported \u2014 DynamoDB rejects touching one key twice, and collapsing it would silently drop the increment. A \`w.increment(...)\` must target a DIFFERENT row (e.g. a parent aggregate's counter); to maintain a counter ON the written entity, write the field as part of the entity itself, not via a derived counter onto its own row.`
       );
     }
-  }
-}
-function assertCounterRoundTrips(args) {
-  const {
-    ownerEntity,
-    aggregateField,
-    ownerMeta,
-    sourceEntity,
-    sourceMeta,
-    destinationKeyFields,
-    keyBindingSourceFields,
-    valueSourceFields
-  } = args;
-  const sourceAttrs = sourcePayloadAttributes(sourceMeta);
-  try {
-    resolveKey([...destinationKeyFields], ownerMeta);
-  } catch (cause) {
-    throw new Error(
-      `Counter aggregate '${aggregateField}' on '${ownerEntity}' binds destination-key fields [${destinationKeyFields.map((f) => `'${f}'`).join(", ")}], which cover no access-pattern partition of the maintained entity '${ownerEntity}'. The counter row could not be resolved \u2014 bind the partition-key field(s) of the index the counter row lives on. (${cause.message})`
-    );
-  }
-  for (const field of keyBindingSourceFields) {
-    if (!sourceAttrs.has(field)) {
-      throw new Error(
-        `Counter aggregate '${aggregateField}' on '${ownerEntity}' reads source field '${field}' to resolve the counter row, but the source entity '${sourceEntity}' carries no attribute '${field}' on its payload (available: ${[...sourceAttrs].sort().map((f) => `'${f}'`).join(", ")}). The destination key could not be built from the source payload \u2014 reject.`
-      );
+    if (kinds.size === 1 && kinds.has("Update")) {
+      replacement.set(bucket[0], view.mergeAdds(bucket));
+      for (const it of bucket.slice(1)) dropped.add(it);
+      continue;
     }
-  }
-  for (const field of valueSourceFields) {
-    if (!sourceAttrs.has(field)) {
-      throw new Error(
-        `Counter aggregate '${aggregateField}' on '${ownerEntity}' tracks \`max('${field}')\`, but the source entity '${sourceEntity}' carries no attribute '${field}' on its payload (available: ${[...sourceAttrs].sort().map((f) => `'${f}'`).join(", ")}). A counter aggregates only the source payload (payload \u540C\u68B1) \u2014 reject.`
-      );
+    if (kinds.size === 1 && (kinds.has("Put") || kinds.has("Delete"))) {
+      for (const it of bucket.slice(1)) dropped.add(it);
+      continue;
     }
+    throw new Error(
+      `Contract runtime: ${bucket.length} transaction items resolve to the same physical row with an unsupported op combination (${[...kinds].sort().join("+")}). A TransactWriteItems may not touch one key twice; this collision is not a known collapse shape (self-row Put/Delete de-dup, swap no-op, or symmetric counter ADDs), so it is rejected rather than silently collapsed.`
+    );
   }
-}
-function logicalNameOf2(meta) {
-  return meta.prefix.endsWith("#") ? meta.prefix.slice(0, -1) : meta.prefix;
-}
-function resolveEntityByName(name, registry) {
-  for (const [klass, meta] of registry) {
-    if (logicalNameOf2(meta) === name) return klass;
+  const out = [];
+  for (const item of items) {
+    if (dropped.has(item)) continue;
+    out.push(replacement.get(item) ?? item);
   }
-  return void 0;
+  return out;
 }
-function parseTrigger(raw) {
-  const idx = raw.lastIndexOf(".");
-  return { entity: raw.slice(0, idx), event: raw.slice(idx + 1) };
-}
-function buildEffect(relation, ownerFactory, trigger, keys, project, sourceMeta, ownerEntity) {
-  const write = relation.options?.write;
-  const updateMode = write?.updateMode;
-  const consistency = write?.consistency;
-  const base = {
-    trigger,
-    targetFactory: ownerFactory,
-    keys,
-    project,
-    ...updateMode !== void 0 ? { updateMode } : {},
-    ...consistency !== void 0 ? { consistency } : {}
-  };
-  if (relation.type === "hasMany") {
-    const read = relation.options?.read;
-    const order = resolveCollectionOrder(relation, sourceMeta, ownerEntity, project);
-    const collection = {
-      field: relation.propertyName,
-      ...read?.maxItems !== void 0 ? { maxItems: read.maxItems } : {},
-      ...order !== void 0 ? { orderBy: order.orderBy, orderDir: order.orderDir } : {}
-    };
-    return { kind: "collection", ...base, collection };
-  }
-  return { kind: "snapshot", ...base };
-}
-function viewSliceProperty(viewName, sliceIndex, slice) {
-  return slice.collection ? `${viewName}#${slice.collection.field}` : `${viewName}#${sliceIndex}`;
-}
-function buildViewEffect(view, slice, trigger) {
-  const targetFactory = () => view.viewClass;
-  const base = {
-    trigger,
-    targetFactory,
-    keys: slice.keys,
-    project: slice.project,
-    ...view.updateMode !== void 0 ? { updateMode: view.updateMode } : {},
-    ...view.consistency !== void 0 ? { consistency: view.consistency } : {}
-  };
-  if (slice.predicate) {
-    return { kind: "membership", ...base, predicate: slice.predicate };
-  }
-  if (slice.collection) {
-    const collection = {
-      field: slice.collection.field,
-      ...slice.collection.maxItems !== void 0 ? { maxItems: slice.collection.maxItems } : {},
-      ...slice.collection.orderBy !== void 0 ? {
-        orderBy: slice.collection.orderBy,
-        orderDir: slice.collection.orderDir ?? "DESC"
-      } : {}
-    };
-    return { kind: "collection", ...base, collection };
-  }
-  return { kind: "snapshot", ...base };
+
+// src/runtime/transaction-commit.ts
+var MAX_TRANSACT_ITEMS = 25;
+var execItemCollapseView = {
+  kind: execItemKind,
+  keySignature: execItemKeySignature,
+  mergeAdds: mergeAddUpdates
+};
+function collapseSameKeyItems(items) {
+  return collapseSameKey(items, execItemCollapseView);
 }
-function resolveCollectionOrder(relation, sourceMeta, ownerEntity, project) {
-  const order = relation.options?.read?.order;
-  if (order === void 0) return void 0;
-  const skFields = sourceMeta.primaryKey ? segmentFieldNames(sourceMeta.primaryKey.segmented.skSegments) : [];
-  const orderField = skFields[skFields.length - 1];
-  if (orderField === void 0) {
-    throw new Error(
-      `Relation '${relation.propertyName}' on '${ownerEntity}' declares \`read.order: '${order}'\` for its maintained collection, but its source entity '${logicalNameOf2(sourceMeta)}' has no sort key to order by. A maintained collection orders by the source's sort-key field (the field the live read sorts on); declare a sort key on '${logicalNameOf2(sourceMeta)}' or drop \`read.order\`.`
+async function commitTransaction(items, options = {}) {
+  const collapsed = collapseSameKeyItems(items);
+  if (collapsed.length === 0) return collapsed;
+  if (collapsed.length > MAX_TRANSACT_ITEMS) {
+    throw options.limitError ? options.limitError(collapsed.length) : new Error(
+      `Transaction exceeds DynamoDB limit of ${MAX_TRANSACT_ITEMS} items`
     );
   }
-  if (!Object.prototype.hasOwnProperty.call(project, orderField)) {
-    throw new Error(
-      `Relation '${relation.propertyName}' on '${ownerEntity}' declares \`read.order: '${order}'\` for its maintained collection, which orders by the source entity '${logicalNameOf2(sourceMeta)}'s sort-key field '${orderField}', but that field is not in the relation's \`projection\` (projected: ${Object.keys(project).map((a) => `'${a}'`).join(", ")}). The maintained collection sorts its projected items, so the order field must be projected \u2014 add '${orderField}' to the projection (e.g. \`{ ${orderField}: '${orderField}', \u2026 }\`) or drop \`read.order\`.`
-    );
+  const sendBatch = (items2) => ClientManager.getExecutor().transactWrite(
+    items2,
+    options.retry !== void 0 ? { retry: options.retry } : void 0
+  );
+  let committed = collapsed;
+  if (options.middleware) {
+    const { runtime, origins, transaction } = options.middleware;
+    const persistCtx = runtime.persistCtx(collapsed, origins, transaction);
+    await runtime.runPersist(persistCtx, async (items2) => sendBatch(items2));
+    committed = persistCtx.items;
+  } else {
+    await sendBatch(collapsed);
   }
-  return { orderBy: `$.entity.${orderField}`, orderDir: order };
-}
-function buildCounterEffect(aggregate, ownerFactory, trigger, event, keys) {
-  const write = aggregate.options.write;
-  const updateMode = write?.updateMode;
-  const consistency = write?.consistency;
-  const value = aggregate.options.value.op === "count" ? { op: "count" } : { op: "max", field: aggregate.options.value.field };
-  return {
-    kind: "counter",
-    trigger,
-    targetFactory: ownerFactory,
-    keys,
-    attribute: aggregate.propertyName,
-    value,
-    ...value.op === "count" ? { delta: COUNT_DELTA_FOR_EVENT[event] } : {},
-    ...updateMode !== void 0 ? { updateMode } : {},
-    ...consistency !== void 0 ? { consistency } : {}
-  };
-}
-function destinationRowKeyOf(ownerEntity, keys) {
-  const parts = Object.entries(keys).map(([field, path]) => `${field}=${path}`).sort();
-  return `${ownerEntity}#${parts.join("&")}`;
+  captureTransactItems(committed, options.modelBySignature ?? EMPTY_MODEL_MAP);
+  return committed;
 }
-function assertNoCycle(items) {
-  const adjacency = /* @__PURE__ */ new Map();
+var EMPTY_MODEL_MAP = /* @__PURE__ */ new Map();
+function captureTransactItems(items, modelBySignature) {
+  if (!ChangeCaptureRegistry.hasSubscribers()) return;
   for (const item of items) {
-    if (!adjacency.has(item.sourceEntity)) adjacency.set(item.sourceEntity, /* @__PURE__ */ new Set());
-    adjacency.get(item.sourceEntity).add(item.ownerEntity);
-  }
-  const WHITE = 0;
-  const GRAY = 1;
-  const BLACK = 2;
-  const color = /* @__PURE__ */ new Map();
-  for (const node of adjacency.keys()) color.set(node, WHITE);
-  for (const start of adjacency.keys()) {
-    if (color.get(start) !== WHITE) continue;
-    const stack = [];
-    const path = [];
-    color.set(start, GRAY);
-    path.push(start);
-    stack.push({ node: start, iter: (adjacency.get(start) ?? /* @__PURE__ */ new Set()).values() });
-    while (stack.length > 0) {
-      const top = stack[stack.length - 1];
-      const next = top.iter.next();
-      if (next.done) {
-        color.set(top.node, BLACK);
-        stack.pop();
-        path.pop();
-        continue;
-      }
-      const child = next.value;
-      const childColor = color.get(child) ?? WHITE;
-      if (childColor === GRAY) {
-        const from = path.indexOf(child);
-        const cycle = [...path.slice(from), child].join(" \u2192 ");
-        throw new Error(
-          `Maintenance dependency cycle detected: ${cycle}. A maintenance trigger chain that loops back on itself is an unbounded cascade \u2014 break the cycle (an entity's maintained shape must not, transitively, be triggered by its own maintenance).`
-        );
-      }
-      if (childColor === WHITE) {
-        color.set(child, GRAY);
-        path.push(child);
-        stack.push({ node: child, iter: (adjacency.get(child) ?? /* @__PURE__ */ new Set()).values() });
-      }
-    }
+    if ("ConditionCheck" in item) continue;
+    captureWrite(captureMetaForItem(item, modelBySignature));
   }
 }
-function buildMaintenanceGraph(registry, views) {
-  const resolvedRegistry = registry ?? MetadataRegistry.getAll();
-  const resolvedViews = views ?? collectViewDefinitions(resolvedRegistry);
-  return buildMaintenanceGraphImpl(resolvedRegistry, resolvedViews);
-}
-function buildMaintenanceGraphImpl(registry, views) {
-  const items = [];
-  const owners = [...registry.entries()].map(([klass, meta]) => ({ klass, meta })).sort((a, b) => a.klass.name < b.klass.name ? -1 : a.klass.name > b.klass.name ? 1 : 0);
-  for (const { klass: ownerClass, meta: ownerMeta } of owners) {
-    const ownerEntity = logicalNameOf2(ownerMeta);
-    const relations = [...ownerMeta.relations].sort(
-      (a, b) => a.propertyName < b.propertyName ? -1 : a.propertyName > b.propertyName ? 1 : 0
-    );
-    for (const relation of relations) {
-      const maintainedOn = relation.options?.write?.maintainedOn;
-      if (!maintainedOn || maintainedOn.length === 0) continue;
-      const sourceClass = relation.targetFactory();
-      const sourceMeta = MetadataRegistry.get(sourceClass);
-      const relationTargetEntity = logicalNameOf2(sourceMeta);
-      const project = buildProjectionMap(
-        relation.options?.projection,
-        ownerEntity,
-        relation.propertyName
-      );
-      const { keys, sourceFields } = buildDestinationKeys(relation.keyBinding);
-      const destinationKeyFields = Object.keys(keys);
-      for (const raw of maintainedOn) {
-        if (!isMaintainTrigger(raw)) {
-          const { event } = parseTrigger(raw);
-          throw new Error(
-            `Maintenance trigger ${JSON.stringify(raw)} on relation '${relation.propertyName}' of '${ownerEntity}' is not a well-formed \`Entity.event\` trigger (event must be one of ${MAINTAIN_EVENTS.map((e) => `'${e}'`).join(" / ")}; got '${event}'). Fix the \`write.maintainedOn\` entry.`
-          );
-        }
-        const trigger = raw;
-        const { entity: triggerEntity } = parseTrigger(trigger);
-        if (!resolveEntityByName(triggerEntity, registry)) {
-          throw new Error(
-            `Maintenance trigger '${trigger}' on relation '${relation.propertyName}' of '${ownerEntity}' names source entity '${triggerEntity}', which is not a registered model. Declare a model named '${triggerEntity}' or fix the trigger's entity segment.`
-          );
-        }
-        if (triggerEntity !== relationTargetEntity) {
-          throw new Error(
-            `Maintenance trigger '${trigger}' on relation '${relation.propertyName}' of '${ownerEntity}' names source entity '${triggerEntity}', but the relation's target (the projected source) is '${relationTargetEntity}'. #124 projects only from the relation target's payload (payload \u540C\u68B1); a trigger on a different entity needs a write-time context fetch, which is Phase 2 \u2014 restrict \`maintainedOn\` to '${relationTargetEntity}.*' triggers.`
-          );
-        }
-        assertMaintenanceRoundTrips({
-          ownerEntity,
-          relationProperty: relation.propertyName,
-          ownerMeta,
-          sourceEntity: triggerEntity,
-          sourceMeta,
-          destinationKeyFields,
-          keyBindingSourceFields: sourceFields,
-          projection: project
-        });
-        const effect = buildEffect(
-          relation,
-          () => ownerClass,
-          trigger,
-          keys,
-          project,
-          sourceMeta,
-          ownerEntity
-        );
-        items.push({
-          trigger,
-          sourceEntity: triggerEntity,
-          sourceClass,
-          ownerEntity,
-          ownerClass,
-          relationProperty: relation.propertyName,
-          destinationRowKey: destinationRowKeyOf(ownerEntity, keys),
-          effect
-        });
-      }
-    }
-    const aggregates = [...ownerMeta.aggregates].sort(
-      (a, b) => a.propertyName < b.propertyName ? -1 : a.propertyName > b.propertyName ? 1 : 0
-    );
-    for (const agg of aggregates) {
-      const maintainedOn = agg.options.write?.maintainedOn;
-      if (!maintainedOn || maintainedOn.length === 0) continue;
-      const sourceClass = agg.targetFactory();
-      const sourceMeta = MetadataRegistry.get(sourceClass);
-      const aggSourceEntity = logicalNameOf2(sourceMeta);
-      const { keys, sourceFields } = buildDestinationKeys(agg.keyBinding);
-      const destinationKeyFields = Object.keys(keys);
-      const valueSourceFields = agg.options.value.op === "max" ? [agg.options.value.field] : [];
-      for (const raw of maintainedOn) {
-        if (!isMaintainTrigger(raw)) {
-          const { event: event2 } = parseTrigger(raw);
-          throw new Error(
-            `Maintenance trigger ${JSON.stringify(raw)} on \`@aggregate\` field '${agg.propertyName}' of '${ownerEntity}' is not a well-formed \`Entity.event\` trigger (event must be one of ${MAINTAIN_EVENTS.map((e) => `'${e}'`).join(" / ")}; got '${event2}'). Fix the \`write.maintainedOn\` entry.`
-          );
-        }
-        const trigger = raw;
-        const parsed = parseTrigger(trigger);
-        const triggerEntity = parsed.entity;
-        const event = parsed.event;
-        if (!resolveEntityByName(triggerEntity, registry)) {
-          throw new Error(
-            `Maintenance trigger '${trigger}' on \`@aggregate\` field '${agg.propertyName}' of '${ownerEntity}' names source entity '${triggerEntity}', which is not a registered model. Declare a model named '${triggerEntity}' or fix the trigger's entity segment.`
-          );
-        }
-        if (triggerEntity !== aggSourceEntity) {
-          throw new Error(
-            `Maintenance trigger '${trigger}' on \`@aggregate\` field '${agg.propertyName}' of '${ownerEntity}' names source entity '${triggerEntity}', but the aggregate's source (the entity being counted) is '${aggSourceEntity}'. A counter aggregates only the rows of its own source (payload \u540C\u68B1); a trigger on a different entity is Phase 2 \u2014 restrict \`maintainedOn\` to '${aggSourceEntity}.*' triggers.`
-          );
-        }
-        if (agg.options.value.op === "count" && COUNT_DELTA_FOR_EVENT[event] === 0) {
-          throw new Error(
-            `\`@aggregate\` field '${agg.propertyName}' of '${ownerEntity}' is a \`count()\` counter maintained on '${trigger}', but a 'updated' event does not change a row count (it adds 0). A \`count()\` counter is maintained on 'created' (+1) and 'removed' (-1); drop the 'updated' trigger.`
-          );
-        }
-        assertCounterRoundTrips({
-          ownerEntity,
-          aggregateField: agg.propertyName,
-          ownerMeta,
-          sourceEntity: triggerEntity,
-          sourceMeta,
-          destinationKeyFields,
-          keyBindingSourceFields: sourceFields,
-          valueSourceFields
-        });
-        const effect = buildCounterEffect(agg, () => ownerClass, trigger, event, keys);
-        items.push({
-          trigger,
-          sourceEntity: triggerEntity,
-          sourceClass,
-          ownerEntity,
-          ownerClass,
-          relationProperty: agg.propertyName,
-          destinationRowKey: destinationRowKeyOf(ownerEntity, keys),
-          effect
-        });
-      }
-    }
-  }
-  for (const view of [...views].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0)) {
-    const ownerClass = view.viewClass;
-    const ownerMeta = MetadataRegistry.get(ownerClass);
-    const ownerEntity = logicalNameOf2(ownerMeta);
-    view.slices.forEach((slice, sliceIndex) => {
-      const sourceClass = slice.sourceClass;
-      const sourceMeta = MetadataRegistry.get(sourceClass);
-      const sourceEntity = logicalNameOf2(sourceMeta);
-      const keys = slice.keys;
-      const destinationKeyFields = Object.keys(keys);
-      const keyBindingSourceFields = Object.values(keys).map((p) => sourceAttributeOf(p));
-      for (const trigger of slice.maintainedOn) {
-        const { entity: triggerEntity } = parseTrigger(trigger);
-        if (triggerEntity !== sourceEntity) {
-          throw new Error(
-            `defineView '${view.name}': source slice trigger '${trigger}' names entity '${triggerEntity}', but the slice's source entity is '${sourceEntity}'. A view source projects only from its own payload (payload \u540C\u68B1); a trigger on a different entity needs a write-time context fetch (RFC \xA74.A.6), which is a deferred follow-up \u2014 restrict the slice's \`maintainedOn\` to '${sourceEntity}.*' triggers.`
-          );
-        }
-        assertMaintenanceRoundTrips({
-          ownerEntity,
-          relationProperty: viewSliceProperty(view.name, sliceIndex, slice),
-          ownerMeta,
-          sourceEntity,
-          sourceMeta,
-          destinationKeyFields,
-          keyBindingSourceFields,
-          projection: slice.project
-        });
-        if (slice.predicate) {
-          if (!isPathRooted(slice.predicate.path)) {
-            throw new Error(
-              `defineView '${view.name}': sparse-view predicate path ${JSON.stringify(slice.predicate.path)} is not a payload-rooted source path (\`$.input.*\` / \`$.entity.*\`). The drain evaluates the predicate against the source image \u2014 use a source attribute path.`
-            );
-          }
-          const predAttr = sourceAttributeOf(slice.predicate.path);
-          if (!sourcePayloadAttributes(sourceMeta).has(predAttr)) {
-            throw new Error(
-              `defineView '${view.name}': sparse-view predicate reads source attribute '${predAttr}' (from '${slice.predicate.path}'), but the source entity '${sourceEntity}' carries no such attribute on its payload (available: ${[...sourcePayloadAttributes(sourceMeta)].sort().map((f) => `'${f}'`).join(", ")}). A membership predicate is payload \u540C\u68B1 only \u2014 reject.`
-            );
-          }
-        }
-        const effect = buildViewEffect(view, slice, trigger);
-        items.push({
-          trigger,
-          sourceEntity,
-          sourceClass,
-          ownerEntity,
-          ownerClass,
-          relationProperty: viewSliceProperty(view.name, sliceIndex, slice),
-          destinationRowKey: destinationRowKeyOf(ownerEntity, keys),
-          effect
-        });
-      }
-    });
+function captureMetaForItem(item, modelBySignature) {
+  const model = modelBySignature.get(execItemKeySignature(item));
+  const labelled = model !== void 0 ? { model } : {};
+  if ("Put" in item) {
+    const Item = item.Put.Item;
+    return {
+      table: item.Put.TableName,
+      ...labelled,
+      op: "put",
+      keys: { pk: String(Item.PK), sk: String(Item.SK ?? "") },
+      newItem: Item
+    };
   }
-  assertNoCycle(items);
-  const byTrigger = /* @__PURE__ */ new Map();
-  const sameRow = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    const triggerBucket = byTrigger.get(item.trigger);
-    if (triggerBucket) triggerBucket.push(item);
-    else byTrigger.set(item.trigger, [item]);
-    const rowKey = `${item.trigger}\0${item.destinationRowKey}`;
-    const rowBucket = sameRow.get(rowKey);
-    if (rowBucket) rowBucket.push(item);
-    else sameRow.set(rowKey, [item]);
-  }
-  const multiMaintainerTargets = /* @__PURE__ */ new Map();
-  for (const [rowKey, bucket] of sameRow) {
-    if (bucket.length > 1) multiMaintainerTargets.set(rowKey, bucket);
+  if ("Update" in item) {
+    return {
+      table: item.Update.TableName,
+      ...labelled,
+      op: "update",
+      keys: { pk: String(item.Update.Key.PK), sk: String(item.Update.Key.SK ?? "") }
+    };
   }
   return {
-    items,
-    byTrigger,
-    effectsFor(trigger) {
-      return byTrigger.get(trigger) ?? [];
-    },
-    multiMaintainerTargets
+    table: item.Delete.TableName,
+    ...labelled,
+    op: "delete",
+    keys: { pk: String(item.Delete.Key.PK), sk: String(item.Delete.Key.SK ?? "") }
   };
 }
-
-// src/cdc/from-change.ts
-function buildFullSelect(metadata) {
-  const select = {};
-  for (const field of metadata.fields) {
-    select[field.propertyName] = true;
-  }
-  return select;
+function execItemKeySignature(item) {
+  const part = (rec) => `${String(rec?.PK ?? "")}#${String(rec?.SK ?? "")}`;
+  if ("Put" in item) return `${item.Put.TableName}#${part(item.Put.Item)}`;
+  if ("Update" in item) return `${item.Update.TableName}#${part(item.Update.Key)}`;
+  if ("Delete" in item) return `${item.Delete.TableName}#${part(item.Delete.Key)}`;
+  return `${item.ConditionCheck.TableName}#${part(item.ConditionCheck.Key)}`;
 }
-function eventOwnedBy(event, metadata, modelName) {
-  if (event.model !== void 0) {
-    return event.model === modelName;
-  }
-  return metadata.prefix.length > 0 && event.keys.pk.startsWith(metadata.prefix);
+function execItemKind(item) {
+  if ("Put" in item) return "Put";
+  if ("Update" in item) return "Update";
+  if ("Delete" in item) return "Delete";
+  return "ConditionCheck";
 }
-function hydrateImage(image, select, metadata, modelClass) {
-  if (image === void 0) return null;
-  const [hydrated] = hydrate([image], select, metadata);
-  const instance = new modelClass();
-  Object.assign(instance, hydrated);
-  for (const emb of metadata.embeddedFields) {
-    const rawEmb = image[emb.propertyName];
-    if (rawEmb !== void 0 && rawEmb !== null) {
-      instance[emb.propertyName] = rawEmb;
+function mergeAddUpdates(updates) {
+  const first = updates[0];
+  if (!("Update" in first)) {
+    throw new Error("Contract runtime: mergeAddUpdates received a non-Update item.");
+  }
+  const deltas = /* @__PURE__ */ new Map();
+  for (const it of updates) {
+    if (!("Update" in it)) {
+      throw new Error("Contract runtime: cannot merge a non-Update item into an ADD.");
+    }
+    const names2 = it.Update.ExpressionAttributeNames ?? {};
+    const values2 = it.Update.ExpressionAttributeValues ?? {};
+    for (const [namePlaceholder, attr] of Object.entries(names2)) {
+      const valuePlaceholder = `:${namePlaceholder.slice(1)}`;
+      const delta = values2[valuePlaceholder];
+      if (typeof delta !== "number") {
+        throw new Error(
+          `Contract runtime: cannot merge same-key counter updates \u2014 an ADD delta on '${attr}' is not numeric.`
+        );
+      }
+      deltas.set(attr, (deltas.get(attr) ?? 0) + delta);
     }
   }
-  return instance;
-}
-function parseChange(event, metadata, modelName, modelClass) {
-  if (!eventOwnedBy(event, metadata, modelName)) {
-    return [null, null];
+  const names = {};
+  const values = {};
+  const clauses = [];
+  let i = 0;
+  for (const [attr, delta] of deltas) {
+    names[`#a${i}`] = attr;
+    values[`:a${i}`] = delta;
+    clauses.push(`#a${i} :a${i}`);
+    i++;
   }
-  const select = buildFullSelect(metadata);
-  const oldRecord = hydrateImage(event.oldImage, select, metadata, modelClass);
-  const newRecord = hydrateImage(event.newImage, select, metadata, modelClass);
-  return [oldRecord, newRecord];
+  const merged = {
+    TableName: first.Update.TableName,
+    Key: first.Update.Key,
+    UpdateExpression: `ADD ${clauses.join(", ")}`,
+    ExpressionAttributeNames: names,
+    ExpressionAttributeValues: values
+  };
+  return { Update: merged };
 }
 
-// src/cdc/subscribe.ts
-function resolveRoutableModels(handlers) {
-  const byName = /* @__PURE__ */ new Map();
-  for (const [cls, meta] of MetadataRegistry.getAll()) {
-    byName.set(cls.name, { cls, meta });
-  }
-  const routable = /* @__PURE__ */ new Map();
-  for (const modelName of Object.keys(handlers)) {
-    const entry = byName.get(modelName);
-    if (!entry) {
-      throw new Error(
-        `DDBModel.subscribe: no model named '${modelName}' is registered. Did you import the model module (so its @model decorator ran) and spell the handler key exactly as the class name?`
-      );
-    }
-    if (!entry.meta.cdcProjected) {
-      throw new Error(
-        `DDBModel.subscribe: model '${modelName}' is not @cdcProjected, so its change events cannot be parsed. Add @cdcProjected() to the model, or remove its handler.`
-      );
-    }
-    routable.set(modelName, {
-      modelClass: entry.cls,
-      metadata: entry.meta,
-      modelName
-    });
-  }
-  return routable;
+// src/operations/transaction.ts
+var MODEL_CLASS_KEY = /* @__PURE__ */ Symbol.for("graphddb.modelClass");
+function attachModelClass(modelStatic, modelClass) {
+  Object.defineProperty(modelStatic, MODEL_CLASS_KEY, {
+    value: modelClass,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+  return modelStatic;
 }
-async function dispatchEvent(event, routable, handlers) {
-  for (const { modelClass, metadata, modelName } of routable.values()) {
-    const [oldRecord, newRecord] = parseChange(
-      event,
-      metadata,
-      modelName,
-      modelClass
+function resolveModelClass(model) {
+  const modelClass = model[MODEL_CLASS_KEY];
+  if (!modelClass) {
+    throw new Error(
+      "Invalid model reference. Use ModelStatic from DDBModel.asModel()."
     );
-    if (oldRecord === null && newRecord === null) continue;
-    const handler = handlers[modelName];
-    await handler(oldRecord, newRecord);
-    return true;
   }
-  return false;
-}
-function buildSubscribeHandler(handlers) {
-  const routable = resolveRoutableModels(handlers);
-  return async (batch) => {
-    const batchItemFailures = [];
-    for (const event of batch.records) {
-      try {
-        await dispatchEvent(event, routable, handlers);
-      } catch {
-        batchItemFailures.push(event.sequenceNumber);
-      }
-    }
-    return { batchItemFailures };
-  };
+  return modelClass;
 }
 
 export {
@@ -3793,34 +2444,16 @@ export {
   pkTemplate,
   skTemplate,
   resolveSegmentedKey,
-  SELECT_SPEC,
-  isSelectBuilder,
-  normalizeSelectSpec,
-  normalizeTopLevelSelect,
-  buildProject,
-  buildRelation,
-  isInlineSnapshotSpec,
-  detectRelationFields,
-  validateInlineSnapshotSelect,
-  getImplicitKeyFields,
   param,
   isParam,
   BATCH_GET_MAX_KEYS,
-  BATCH_WRITE_MAX_ITEMS,
   chunkArray,
-  DynamoExecutor,
-  DEFAULT_MAX_ATTEMPTS,
-  DEFAULT_RETRY_POLICY,
-  isRetryableError,
-  isRetryableTransactionCancellation,
-  RetryingExecutor,
   ClientManager,
   isRawCondition,
   cond,
   compileRawCondition,
   condParamName,
   serializeRawCondition,
-  collectRawConditionParams,
   CONDITION_OPERATOR_KEYS,
   resolveConditionTree,
   buildConditionExpression,
@@ -3831,7 +2464,6 @@ export {
   buildReadRuntime,
   buildWriteRuntime,
   ctxModelFor,
-  buildUpdateExpression,
   attachHiddenKey,
   buildUpdateInput,
   executeUpdate,
@@ -3840,27 +2472,8 @@ export {
   buildPutInput,
   executePut,
   MAX_TRANSACT_ITEMS,
-  collapseSameKeyItems,
   commitTransaction,
   execItemKeySignature,
   attachModelClass,
-  resolveModelClass,
-  TransactionContext,
-  executeTransaction,
-  hydrate,
-  maintainTrigger,
-  isMaintainTrigger,
-  preview,
-  identity,
-  LIFECYCLE_CONTRACT_MARKER,
-  isLifecycleContract,
-  ENTITY_WRITES_MARKER,
-  isEntityWritesDefinition,
-  entityWrites,
-  getEntityWrites,
-  lifecyclePhaseForIntent,
-  collectViewDefinitions,
-  buildMaintenanceGraph,
-  parseChange,
-  buildSubscribeHandler
+  resolveModelClass
 };