@nicia-ai/typegraph 0.49.0 → 0.50.0

package/dist/{chunk-KF6K7TGH.js → chunk-2GIV5X4P.js}

@@ -1,19 +1,19 @@
-import { getEmbeddingFields, validateResolvedNodeUniqueness, createUniquenessContext, applyNodeInsertSideEffectsBatch, createNodeWriteContext, applyNodeSoftDelete, applyNodeHardDelete, applyNodeUpdate, applyNodeInsertSideEffects, checkUniquenessConstraints } from './chunk-I4GAZH5Z.js';
-import { runInWriteTransaction, refKey, runHookedWriteOperation, validateNodeProps } from './chunk-ZFMCDJGB.js';
-import { encodeTupleKey, runInsertBatch, nodeInsertDispatch, runInsertBatchReturning, getNodeRowsByIds, generateId, runInsertNoReturn } from './chunk-S5TERQVW.js';
-import { canonicalEqual } from './chunk-JBQQ7THH.js';
-import { deriveBackend } from './chunk-UGHG7PGX.js';
-import { createSqlSchema, DEFAULT_SQL_SCHEMA } from './chunk-NVY5CJFP.js';
-import { rowPropsToObject, isLiveNodeRow } from './chunk-6LN7FIVU.js';
-import { checkCardinality, checkUniqueEdge, checkWherePredicate, computeUniqueKey, getKindsForUniquenessCheck, checkDisjointness } from './chunk-GLHXM7C4.js';
-import { validateOptionalCanonicalIsoDate, nowIso, resolveStampedValidityLowerBound, assertOrderedValidityWindow, preservesImmutableLowerBound, assertWritableValidityWindow } from './chunk-5K2BKEBD.js';
-import { getDialect, compileNodeIndexFieldKeys, compileIndexWhere } from './chunk-ZDKTPBGV.js';
-import { sql, asCompiledRowsSql } from './chunk-3DMMGT6S.js';
+import { nodeClaimSites, nodeClaimEntries, getEmbeddingFields, createNodeWriteContext, applyNodeSetUpdate, applyNodeResurrect, applyNodeHardDelete, applyNodeSoftDelete, applyNodeUpdate, withNodeCreateClaimsBatch, applyNodeInsertSyncFansBatch, withNodeCreateClaims, applyNodeInsertSyncFans, checkUniquenessConstraints, createUniquenessContext } from './chunk-VTJVMP4I.js';
+import { EDGE_CARDINALITY_SPECS, claimEdgeCardinalityBatch, claimEdgeCardinality, purgeEdgeClaims } from './chunk-YA36ABIL.js';
+import { refKey } from './chunk-GVYVGGPJ.js';
+import { runInWriteTransaction, runHookedWriteOperation, validateNodeProps, getNodeRowsByIds, generateId, nodeInsertDispatch, edgeInsertDispatch, runInsertBatch, runInsertBatchReturning, runInsertNoReturn } from './chunk-FX5ZW6PN.js';
+import { deriveBackend, canonicalEqual } from './chunk-IRPYOHRC.js';
+import { createSqlSchema, DEFAULT_SQL_SCHEMA } from './chunk-Y55DLLEG.js';
+import { rowPropsToObject, isLiveNodeRow } from './chunk-PALYTHGM.js';
+import { checkDisjointness, checkUniqueEdge, checkCardinality, uniquenessProbeKinds, encodeTupleKey, checkWherePredicate, computeUniqueKey } from './chunk-5LKOVCPP.js';
+import { assertsStoredLowerBound, assertsStoredUpperBound, validateOptionalCanonicalIsoDate, nowIso, resolveStampedValidityLowerBound, assertOrderedValidityWindow, preservesImmutableLowerBound, assertWritableValidityWindow } from './chunk-K46SDNQD.js';
+import { getDialect, compileNodeIndexFieldKeys, compileIndexWhere } from './chunk-EDLKIQRI.js';
+import { sql, asCompiledRowsSql } from './chunk-46UGOVRW.js';
 import { getSearchableFields } from './chunk-PC2UBAUB.js';
-import { filterReservedKeys, RESERVED_NODE_KEYS, RESERVED_EDGE_KEYS, assertJsonValue } from './chunk-XVWOYKIK.js';
-import { ValidationError, ConfigurationError, DatabaseOperationError, UniquenessError, NodeNotFoundError, KindNotFoundError, NodeConstraintNotFoundError, NodeIndexNotFoundError, ENTITY_ALREADY_EXISTS_CODE } from './chunk-ZLONH2UD.js';
+import { filterReservedKeys, RESERVED_NODE_KEYS, RESERVED_EDGE_KEYS, assertJsonValue } from './chunk-FZHF5UWR.js';
+import { ValidationError, ConfigurationError, DatabaseOperationError, UniquenessError, KindNotFoundError, NodeConstraintNotFoundError, NodeIndexNotFoundError, ENTITY_ALREADY_EXISTS_CODE, NodeNotFoundError } from './chunk-YDEJQWOL.js';
 import { resolveJsonPointer } from './chunk-FWJKWH6U.js';
-import { requireDefined, createDataKeyedBag, hasOwnKey } from './chunk-DYATYRY4.js';
+import { createDataKeyedBag, requireDefined, hasOwnKey } from './chunk-DYATYRY4.js';
 
 // src/store/row-mappers.ts
 function nullToUndefined(value) {
@@ -68,13 +68,29 @@ 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 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 = nodeClaimSites(
+        registry,
+        kind,
+        registration.unique ?? [],
+        operation
+      ).find((site) => site.placement === "pre-insert");
+      if (gating !== void 0) return gating.refusalReason;
+    }
   }
-  const sharedScope = uniqueConstraints.some(
-    (constraint) => 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);
@@ -87,71 +103,435 @@ async function checkDisjointnessConstraint(ctx, kind, id) {
   }
 }
 async function checkCardinalityConstraint(ctx, edgeKind, cardinality, fromKind, fromId, toKind, toId, validTo) {
-  switch (cardinality) {
-    case "many": {
+  if (cardinality === "many") return;
+  const spec = 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 = 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 = 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 encodeTupleKey([graphId, kind, id]);
+}
+function buildEdgeFromCacheKey(graphId, edgeKind, fromKind, fromId) {
+  return encodeTupleKey([graphId, edgeKind, fromKind, fromId]);
+}
+function buildEdgeBetweenCacheKey(graphId, edgeKind, fromKind, fromId, toKind, toId) {
+  return encodeTupleKey([graphId, edgeKind, fromKind, fromId, toKind, toId]);
+}
+function buildCountEdgesFromCacheKey(params) {
+  const activeOnly = params.activeOnly === true ? "1" : "0";
+  return 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 = 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 = 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 = 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 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 purgeEdgeClaims(backend, ctx.graphId, [work.id]);
+  }
+}
+
+// src/store/operations/write-fences.ts
+function createWriteParamsDraft() {
+  return {};
+}
+function assertsStoredWindowState(fences) {
+  return assertsStoredLowerBound(fences.validityLowerBound) || 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 (!assertsStoredLowerBound(fence)) return;
+  draft.expectedValidFrom = fence.expectedValidFrom;
+}
+var NODE_UPDATE_FENCE_APPLIERS = {
+  validityLowerBound: applyValidityLowerBound
+};
+var NODE_SET_UPDATE_FENCE_APPLIERS = {
+  validityLowerBound: (fence) => {
+    if (!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 (!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 = createNodeWriteContext(ctx.graphId, ctx.registry, lock);
+  const dispatch = nodeInsertDispatch(target);
+  const edgeContext = createEdgeWriteContext(ctx.graphId, lock);
+  const edgeDispatch = 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 withNodeCreateClaims(
+        writeContext,
+        work.claim,
+        target,
+        () => dispatch.one(work.params)
+      );
+      await applyNodeInsertSyncFans(writeContext, work.sideEffects, target);
+      return row;
+    },
+    createNodeNoReturn: async (work) => {
+      await withNodeCreateClaims(
+        writeContext,
+        work.claim,
+        target,
+        () => runInsertNoReturn(dispatch, work.params)
+      );
+      await applyNodeInsertSyncFans(writeContext, work.sideEffects, target);
+    },
+    createNodes: async (work) => {
+      const rows = await withNodeCreateClaimsBatch(
+        writeContext,
+        work.map((item) => item.claim),
+        target,
+        () => runInsertBatchReturning(
+          dispatch,
+          work.map((item) => item.params)
+        )
+      );
+      await applyNodeInsertSyncFansBatch(
+        writeContext,
+        work.map((item) => item.sideEffects),
+        target
+      );
+      return rows;
+    },
+    createNodesNoReturn: async (work) => {
+      await withNodeCreateClaimsBatch(
+        writeContext,
+        work.map((item) => item.claim),
+        target,
+        () => runInsertBatch(
+          dispatch,
+          work.map((item) => item.params)
+        )
+      );
+      await applyNodeInsertSyncFansBatch(
+        writeContext,
+        work.map((item) => item.sideEffects),
+        target
+      );
+    },
+    reviseNode: (work, fences) => {
+      const draft = createWriteParamsDraft();
+      applyWriteFences(NODE_UPDATE_FENCE_APPLIERS, fences, draft);
+      return applyNodeUpdate(writeContext, { ...work, ...draft }, target);
+    },
+    retireNode: (work, policy) => applyNodeSoftDelete(writeContext, work, target, policy),
+    purgeNode: (work) => applyNodeHardDelete(writeContext, work, target),
+    reviveNode: (work) => applyNodeResurrect(writeContext, work, target),
+    reviseNodeSet: (work, fences) => {
+      applyWriteFences(
+        NODE_SET_UPDATE_FENCE_APPLIERS,
+        fences,
+        createWriteParamsDraft()
+      );
+      return 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 claimEdgeCardinality(target, work.claim);
       }
-      const count = await ctx.backend.countEdgesFrom({
-        graphId: ctx.graphId,
-        edgeKind,
-        fromKind,
-        fromId,
-        activeOnly: true
-      });
-      const error = checkCardinality(
-        edgeKind,
-        fromKind,
-        fromId,
-        "oneActive",
-        count,
-        count > 0
+      return edgeDispatch.one(work.params);
+    },
+    createEdgeNoReturn: async (work) => {
+      if (work.claim !== void 0) {
+        await claimEdgeCardinality(target, work.claim);
+      }
+      await runInsertNoReturn(edgeDispatch, work.params);
+    },
+    createEdges: async (work) => {
+      await claimEdgeCardinalityBatch(target, edgeBatchClaims(work));
+      return runInsertBatchReturning(
+        edgeDispatch,
+        work.map((item) => item.params)
       );
-      if (error) throw error;
-      return;
+    },
+    createEdgesNoReturn: async (work) => {
+      await claimEdgeCardinalityBatch(target, edgeBatchClaims(work));
+      await 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 = 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(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 runInWriteTransaction(
+    ctx,
+    backend,
+    planFrame(ctx, plan, rowWork),
+    planTransactionOptions(plan, options)
+  );
+}
+function runHookedWritePlan(ctx, opContext, plan, backend, rowWork, options) {
+  return 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
@@ -266,12 +646,18 @@ 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 encodeTupleKey([graphId, kind, id]);
@@ -290,14 +676,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
   };
 }
@@ -312,7 +698,7 @@ function resolveConstraint(graph, kind, constraintName) {
   }
   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();
@@ -368,71 +754,72 @@ function createNodeBatchValidationBackend(graphId, registry, backend) {
     });
   }
   function registerPendingUniqueEntries(kind, id, props, constraints) {
-    for (const constraint of constraints) {
-      if (!checkWherePredicate(constraint, props)) continue;
-      const key = computeUniqueKey(
-        props,
-        constraint.fields,
-        constraint.collation
-      );
-      const concreteEntryKey = buildUniqueCacheKey(
-        graphId,
-        kind,
-        constraint.name,
-        key
+    for (const entry of 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 = 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(
+      nodeClaimEntries(registry, kind, id, oldProps, constraints, "update").map(
+        (entry) => [entry.constraintName, entry]
+      )
+    );
+    const newEntries = new Map(
+      nodeClaimEntries(registry, kind, id, newProps, constraints, "update").map(
+        (entry) => [entry.constraintName, entry]
+      )
+    );
     for (const constraint of constraints) {
-      const oldApplies = checkWherePredicate(constraint, oldProps);
-      const newApplies = checkWherePredicate(constraint, newProps);
-      const oldKey = oldApplies ? computeUniqueKey(oldProps, constraint.fields, constraint.collation) : void 0;
-      const newKey = newApplies ? computeUniqueKey(newProps, constraint.fields, constraint.collation) : void 0;
-      if (oldKey === newKey) continue;
-      const kindsToCheck = getKindsForUniquenessCheck(
+      const oldEntry = oldEntries.get(constraint.name);
+      const newEntry = newEntries.get(constraint.name);
+      if (oldEntry?.key === newEntry?.key) continue;
+      const kindsToCheck = 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);
         }
       }
     }
@@ -447,12 +834,13 @@ function createNodeBatchValidationBackend(graphId, registry, backend) {
     if (uniqueCache.has(cacheKey)) return;
     uniqueCache.set(cacheKey, row);
   }
-  const validationBackend = deriveBackend(backend, {
+  const reads = {
     getNode: getNodeCached,
     checkUnique: checkUniqueCached
-  });
+  };
   return {
-    backend: validationBackend,
+    reads,
+    reader: deriveBackend(backend, reads),
     registerPendingNode,
     registerPendingUniqueEntries,
     registerAppliedNodeUpdate,
@@ -529,35 +917,33 @@ async function validateAndPrepareNodeCreate(ctx, input, id, backend, options) {
     backend
   );
 }
-async function finalizeNodeCreateBatch(ctx, preparedCreates, backend, lock) {
-  await applyNodeInsertSideEffectsBatch(
-    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 applyNodeInsertSideEffects(
-    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 = validateNodeProps(
@@ -591,10 +977,10 @@ function nodeUpsertDirtyCheck(ctx, kind, id, existingProps, inputProps) {
     unchanged: 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);
+  const existing = await target.getNode(ctx.graphId, kind, id);
   if (!existing) throw new NodeNotFoundError(kind, id);
   const { registration, validatedProps } = resolveNodeUpdateProps(
     ctx,
@@ -626,55 +1012,44 @@ async function performNodeUpdate(ctx, input, backend, lock, options) {
     },
     validTo
   );
-  const writeContext = 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 applyNodeUpdate(
-      writeContext,
+    const row2 = await session.reviseNode(
       { ...shared, existing, clearDeleted: true, ...resurrectionLowerBound },
-      backend
+      fences
     );
     return rowToNode(row2);
   }
   if (!isLiveNodeRow(existing)) throw new NodeNotFoundError(kind, id);
-  const row = await applyNodeUpdate(
-    writeContext,
+  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) {
@@ -721,14 +1096,18 @@ 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 (!checkWherePredicate(constraint, draft.validatedProps)) continue;
-        const key = computeUniqueKey(
-          draft.validatedProps,
-          constraint.fields,
-          constraint.collation
-        );
-        const kindsToCheck = getKindsForUniquenessCheck(
+      for (const entry of 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 = uniquenessProbeKinds(
           draft.kind,
           constraint.scope,
           ctx.registry
@@ -767,12 +1146,12 @@ 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 ?? generateId(), options)
   );
@@ -813,7 +1192,7 @@ function partitionCreates(preparedCreates) {
 function isNodeUpdateNoRowError(error) {
   return error instanceof 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 DatabaseOperationError(
@@ -831,8 +1210,7 @@ async function resurrectPreparedNode(ctx, target, lock, prepared) {
     resurrectionInstant
   );
   try {
-    return await applyNodeUpdate(
-      createNodeWriteContext(ctx.graphId, ctx.registry, lock),
+    return await session.reviseNode(
       {
         existing: current,
         clearDeleted: true,
@@ -845,7 +1223,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;
@@ -860,7 +1242,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,
@@ -869,16 +1256,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,
@@ -886,7 +1279,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);
         }
       }
@@ -899,7 +1292,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);
         }
       }
@@ -912,13 +1305,16 @@ async function executeNodeCreateInternal(ctx, input, backend, options) {
   const id = input.id ?? generateId();
   const opContext = ctx.createOperationContext("create", "node", kind, id);
   const shouldReturnRow = options?.returnRow ?? true;
-  return 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,
@@ -930,8 +1326,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) {
@@ -940,22 +1336,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 runInsertNoReturn(
-          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")
     }
   );
 }
@@ -974,46 +1364,43 @@ async function executeNodeCreate(ctx, input, backend, options) {
 }
 async function executeNodeCreateNoReturnBatch(ctx, inputs, backend) {
   if (inputs.length === 0) return;
-  await 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",
-        () => runInsertBatch(
-          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 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,
@@ -1023,18 +1410,16 @@ async function executeNodeCreateBatch(ctx, inputs, backend, options) {
       const partition = partitionCreates(preparedCreates);
       const inserted = await withAlreadyExistsTranslation(
         "node",
-        () => runInsertBatchReturning(
-          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) => [
           refKey({ kind: row.kind, id: row.id }),
@@ -1051,39 +1436,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 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");
-      }
+    async (session, target) => {
       const validTo = 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,
@@ -1094,8 +1476,8 @@ async function executeNodeUpdate(ctx, input, backend, options) {
       const node = await performNodeUpdateWithResurrectionRecovery(
         ctx,
         input,
+        session,
         target,
-        lock,
         options
       );
       if (options?.clearDeleted && identity !== void 0) {
@@ -1104,13 +1486,6 @@ async function executeNodeUpdate(ctx, input, backend, options) {
         ]);
       }
       return node;
-    },
-    {
-      fencesConstraintProbe: nodeFencesConstraintProbe(
-        ctx,
-        input.kind,
-        "update"
-      )
     }
   );
 }
@@ -1205,107 +1580,32 @@ async function executeNodeUpdateWhere(ctx, kind, inputPatch, candidateIds, candi
   const hookContext = ctx.createBulkOperationContext("updateWhere", kind);
   return ctx.withBulkOperationHooks(
     hookContext,
-    () => 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 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 ConfigurationError(
-            "The transaction backend lacks batched uniqueness operations",
-            { code: "SET_UPDATE_UNIQUENESS_UNSUPPORTED", kind }
-          );
-        }
-        if (getSearchableFields(schema).length > 0 && (target.upsertFulltext === void 0 || target.deleteFulltext === void 0 || target.upsertFulltextBatch === void 0 || target.deleteFulltextBatch === void 0)) {
-          throw new ConfigurationError(
-            "The transaction backend lacks batched fulltext operations",
-            { code: "SET_UPDATE_FULLTEXT_UNSUPPORTED", kind }
-          );
-        }
-        if (getEmbeddingFields(schema).length > 0 && (target.upsertEmbedding === void 0 || target.deleteEmbedding === void 0 || target.upsertEmbeddingBatch === void 0 || target.deleteEmbeddingBatch === void 0)) {
-          throw new 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 = rowPropsToObject(row.props);
-          const validatedProps = validateNodeProps(schema, props, {
-            kind,
-            operation: "update",
-            id: row.id
-          });
-          if (!canonicalEqual(validatedProps, props)) {
-            throw new 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 validateResolvedNodeUniqueness(
-            createUniquenessContext(ctx.graphId, ctx.registry, target),
-            sidecarItems.map((item) => ({
-              kind: item.kind,
-              id: item.id,
-              props: item.props,
-              constraints: item.uniqueConstraints
-            }))
-          );
-          await requireDefined(hardDeleteUniquesByNodeIds)({
-            graphId: ctx.graphId,
-            concreteKind: kind,
-            nodeIds: result.rows.map((row) => row.id)
-          });
-        }
-        await applyNodeInsertSideEffectsBatch(
-          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 }
     )
   );
 }
@@ -1313,18 +1613,22 @@ async function executeNodeUpsertUpdate(ctx, input, backend, options) {
   if (input.clearValidTo === true) {
     assertClearValidToSupported(backend, "node");
   }
-  return 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) => {
+    async (session, target) => {
       const validTo = 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,
@@ -1335,8 +1639,8 @@ async function executeNodeUpsertUpdate(ctx, input, backend, options) {
       const node = await performNodeUpdateWithResurrectionRecovery(
         ctx,
         input,
+        session,
         target,
-        lock,
         options
       );
       if (options?.clearDeleted && identity !== void 0) {
@@ -1345,13 +1649,6 @@ async function executeNodeUpsertUpdate(ctx, input, backend, options) {
         ]);
       }
       return node;
-    },
-    {
-      fencesConstraintProbe: nodeFencesConstraintProbe(
-        ctx,
-        input.kind,
-        "update"
-      )
     }
   );
 }
@@ -1359,26 +1656,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 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 || !isLiveNodeRow(preflight)) return;
-      await applyNodeSoftDelete(
-        createNodeWriteContext(ctx.graphId, ctx.registry, lock),
-        {
-          existing: preflight,
-          schema: registration.type.schema,
-          uniqueConstraints: registration.unique ?? [],
-          onDelete: registration.onDelete
-        },
-        target
-      );
+      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");
       }
@@ -1386,32 +1679,23 @@ async function executeNodeDelete(ctx, kind, id, backend) {
   );
 }
 async function executeNodeDeleteBatch(ctx, kind, ids, backend) {
-  await 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 = 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 || !isLiveNodeRow(preflight)) continue;
-        await applyNodeSoftDelete(
-          writeContext,
-          {
-            existing: preflight,
-            schema: registration.type.schema,
-            uniqueConstraints: registration.unique ?? [],
-            onDelete: registration.onDelete
-          },
-          target
-        );
+        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");
         }
@@ -1426,24 +1710,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 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 applyNodeHardDelete(
-        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");
       }
@@ -1473,7 +1753,7 @@ async function executeNodeGetOrCreateByConstraint(ctx, kind, constraintName, pro
     constraint.fields,
     constraint.collation
   );
-  const kindsToCheck = getKindsForUniquenessCheck(
+  const kindsToCheck = uniquenessProbeKinds(
     kind,
     constraint.scope,
     ctx.registry
@@ -1548,7 +1828,7 @@ async function executeNodeFindByConstraint(ctx, kind, constraintName, props, bac
     constraint.fields,
     constraint.collation
   );
-  const kindsToCheck = getKindsForUniquenessCheck(
+  const kindsToCheck = uniquenessProbeKinds(
     kind,
     constraint.scope,
     ctx.registry
@@ -1602,7 +1882,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 = getKindsForUniquenessCheck(
+  const kindsToCheck = uniquenessProbeKinds(
     kind,
     constraint.scope,
     ctx.registry
@@ -1877,7 +2157,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 = getKindsForUniquenessCheck(
+  const kindsToCheck = uniquenessProbeKinds(
     kind,
     constraint.scope,
     ctx.registry
@@ -1985,6 +2265,6 @@ async function executeNodeBulkGetOrCreateByConstraint(ctx, kind, constraintName,
   }
 }
 
-export { assertClearValidToSupported, assertValidityEndMutation, checkCardinalityConstraint, createNodeBatchValidationBackend, edgeWriteNeedsConstraintFence, executeNodeBulkFindByConstraint, executeNodeBulkFindByIndex, executeNodeBulkGetOrCreateByConstraint, executeNodeCreate, executeNodeCreateBatch, executeNodeCreateNoReturnBatch, executeNodeDelete, executeNodeDeleteBatch, executeNodeFindByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeUpdate, executeNodeUpdateWhere, executeNodeUpsertUpdate, nodeUpsertDirtyCheck, primeBatchValidationCaches, rowToEdge, rowToEdgeMeta, rowToNode, rowToNodeMeta, validityEndAfterMutation, withAlreadyExistsTranslation };
-//# sourceMappingURL=chunk-KF6K7TGH.js.map
-//# sourceMappingURL=chunk-KF6K7TGH.js.map
+export { assertClearValidToSupported, assertValidityEndMutation, assertsStoredWindowState, checkCardinalityConstraint, checkDisjointnessConstraint, createEdgeBatchValidationBackend, createNodeBatchValidationSeams, edgeWriteNeedsConstraintFence, edgeWritePlan, executeNodeBulkFindByConstraint, executeNodeBulkFindByIndex, executeNodeBulkGetOrCreateByConstraint, executeNodeCreate, executeNodeCreateBatch, executeNodeCreateNoReturnBatch, executeNodeDelete, executeNodeDeleteBatch, executeNodeFindByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeUpdate, executeNodeUpdateWhere, executeNodeUpsertUpdate, graphOwesClaims, mixedWritePlan, nodeUpsertDirtyCheck, primeBatchValidationCaches, rowToEdge, rowToEdgeMeta, rowToNode, rowToNodeMeta, runHookedWritePlan, runWritePlan, unfencedTarget, validityEndAfterMutation, withAlreadyExistsTranslation };
+//# sourceMappingURL=chunk-2GIV5X4P.js.map
+//# sourceMappingURL=chunk-2GIV5X4P.js.map