@nicia-ai/typegraph 0.48.0 → 0.50.0

package/dist/{chunk-JB6T4GLL.cjs → chunk-C76WFIVZ.cjs}

@@ -1,19 +1,19 @@
 'use strict';
 
-var chunk3KOY4FH3_cjs = require('./chunk-3KOY4FH3.cjs');
-var chunkJFRT7S3B_cjs = require('./chunk-JFRT7S3B.cjs');
-var chunkEZEEWCFJ_cjs = require('./chunk-EZEEWCFJ.cjs');
-var chunkPWLJ77UV_cjs = require('./chunk-PWLJ77UV.cjs');
-var chunkSIT26LAZ_cjs = require('./chunk-SIT26LAZ.cjs');
-var chunk3U5ABFDW_cjs = require('./chunk-3U5ABFDW.cjs');
-var chunk5PRKMB24_cjs = require('./chunk-5PRKMB24.cjs');
-var chunkFQPEMEWX_cjs = require('./chunk-FQPEMEWX.cjs');
-var chunkTQHGE7UC_cjs = require('./chunk-TQHGE7UC.cjs');
-var chunkL3LQNR34_cjs = require('./chunk-L3LQNR34.cjs');
-var chunkEDN4Y4ZG_cjs = require('./chunk-EDN4Y4ZG.cjs');
+var chunkTUVD4DFR_cjs = require('./chunk-TUVD4DFR.cjs');
+var chunk7PRMDZIA_cjs = require('./chunk-7PRMDZIA.cjs');
+var chunk5OWHU7Z7_cjs = require('./chunk-5OWHU7Z7.cjs');
+var chunkRDP6ZRSM_cjs = require('./chunk-RDP6ZRSM.cjs');
+var chunkZBFZGLZE_cjs = require('./chunk-ZBFZGLZE.cjs');
+var chunkIHK5KA2Q_cjs = require('./chunk-IHK5KA2Q.cjs');
+var chunkGHZPZNFC_cjs = require('./chunk-GHZPZNFC.cjs');
+var chunkLLVOQOWE_cjs = require('./chunk-LLVOQOWE.cjs');
+var chunkM5MSP3BI_cjs = require('./chunk-M5MSP3BI.cjs');
+var chunkTEC24ZDA_cjs = require('./chunk-TEC24ZDA.cjs');
+var chunkOJHD3LXJ_cjs = require('./chunk-OJHD3LXJ.cjs');
 var chunkHAHNRASW_cjs = require('./chunk-HAHNRASW.cjs');
-var chunk6NGW27EO_cjs = require('./chunk-6NGW27EO.cjs');
-var chunkMRDBBHIZ_cjs = require('./chunk-MRDBBHIZ.cjs');
+var chunkVLBTRXA2_cjs = require('./chunk-VLBTRXA2.cjs');
+var chunkX4GDXBOP_cjs = require('./chunk-X4GDXBOP.cjs');
 var chunkA7J2YDDI_cjs = require('./chunk-A7J2YDDI.cjs');
 var chunkN66HCGCY_cjs = require('./chunk-N66HCGCY.cjs');
 
@@ -22,8 +22,8 @@ function nullToUndefined(value) {
   return value === null ? void 0 : value;
 }
 function rowToNode(row) {
-  const rawProps = chunk5PRKMB24_cjs.rowPropsToObject(row.props);
-  const props = chunk6NGW27EO_cjs.filterReservedKeys(rawProps, chunk6NGW27EO_cjs.RESERVED_NODE_KEYS);
+  const rawProps = chunkGHZPZNFC_cjs.rowPropsToObject(row.props);
+  const props = chunkVLBTRXA2_cjs.filterReservedKeys(rawProps, chunkVLBTRXA2_cjs.RESERVED_NODE_KEYS);
   return {
     kind: row.kind,
     id: row.id,
@@ -42,8 +42,8 @@ function rowToNodeMeta(row) {
   };
 }
 function rowToEdge(row) {
-  const rawProps = chunk5PRKMB24_cjs.rowPropsToObject(row.props);
-  const props = chunk6NGW27EO_cjs.filterReservedKeys(rawProps, chunk6NGW27EO_cjs.RESERVED_EDGE_KEYS);
+  const rawProps = chunkGHZPZNFC_cjs.rowPropsToObject(row.props);
+  const props = chunkVLBTRXA2_cjs.filterReservedKeys(rawProps, chunkVLBTRXA2_cjs.RESERVED_EDGE_KEYS);
   return {
     id: row.id,
     kind: row.kind,
@@ -70,96 +70,476 @@ function edgeWriteNeedsConstraintFence(cardinality) {
   return cardinality === "many" ? void 0 : "edgeCardinality";
 }
 function nodeWriteNeedsConstraintFence(registry, kind, uniqueConstraints, operation) {
-  if (operation === "create" && registry.getDisjointKinds(kind).length > 0) {
-    return "nodeDisjointness";
+  return chunkTUVD4DFR_cjs.nodeClaimSites(registry, kind, uniqueConstraints, operation).find(
+    (site) => site.needsLockFence
+  )?.refusalReason;
+}
+function graphOwesClaims(graph, registry) {
+  for (const [kind, registration] of Object.entries(graph.nodes)) {
+    for (const operation of ["create", "update"]) {
+      const gating = chunkTUVD4DFR_cjs.nodeClaimSites(
+        registry,
+        kind,
+        registration.unique ?? [],
+        operation
+      ).find((site) => site.placement === "pre-insert");
+      if (gating !== void 0) return gating.refusalReason;
+    }
   }
-  const sharedScope = uniqueConstraints.some(
-    (constraint) => chunkFQPEMEWX_cjs.getKindsForUniquenessCheck(kind, constraint.scope, registry).length > 1
-  );
-  return sharedScope ? "nodeUniquenessScope" : void 0;
+  for (const registration of Object.values(graph.edges)) {
+    const reason = edgeWriteNeedsConstraintFence(
+      registration.cardinality ?? "many"
+    );
+    if (reason !== void 0) return reason;
+  }
+  return void 0;
 }
 async function checkDisjointnessConstraint(ctx, kind, id) {
   const disjointKinds = ctx.registry.getDisjointKinds(kind);
   for (const disjointKind of disjointKinds) {
     const existing = await ctx.backend.getNode(ctx.graphId, disjointKind, id);
     if (existing && !existing.deleted_at) {
-      const error = chunkFQPEMEWX_cjs.checkDisjointness(id, kind, [disjointKind], ctx.registry);
+      const error = chunkLLVOQOWE_cjs.checkDisjointness(id, kind, [disjointKind], ctx.registry);
       if (error) throw error;
     }
   }
 }
 async function checkCardinalityConstraint(ctx, edgeKind, cardinality, fromKind, fromId, toKind, toId, validTo) {
-  switch (cardinality) {
-    case "many": {
+  if (cardinality === "many") return;
+  const spec = chunk7PRMDZIA_cjs.EDGE_CARDINALITY_SPECS[cardinality];
+  if (!spec.claimsWhenBornEnded && validTo !== void 0) return;
+  if (spec.keyShape === "fromAndTo") {
+    const exists = await ctx.backend.edgeExistsBetween({
+      graphId: ctx.graphId,
+      edgeKind,
+      fromKind,
+      fromId,
+      toKind,
+      toId
+    });
+    const error2 = chunkLLVOQOWE_cjs.checkUniqueEdge(
+      edgeKind,
+      fromKind,
+      fromId,
+      toKind,
+      toId,
+      exists ? 1 : 0
+    );
+    if (error2) throw error2;
+    return;
+  }
+  const count = await ctx.backend.countEdgesFrom({
+    graphId: ctx.graphId,
+    edgeKind,
+    fromKind,
+    fromId,
+    activeOnly: spec.holderLiveness === "liveAndActive"
+  });
+  const error = chunkLLVOQOWE_cjs.checkCardinality(
+    edgeKind,
+    fromKind,
+    fromId,
+    cardinality,
+    count,
+    count > 0
+  );
+  if (error) throw error;
+}
+
+// src/store/operations/edge-batch-validation.ts
+function buildEdgeEndpointCacheKey(graphId, kind, id) {
+  return chunkLLVOQOWE_cjs.encodeTupleKey([graphId, kind, id]);
+}
+function buildEdgeFromCacheKey(graphId, edgeKind, fromKind, fromId) {
+  return chunkLLVOQOWE_cjs.encodeTupleKey([graphId, edgeKind, fromKind, fromId]);
+}
+function buildEdgeBetweenCacheKey(graphId, edgeKind, fromKind, fromId, toKind, toId) {
+  return chunkLLVOQOWE_cjs.encodeTupleKey([graphId, edgeKind, fromKind, fromId, toKind, toId]);
+}
+function buildCountEdgesFromCacheKey(params) {
+  const activeOnly = params.activeOnly === true ? "1" : "0";
+  return chunkLLVOQOWE_cjs.encodeTupleKey([
+    params.graphId,
+    params.edgeKind,
+    params.fromKind,
+    params.fromId,
+    activeOnly
+  ]);
+}
+function incrementPendingCount(counts, key) {
+  const previous = counts.get(key) ?? 0;
+  counts.set(key, previous + 1);
+}
+function createEdgeBatchValidationBackend(backend) {
+  const endpointCache = /* @__PURE__ */ new Map();
+  const countEdgesFromCache = /* @__PURE__ */ new Map();
+  const edgeExistsCache = /* @__PURE__ */ new Map();
+  const pendingOneCounts = /* @__PURE__ */ new Map();
+  const pendingOneActiveCounts = /* @__PURE__ */ new Map();
+  const pendingUniquePairs = /* @__PURE__ */ new Set();
+  async function getNodeCached(graphId, kind, id) {
+    const cacheKey = buildEdgeEndpointCacheKey(graphId, kind, id);
+    if (endpointCache.has(cacheKey)) {
+      return endpointCache.get(cacheKey);
+    }
+    const node = await backend.getNode(graphId, kind, id);
+    endpointCache.set(cacheKey, node);
+    return node;
+  }
+  function seedEndpointRow(graphId, kind, id, row) {
+    const cacheKey = buildEdgeEndpointCacheKey(graphId, kind, id);
+    if (endpointCache.has(cacheKey)) return;
+    endpointCache.set(cacheKey, row);
+  }
+  async function countEdgesFromCached(params) {
+    const cacheKey = buildCountEdgesFromCacheKey(params);
+    let baseCount = countEdgesFromCache.get(cacheKey);
+    if (baseCount === void 0) {
+      baseCount = await backend.countEdgesFrom(params);
+      countEdgesFromCache.set(cacheKey, baseCount);
+    }
+    const pendingKey = buildEdgeFromCacheKey(
+      params.graphId,
+      params.edgeKind,
+      params.fromKind,
+      params.fromId
+    );
+    const pendingCount = params.activeOnly === true ? pendingOneActiveCounts.get(pendingKey) ?? 0 : pendingOneCounts.get(pendingKey) ?? 0;
+    return baseCount + pendingCount;
+  }
+  async function edgeExistsBetweenCached(params) {
+    const cacheKey = buildEdgeBetweenCacheKey(
+      params.graphId,
+      params.edgeKind,
+      params.fromKind,
+      params.fromId,
+      params.toKind,
+      params.toId
+    );
+    if (pendingUniquePairs.has(cacheKey)) {
+      return true;
+    }
+    if (edgeExistsCache.has(cacheKey)) {
+      return edgeExistsCache.get(cacheKey) ?? false;
+    }
+    const exists = await backend.edgeExistsBetween(params);
+    edgeExistsCache.set(cacheKey, exists);
+    return exists;
+  }
+  function registerPendingEdgeForCardinality(insertParams, cardinality) {
+    const fromCacheKey = buildEdgeFromCacheKey(
+      insertParams.graphId,
+      insertParams.kind,
+      insertParams.fromKind,
+      insertParams.fromId
+    );
+    if (cardinality === "one") {
+      incrementPendingCount(pendingOneCounts, fromCacheKey);
       return;
     }
-    case "one": {
-      const count = await ctx.backend.countEdgesFrom({
-        graphId: ctx.graphId,
-        edgeKind,
-        fromKind,
-        fromId
-      });
-      const error = chunkFQPEMEWX_cjs.checkCardinality(
-        edgeKind,
-        fromKind,
-        fromId,
-        "one",
-        count,
-        false
-      );
-      if (error) throw error;
+    if (cardinality === "oneActive") {
+      if (insertParams.validTo === void 0) {
+        incrementPendingCount(pendingOneActiveCounts, fromCacheKey);
+      }
       return;
     }
-    case "unique": {
-      const exists = await ctx.backend.edgeExistsBetween({
-        graphId: ctx.graphId,
-        edgeKind,
-        fromKind,
-        fromId,
-        toKind,
-        toId
-      });
-      const error = chunkFQPEMEWX_cjs.checkUniqueEdge(
-        edgeKind,
-        fromKind,
-        fromId,
-        toKind,
-        toId,
-        exists ? 1 : 0
+    if (cardinality === "unique") {
+      const uniqueCacheKey = buildEdgeBetweenCacheKey(
+        insertParams.graphId,
+        insertParams.kind,
+        insertParams.fromKind,
+        insertParams.fromId,
+        insertParams.toKind,
+        insertParams.toId
       );
-      if (error) throw error;
-      return;
+      pendingUniquePairs.add(uniqueCacheKey);
     }
-    case "oneActive": {
-      if (validTo !== void 0) {
-        return;
+  }
+  const validationBackend = chunkZBFZGLZE_cjs.deriveBackend(backend, {
+    getNode: getNodeCached,
+    countEdgesFrom: countEdgesFromCached,
+    edgeExistsBetween: edgeExistsBetweenCached
+  });
+  return {
+    backend: validationBackend,
+    registerPendingEdgeForCardinality,
+    seedEndpointRow
+  };
+}
+
+// src/store/operations/edge-write-pipeline.ts
+function createEdgeWriteContext(graphId, lock) {
+  return { graphId, lock };
+}
+async function applyEdgeUpdate(ctx, args, backend) {
+  const { claim, ...rowWork } = args;
+  if (claim !== void 0) await chunk7PRMDZIA_cjs.claimEdgeCardinality(backend, claim);
+  const updateParams = { graphId: ctx.graphId, ...rowWork };
+  return backend.updateEdge(updateParams);
+}
+function applyEdgeSoftDelete(ctx, work, backend) {
+  return backend.deleteEdge({
+    graphId: ctx.graphId,
+    id: work.id,
+    kind: work.kind
+  });
+}
+async function applyEdgeHardDelete(ctx, work, backend) {
+  await backend.hardDeleteEdge({
+    graphId: ctx.graphId,
+    id: work.id,
+    kind: work.kind
+  });
+  if (work.holdsCardinalityClaim) {
+    await chunk7PRMDZIA_cjs.purgeEdgeClaims(backend, ctx.graphId, [work.id]);
+  }
+}
+
+// src/store/operations/write-fences.ts
+function createWriteParamsDraft() {
+  return {};
+}
+function assertsStoredWindowState(fences) {
+  return chunkM5MSP3BI_cjs.assertsStoredLowerBound(fences.validityLowerBound) || chunkM5MSP3BI_cjs.assertsStoredUpperBound(fences.validityUpperBound);
+}
+var UnsupportedWriteFenceError = class extends Error {
+  fence;
+  kind;
+  constructor(fence, kind) {
+    super(
+      `The ${kind} statement cannot carry the "${fence}" fence, so the write is refused rather than run unfenced. Assert nothing ({}) or use a write shape whose statement carries it.`
+    );
+    this.name = "UnsupportedWriteFenceError";
+    this.fence = fence;
+    this.kind = kind;
+  }
+};
+function applyValidityLowerBound(fence, draft) {
+  if (!chunkM5MSP3BI_cjs.assertsStoredLowerBound(fence)) return;
+  draft.expectedValidFrom = fence.expectedValidFrom;
+}
+var NODE_UPDATE_FENCE_APPLIERS = {
+  validityLowerBound: applyValidityLowerBound
+};
+var NODE_SET_UPDATE_FENCE_APPLIERS = {
+  validityLowerBound: (fence) => {
+    if (!chunkM5MSP3BI_cjs.assertsStoredLowerBound(fence)) return;
+    throw new UnsupportedWriteFenceError("validityLowerBound", "nodeSetUpdate");
+  }
+};
+function applyEdgeIdentity(fence, draft) {
+  draft.kind = fence.kind;
+  if (fence.fromKind !== void 0) draft.fromKind = fence.fromKind;
+  if (fence.fromId !== void 0) draft.fromId = fence.fromId;
+  if (fence.toKind !== void 0) draft.toKind = fence.toKind;
+  if (fence.toId !== void 0) draft.toId = fence.toId;
+}
+function applyValidityUpperBound(fence, draft) {
+  if (!chunkM5MSP3BI_cjs.assertsStoredUpperBound(fence)) return;
+  draft.expectedValidTo = fence.expectedValidTo;
+}
+var EDGE_UPDATE_FENCE_APPLIERS = {
+  validityLowerBound: applyValidityLowerBound,
+  validityUpperBound: applyValidityUpperBound,
+  edgeIdentity: applyEdgeIdentity
+};
+function applyWriteFences(appliers, fences, draft) {
+  for (const key of Object.keys(appliers)) {
+    const applier = appliers[key];
+    applier(fences[key], draft);
+  }
+}
+
+// src/store/operations/write-session.ts
+function unfencedTarget(target) {
+  return target;
+}
+function edgeBatchClaims(work) {
+  return work.flatMap((item) => item.claim === void 0 ? [] : [item.claim]);
+}
+function createWriteSession(ctx, target, lock) {
+  const writeContext = chunkTUVD4DFR_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock);
+  const dispatch = chunkRDP6ZRSM_cjs.nodeInsertDispatch(target);
+  const edgeContext = createEdgeWriteContext(ctx.graphId, lock);
+  const edgeDispatch = chunkRDP6ZRSM_cjs.edgeInsertDispatch(target);
+  return {
+    // The pinned coordination order, spelled once per insert shape:
+    // pre-insert claims, the row, post-insert claims, the sync fans. The claim
+    // seam owns the two groups and the compensation between them; this surface
+    // owns only "the row write it gates is THIS one".
+    createNode: async (work) => {
+      const row = await chunkTUVD4DFR_cjs.withNodeCreateClaims(
+        writeContext,
+        work.claim,
+        target,
+        () => dispatch.one(work.params)
+      );
+      await chunkTUVD4DFR_cjs.applyNodeInsertSyncFans(writeContext, work.sideEffects, target);
+      return row;
+    },
+    createNodeNoReturn: async (work) => {
+      await chunkTUVD4DFR_cjs.withNodeCreateClaims(
+        writeContext,
+        work.claim,
+        target,
+        () => chunkRDP6ZRSM_cjs.runInsertNoReturn(dispatch, work.params)
+      );
+      await chunkTUVD4DFR_cjs.applyNodeInsertSyncFans(writeContext, work.sideEffects, target);
+    },
+    createNodes: async (work) => {
+      const rows = await chunkTUVD4DFR_cjs.withNodeCreateClaimsBatch(
+        writeContext,
+        work.map((item) => item.claim),
+        target,
+        () => chunkRDP6ZRSM_cjs.runInsertBatchReturning(
+          dispatch,
+          work.map((item) => item.params)
+        )
+      );
+      await chunkTUVD4DFR_cjs.applyNodeInsertSyncFansBatch(
+        writeContext,
+        work.map((item) => item.sideEffects),
+        target
+      );
+      return rows;
+    },
+    createNodesNoReturn: async (work) => {
+      await chunkTUVD4DFR_cjs.withNodeCreateClaimsBatch(
+        writeContext,
+        work.map((item) => item.claim),
+        target,
+        () => chunkRDP6ZRSM_cjs.runInsertBatch(
+          dispatch,
+          work.map((item) => item.params)
+        )
+      );
+      await chunkTUVD4DFR_cjs.applyNodeInsertSyncFansBatch(
+        writeContext,
+        work.map((item) => item.sideEffects),
+        target
+      );
+    },
+    reviseNode: (work, fences) => {
+      const draft = createWriteParamsDraft();
+      applyWriteFences(NODE_UPDATE_FENCE_APPLIERS, fences, draft);
+      return chunkTUVD4DFR_cjs.applyNodeUpdate(writeContext, { ...work, ...draft }, target);
+    },
+    retireNode: (work, policy) => chunkTUVD4DFR_cjs.applyNodeSoftDelete(writeContext, work, target, policy),
+    purgeNode: (work) => chunkTUVD4DFR_cjs.applyNodeHardDelete(writeContext, work, target),
+    reviveNode: (work) => chunkTUVD4DFR_cjs.applyNodeResurrect(writeContext, work, target),
+    reviseNodeSet: (work, fences) => {
+      applyWriteFences(
+        NODE_SET_UPDATE_FENCE_APPLIERS,
+        fences,
+        createWriteParamsDraft()
+      );
+      return chunkTUVD4DFR_cjs.applyNodeSetUpdate(writeContext, work, target);
+    },
+    // An edge write obliges no DERIVED data, so these apply no sync fans — but a
+    // constrained kind owes its cardinality claim, at the same PRE-INSERT
+    // placement a node's scope-spanning claim takes and for the same reason: the
+    // probe that authorised the insert read a population no key fences. The
+    // batch issues ONE sorted statement (`claimEdgeCardinalityBatch` orders by
+    // `compareClaimTargets`), so a batch and a peer batch take their row locks
+    // in the same order.
+    createEdge: async (work) => {
+      if (work.claim !== void 0) {
+        await chunk7PRMDZIA_cjs.claimEdgeCardinality(target, work.claim);
       }
-      const count = await ctx.backend.countEdgesFrom({
-        graphId: ctx.graphId,
-        edgeKind,
-        fromKind,
-        fromId,
-        activeOnly: true
-      });
-      const error = chunkFQPEMEWX_cjs.checkCardinality(
-        edgeKind,
-        fromKind,
-        fromId,
-        "oneActive",
-        count,
-        count > 0
+      return edgeDispatch.one(work.params);
+    },
+    createEdgeNoReturn: async (work) => {
+      if (work.claim !== void 0) {
+        await chunk7PRMDZIA_cjs.claimEdgeCardinality(target, work.claim);
+      }
+      await chunkRDP6ZRSM_cjs.runInsertNoReturn(edgeDispatch, work.params);
+    },
+    createEdges: async (work) => {
+      await chunk7PRMDZIA_cjs.claimEdgeCardinalityBatch(target, edgeBatchClaims(work));
+      return chunkRDP6ZRSM_cjs.runInsertBatchReturning(
+        edgeDispatch,
+        work.map((item) => item.params)
       );
-      if (error) throw error;
-      return;
+    },
+    createEdgesNoReturn: async (work) => {
+      await chunk7PRMDZIA_cjs.claimEdgeCardinalityBatch(target, edgeBatchClaims(work));
+      await chunkRDP6ZRSM_cjs.runInsertBatch(
+        edgeDispatch,
+        work.map((item) => item.params)
+      );
+    },
+    reviseEdge: (work, fences) => {
+      const draft = createWriteParamsDraft();
+      applyWriteFences(EDGE_UPDATE_FENCE_APPLIERS, fences, draft);
+      return applyEdgeUpdate(edgeContext, { ...work, ...draft }, target);
+    },
+    retireEdge: (work) => applyEdgeSoftDelete(edgeContext, work, target),
+    purgeEdge: (work) => applyEdgeHardDelete(edgeContext, work, target)
+  };
+}
+
+// src/store/operations/write-executor.ts
+function planFrame(ctx, plan, rowWork) {
+  return async (target, lock) => {
+    if (plan.requiresIdentityLock) {
+      const acquireIdentityLock = chunkN66HCGCY_cjs.requireDefined(
+        ctx.identityLock,
+        "write plan declares identity participation with no acquirer"
+      );
+      await acquireIdentityLock(target);
     }
-  }
+    const mintSessionOver = (sessionTarget) => createWriteSession(ctx, sessionTarget, lock);
+    const mintOverlaidSession = (reads) => mintSessionOver(chunkZBFZGLZE_cjs.deriveBackend(target, reads));
+    return rowWork(
+      mintSessionOver(target),
+      target,
+      mintOverlaidSession
+    );
+  };
+}
+function planTransactionOptions(plan, options) {
+  return { ...options, fencesConstraintProbe: plan.constraintProbe };
+}
+function runWritePlan(ctx, plan, backend, rowWork, options) {
+  return chunkRDP6ZRSM_cjs.runInWriteTransaction(
+    ctx,
+    backend,
+    planFrame(ctx, plan, rowWork),
+    planTransactionOptions(plan, options)
+  );
+}
+function runHookedWritePlan(ctx, opContext, plan, backend, rowWork, options) {
+  return chunkRDP6ZRSM_cjs.runHookedWriteOperation(
+    ctx,
+    opContext,
+    backend,
+    planFrame(ctx, plan, rowWork),
+    planTransactionOptions(plan, options)
+  );
+}
+
+// src/store/operations/write-plan.ts
+function nodeWritePlan(constraintProbe, requiresIdentityLock) {
+  return { entity: "node", constraintProbe, requiresIdentityLock };
+}
+function nodeBatchWritePlan(constraintProbes, requiresIdentityLock) {
+  return {
+    entity: "node",
+    constraintProbe: constraintProbes.find((probe) => probe !== void 0),
+    requiresIdentityLock
+  };
+}
+function edgeWritePlan(constraintProbe) {
+  return { entity: "edge", constraintProbe, requiresIdentityLock: false };
+}
+function mixedWritePlan(constraintProbe, requiresIdentityLock) {
+  return { entity: "mixed", constraintProbe, requiresIdentityLock };
 }
 
 // src/store/validity-end.ts
 function assertValidityEndMutation(input, context) {
   if (input.validTo === void 0 || input.clearValidTo !== true) return;
-  throw new chunkMRDBBHIZ_cjs.ValidationError(
+  throw new chunkX4GDXBOP_cjs.ValidationError(
     '"validTo" and "clearValidTo" are mutually exclusive',
     {
       ...context,
@@ -179,7 +559,7 @@ function validityEndAfterMutation(input, current) {
 }
 function assertClearValidToSupported(backend, entityType) {
   if (backend.capabilities.clearValidTo === true) return;
-  throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+  throw new chunkX4GDXBOP_cjs.ConfigurationError(
     `This backend does not support clearing ${entityType} validTo`,
     {
       code: "CLEAR_VALID_TO_UNSUPPORTED",
@@ -195,7 +575,7 @@ var ENTITY_LABELS = {
 };
 function alreadyExistsError(entity, kind, id, detail, cause) {
   const label = ENTITY_LABELS[entity];
-  return new chunkMRDBBHIZ_cjs.ValidationError(
+  return new chunkX4GDXBOP_cjs.ValidationError(
     `${label.title} already exists: ${detail}`,
     {
       entityType: entity,
@@ -205,7 +585,7 @@ function alreadyExistsError(entity, kind, id, detail, cause) {
       issues: [
         {
           path: "id",
-          code: chunkMRDBBHIZ_cjs.ENTITY_ALREADY_EXISTS_CODE,
+          code: chunkX4GDXBOP_cjs.ENTITY_ALREADY_EXISTS_CODE,
           message: `${label.article} with this ID already exists`
         }
       ]
@@ -220,7 +600,7 @@ function createAlreadyExistsError(entity, kind, id) {
   return alreadyExistsError(entity, kind, id, `${kind}/${id}`, void 0);
 }
 function isDuplicateKeyInsertError(error, entity) {
-  return error instanceof chunkMRDBBHIZ_cjs.DatabaseOperationError && error.details.operation === "insert" && error.details.entity === entity && error.details.reason === "duplicate_key";
+  return error instanceof chunkX4GDXBOP_cjs.DatabaseOperationError && error.details.operation === "insert" && error.details.entity === entity && error.details.reason === "duplicate_key";
 }
 function rethrowAsAlreadyExists(error, entity) {
   if (!isDuplicateKeyInsertError(error, entity)) throw error;
@@ -254,9 +634,9 @@ async function withAlreadyExistsTranslation(entity, run) {
 
 // src/store/operations/node-operations.ts
 function getNodeRegistration(graph, kind) {
-  if (!chunkN66HCGCY_cjs.hasOwnKey(graph.nodes, kind)) throw new chunkMRDBBHIZ_cjs.KindNotFoundError(kind, "node");
+  if (!chunkN66HCGCY_cjs.hasOwnKey(graph.nodes, kind)) throw new chunkX4GDXBOP_cjs.KindNotFoundError(kind, "node");
   const registration = graph.nodes[kind];
-  if (registration === void 0) throw new chunkMRDBBHIZ_cjs.KindNotFoundError(kind, "node");
+  if (registration === void 0) throw new chunkX4GDXBOP_cjs.KindNotFoundError(kind, "node");
   return registration;
 }
 function nodeFencesConstraintProbe(ctx, kind, operation) {
@@ -268,18 +648,24 @@ function nodeFencesConstraintProbe(ctx, kind, operation) {
     operation
   );
 }
-function nodeBatchFencesConstraintProbe(ctx, inputs, operation) {
-  for (const input of inputs) {
-    const reason = nodeFencesConstraintProbe(ctx, input.kind, operation);
-    if (reason !== void 0) return reason;
-  }
-  return void 0;
+function nodeBatchConstraintProbes(ctx, inputs, operation) {
+  return inputs.map(
+    (input) => nodeFencesConstraintProbe(ctx, input.kind, operation)
+  );
+}
+function nodeWritePlanContext(ctx) {
+  const identity = ctx.identity;
+  if (identity === void 0) return ctx;
+  return { ...ctx, identityLock: identity.lock };
+}
+function nodeRequiresIdentityLock(ctx) {
+  return ctx.identity !== void 0;
 }
 function buildNodeCacheKey(graphId, kind, id) {
-  return chunkEZEEWCFJ_cjs.encodeTupleKey([graphId, kind, id]);
+  return chunkLLVOQOWE_cjs.encodeTupleKey([graphId, kind, id]);
 }
 function buildUniqueCacheKey(graphId, nodeKind, constraintName, key) {
-  return chunkEZEEWCFJ_cjs.encodeTupleKey([graphId, nodeKind, constraintName, key]);
+  return chunkLLVOQOWE_cjs.encodeTupleKey([graphId, nodeKind, constraintName, key]);
 }
 function buildInsertNodeParams(graphId, kind, id, props, validFrom, validTo) {
   const insertParams = {
@@ -292,14 +678,14 @@ function buildInsertNodeParams(graphId, kind, id, props, validFrom, validTo) {
   if (validTo !== void 0) insertParams.validTo = validTo;
   return insertParams;
 }
-function createPendingUniqueRow(graphId, nodeKind, constraintName, key, nodeId) {
+function createPendingUniqueRow(graphId, nodeKind, constraintName, key, owner) {
   return {
     graph_id: graphId,
     node_kind: nodeKind,
     constraint_name: constraintName,
     key,
-    node_id: nodeId,
-    concrete_kind: nodeKind,
+    node_id: owner.nodeId,
+    concrete_kind: owner.concreteKind,
     deleted_at: void 0
   };
 }
@@ -310,11 +696,11 @@ function resolveConstraint(graph, kind, constraintName) {
     (candidate) => candidate.name === constraintName
   );
   if (constraint === void 0) {
-    throw new chunkMRDBBHIZ_cjs.NodeConstraintNotFoundError(constraintName, kind);
+    throw new chunkX4GDXBOP_cjs.NodeConstraintNotFoundError(constraintName, kind);
   }
   return constraint;
 }
-function createNodeBatchValidationBackend(graphId, registry, backend) {
+function createNodeBatchValidationSeams(graphId, registry, backend) {
   const nodeCache = /* @__PURE__ */ new Map();
   const pendingNodes = /* @__PURE__ */ new Map();
   const uniqueCache = /* @__PURE__ */ new Map();
@@ -370,71 +756,72 @@ function createNodeBatchValidationBackend(graphId, registry, backend) {
     });
   }
   function registerPendingUniqueEntries(kind, id, props, constraints) {
-    for (const constraint of constraints) {
-      if (!chunkFQPEMEWX_cjs.checkWherePredicate(constraint, props)) continue;
-      const key = chunkFQPEMEWX_cjs.computeUniqueKey(
-        props,
-        constraint.fields,
-        constraint.collation
-      );
-      const concreteEntryKey = buildUniqueCacheKey(
-        graphId,
-        kind,
-        constraint.name,
-        key
+    for (const entry of chunkTUVD4DFR_cjs.nodeClaimEntries(
+      registry,
+      kind,
+      id,
+      props,
+      constraints,
+      "create"
+    )) {
+      pendingUniqueOwners.set(
+        buildUniqueCacheKey(
+          graphId,
+          entry.axis,
+          entry.constraintName,
+          entry.key
+        ),
+        { concreteKind: kind, nodeId: id }
       );
-      pendingUniqueOwners.set(concreteEntryKey, id);
-      if (constraint.scope !== "kind") {
-        const kindsToCheck = chunkFQPEMEWX_cjs.getKindsForUniquenessCheck(
-          kind,
-          constraint.scope,
-          registry
-        );
-        for (const kindToCheck of kindsToCheck) {
-          const inheritedEntryKey = buildUniqueCacheKey(
-            graphId,
-            kindToCheck,
-            constraint.name,
-            key
-          );
-          pendingUniqueOwners.set(inheritedEntryKey, id);
-        }
-      }
     }
   }
   function registerAppliedNodeUpdate(kind, id, oldProps, newProps, constraints) {
+    const owner = { concreteKind: kind, nodeId: id };
+    const oldEntries = new Map(
+      chunkTUVD4DFR_cjs.nodeClaimEntries(registry, kind, id, oldProps, constraints, "update").map(
+        (entry) => [entry.constraintName, entry]
+      )
+    );
+    const newEntries = new Map(
+      chunkTUVD4DFR_cjs.nodeClaimEntries(registry, kind, id, newProps, constraints, "update").map(
+        (entry) => [entry.constraintName, entry]
+      )
+    );
     for (const constraint of constraints) {
-      const oldApplies = chunkFQPEMEWX_cjs.checkWherePredicate(constraint, oldProps);
-      const newApplies = chunkFQPEMEWX_cjs.checkWherePredicate(constraint, newProps);
-      const oldKey = oldApplies ? chunkFQPEMEWX_cjs.computeUniqueKey(oldProps, constraint.fields, constraint.collation) : void 0;
-      const newKey = newApplies ? chunkFQPEMEWX_cjs.computeUniqueKey(newProps, constraint.fields, constraint.collation) : void 0;
-      if (oldKey === newKey) continue;
-      const kindsToCheck = chunkFQPEMEWX_cjs.getKindsForUniquenessCheck(
+      const oldEntry = oldEntries.get(constraint.name);
+      const newEntry = newEntries.get(constraint.name);
+      if (oldEntry?.key === newEntry?.key) continue;
+      const kindsToCheck = chunkLLVOQOWE_cjs.uniquenessProbeKinds(
         kind,
         constraint.scope,
         registry
       );
-      if (oldKey !== void 0) {
+      if (oldEntry !== void 0) {
         for (const kindToCheck of kindsToCheck) {
           const cacheKey = buildUniqueCacheKey(
             graphId,
             kindToCheck,
             constraint.name,
-            oldKey
+            oldEntry.key
           );
           pendingUniqueOwners.delete(cacheKey);
           uniqueCache.set(cacheKey, void 0);
         }
       }
-      if (newKey !== void 0) {
+      if (newEntry !== void 0) {
         for (const kindToCheck of kindsToCheck) {
           const cacheKey = buildUniqueCacheKey(
             graphId,
             kindToCheck,
             constraint.name,
-            newKey
+            newEntry.key
           );
-          pendingUniqueOwners.set(cacheKey, id);
+          if (kindToCheck === newEntry.axis) {
+            pendingUniqueOwners.set(cacheKey, owner);
+            continue;
+          }
+          pendingUniqueOwners.delete(cacheKey);
+          uniqueCache.set(cacheKey, void 0);
         }
       }
     }
@@ -449,12 +836,13 @@ function createNodeBatchValidationBackend(graphId, registry, backend) {
     if (uniqueCache.has(cacheKey)) return;
     uniqueCache.set(cacheKey, row);
   }
-  const validationBackend = chunkSIT26LAZ_cjs.deriveBackend(backend, {
+  const reads = {
     getNode: getNodeCached,
     checkUnique: checkUniqueCached
-  });
+  };
   return {
-    backend: validationBackend,
+    reads,
+    reader: chunkZBFZGLZE_cjs.deriveBackend(backend, reads),
     registerPendingNode,
     registerPendingUniqueEntries,
     registerAppliedNodeUpdate,
@@ -466,16 +854,16 @@ function draftNodeCreate(ctx, input, id, options) {
   const kind = input.kind;
   const registration = getNodeRegistration(ctx.graph, kind);
   const nodeKind = registration.type;
-  const validatedProps = options?.propsPreValidated === true ? input.props : chunkJFRT7S3B_cjs.validateNodeProps(nodeKind.schema, input.props, {
+  const validatedProps = options?.propsPreValidated === true ? input.props : chunkRDP6ZRSM_cjs.validateNodeProps(nodeKind.schema, input.props, {
     kind,
     operation: "create"
   });
-  const validFrom = chunkTQHGE7UC_cjs.validateOptionalCanonicalIsoDate(
+  const validFrom = chunkM5MSP3BI_cjs.validateOptionalCanonicalIsoDate(
     input.validFrom,
     "validFrom"
   );
-  const validTo = chunkTQHGE7UC_cjs.validateOptionalCanonicalIsoDate(input.validTo, "validTo");
-  chunkTQHGE7UC_cjs.assertOrderedValidityWindow(`${kind} "${id}"`, validFrom, validTo);
+  const validTo = chunkM5MSP3BI_cjs.validateOptionalCanonicalIsoDate(input.validTo, "validTo");
+  chunkM5MSP3BI_cjs.assertOrderedValidityWindow(`${kind} "${id}"`, validFrom, validTo);
   return {
     kind,
     id,
@@ -499,8 +887,8 @@ async function finishNodeCreatePreparation(ctx, draft, backend) {
     backend
   };
   await checkDisjointnessConstraint(constraintContext, kind, id);
-  await chunk3KOY4FH3_cjs.checkUniquenessConstraints(
-    chunk3KOY4FH3_cjs.createUniquenessContext(ctx.graphId, ctx.registry, backend),
+  await chunkTUVD4DFR_cjs.checkUniquenessConstraints(
+    chunkTUVD4DFR_cjs.createUniquenessContext(ctx.graphId, ctx.registry, backend),
     kind,
     id,
     validatedProps,
@@ -531,38 +919,36 @@ async function validateAndPrepareNodeCreate(ctx, input, id, backend, options) {
     backend
   );
 }
-async function finalizeNodeCreateBatch(ctx, preparedCreates, backend, lock) {
-  await chunk3KOY4FH3_cjs.applyNodeInsertSideEffectsBatch(
-    chunk3KOY4FH3_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
-    preparedCreates.map((prepared) => ({
-      kind: prepared.kind,
-      id: prepared.id,
-      schema: prepared.nodeKind.schema,
-      props: prepared.validatedProps,
-      uniqueConstraints: prepared.uniqueConstraints
-    })),
-    backend
-  );
+function nodeCreateSideEffectItem(prepared) {
+  return {
+    kind: prepared.kind,
+    id: prepared.id,
+    schema: prepared.nodeKind.schema,
+    props: prepared.validatedProps,
+    uniqueConstraints: prepared.uniqueConstraints
+  };
+}
+function nodeCreateClaimItem(prepared) {
+  return {
+    kind: prepared.kind,
+    id: prepared.id,
+    props: prepared.validatedProps,
+    constraints: prepared.uniqueConstraints
+  };
+}
+function nodeInsertWork(prepared) {
+  return {
+    params: prepared.insertParams,
+    claim: nodeCreateClaimItem(prepared),
+    sideEffects: nodeCreateSideEffectItem(prepared)
+  };
 }
 function foldReferences(preparedCreates) {
   return preparedCreates.filter((prepared) => prepared.idProvided).map((prepared) => ({ kind: prepared.kind, id: prepared.id }));
 }
-async function finalizeNodeCreate(ctx, prepared, backend, lock) {
-  await chunk3KOY4FH3_cjs.applyNodeInsertSideEffects(
-    chunk3KOY4FH3_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
-    {
-      kind: prepared.kind,
-      id: prepared.id,
-      schema: prepared.nodeKind.schema,
-      props: prepared.validatedProps,
-      uniqueConstraints: prepared.uniqueConstraints
-    },
-    backend
-  );
-}
 function computeNodeUpdate(ctx, kind, id, existingProps, inputProps) {
   const registration = getNodeRegistration(ctx.graph, kind);
-  const validatedProps = chunkJFRT7S3B_cjs.validateNodeProps(
+  const validatedProps = chunkRDP6ZRSM_cjs.validateNodeProps(
     registration.type.schema,
     { ...existingProps, ...inputProps },
     { kind, operation: "update", id }
@@ -570,7 +956,7 @@ function computeNodeUpdate(ctx, kind, id, existingProps, inputProps) {
   return { registration, validatedProps };
 }
 function resolveNodeUpdateProps(ctx, existing, inputProps) {
-  const existingProps = chunk5PRKMB24_cjs.rowPropsToObject(existing.props);
+  const existingProps = chunkGHZPZNFC_cjs.rowPropsToObject(existing.props);
   const { registration, validatedProps } = computeNodeUpdate(
     ctx,
     existing.kind,
@@ -590,30 +976,30 @@ function nodeUpsertDirtyCheck(ctx, kind, id, existingProps, inputProps) {
   );
   return {
     validatedProps,
-    unchanged: chunkPWLJ77UV_cjs.canonicalEqual(validatedProps, existingProps)
+    unchanged: chunkZBFZGLZE_cjs.canonicalEqual(validatedProps, existingProps)
   };
 }
-async function performNodeUpdate(ctx, input, backend, lock, options) {
+async function performNodeUpdate(ctx, input, session, target, options) {
   const { kind, id } = input;
   assertValidityEndMutation(input, { entityType: "node", kind, id });
-  const existing = await backend.getNode(ctx.graphId, kind, id);
-  if (!existing) throw new chunkMRDBBHIZ_cjs.NodeNotFoundError(kind, id);
+  const existing = await target.getNode(ctx.graphId, kind, id);
+  if (!existing) throw new chunkX4GDXBOP_cjs.NodeNotFoundError(kind, id);
   const { registration, validatedProps } = resolveNodeUpdateProps(
     ctx,
     existing,
     input.props
   );
   const nodeKind = registration.type;
-  const validTo = chunkTQHGE7UC_cjs.validateOptionalCanonicalIsoDate(input.validTo, "validTo");
-  const resurrectionInstant = options?.clearDeleted === true && existing.deleted_at !== void 0 ? chunkTQHGE7UC_cjs.nowIso() : void 0;
-  const preservesLiveLowerBound = resurrectionInstant === void 0 && chunkTQHGE7UC_cjs.preservesImmutableLowerBound(input.onImmutableLowerBound);
-  const statedValidFrom = chunkTQHGE7UC_cjs.validateOptionalCanonicalIsoDate(
+  const validTo = chunkM5MSP3BI_cjs.validateOptionalCanonicalIsoDate(input.validTo, "validTo");
+  const resurrectionInstant = options?.clearDeleted === true && existing.deleted_at !== void 0 ? chunkM5MSP3BI_cjs.nowIso() : void 0;
+  const preservesLiveLowerBound = resurrectionInstant === void 0 && chunkM5MSP3BI_cjs.preservesImmutableLowerBound(input.onImmutableLowerBound);
+  const statedValidFrom = chunkM5MSP3BI_cjs.validateOptionalCanonicalIsoDate(
     input.validFrom,
     "validFrom"
   );
   const validFrom = preservesLiveLowerBound ? void 0 : statedValidFrom;
-  const resurrectionBound = resurrectionInstant === void 0 ? void 0 : chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(validFrom, validTo, resurrectionInstant);
-  const windowVerdict = chunkTQHGE7UC_cjs.assertWritableValidityWindow(
+  const resurrectionBound = resurrectionInstant === void 0 ? void 0 : chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(validFrom, validTo, resurrectionInstant);
+  const windowVerdict = chunkM5MSP3BI_cjs.assertWritableValidityWindow(
     `${kind} "${id}"`,
     validFrom,
     resurrectionInstant === void 0 ? {
@@ -628,55 +1014,44 @@ async function performNodeUpdate(ctx, input, backend, lock, options) {
     },
     validTo
   );
-  const writeContext = chunk3KOY4FH3_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock);
   const shared = {
     schema: nodeKind.schema,
     validatedProps,
     uniqueConstraints: registration.unique ?? [],
     ...validTo !== void 0 && { validTo },
-    ...input.clearValidTo === true && { clearValidTo: true },
-    // The bound the verdict above READ, carried into the UPDATE's own `WHERE`
-    // so the row this writes is the row that was judged. The verdict hands over
-    // the predicate rather than a flag, so both conditions that decide it — did
-    // the verdict consult the effective bound, and WAS that bound the row's
-    // stored one — are answered where they are known. A plain
-    // `update({ props })` states no window, reads no bound, and stays unfenced:
-    // the same rule `UpdateEdgeParams`'s identity components follow, for the
-    // same reason. The resurrecting leg is judged against `resurrectionInstant`
-    // and so fences on `deleted_at IS NOT NULL` alone, converging through the
-    // recovery below.
-    ...windowVerdict.storedLowerBoundFence
+    ...input.clearValidTo === true && { clearValidTo: true }
+  };
+  const fences = {
+    validityLowerBound: windowVerdict.storedLowerBoundFence
   };
   if (options?.clearDeleted) {
     const resurrectionLowerBound = resurrectionInstant === void 0 ? validFrom !== void 0 && { validFrom } : { validFrom: resurrectionBound ?? null };
-    const row2 = await chunk3KOY4FH3_cjs.applyNodeUpdate(
-      writeContext,
+    const row2 = await session.reviseNode(
       { ...shared, existing, clearDeleted: true, ...resurrectionLowerBound },
-      backend
+      fences
     );
     return rowToNode(row2);
   }
-  if (!chunk5PRKMB24_cjs.isLiveNodeRow(existing)) throw new chunkMRDBBHIZ_cjs.NodeNotFoundError(kind, id);
-  const row = await chunk3KOY4FH3_cjs.applyNodeUpdate(
-    writeContext,
+  if (!chunkGHZPZNFC_cjs.isLiveNodeRow(existing)) throw new chunkX4GDXBOP_cjs.NodeNotFoundError(kind, id);
+  const row = await session.reviseNode(
     // An in-place update must not rewrite the stored bound, so it keeps the
     // conditional spread: `buildUpdateNode` ignores `validFrom` off the
     // resurrection leg, and stating one here would claim a rewrite that no
     // statement performs.
     { ...shared, existing, ...validFrom !== void 0 && { validFrom } },
-    backend
+    fences
   );
   return rowToNode(row);
 }
 var NODE_UPDATE_ATTEMPTS = 2;
-async function performNodeUpdateWithResurrectionRecovery(ctx, input, target, lock, options) {
+async function performNodeUpdateWithResurrectionRecovery(ctx, input, session, target, options) {
   for (let attempt = 1; attempt <= NODE_UPDATE_ATTEMPTS; attempt += 1) {
     try {
       return await performNodeUpdate(
         ctx,
         input,
+        session,
         target,
-        lock,
         attempt === 1 ? options : void 0
       );
     } catch (error) {
@@ -685,15 +1060,15 @@ async function performNodeUpdateWithResurrectionRecovery(ctx, input, target, loc
       }
       const current = await target.getNode(ctx.graphId, input.kind, input.id);
       if (current === void 0 || current.deleted_at !== void 0) {
-        throw new chunkMRDBBHIZ_cjs.NodeNotFoundError(input.kind, input.id);
+        throw new chunkX4GDXBOP_cjs.NodeNotFoundError(input.kind, input.id);
       }
     }
   }
-  throw new chunkMRDBBHIZ_cjs.NodeNotFoundError(input.kind, input.id);
+  throw new chunkX4GDXBOP_cjs.NodeNotFoundError(input.kind, input.id);
 }
 function nodeUpdateRaceError(input, error) {
   if (!isNodeUpdateNoRowError(error)) return error;
-  return new chunkMRDBBHIZ_cjs.DatabaseOperationError(
+  return new chunkX4GDXBOP_cjs.DatabaseOperationError(
     `Node update for ${input.kind} "${input.id}" could not be applied to a stable row after ${NODE_UPDATE_ATTEMPTS} attempts: the row was removed and recreated between each read and its write. A concurrent writer is replacing this node faster than it can be read; serialize the writers, or retry.`,
     {
       operation: "update",
@@ -723,20 +1098,24 @@ async function primeBatchValidationCaches(ctx, drafts, backend, seams) {
   if (backend.checkUniqueBatch !== void 0) {
     const groups = /* @__PURE__ */ new Map();
     for (const draft of drafts) {
-      for (const constraint of draft.uniqueConstraints) {
-        if (!chunkFQPEMEWX_cjs.checkWherePredicate(constraint, draft.validatedProps)) continue;
-        const key = chunkFQPEMEWX_cjs.computeUniqueKey(
-          draft.validatedProps,
-          constraint.fields,
-          constraint.collation
-        );
-        const kindsToCheck = chunkFQPEMEWX_cjs.getKindsForUniquenessCheck(
+      for (const entry of chunkTUVD4DFR_cjs.nodeClaimEntries(
+        ctx.registry,
+        draft.kind,
+        draft.id,
+        draft.validatedProps,
+        draft.uniqueConstraints,
+        "create"
+      )) {
+        if (entry.refusal.kind !== "uniqueness") continue;
+        const constraint = entry.refusal.constraint;
+        const key = entry.key;
+        const kindsToCheck = chunkLLVOQOWE_cjs.uniquenessProbeKinds(
           draft.kind,
           constraint.scope,
           ctx.registry
         );
         for (const kindToCheck of kindsToCheck) {
-          const groupKey = chunkEZEEWCFJ_cjs.encodeTupleKey([kindToCheck, constraint.name]);
+          const groupKey = chunkLLVOQOWE_cjs.encodeTupleKey([kindToCheck, constraint.name]);
           const group = groups.get(groupKey) ?? {
             nodeKind: kindToCheck,
             constraintName: constraint.name,
@@ -769,14 +1148,14 @@ async function primeBatchValidationCaches(ctx, drafts, backend, seams) {
 }
 async function prepareBatchCreates(ctx, inputs, backend, options) {
   const {
-    backend: validationBackend,
+    reader: validationBackend,
     registerPendingNode,
     registerPendingUniqueEntries,
     seedNodeRow,
     seedUniqueRow
-  } = createNodeBatchValidationBackend(ctx.graphId, ctx.registry, backend);
+  } = createNodeBatchValidationSeams(ctx.graphId, ctx.registry, backend);
   const drafts = inputs.map(
-    (input) => draftNodeCreate(ctx, input, input.id ?? chunkEZEEWCFJ_cjs.generateId(), options)
+    (input) => draftNodeCreate(ctx, input, input.id ?? chunkRDP6ZRSM_cjs.generateId(), options)
   );
   await primeBatchValidationCaches(ctx, drafts, backend, {
     seedNodeRow,
@@ -813,12 +1192,12 @@ function partitionCreates(preparedCreates) {
   return { inserts, resurrections };
 }
 function isNodeUpdateNoRowError(error) {
-  return error instanceof chunkMRDBBHIZ_cjs.DatabaseOperationError && error.details.operation === "update" && error.details.entity === "node" && error.details.reason === "no_row_returned";
+  return error instanceof chunkX4GDXBOP_cjs.DatabaseOperationError && error.details.operation === "update" && error.details.entity === "node" && error.details.reason === "no_row_returned";
 }
-async function resurrectPreparedNode(ctx, target, lock, prepared) {
+async function resurrectPreparedNode(ctx, session, target, prepared) {
   const current = await target.getNode(ctx.graphId, prepared.kind, prepared.id);
   if (current === void 0) {
-    throw new chunkMRDBBHIZ_cjs.DatabaseOperationError(
+    throw new chunkX4GDXBOP_cjs.DatabaseOperationError(
       `Node tombstone disappeared before resurrection: ${prepared.kind} ${prepared.id}`,
       { operation: "update", entity: "node" }
     );
@@ -826,15 +1205,14 @@ async function resurrectPreparedNode(ctx, target, lock, prepared) {
   if (current.deleted_at === void 0) {
     throw createAlreadyExistsError("node", prepared.kind, prepared.id);
   }
-  const resurrectionInstant = chunkTQHGE7UC_cjs.nowIso();
-  const resurrectionBound = chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(
+  const resurrectionInstant = chunkM5MSP3BI_cjs.nowIso();
+  const resurrectionBound = chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(
     prepared.insertParams.validFrom,
     prepared.insertParams.validTo,
     resurrectionInstant
   );
   try {
-    return await chunk3KOY4FH3_cjs.applyNodeUpdate(
-      chunk3KOY4FH3_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
+    return await session.reviseNode(
       {
         existing: current,
         clearDeleted: true,
@@ -847,7 +1225,11 @@ async function resurrectPreparedNode(ctx, target, lock, prepared) {
         validFrom: resurrectionBound ?? null,
         ...prepared.insertParams.validTo === void 0 ? {} : { validTo: prepared.insertParams.validTo }
       },
-      target
+      // This resurrection reads no stored bound: it rewrites the whole window
+      // and is fenced by the UPDATE's own `deleted_at IS NOT NULL` predicate,
+      // so it asserts nothing about `valid_from`. `{}` is how a write states
+      // that, and it is the only way to state it.
+      { validityLowerBound: {} }
     );
   } catch (error) {
     if (!isNodeUpdateNoRowError(error)) throw error;
@@ -862,7 +1244,12 @@ async function resurrectPreparedNode(ctx, target, lock, prepared) {
     throw error;
   }
 }
+function prefersClaimRow(incumbent, candidate) {
+  if (incumbent === void 0) return true;
+  return incumbent.deleted_at !== void 0 && candidate.deleted_at === void 0;
+}
 async function findUniqueRowAcrossKinds(backend, graphId, constraintName, key, kindsToCheck, includeDeleted) {
+  let preferred;
   for (const kindToCheck of kindsToCheck) {
     const row = await backend.checkUnique({
       graphId,
@@ -871,16 +1258,22 @@ async function findUniqueRowAcrossKinds(backend, graphId, constraintName, key, k
       key,
       includeDeleted
     });
-    if (row !== void 0) return row;
+    if (row === void 0) continue;
+    if (!prefersClaimRow(preferred, row)) continue;
+    preferred = row;
+    if (row.deleted_at === void 0) return row;
   }
-  return void 0;
+  return preferred;
 }
 async function batchCheckUniqueAcrossKinds(backend, graphId, constraintName, uniqueKeys, kindsToCheck, includeDeleted) {
   const existingByKey = /* @__PURE__ */ new Map();
   for (const kindToCheck of kindsToCheck) {
     if (backend.checkUniqueBatch === void 0) {
       for (const key of uniqueKeys) {
-        if (existingByKey.has(key)) continue;
+        const incumbent = existingByKey.get(key);
+        if (incumbent !== void 0 && incumbent.deleted_at === void 0) {
+          continue;
+        }
         const row = await backend.checkUnique({
           graphId,
           nodeKind: kindToCheck,
@@ -888,7 +1281,7 @@ async function batchCheckUniqueAcrossKinds(backend, graphId, constraintName, uni
           key,
           includeDeleted
         });
-        if (row !== void 0) {
+        if (row !== void 0 && prefersClaimRow(incumbent, row)) {
           existingByKey.set(row.key, row);
         }
       }
@@ -901,7 +1294,7 @@ async function batchCheckUniqueAcrossKinds(backend, graphId, constraintName, uni
         includeDeleted
       });
       for (const row of rows) {
-        if (!existingByKey.has(row.key)) {
+        if (prefersClaimRow(existingByKey.get(row.key), row)) {
           existingByKey.set(row.key, row);
         }
       }
@@ -911,16 +1304,19 @@ async function batchCheckUniqueAcrossKinds(backend, graphId, constraintName, uni
 }
 async function executeNodeCreateInternal(ctx, input, backend, options) {
   const kind = input.kind;
-  const id = input.id ?? chunkEZEEWCFJ_cjs.generateId();
+  const id = input.id ?? chunkRDP6ZRSM_cjs.generateId();
   const opContext = ctx.createOperationContext("create", "node", kind, id);
   const shouldReturnRow = options?.returnRow ?? true;
-  return chunkJFRT7S3B_cjs.runHookedWriteOperation(
-    ctx,
+  return runHookedWritePlan(
+    nodeWritePlanContext(ctx),
     opContext,
+    nodeWritePlan(
+      nodeFencesConstraintProbe(ctx, kind, "create"),
+      nodeRequiresIdentityLock(ctx)
+    ),
     backend,
-    async (target, lock) => {
+    async (session, target) => {
       const identity = ctx.identity;
-      if (identity !== void 0) await identity.lock(target);
       const prepared = await validateAndPrepareNodeCreate(
         ctx,
         input,
@@ -932,8 +1328,8 @@ async function executeNodeCreateInternal(ctx, input, backend, options) {
       if (existing !== void 0) {
         const resurrected = await resurrectPreparedNode(
           ctx,
+          session,
           target,
-          lock,
           prepared
         );
         if (identity !== void 0) {
@@ -942,22 +1338,16 @@ async function executeNodeCreateInternal(ctx, input, backend, options) {
         return shouldReturnRow ? rowToNode(resurrected) : void 0;
       }
       const row = await withAlreadyExistsTranslation("node", async () => {
-        if (shouldReturnRow) return target.insertNode(prepared.insertParams);
-        await chunkEZEEWCFJ_cjs.runInsertNoReturn(
-          chunkEZEEWCFJ_cjs.nodeInsertDispatch(target),
-          prepared.insertParams
-        );
+        const work = nodeInsertWork(prepared);
+        if (shouldReturnRow) return session.createNode(work);
+        await session.createNodeNoReturn(work);
         return;
       });
-      await finalizeNodeCreate(ctx, prepared, target, lock);
       if (identity !== void 0) {
         await identity.foldCreated(target, foldReferences([prepared]));
       }
       if (row === void 0) return;
       return rowToNode(row);
-    },
-    {
-      fencesConstraintProbe: nodeFencesConstraintProbe(ctx, kind, "create")
     }
   );
 }
@@ -967,7 +1357,7 @@ async function executeNodeCreate(ctx, input, backend, options) {
     ...options
   });
   if (!result) {
-    throw new chunkMRDBBHIZ_cjs.DatabaseOperationError(
+    throw new chunkX4GDXBOP_cjs.DatabaseOperationError(
       "Node create failed: expected created node row",
       { operation: "insert", entity: "node" }
     );
@@ -976,46 +1366,43 @@ async function executeNodeCreate(ctx, input, backend, options) {
 }
 async function executeNodeCreateNoReturnBatch(ctx, inputs, backend) {
   if (inputs.length === 0) return;
-  await chunkJFRT7S3B_cjs.runInWriteTransaction(
-    ctx,
+  await runWritePlan(
+    nodeWritePlanContext(ctx),
+    nodeBatchWritePlan(
+      nodeBatchConstraintProbes(ctx, inputs, "create"),
+      nodeRequiresIdentityLock(ctx)
+    ),
     backend,
-    async (target, lock) => {
+    async (session, target) => {
       const identity = ctx.identity;
-      if (identity !== void 0) await identity.lock(target);
       const preparedCreates = await prepareBatchCreates(ctx, inputs, target);
       const partition = partitionCreates(preparedCreates);
       await withAlreadyExistsTranslation(
         "node",
-        () => chunkEZEEWCFJ_cjs.runInsertBatch(
-          chunkEZEEWCFJ_cjs.nodeInsertDispatch(target),
-          partition.inserts.map((prepared) => prepared.insertParams)
+        () => session.createNodesNoReturn(
+          partition.inserts.map((prepared) => nodeInsertWork(prepared))
         )
       );
       for (const prepared of partition.resurrections) {
-        await resurrectPreparedNode(ctx, target, lock, prepared);
+        await resurrectPreparedNode(ctx, session, target, prepared);
       }
-      await finalizeNodeCreateBatch(ctx, partition.inserts, target, lock);
       if (identity !== void 0) {
         await identity.foldCreated(target, foldReferences(preparedCreates));
       }
-    },
-    {
-      fencesConstraintProbe: nodeBatchFencesConstraintProbe(
-        ctx,
-        inputs,
-        "create"
-      )
     }
   );
 }
 async function executeNodeCreateBatch(ctx, inputs, backend, options) {
   if (inputs.length === 0) return [];
-  return chunkJFRT7S3B_cjs.runInWriteTransaction(
-    ctx,
+  return runWritePlan(
+    nodeWritePlanContext(ctx),
+    nodeBatchWritePlan(
+      nodeBatchConstraintProbes(ctx, inputs, "create"),
+      nodeRequiresIdentityLock(ctx)
+    ),
     backend,
-    async (target, lock) => {
+    async (session, target) => {
       const identity = ctx.identity;
-      if (identity !== void 0) await identity.lock(target);
       const preparedCreates = await prepareBatchCreates(
         ctx,
         inputs,
@@ -1025,27 +1412,25 @@ async function executeNodeCreateBatch(ctx, inputs, backend, options) {
       const partition = partitionCreates(preparedCreates);
       const inserted = await withAlreadyExistsTranslation(
         "node",
-        () => chunkEZEEWCFJ_cjs.runInsertBatchReturning(
-          chunkEZEEWCFJ_cjs.nodeInsertDispatch(target),
-          partition.inserts.map((prepared) => prepared.insertParams)
+        () => session.createNodes(
+          partition.inserts.map((prepared) => nodeInsertWork(prepared))
         )
       );
       const resurrected = [];
       for (const prepared of partition.resurrections) {
         resurrected.push(
-          await resurrectPreparedNode(ctx, target, lock, prepared)
+          await resurrectPreparedNode(ctx, session, target, prepared)
         );
       }
-      await finalizeNodeCreateBatch(ctx, partition.inserts, target, lock);
       const byReference = new Map(
         [...inserted, ...resurrected].map((row) => [
-          chunkJFRT7S3B_cjs.refKey({ kind: row.kind, id: row.id }),
+          chunk5OWHU7Z7_cjs.refKey({ kind: row.kind, id: row.id }),
           row
         ])
       );
       const rows = preparedCreates.map(
         (prepared) => chunkN66HCGCY_cjs.requireDefined(
-          byReference.get(chunkJFRT7S3B_cjs.refKey({ kind: prepared.kind, id: prepared.id })),
+          byReference.get(chunk5OWHU7Z7_cjs.refKey({ kind: prepared.kind, id: prepared.id })),
           `Missing written row for ${prepared.kind} ${prepared.id}`
         )
       );
@@ -1053,39 +1438,36 @@ async function executeNodeCreateBatch(ctx, inputs, backend, options) {
         await identity.foldCreated(target, foldReferences(preparedCreates));
       }
       return rows.map((row) => rowToNode(row));
-    },
-    {
-      fencesConstraintProbe: nodeBatchFencesConstraintProbe(
-        ctx,
-        inputs,
-        "create"
-      )
     }
   );
 }
 async function executeNodeUpdate(ctx, input, backend, options) {
+  if (input.clearValidTo === true) {
+    assertClearValidToSupported(backend, "node");
+  }
   const opContext = ctx.createOperationContext(
     "update",
     "node",
     input.kind,
     input.id
   );
-  return chunkJFRT7S3B_cjs.runHookedWriteOperation(
-    ctx,
+  return runHookedWritePlan(
+    nodeWritePlanContext(ctx),
     opContext,
+    nodeWritePlan(
+      nodeFencesConstraintProbe(ctx, input.kind, "update"),
+      // Identity participates in an update when it RESURRECTS, and when it
+      // states a validity end: a live-row update cannot change a node's kind, so
+      // nothing folds, but an end reads the identity assertions that touch it.
+      options?.clearDeleted === true || input.validTo !== void 0 ? nodeRequiresIdentityLock(ctx) : false
+    ),
     backend,
-    async (target, lock) => {
-      if (input.clearValidTo === true) {
-        assertClearValidToSupported(backend, "node");
-      }
-      const validTo = chunkTQHGE7UC_cjs.validateOptionalCanonicalIsoDate(
+    async (session, target) => {
+      const validTo = chunkM5MSP3BI_cjs.validateOptionalCanonicalIsoDate(
         input.validTo,
         "validTo"
       );
       const identity = ctx.identity;
-      if (identity !== void 0 && (options?.clearDeleted === true || input.validTo !== void 0)) {
-        await identity.lock(target);
-      }
       if (identity !== void 0 && validTo !== void 0) {
         await identity.requireValidityEndCompatible(
           target,
@@ -1096,8 +1478,8 @@ async function executeNodeUpdate(ctx, input, backend, options) {
       const node = await performNodeUpdateWithResurrectionRecovery(
         ctx,
         input,
+        session,
         target,
-        lock,
         options
       );
       if (options?.clearDeleted && identity !== void 0) {
@@ -1106,13 +1488,6 @@ async function executeNodeUpdate(ctx, input, backend, options) {
         ]);
       }
       return node;
-    },
-    {
-      fencesConstraintProbe: nodeFencesConstraintProbe(
-        ctx,
-        input.kind,
-        "update"
-      )
     }
   );
 }
@@ -1121,19 +1496,19 @@ async function executeNodeUpdateWhere(ctx, kind, inputPatch, candidateIds, candi
   const schema = registration.type.schema;
   const uniqueConstraints = registration.unique ?? [];
   if (!backend.capabilities.transactions) {
-    throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+    throw new chunkX4GDXBOP_cjs.ConfigurationError(
       "updateWhere() requires a transactional backend so validation and sidecars are atomic",
       { code: "SET_UPDATE_TRANSACTIONS_REQUIRED", kind }
     );
   }
   if (backend.updateNodeSet === void 0) {
-    throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+    throw new chunkX4GDXBOP_cjs.ConfigurationError(
       "This backend does not support set-based node updates",
       { code: "SET_UPDATE_UNSUPPORTED", kind }
     );
   }
   if (Object.keys(inputPatch).length === 0) {
-    throw new chunkMRDBBHIZ_cjs.ValidationError("updateWhere() patch must not be empty", {
+    throw new chunkX4GDXBOP_cjs.ValidationError("updateWhere() patch must not be empty", {
       entityType: "node",
       kind,
       operation: "update",
@@ -1144,7 +1519,7 @@ async function executeNodeUpdateWhere(ctx, kind, inputPatch, candidateIds, candi
     (property) => !Object.hasOwn(schema.shape, property)
   );
   if (unknownProperty !== void 0) {
-    throw new chunkMRDBBHIZ_cjs.ValidationError(
+    throw new chunkX4GDXBOP_cjs.ValidationError(
       `Unknown ${kind} property in updateWhere() patch: ${unknownProperty}`,
       {
         entityType: "node",
@@ -1159,7 +1534,7 @@ async function executeNodeUpdateWhere(ctx, kind, inputPatch, candidateIds, candi
       }
     );
   }
-  const parsedPatch = chunkJFRT7S3B_cjs.validateNodeProps(schema.partial(), inputPatch, {
+  const parsedPatch = chunkRDP6ZRSM_cjs.validateNodeProps(schema.partial(), inputPatch, {
     kind,
     operation: "update"
   });
@@ -1170,11 +1545,11 @@ async function executeNodeUpdateWhere(ctx, kind, inputPatch, candidateIds, candi
       unsetProperties.push(property);
       continue;
     }
-    chunk6NGW27EO_cjs.assertJsonValue(value, property, `Node "${kind}" updateWhere patch`);
+    chunkVLBTRXA2_cjs.assertJsonValue(value, property, `Node "${kind}" updateWhere patch`);
     patch[property] = value;
   }
   if (Object.keys(patch).length === 0 && unsetProperties.length === 0) {
-    throw new chunkMRDBBHIZ_cjs.ValidationError(
+    throw new chunkX4GDXBOP_cjs.ValidationError(
       "updateWhere() patch has no recognized properties",
       {
         entityType: "node",
@@ -1187,19 +1562,19 @@ async function executeNodeUpdateWhere(ctx, kind, inputPatch, candidateIds, candi
     );
   }
   if (uniqueConstraints.length > 0 && (backend.hardDeleteUniquesByNodeIds === void 0 || backend.insertUniqueBatch === void 0 || backend.checkUniqueBatch === void 0)) {
-    throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+    throw new chunkX4GDXBOP_cjs.ConfigurationError(
       "updateWhere() requires batched uniqueness sidecar operations for constrained nodes",
       { code: "SET_UPDATE_UNIQUENESS_UNSUPPORTED", kind }
     );
   }
   if (chunkHAHNRASW_cjs.getSearchableFields(schema).length > 0 && (backend.upsertFulltext === void 0 || backend.deleteFulltext === void 0 || backend.upsertFulltextBatch === void 0 || backend.deleteFulltextBatch === void 0)) {
-    throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+    throw new chunkX4GDXBOP_cjs.ConfigurationError(
       "updateWhere() requires batched fulltext sidecar operations for searchable nodes",
       { code: "SET_UPDATE_FULLTEXT_UNSUPPORTED", kind }
     );
   }
-  if (chunk3KOY4FH3_cjs.getEmbeddingFields(schema).length > 0 && (backend.upsertEmbedding === void 0 || backend.deleteEmbedding === void 0 || backend.upsertEmbeddingBatch === void 0 || backend.deleteEmbeddingBatch === void 0)) {
-    throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+  if (chunkTUVD4DFR_cjs.getEmbeddingFields(schema).length > 0 && (backend.upsertEmbedding === void 0 || backend.deleteEmbedding === void 0 || backend.upsertEmbeddingBatch === void 0 || backend.deleteEmbeddingBatch === void 0)) {
+    throw new chunkX4GDXBOP_cjs.ConfigurationError(
       "updateWhere() requires batched vector sidecar operations for embedded nodes",
       { code: "SET_UPDATE_VECTOR_UNSUPPORTED", kind }
     );
@@ -1207,107 +1582,32 @@ async function executeNodeUpdateWhere(ctx, kind, inputPatch, candidateIds, candi
   const hookContext = ctx.createBulkOperationContext("updateWhere", kind);
   return ctx.withBulkOperationHooks(
     hookContext,
-    () => chunkJFRT7S3B_cjs.runInWriteTransaction(
-      ctx,
+    () => runWritePlan(
+      nodeWritePlanContext(ctx),
+      // The set update re-checks every changed unique key across the
+      // constraint's scope before rebuilding the sidecars, so a shared-scope
+      // constraint makes it a constrained write like any other update.
+      // Identity does not participate: a set update rewrites props, and no
+      // patch can change a node's kind.
+      nodeWritePlan(nodeFencesConstraintProbe(ctx, kind, "update"), false),
       backend,
-      async (target, lock) => {
-        const updateNodeSet = target.updateNodeSet;
-        if (updateNodeSet === void 0) {
-          throw new chunkMRDBBHIZ_cjs.ConfigurationError(
-            "The transaction backend does not support set-based node updates",
-            { code: "SET_UPDATE_UNSUPPORTED", kind }
-          );
-        }
-        const hardDeleteUniquesByNodeIds = target.hardDeleteUniquesByNodeIds;
-        if (uniqueConstraints.length > 0 && (hardDeleteUniquesByNodeIds === void 0 || target.insertUniqueBatch === void 0 || target.checkUniqueBatch === void 0)) {
-          throw new chunkMRDBBHIZ_cjs.ConfigurationError(
-            "The transaction backend lacks batched uniqueness operations",
-            { code: "SET_UPDATE_UNIQUENESS_UNSUPPORTED", kind }
-          );
-        }
-        if (chunkHAHNRASW_cjs.getSearchableFields(schema).length > 0 && (target.upsertFulltext === void 0 || target.deleteFulltext === void 0 || target.upsertFulltextBatch === void 0 || target.deleteFulltextBatch === void 0)) {
-          throw new chunkMRDBBHIZ_cjs.ConfigurationError(
-            "The transaction backend lacks batched fulltext operations",
-            { code: "SET_UPDATE_FULLTEXT_UNSUPPORTED", kind }
-          );
-        }
-        if (chunk3KOY4FH3_cjs.getEmbeddingFields(schema).length > 0 && (target.upsertEmbedding === void 0 || target.deleteEmbedding === void 0 || target.upsertEmbeddingBatch === void 0 || target.deleteEmbeddingBatch === void 0)) {
-          throw new chunkMRDBBHIZ_cjs.ConfigurationError(
-            "The transaction backend lacks batched vector operations",
-            { code: "SET_UPDATE_VECTOR_UNSUPPORTED", kind }
-          );
-        }
-        const result = await updateNodeSet({
-          graphId: ctx.graphId,
+      (session) => session.reviseNodeSet(
+        {
           kind,
+          schema,
+          uniqueConstraints,
           patch,
           unsetProperties,
           candidateIds,
           candidateIdColumn
-        });
-        if (result.affectedCount === 0) return { affectedCount: 0 };
-        const sidecarItems = result.rows.map((row) => {
-          const props = chunk5PRKMB24_cjs.rowPropsToObject(row.props);
-          const validatedProps = chunkJFRT7S3B_cjs.validateNodeProps(schema, props, {
-            kind,
-            operation: "update",
-            id: row.id
-          });
-          if (!chunkPWLJ77UV_cjs.canonicalEqual(validatedProps, props)) {
-            throw new chunkMRDBBHIZ_cjs.ValidationError(
-              `Set update would persist a non-canonical ${kind} row`,
-              {
-                entityType: "node",
-                kind,
-                operation: "update",
-                id: row.id,
-                issues: [
-                  {
-                    path: "props",
-                    message: "The complete row requires schema normalization"
-                  }
-                ]
-              }
-            );
-          }
-          return {
-            kind,
-            id: row.id,
-            schema,
-            props: validatedProps,
-            uniqueConstraints
-          };
-        });
-        if (uniqueConstraints.length > 0) {
-          await chunk3KOY4FH3_cjs.validateResolvedNodeUniqueness(
-            chunk3KOY4FH3_cjs.createUniquenessContext(ctx.graphId, ctx.registry, target),
-            sidecarItems.map((item) => ({
-              kind: item.kind,
-              id: item.id,
-              props: item.props,
-              constraints: item.uniqueConstraints
-            }))
-          );
-          await chunkN66HCGCY_cjs.requireDefined(hardDeleteUniquesByNodeIds)({
-            graphId: ctx.graphId,
-            concreteKind: kind,
-            nodeIds: result.rows.map((row) => row.id)
-          });
-        }
-        await chunk3KOY4FH3_cjs.applyNodeInsertSideEffectsBatch(
-          chunk3KOY4FH3_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
-          sidecarItems,
-          target
-        );
-        return { affectedCount: result.affectedCount };
-      },
-      {
-        didWrite: (result) => result.affectedCount > 0,
-        // The set update re-checks every changed unique key across the
-        // constraint's scope before rebuilding the sidecars, so a shared-scope
-        // constraint makes it a constrained write like any other update.
-        fencesConstraintProbe: nodeFencesConstraintProbe(ctx, kind, "update")
-      }
+        },
+        // This path states no window — it patches properties — so the write
+        // asserts no stored lower bound. The set UPDATE has no field to
+        // carry one, so a future windowed set update is refused here rather
+        // than run unfenced.
+        { validityLowerBound: {} }
+      ),
+      { didWrite: (result) => result.affectedCount > 0 }
     )
   );
 }
@@ -1315,18 +1615,22 @@ async function executeNodeUpsertUpdate(ctx, input, backend, options) {
   if (input.clearValidTo === true) {
     assertClearValidToSupported(backend, "node");
   }
-  return chunkJFRT7S3B_cjs.runInWriteTransaction(
-    ctx,
+  return runWritePlan(
+    nodeWritePlanContext(ctx),
+    nodeWritePlan(
+      nodeFencesConstraintProbe(ctx, input.kind, "update"),
+      // Conditional for the same reason as {@link executeNodeUpdate}: a
+      // resurrecting upsert folds, and stating a validity end reads the
+      // identity's other members, so both take the lock.
+      options?.clearDeleted === true || input.validTo !== void 0 ? nodeRequiresIdentityLock(ctx) : false
+    ),
     backend,
-    async (target, lock) => {
-      const validTo = chunkTQHGE7UC_cjs.validateOptionalCanonicalIsoDate(
+    async (session, target) => {
+      const validTo = chunkM5MSP3BI_cjs.validateOptionalCanonicalIsoDate(
         input.validTo,
         "validTo"
       );
       const identity = ctx.identity;
-      if (identity !== void 0 && (options?.clearDeleted === true || input.validTo !== void 0)) {
-        await identity.lock(target);
-      }
       if (identity !== void 0 && validTo !== void 0) {
         await identity.requireValidityEndCompatible(
           target,
@@ -1337,8 +1641,8 @@ async function executeNodeUpsertUpdate(ctx, input, backend, options) {
       const node = await performNodeUpdateWithResurrectionRecovery(
         ctx,
         input,
+        session,
         target,
-        lock,
         options
       );
       if (options?.clearDeleted && identity !== void 0) {
@@ -1347,13 +1651,6 @@ async function executeNodeUpsertUpdate(ctx, input, backend, options) {
         ]);
       }
       return node;
-    },
-    {
-      fencesConstraintProbe: nodeFencesConstraintProbe(
-        ctx,
-        input.kind,
-        "update"
-      )
     }
   );
 }
@@ -1361,26 +1658,22 @@ async function executeNodeDelete(ctx, kind, id, backend) {
   const gate = await backend.getNode(ctx.graphId, kind, id);
   if (!gate || gate.deleted_at) return;
   const opContext = ctx.createOperationContext("delete", "node", kind, id);
-  return chunkJFRT7S3B_cjs.runHookedWriteOperation(
-    ctx,
+  return runHookedWritePlan(
+    nodeWritePlanContext(ctx),
     opContext,
+    nodeWritePlan(void 0, nodeRequiresIdentityLock(ctx)),
     backend,
-    async (target, lock) => {
+    async (session, target) => {
       const identity = ctx.identity;
-      if (identity !== void 0) await identity.lock(target);
       const registration = getNodeRegistration(ctx.graph, kind);
       const preflight = await target.getNode(ctx.graphId, kind, id);
-      if (!preflight || !chunk5PRKMB24_cjs.isLiveNodeRow(preflight)) return;
-      await chunk3KOY4FH3_cjs.applyNodeSoftDelete(
-        chunk3KOY4FH3_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
-        {
-          existing: preflight,
-          schema: registration.type.schema,
-          uniqueConstraints: registration.unique ?? [],
-          onDelete: registration.onDelete
-        },
-        target
-      );
+      if (!preflight || !chunkGHZPZNFC_cjs.isLiveNodeRow(preflight)) return;
+      await session.retireNode({
+        existing: preflight,
+        schema: registration.type.schema,
+        uniqueConstraints: registration.unique ?? [],
+        onDelete: registration.onDelete
+      });
       if (identity !== void 0) {
         await identity.detachDeleted(target, { kind, id }, "soft");
       }
@@ -1388,32 +1681,23 @@ async function executeNodeDelete(ctx, kind, id, backend) {
   );
 }
 async function executeNodeDeleteBatch(ctx, kind, ids, backend) {
-  await chunkJFRT7S3B_cjs.runInWriteTransaction(
-    ctx,
+  await runWritePlan(
+    nodeWritePlanContext(ctx),
+    nodeWritePlan(void 0, nodeRequiresIdentityLock(ctx)),
     backend,
-    async (target, lock) => {
+    async (session, target) => {
       const identity = ctx.identity;
-      if (identity !== void 0) await identity.lock(target);
       const registration = getNodeRegistration(ctx.graph, kind);
-      const writeContext = chunk3KOY4FH3_cjs.createNodeWriteContext(
-        ctx.graphId,
-        ctx.registry,
-        lock
-      );
       let affectedCount = 0;
       for (const id of ids) {
         const preflight = await target.getNode(ctx.graphId, kind, id);
-        if (!preflight || !chunk5PRKMB24_cjs.isLiveNodeRow(preflight)) continue;
-        await chunk3KOY4FH3_cjs.applyNodeSoftDelete(
-          writeContext,
-          {
-            existing: preflight,
-            schema: registration.type.schema,
-            uniqueConstraints: registration.unique ?? [],
-            onDelete: registration.onDelete
-          },
-          target
-        );
+        if (!preflight || !chunkGHZPZNFC_cjs.isLiveNodeRow(preflight)) continue;
+        await session.retireNode({
+          existing: preflight,
+          schema: registration.type.schema,
+          uniqueConstraints: registration.unique ?? [],
+          onDelete: registration.onDelete
+        });
         if (identity !== void 0) {
           await identity.detachDeleted(target, { kind, id }, "soft");
         }
@@ -1428,24 +1712,20 @@ async function executeNodeHardDelete(ctx, kind, id, backend) {
   const gate = await backend.getNode(ctx.graphId, kind, id);
   if (!gate) return;
   const opContext = ctx.createOperationContext("delete", "node", kind, id);
-  return chunkJFRT7S3B_cjs.runHookedWriteOperation(
-    ctx,
+  return runHookedWritePlan(
+    nodeWritePlanContext(ctx),
     opContext,
+    nodeWritePlan(void 0, nodeRequiresIdentityLock(ctx)),
     backend,
-    async (target, lock) => {
+    async (session, target) => {
       const identity = ctx.identity;
-      if (identity !== void 0) await identity.lock(target);
       const registration = getNodeRegistration(ctx.graph, kind);
-      await chunk3KOY4FH3_cjs.applyNodeHardDelete(
-        chunk3KOY4FH3_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
-        {
-          kind,
-          id,
-          schema: registration.type.schema,
-          onDelete: registration.onDelete
-        },
-        target
-      );
+      await session.purgeNode({
+        kind,
+        id,
+        schema: registration.type.schema,
+        onDelete: registration.onDelete
+      });
       if (identity !== void 0) {
         await identity.detachDeleted(target, { kind, id }, "hard");
       }
@@ -1456,12 +1736,12 @@ async function executeNodeGetOrCreateByConstraint(ctx, kind, constraintName, pro
   const ifExists = options?.ifExists ?? "return";
   const registration = getNodeRegistration(ctx.graph, kind);
   const nodeKind = registration.type;
-  const validatedProps = chunkJFRT7S3B_cjs.validateNodeProps(nodeKind.schema, props, {
+  const validatedProps = chunkRDP6ZRSM_cjs.validateNodeProps(nodeKind.schema, props, {
     kind,
     operation: "create"
   });
   const constraint = resolveConstraint(ctx.graph, kind, constraintName);
-  if (!chunkFQPEMEWX_cjs.checkWherePredicate(constraint, validatedProps)) {
+  if (!chunkLLVOQOWE_cjs.checkWherePredicate(constraint, validatedProps)) {
     const node = await executeNodeCreate(
       ctx,
       { kind, props: validatedProps },
@@ -1470,12 +1750,12 @@ async function executeNodeGetOrCreateByConstraint(ctx, kind, constraintName, pro
     );
     return { node, action: "created" };
   }
-  const key = chunkFQPEMEWX_cjs.computeUniqueKey(
+  const key = chunkLLVOQOWE_cjs.computeUniqueKey(
     validatedProps,
     constraint.fields,
     constraint.collation
   );
-  const kindsToCheck = chunkFQPEMEWX_cjs.getKindsForUniquenessCheck(
+  const kindsToCheck = chunkLLVOQOWE_cjs.uniquenessProbeKinds(
     kind,
     constraint.scope,
     ctx.registry
@@ -1532,25 +1812,25 @@ async function executeNodeGetOrCreateByConstraint(ctx, kind, constraintName, pro
   try {
     return await attempt();
   } catch (error) {
-    if (!(error instanceof chunkMRDBBHIZ_cjs.UniquenessError)) throw error;
+    if (!(error instanceof chunkX4GDXBOP_cjs.UniquenessError)) throw error;
     return attempt();
   }
 }
 async function executeNodeFindByConstraint(ctx, kind, constraintName, props, backend) {
   const registration = getNodeRegistration(ctx.graph, kind);
   const nodeKind = registration.type;
-  const validatedProps = chunkJFRT7S3B_cjs.validateNodeProps(nodeKind.schema, props, {
+  const validatedProps = chunkRDP6ZRSM_cjs.validateNodeProps(nodeKind.schema, props, {
     kind,
     operation: "create"
   });
   const constraint = resolveConstraint(ctx.graph, kind, constraintName);
-  if (!chunkFQPEMEWX_cjs.checkWherePredicate(constraint, validatedProps)) return void 0;
-  const key = chunkFQPEMEWX_cjs.computeUniqueKey(
+  if (!chunkLLVOQOWE_cjs.checkWherePredicate(constraint, validatedProps)) return void 0;
+  const key = chunkLLVOQOWE_cjs.computeUniqueKey(
     validatedProps,
     constraint.fields,
     constraint.collation
   );
-  const kindsToCheck = chunkFQPEMEWX_cjs.getKindsForUniquenessCheck(
+  const kindsToCheck = chunkLLVOQOWE_cjs.uniquenessProbeKinds(
     kind,
     constraint.scope,
     ctx.registry
@@ -1576,12 +1856,12 @@ async function executeNodeFindByConstraint(ctx, kind, constraintName, props, bac
 function validateAndComputeKeys(nodeKind, kind, constraint, items) {
   const validated = [];
   for (const item of items) {
-    const validatedProps = chunkJFRT7S3B_cjs.validateNodeProps(nodeKind.schema, item.props, {
+    const validatedProps = chunkRDP6ZRSM_cjs.validateNodeProps(nodeKind.schema, item.props, {
       kind,
       operation: "create"
     });
-    const applies = chunkFQPEMEWX_cjs.checkWherePredicate(constraint, validatedProps);
-    const key = applies ? chunkFQPEMEWX_cjs.computeUniqueKey(
+    const applies = chunkLLVOQOWE_cjs.checkWherePredicate(constraint, validatedProps);
+    const key = applies ? chunkLLVOQOWE_cjs.computeUniqueKey(
       validatedProps,
       constraint.fields,
       constraint.collation
@@ -1604,7 +1884,7 @@ async function executeNodeBulkFindByConstraint(ctx, kind, constraintName, items,
   const constraint = resolveConstraint(ctx.graph, kind, constraintName);
   const validated = validateAndComputeKeys(nodeKind, kind, constraint, items);
   const uniqueKeys = collectUniqueKeys(validated);
-  const kindsToCheck = chunkFQPEMEWX_cjs.getKindsForUniquenessCheck(
+  const kindsToCheck = chunkLLVOQOWE_cjs.uniquenessProbeKinds(
     kind,
     constraint.scope,
     ctx.registry
@@ -1654,10 +1934,10 @@ function resolveNodeIndex(graph, kind, indexName) {
     (candidate) => candidate.entity === "node" && candidate.kind === kind && candidate.name === indexName
   );
   if (declaration?.entity !== "node") {
-    throw new chunkMRDBBHIZ_cjs.NodeIndexNotFoundError(indexName, kind);
+    throw new chunkX4GDXBOP_cjs.NodeIndexNotFoundError(indexName, kind);
   }
   if (declaration.method !== void 0) {
-    throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+    throw new chunkX4GDXBOP_cjs.ConfigurationError(
       `bulkFindByIndex cannot probe index "${indexName}" (method "${declaration.method}"): only btree indexes serve equality probes.`,
       { indexName, kind, method: declaration.method }
     );
@@ -1695,7 +1975,7 @@ function validateIndexProbeValue(value, valueType, pointer, kind) {
   }
 }
 function indexProbeTypeError(pointer, kind, expected, value) {
-  return new chunkMRDBBHIZ_cjs.ValidationError(
+  return new chunkX4GDXBOP_cjs.ValidationError(
     `Index probe value for "${pointer}" on node kind "${kind}" has an incompatible type`,
     {
       entityType: "node",
@@ -1729,7 +2009,7 @@ async function executeNodeBulkFindByIndex(ctx, kind, indexName, items, backend,
   if (items.length === 0) return [];
   const index = resolveNodeIndex(ctx.graph, kind, indexName);
   if (index.fields.length === 0) {
-    throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+    throw new chunkX4GDXBOP_cjs.ConfigurationError(
       `bulkFindByIndex requires an index with at least one prop-based field on index "${indexName}" (node kind "${kind}")`,
       { indexName, kind },
       {
@@ -1738,7 +2018,7 @@ async function executeNodeBulkFindByIndex(ctx, kind, indexName, items, backend,
     );
   }
   if (index.fieldValueTypes.includes("date")) {
-    throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+    throw new chunkX4GDXBOP_cjs.ConfigurationError(
       `bulkFindByIndex does not support date-typed key fields on index "${indexName}" (node kind "${kind}")`,
       { indexName, kind },
       {
@@ -1748,7 +2028,7 @@ async function executeNodeBulkFindByIndex(ctx, kind, indexName, items, backend,
   }
   const limitPerInput = options?.limitPerInput;
   if (limitPerInput !== void 0 && (!Number.isInteger(limitPerInput) || limitPerInput <= 0)) {
-    throw new chunkMRDBBHIZ_cjs.ValidationError(
+    throw new chunkX4GDXBOP_cjs.ValidationError(
       "bulkFindByIndex limitPerInput must be a positive integer",
       {
         entityType: "node",
@@ -1763,7 +2043,7 @@ async function executeNodeBulkFindByIndex(ctx, kind, indexName, items, backend,
       }
     );
   }
-  const adapter = chunkL3LQNR34_cjs.getDialect(backend.dialect);
+  const adapter = chunkTEC24ZDA_cjs.getDialect(backend.dialect);
   const probes = items.map(
     (item) => index.fields.map((pointer, position) => {
       const value = chunkA7J2YDDI_cjs.resolveJsonPointer(item.props, pointer);
@@ -1790,47 +2070,47 @@ async function executeNodeBulkFindByIndex(ctx, kind, indexName, items, backend,
     }
     groupToInputs[existing]?.push(inputIndex);
   }
-  const schema = backend.tableNames ? chunk3U5ABFDW_cjs.createSqlSchema(backend.tableNames) : chunk3U5ABFDW_cjs.DEFAULT_SQL_SCHEMA;
+  const schema = backend.tableNames ? chunkIHK5KA2Q_cjs.createSqlSchema(backend.tableNames) : chunkIHK5KA2Q_cjs.DEFAULT_SQL_SCHEMA;
   const compileContext = {
     dialect: backend.dialect,
-    propsColumn: chunkEDN4Y4ZG_cjs.sql.raw(`"props"`),
-    systemColumn: (column) => chunkEDN4Y4ZG_cjs.sql.raw(`"${column}"`)
+    propsColumn: chunkOJHD3LXJ_cjs.sql.raw(`"props"`),
+    systemColumn: (column) => chunkOJHD3LXJ_cjs.sql.raw(`"${column}"`)
   };
-  const fieldKeys = chunkL3LQNR34_cjs.compileNodeIndexFieldKeys(index, compileContext);
+  const fieldKeys = chunkTEC24ZDA_cjs.compileNodeIndexFieldKeys(index, compileContext);
   const groupPredicates = groupProbes.map(
-    (probe) => chunkEDN4Y4ZG_cjs.sql`(${chunkEDN4Y4ZG_cjs.sql.join(
+    (probe) => chunkOJHD3LXJ_cjs.sql`(${chunkOJHD3LXJ_cjs.sql.join(
       fieldKeys.map((fieldKey, position) => {
         const value = probe[position];
         if (value === void 0 || value === null) {
-          return chunkEDN4Y4ZG_cjs.sql`${fieldKey} IS NULL`;
+          return chunkOJHD3LXJ_cjs.sql`${fieldKey} IS NULL`;
         }
         return adapter.nullSafeEquals(
           fieldKey,
-          chunkEDN4Y4ZG_cjs.sql`${coerceIndexProbeBind(value, adapter)}`
+          chunkOJHD3LXJ_cjs.sql`${coerceIndexProbeBind(value, adapter)}`
         );
       }),
-      chunkEDN4Y4ZG_cjs.sql` AND `
+      chunkOJHD3LXJ_cjs.sql` AND `
     )})`
   );
   const caseBranches = groupPredicates.map(
-    (predicate, group) => chunkEDN4Y4ZG_cjs.sql`WHEN ${predicate} THEN ${chunkEDN4Y4ZG_cjs.sql.raw(String(group))}`
+    (predicate, group) => chunkOJHD3LXJ_cjs.sql`WHEN ${predicate} THEN ${chunkOJHD3LXJ_cjs.sql.raw(String(group))}`
   );
-  const probeIndexExpr = chunkEDN4Y4ZG_cjs.sql`CASE ${chunkEDN4Y4ZG_cjs.sql.join(caseBranches, chunkEDN4Y4ZG_cjs.sql` `)} ELSE NULL END`;
+  const probeIndexExpr = chunkOJHD3LXJ_cjs.sql`CASE ${chunkOJHD3LXJ_cjs.sql.join(caseBranches, chunkOJHD3LXJ_cjs.sql` `)} ELSE NULL END`;
   const conditions = [
-    chunkEDN4Y4ZG_cjs.sql`"graph_id" = ${ctx.graphId}`,
-    chunkEDN4Y4ZG_cjs.sql`"kind" = ${kind}`,
-    chunkEDN4Y4ZG_cjs.sql`"deleted_at" IS NULL`
+    chunkOJHD3LXJ_cjs.sql`"graph_id" = ${ctx.graphId}`,
+    chunkOJHD3LXJ_cjs.sql`"kind" = ${kind}`,
+    chunkOJHD3LXJ_cjs.sql`"deleted_at" IS NULL`
   ];
   if (index.where !== void 0) {
-    conditions.push(chunkL3LQNR34_cjs.compileIndexWhere(compileContext, index.where));
+    conditions.push(chunkTEC24ZDA_cjs.compileIndexWhere(compileContext, index.where));
   }
-  conditions.push(chunkEDN4Y4ZG_cjs.sql`(${chunkEDN4Y4ZG_cjs.sql.join(groupPredicates, chunkEDN4Y4ZG_cjs.sql` OR `)})`);
-  const whereClause = chunkEDN4Y4ZG_cjs.sql.join(conditions, chunkEDN4Y4ZG_cjs.sql` AND `);
-  const probedSelect = chunkEDN4Y4ZG_cjs.sql`SELECT "id", ${probeIndexExpr} AS probe_idx FROM ${schema.nodesTable} WHERE ${whereClause}`;
+  conditions.push(chunkOJHD3LXJ_cjs.sql`(${chunkOJHD3LXJ_cjs.sql.join(groupPredicates, chunkOJHD3LXJ_cjs.sql` OR `)})`);
+  const whereClause = chunkOJHD3LXJ_cjs.sql.join(conditions, chunkOJHD3LXJ_cjs.sql` AND `);
+  const probedSelect = chunkOJHD3LXJ_cjs.sql`SELECT "id", ${probeIndexExpr} AS probe_idx FROM ${schema.nodesTable} WHERE ${whereClause}`;
   const capInSql = limitPerInput !== void 0 && backend.capabilities.windowFunctions;
-  const query = capInSql ? chunkEDN4Y4ZG_cjs.sql`SELECT "id", probe_idx FROM (SELECT "id", probe_idx, ROW_NUMBER() OVER (PARTITION BY probe_idx ORDER BY "id") AS probe_rank FROM (${probedSelect}) AS probed) AS ranked WHERE probe_rank <= ${limitPerInput} ORDER BY probe_idx, "id"` : chunkEDN4Y4ZG_cjs.sql`${probedSelect} ORDER BY probe_idx, "id"`;
+  const query = capInSql ? chunkOJHD3LXJ_cjs.sql`SELECT "id", probe_idx FROM (SELECT "id", probe_idx, ROW_NUMBER() OVER (PARTITION BY probe_idx ORDER BY "id") AS probe_rank FROM (${probedSelect}) AS probed) AS ranked WHERE probe_rank <= ${limitPerInput} ORDER BY probe_idx, "id"` : chunkOJHD3LXJ_cjs.sql`${probedSelect} ORDER BY probe_idx, "id"`;
   const rawMatches = await backend.execute(
-    chunkEDN4Y4ZG_cjs.asCompiledRowsSql(query)
+    chunkOJHD3LXJ_cjs.asCompiledRowsSql(query)
   );
   const matches = limitPerInput !== void 0 && !capInSql ? capMatchesPerGroup(rawMatches, limitPerInput) : rawMatches;
   const nodesById = await hydrateNodesById(
@@ -1863,7 +2143,7 @@ function capMatchesPerGroup(matches, limitPerInput) {
   return capped;
 }
 async function hydrateNodesById(backend, graphId, kind, ids) {
-  const rowsById = await chunkEZEEWCFJ_cjs.getNodeRowsByIds(backend, graphId, kind, ids);
+  const rowsById = await chunkRDP6ZRSM_cjs.getNodeRowsByIds(backend, graphId, kind, ids);
   const nodesById = /* @__PURE__ */ new Map();
   for (const [id, row] of rowsById) {
     if (row.deleted_at !== void 0) continue;
@@ -1879,7 +2159,7 @@ async function executeNodeBulkGetOrCreateByConstraint(ctx, kind, constraintName,
   const constraint = resolveConstraint(ctx.graph, kind, constraintName);
   const validated = validateAndComputeKeys(nodeKind, kind, constraint, items);
   const uniqueKeys = collectUniqueKeys(validated);
-  const kindsToCheck = chunkFQPEMEWX_cjs.getKindsForUniquenessCheck(
+  const kindsToCheck = chunkLLVOQOWE_cjs.uniquenessProbeKinds(
     kind,
     constraint.scope,
     ctx.registry
@@ -1982,16 +2262,20 @@ async function executeNodeBulkGetOrCreateByConstraint(ctx, kind, constraintName,
   try {
     return await attempt();
   } catch (error) {
-    if (!(error instanceof chunkMRDBBHIZ_cjs.UniquenessError)) throw error;
+    if (!(error instanceof chunkX4GDXBOP_cjs.UniquenessError)) throw error;
     return attempt();
   }
 }
 
 exports.assertClearValidToSupported = assertClearValidToSupported;
 exports.assertValidityEndMutation = assertValidityEndMutation;
+exports.assertsStoredWindowState = assertsStoredWindowState;
 exports.checkCardinalityConstraint = checkCardinalityConstraint;
-exports.createNodeBatchValidationBackend = createNodeBatchValidationBackend;
+exports.checkDisjointnessConstraint = checkDisjointnessConstraint;
+exports.createEdgeBatchValidationBackend = createEdgeBatchValidationBackend;
+exports.createNodeBatchValidationSeams = createNodeBatchValidationSeams;
 exports.edgeWriteNeedsConstraintFence = edgeWriteNeedsConstraintFence;
+exports.edgeWritePlan = edgeWritePlan;
 exports.executeNodeBulkFindByConstraint = executeNodeBulkFindByConstraint;
 exports.executeNodeBulkFindByIndex = executeNodeBulkFindByIndex;
 exports.executeNodeBulkGetOrCreateByConstraint = executeNodeBulkGetOrCreateByConstraint;
@@ -2006,13 +2290,18 @@ exports.executeNodeHardDelete = executeNodeHardDelete;
 exports.executeNodeUpdate = executeNodeUpdate;
 exports.executeNodeUpdateWhere = executeNodeUpdateWhere;
 exports.executeNodeUpsertUpdate = executeNodeUpsertUpdate;
+exports.graphOwesClaims = graphOwesClaims;
+exports.mixedWritePlan = mixedWritePlan;
 exports.nodeUpsertDirtyCheck = nodeUpsertDirtyCheck;
 exports.primeBatchValidationCaches = primeBatchValidationCaches;
 exports.rowToEdge = rowToEdge;
 exports.rowToEdgeMeta = rowToEdgeMeta;
 exports.rowToNode = rowToNode;
 exports.rowToNodeMeta = rowToNodeMeta;
+exports.runHookedWritePlan = runHookedWritePlan;
+exports.runWritePlan = runWritePlan;
+exports.unfencedTarget = unfencedTarget;
 exports.validityEndAfterMutation = validityEndAfterMutation;
 exports.withAlreadyExistsTranslation = withAlreadyExistsTranslation;
-//# sourceMappingURL=chunk-JB6T4GLL.cjs.map
-//# sourceMappingURL=chunk-JB6T4GLL.cjs.map
+//# sourceMappingURL=chunk-C76WFIVZ.cjs.map
+//# sourceMappingURL=chunk-C76WFIVZ.cjs.map