graphddb 0.7.10 → 0.8.1

package/dist/{chunk-3ZU2VW3L.js → chunk-L2NEDS7U.js}

@@ -5,7 +5,7 @@ import {
   createDefaultLinter,
   isColumn,
   isKeyDefinition
-} from "./chunk-PDUVTYC5.js";
+} from "./chunk-XTWXMOHD.js";
 
 // src/decorators/gsi.ts
 var GSI_MARKER = /* @__PURE__ */ Symbol("graphddb:gsi");
@@ -314,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 = {
@@ -453,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) {
@@ -533,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;
@@ -541,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.
    */
@@ -553,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;
@@ -615,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();
   }
@@ -643,216 +831,28 @@ 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/select/cond.ts
+var RAW_COND = /* @__PURE__ */ Symbol.for("graphddb.rawCond");
+function isRawCondition(value) {
+  return typeof value === "object" && value !== null && value[RAW_COND] === true;
 }
-
-// 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);
+function cond(template, ...parts) {
+  return {
+    [RAW_COND]: true,
+    template,
+    parts
+  };
+}
+function compileRawCondition(raw, allocName, allocValue) {
+  let out = raw.template[0];
+  for (let i = 0; i < raw.parts.length; i++) {
+    const part = raw.parts[i];
+    if (isColumn(part)) {
+      out += allocName(part.name);
+    } else {
+      out += allocValue(part);
     }
-    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) {
-  return typeof value === "object" && value !== null && value[RAW_COND] === true;
-}
-function cond(template, ...parts) {
-  return {
-    [RAW_COND]: true,
-    template,
-    parts
-  };
-}
-function compileRawCondition(raw, allocName, allocValue) {
-  let out = raw.template[0];
-  for (let i = 0; i < raw.parts.length; i++) {
-    const part = raw.parts[i];
-    if (isColumn(part)) {
-      out += allocName(part.name);
-    } else {
-      out += allocValue(part);
-    }
-    out += raw.template[i + 1];
+    out += raw.template[i + 1];
   }
   return out;
 }
@@ -896,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([
@@ -1156,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) {
@@ -1358,52 +1284,24 @@ 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();
-  /**
-   * Stream-enable opt-in, keyed by the model class. A model is only eligible to
-   * have its pre-write image fetched (`ReturnValues: ALL_OLD`) when it has been
-   * explicitly stream-enabled here. Default is disabled.
-   */
-  streamEnabled = /* @__PURE__ */ new Set();
-  /** Register an internal subscriber. Returns an idempotent unsubscribe. */
-  register(subscriber) {
-    this.subscribers.add(subscriber);
-    let active = true;
-    return () => {
-      if (!active) return;
-      active = false;
-      this.subscribers.delete(subscriber);
-    };
+// src/capture/registry.ts
+var ChangeCaptureRegistryImpl = class {
+  subscribers = /* @__PURE__ */ new Set();
+  /**
+   * Stream-enable opt-in, keyed by the model class. A model is only eligible to
+   * have its pre-write image fetched (`ReturnValues: ALL_OLD`) when it has been
+   * explicitly stream-enabled here. Default is disabled.
+   */
+  streamEnabled = /* @__PURE__ */ new Set();
+  /** Register an internal subscriber. Returns an idempotent unsubscribe. */
+  register(subscriber) {
+    this.subscribers.add(subscriber);
+    let active = true;
+    return () => {
+      if (!active) return;
+      active = false;
+      this.subscribers.delete(subscriber);
+    };
   }
   /** True when at least one subscriber is live. Cheap fast-path gate. */
   hasSubscribers() {
@@ -1727,115 +1625,115 @@ function ctxModelFor(modelClass) {
   return resolved;
 }
 
-// src/operations/put.ts
-function buildPutInput(modelClass, item, 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 serialized = {};
-  for (const fieldMeta of meta.fields) {
-    const value = item[fieldMeta.propertyName];
-    if (value !== void 0) {
-      serialized[fieldMeta.propertyName] = serializeFieldValue(value, fieldMeta);
+// 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 });
     }
   }
-  const keyInput = {};
-  for (const fieldName of meta.primaryKey.inputFieldNames) {
-    keyInput[fieldName] = serialized[fieldName] ?? item[fieldName];
+  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 { pk, sk } = resolveSegmentedKey(
-    meta.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;
-    }
+  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 available = {};
-  for (const fieldName of meta.fields.map((f) => f.propertyName)) {
-    available[fieldName] = serialized[fieldName] ?? item[fieldName];
+  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);
   }
-  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;
+  const parts = [];
+  if (setClauses.length > 0) {
+    parts.push(`SET ${setClauses.join(", ")}`);
   }
-  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;
-    }
+  if (removeClauses.length > 0) {
+    parts.push(`REMOVE ${removeClauses.join(", ")}`);
   }
-  return putInput;
+  return {
+    expression: parts.join(" "),
+    names,
+    values
+  };
 }
-async function executePut(modelClass, item, options) {
-  const mw = writeRuntimeFor(options);
-  if (mw) {
-    await executeSingleWriteWithHooks({ kind: "put", modelClass, item, options }, mw);
-    return;
+
+// 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."
+    );
   }
-  await executePutCore(modelClass, item, options);
-}
-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 sk = raw.SK;
+  const value = {
+    PK: pk,
+    SK: typeof sk === "string" ? sk : ""
+  };
+  Object.defineProperty(result, GRAPHDDB_KEY, {
+    value,
+    enumerable: false,
+    writable: false,
+    configurable: false
   });
-  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 } : {}
-    });
-  }
+  return result;
+}
+function readHiddenKey(entity) {
+  const value = entity[GRAPHDDB_KEY];
+  if (value === void 0) return void 0;
+  return value;
 }
 
-// src/operations/delete.ts
-function buildDeleteInput(modelClass, keyObj, options) {
-  const meta = MetadataRegistry.get(modelClass);
-  if (!meta.primaryKey) {
+// 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(
-      `No primary key defined for '${modelClass.name}'. Ensure the model has a static \`keys = key(...)\` definition.`
+      `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 tableName = TableMapping.resolve(meta.tableName);
-  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 primaryKey.inputFieldNames) {
+    let value = entity[fieldName];
     const fieldMeta = fieldMap.get(fieldName);
     if (fieldMeta && value !== void 0) {
       value = serializeFieldValue(value, fieldMeta);
@@ -1843,173 +1741,11 @@ function buildDeleteInput(modelClass, keyObj, options) {
     keyInput[fieldName] = value;
   }
   const { pk, sk } = resolveSegmentedKey(
-    meta.primaryKey.segmented,
+    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 ?? "" };
+  return { pk, sk: sk ?? "" };
 }
 function buildGsiRederiveSets(modelClass, meta, entity, serializedChanges, fieldMap, names, values, options) {
   const changedFields = new Set(Object.keys(serializedChanges));
@@ -2258,6 +1994,259 @@ async function executeUpdateCore(modelClass, entity, changes, options, persistVi
   }
 }
 
+// src/operations/delete.ts
+function buildDeleteInput(modelClass, keyObj, 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])
+  );
+  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;
+  }
+  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/put.ts
+function buildPutInput(modelClass, item, 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 serialized = {};
+  for (const fieldMeta of meta.fields) {
+    const value = item[fieldMeta.propertyName];
+    if (value !== void 0) {
+      serialized[fieldMeta.propertyName] = serializeFieldValue(value, fieldMeta);
+    }
+  }
+  const keyInput = {};
+  for (const fieldName of meta.primaryKey.inputFieldNames) {
+    keyInput[fieldName] = serialized[fieldName] ?? item[fieldName];
+  }
+  const { pk, sk } = resolveSegmentedKey(
+    meta.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;
+    }
+  }
+  const available = {};
+  for (const fieldName of meta.fields.map((f) => f.propertyName)) {
+    available[fieldName] = serialized[fieldName] ?? item[fieldName];
+  }
+  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;
+  }
+  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;
+    }
+  }
+  return putInput;
+}
+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);
+}
+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 } : {}
+    });
+  }
+}
+
 // src/runtime/same-key-collapse.ts
 function collapseSameKey(items, view) {
   const groups = /* @__PURE__ */ new Map();
@@ -2448,182 +2437,6 @@ function resolveModelClass(model) {
   }
   return modelClass;
 }
-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",
-      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 }
-    });
-    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) };
-}
 
 export {
   gsi,
@@ -2634,21 +2447,13 @@ export {
   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,
@@ -2659,7 +2464,6 @@ export {
   buildReadRuntime,
   buildWriteRuntime,
   ctxModelFor,
-  buildUpdateExpression,
   attachHiddenKey,
   buildUpdateInput,
   executeUpdate,
@@ -2668,11 +2472,8 @@ export {
   buildPutInput,
   executePut,
   MAX_TRANSACT_ITEMS,
-  collapseSameKeyItems,
   commitTransaction,
   execItemKeySignature,
   attachModelClass,
-  resolveModelClass,
-  TransactionContext,
-  executeTransaction
+  resolveModelClass
 };