@nicia-ai/typegraph 0.45.0 → 0.46.0

package/dist/{chunk-UCQ3BFSY.cjs → chunk-7GT72YHH.cjs}

@@ -1,26 +1,28 @@
 'use strict';
 
-var chunkJ7LXTUTP_cjs = require('./chunk-J7LXTUTP.cjs');
-var chunkCPEL3YIR_cjs = require('./chunk-CPEL3YIR.cjs');
-var chunkEKFUG4G7_cjs = require('./chunk-EKFUG4G7.cjs');
-var chunkKKYELPZ2_cjs = require('./chunk-KKYELPZ2.cjs');
-var chunkACSVZPK7_cjs = require('./chunk-ACSVZPK7.cjs');
-var chunkZTAJL4DT_cjs = require('./chunk-ZTAJL4DT.cjs');
-var chunkJXUTCSXX_cjs = require('./chunk-JXUTCSXX.cjs');
-var chunkU5W4LKZV_cjs = require('./chunk-U5W4LKZV.cjs');
-var chunk764JHTLT_cjs = require('./chunk-764JHTLT.cjs');
+var chunkTTAITEPJ_cjs = require('./chunk-TTAITEPJ.cjs');
+var chunkXNLIZYRZ_cjs = require('./chunk-XNLIZYRZ.cjs');
+var chunkXMQSEJCF_cjs = require('./chunk-XMQSEJCF.cjs');
+var chunkPWLJ77UV_cjs = require('./chunk-PWLJ77UV.cjs');
+var chunkNFCVHQ5P_cjs = require('./chunk-NFCVHQ5P.cjs');
+var chunkXBYVV3MP_cjs = require('./chunk-XBYVV3MP.cjs');
+var chunkE4WNQBEF_cjs = require('./chunk-E4WNQBEF.cjs');
+var chunkQ7Q4WSLJ_cjs = require('./chunk-Q7Q4WSLJ.cjs');
+var chunk4UGOKMI5_cjs = require('./chunk-4UGOKMI5.cjs');
+var chunkVCRRKBLN_cjs = require('./chunk-VCRRKBLN.cjs');
 var chunkHAHNRASW_cjs = require('./chunk-HAHNRASW.cjs');
-var chunkD54WH24V_cjs = require('./chunk-D54WH24V.cjs');
-var chunkC4F7VJ5D_cjs = require('./chunk-C4F7VJ5D.cjs');
-var chunkTDXIBCGY_cjs = require('./chunk-TDXIBCGY.cjs');
+var chunkLBJKZXDE_cjs = require('./chunk-LBJKZXDE.cjs');
+var chunkNI72YOJB_cjs = require('./chunk-NI72YOJB.cjs');
+var chunkA7J2YDDI_cjs = require('./chunk-A7J2YDDI.cjs');
+var chunkN66HCGCY_cjs = require('./chunk-N66HCGCY.cjs');
 
 // src/store/row-mappers.ts
 function nullToUndefined(value) {
   return value === null ? void 0 : value;
 }
 function rowToNode(row) {
-  const rawProps = chunkEKFUG4G7_cjs.rowPropsToObject(row.props);
-  const props = chunkD54WH24V_cjs.filterReservedKeys(rawProps, chunkD54WH24V_cjs.RESERVED_NODE_KEYS);
+  const rawProps = chunkXBYVV3MP_cjs.rowPropsToObject(row.props);
+  const props = chunkLBJKZXDE_cjs.filterReservedKeys(rawProps, chunkLBJKZXDE_cjs.RESERVED_NODE_KEYS);
   return {
     kind: row.kind,
     id: row.id,
@@ -39,8 +41,8 @@ function rowToNodeMeta(row) {
   };
 }
 function rowToEdge(row) {
-  const rawProps = chunkEKFUG4G7_cjs.rowPropsToObject(row.props);
-  const props = chunkD54WH24V_cjs.filterReservedKeys(rawProps, chunkD54WH24V_cjs.RESERVED_EDGE_KEYS);
+  const rawProps = chunkXBYVV3MP_cjs.rowPropsToObject(row.props);
+  const props = chunkLBJKZXDE_cjs.filterReservedKeys(rawProps, chunkLBJKZXDE_cjs.RESERVED_EDGE_KEYS);
   return {
     id: row.id,
     kind: row.kind,
@@ -62,65 +64,25 @@ function rowToEdgeMeta(row) {
   };
 }
 
-// src/store/operations/write-transaction.ts
-async function lockSchemaVersionForStoreWrite(ctx, backend) {
-  const expectedVersion = ctx.schemaVersion;
-  if (expectedVersion === void 0) return;
-  if ("transaction" in backend && !backend.capabilities.transactions) {
-    throw new chunkC4F7VJ5D_cjs.ConfigurationError(
-      "Schema-managed Store writes require a transactional backend so schema changes and entity writes can share one fence.",
-      {
-        code: "SCHEMA_WRITE_FENCE_UNSUPPORTED",
-        graphId: ctx.graphId
-      }
-    );
-  }
-  const lockSchemaVersionForWrite = backend.lockSchemaVersionForWrite;
-  if (lockSchemaVersionForWrite === void 0) {
-    throw new chunkC4F7VJ5D_cjs.ConfigurationError(
-      "This backend cannot fence schema-managed Store writes against a concurrent schema change.",
-      {
-        code: "SCHEMA_WRITE_FENCE_UNSUPPORTED",
-        graphId: ctx.graphId
-      }
-    );
-  }
-  await lockSchemaVersionForWrite({
-    graphId: ctx.graphId,
-    expectedVersion
-  });
-}
-function runInWriteTransaction(ctx, backend, fn, options) {
-  const ownsWriteLock = "transaction" in backend && backend.capabilities.transactions;
-  return chunkEKFUG4G7_cjs.runOptionallyInTransaction(backend, async (target) => {
-    await lockSchemaVersionForStoreWrite(ctx, target);
-    const lock = ctx.historyEnabled || ctx.revisionTrackingEnabled ? await chunkJ7LXTUTP_cjs.lockRecordedGraphWrite(target, ctx.graphId) : chunkJ7LXTUTP_cjs.uncapturedGraphWriteLock();
-    const result = await fn(target, lock);
-    if (ctx.revisionTrackingEnabled && !ctx.historyEnabled && (options?.didWrite?.(result) ?? true)) {
-      await chunkJ7LXTUTP_cjs.advanceRevisionClock(
-        target,
-        ctx.revisionSchema,
-        ctx.graphId,
-        ownsWriteLock
-      );
-    }
-    return result;
-  });
+// src/store/constraints.ts
+function edgeWriteNeedsConstraintFence(cardinality) {
+  return cardinality === "many" ? void 0 : "edgeCardinality";
 }
-function runHookedWriteOperation(ctx, opContext, backend, body) {
-  return ctx.withOperationHooks(
-    opContext,
-    () => runInWriteTransaction(ctx, backend, body)
+function nodeWriteNeedsConstraintFence(registry, kind, uniqueConstraints, operation) {
+  if (operation === "create" && registry.getDisjointKinds(kind).length > 0) {
+    return "nodeDisjointness";
+  }
+  const sharedScope = uniqueConstraints.some(
+    (constraint) => chunkE4WNQBEF_cjs.getKindsForUniquenessCheck(kind, constraint.scope, registry).length > 1
   );
+  return sharedScope ? "nodeUniquenessScope" : void 0;
 }
-
-// src/store/constraints.ts
 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 = chunkJ7LXTUTP_cjs.checkDisjointness(id, kind, [disjointKind], ctx.registry);
+      const error = chunkE4WNQBEF_cjs.checkDisjointness(id, kind, [disjointKind], ctx.registry);
       if (error) throw error;
     }
   }
@@ -137,7 +99,7 @@ async function checkCardinalityConstraint(ctx, edgeKind, cardinality, fromKind,
         fromKind,
         fromId
       });
-      const error = chunkJ7LXTUTP_cjs.checkCardinality(
+      const error = chunkE4WNQBEF_cjs.checkCardinality(
         edgeKind,
         fromKind,
         fromId,
@@ -157,7 +119,7 @@ async function checkCardinalityConstraint(ctx, edgeKind, cardinality, fromKind,
         toKind,
         toId
       });
-      const error = chunkJ7LXTUTP_cjs.checkUniqueEdge(
+      const error = chunkE4WNQBEF_cjs.checkUniqueEdge(
         edgeKind,
         fromKind,
         fromId,
@@ -179,7 +141,7 @@ async function checkCardinalityConstraint(ctx, edgeKind, cardinality, fromKind,
         fromId,
         activeOnly: true
       });
-      const error = chunkJ7LXTUTP_cjs.checkCardinality(
+      const error = chunkE4WNQBEF_cjs.checkCardinality(
         edgeKind,
         fromKind,
         fromId,
@@ -193,31 +155,98 @@ async function checkCardinalityConstraint(ctx, edgeKind, cardinality, fromKind,
   }
 }
 
+// src/store/operations/already-exists.ts
+var ENTITY_LABELS = {
+  node: { title: "Node", article: "A node" },
+  edge: { title: "Edge", article: "An edge" }
+};
+function alreadyExistsError(entity, kind, id, detail, cause) {
+  const label = ENTITY_LABELS[entity];
+  return new chunkNI72YOJB_cjs.ValidationError(
+    `${label.title} already exists: ${detail}`,
+    {
+      entityType: entity,
+      kind,
+      operation: "create",
+      ...id === void 0 ? {} : { id },
+      issues: [
+        {
+          path: "id",
+          code: chunkNI72YOJB_cjs.ENTITY_ALREADY_EXISTS_CODE,
+          message: `${label.article} with this ID already exists`
+        }
+      ]
+    },
+    {
+      suggestion: `Use a different ID or update the existing ${entity}.`,
+      ...cause === void 0 ? {} : { cause }
+    }
+  );
+}
+function createAlreadyExistsError(entity, kind, id) {
+  return alreadyExistsError(entity, kind, id, `${kind}/${id}`, void 0);
+}
+function isDuplicateKeyInsertError(error, entity) {
+  return error instanceof chunkNI72YOJB_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;
+  const attempted = error.details.attempted ?? [];
+  const first = attempted[0];
+  if (first === void 0) throw error;
+  if (attempted.length === 1) {
+    throw alreadyExistsError(
+      entity,
+      first.kind,
+      first.id,
+      `${first.kind}/${first.id}`,
+      error
+    );
+  }
+  throw alreadyExistsError(
+    entity,
+    first.kind,
+    void 0,
+    `one of the ${attempted.length} ${first.kind} ids in the refused insert`,
+    error
+  );
+}
+async function withAlreadyExistsTranslation(entity, run) {
+  try {
+    return await run();
+  } catch (error) {
+    rethrowAsAlreadyExists(error, entity);
+  }
+}
+
 // src/store/operations/node-operations.ts
 function getNodeRegistration(graph, kind) {
+  if (!chunkN66HCGCY_cjs.hasOwnKey(graph.nodes, kind)) throw new chunkNI72YOJB_cjs.KindNotFoundError(kind, "node");
   const registration = graph.nodes[kind];
-  if (registration === void 0) throw new chunkC4F7VJ5D_cjs.KindNotFoundError(kind, "node");
+  if (registration === void 0) throw new chunkNI72YOJB_cjs.KindNotFoundError(kind, "node");
   return registration;
 }
-var CACHE_KEY_SEPARATOR = "\0";
+function nodeFencesConstraintProbe(ctx, kind, operation) {
+  if (!chunkN66HCGCY_cjs.hasOwnKey(ctx.graph.nodes, kind)) return void 0;
+  return nodeWriteNeedsConstraintFence(
+    ctx.registry,
+    kind,
+    getNodeRegistration(ctx.graph, kind).unique ?? [],
+    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 buildNodeCacheKey(graphId, kind, id) {
-  return `${graphId}${CACHE_KEY_SEPARATOR}${kind}${CACHE_KEY_SEPARATOR}${id}`;
+  return chunkXNLIZYRZ_cjs.encodeTupleKey([graphId, kind, id]);
 }
 function buildUniqueCacheKey(graphId, nodeKind, constraintName, key) {
-  return `${graphId}${CACHE_KEY_SEPARATOR}${nodeKind}${CACHE_KEY_SEPARATOR}${constraintName}${CACHE_KEY_SEPARATOR}${key}`;
-}
-function createNodeAlreadyExistsError(kind, id) {
-  return new chunkC4F7VJ5D_cjs.ValidationError(
-    `Node already exists: ${kind}/${id}`,
-    {
-      entityType: "node",
-      kind,
-      operation: "create",
-      id,
-      issues: [{ path: "id", message: "A node with this ID already exists" }]
-    },
-    { suggestion: `Use a different ID or update the existing node.` }
-  );
+  return chunkXNLIZYRZ_cjs.encodeTupleKey([graphId, nodeKind, constraintName, key]);
 }
 function buildInsertNodeParams(graphId, kind, id, props, validFrom, validTo) {
   const insertParams = {
@@ -248,7 +277,7 @@ function resolveConstraint(graph, kind, constraintName) {
     (candidate) => candidate.name === constraintName
   );
   if (constraint === void 0) {
-    throw new chunkC4F7VJ5D_cjs.NodeConstraintNotFoundError(constraintName, kind);
+    throw new chunkNI72YOJB_cjs.NodeConstraintNotFoundError(constraintName, kind);
   }
   return constraint;
 }
@@ -309,8 +338,8 @@ function createNodeBatchValidationBackend(graphId, registry, backend) {
   }
   function registerPendingUniqueEntries(kind, id, props, constraints) {
     for (const constraint of constraints) {
-      if (!chunkJ7LXTUTP_cjs.checkWherePredicate(constraint, props)) continue;
-      const key = chunkJ7LXTUTP_cjs.computeUniqueKey(
+      if (!chunkE4WNQBEF_cjs.checkWherePredicate(constraint, props)) continue;
+      const key = chunkE4WNQBEF_cjs.computeUniqueKey(
         props,
         constraint.fields,
         constraint.collation
@@ -323,7 +352,7 @@ function createNodeBatchValidationBackend(graphId, registry, backend) {
       );
       pendingUniqueOwners.set(concreteEntryKey, id);
       if (constraint.scope !== "kind") {
-        const kindsToCheck = chunkJ7LXTUTP_cjs.getKindsForUniquenessCheck(
+        const kindsToCheck = chunkE4WNQBEF_cjs.getKindsForUniquenessCheck(
           kind,
           constraint.scope,
           registry
@@ -342,12 +371,12 @@ function createNodeBatchValidationBackend(graphId, registry, backend) {
   }
   function registerAppliedNodeUpdate(kind, id, oldProps, newProps, constraints) {
     for (const constraint of constraints) {
-      const oldApplies = chunkJ7LXTUTP_cjs.checkWherePredicate(constraint, oldProps);
-      const newApplies = chunkJ7LXTUTP_cjs.checkWherePredicate(constraint, newProps);
-      const oldKey = oldApplies ? chunkJ7LXTUTP_cjs.computeUniqueKey(oldProps, constraint.fields, constraint.collation) : void 0;
-      const newKey = newApplies ? chunkJ7LXTUTP_cjs.computeUniqueKey(newProps, constraint.fields, constraint.collation) : void 0;
+      const oldApplies = chunkE4WNQBEF_cjs.checkWherePredicate(constraint, oldProps);
+      const newApplies = chunkE4WNQBEF_cjs.checkWherePredicate(constraint, newProps);
+      const oldKey = oldApplies ? chunkE4WNQBEF_cjs.computeUniqueKey(oldProps, constraint.fields, constraint.collation) : void 0;
+      const newKey = newApplies ? chunkE4WNQBEF_cjs.computeUniqueKey(newProps, constraint.fields, constraint.collation) : void 0;
       if (oldKey === newKey) continue;
-      const kindsToCheck = chunkJ7LXTUTP_cjs.getKindsForUniquenessCheck(
+      const kindsToCheck = chunkE4WNQBEF_cjs.getKindsForUniquenessCheck(
         kind,
         constraint.scope,
         registry
@@ -387,7 +416,7 @@ function createNodeBatchValidationBackend(graphId, registry, backend) {
     if (uniqueCache.has(cacheKey)) return;
     uniqueCache.set(cacheKey, row);
   }
-  const validationBackend = chunkEKFUG4G7_cjs.createBackendOverlay(backend, {
+  const validationBackend = chunkXBYVV3MP_cjs.createBackendOverlay(backend, {
     getNode: getNodeCached,
     checkUnique: checkUniqueCached
   });
@@ -404,25 +433,32 @@ 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 : chunkKKYELPZ2_cjs.validateNodeProps(nodeKind.schema, input.props, {
+  const validatedProps = options?.propsPreValidated === true ? input.props : chunkXNLIZYRZ_cjs.validateNodeProps(nodeKind.schema, input.props, {
     kind,
     operation: "create"
   });
+  const validFrom = chunkQ7Q4WSLJ_cjs.validateOptionalCanonicalIsoDate(
+    input.validFrom,
+    "validFrom"
+  );
+  const validTo = chunkQ7Q4WSLJ_cjs.validateOptionalCanonicalIsoDate(input.validTo, "validTo");
+  chunkQ7Q4WSLJ_cjs.assertOrderedValidityWindow(`${kind} "${id}"`, validFrom, validTo);
   return {
     kind,
     id,
+    idProvided: input.id !== void 0,
     nodeKind,
     uniqueConstraints: registration.unique ?? [],
     validatedProps,
-    validFrom: chunkZTAJL4DT_cjs.validateOptionalCanonicalIsoDate(input.validFrom, "validFrom"),
-    validTo: chunkZTAJL4DT_cjs.validateOptionalCanonicalIsoDate(input.validTo, "validTo")
+    validFrom,
+    validTo
   };
 }
 async function finishNodeCreatePreparation(ctx, draft, backend) {
   const { kind, id, validatedProps, uniqueConstraints } = draft;
   const existingNode = await backend.getNode(ctx.graphId, kind, id);
   if (existingNode && !existingNode.deleted_at) {
-    throw createNodeAlreadyExistsError(kind, id);
+    throw createAlreadyExistsError("node", kind, id);
   }
   const constraintContext = {
     graphId: ctx.graphId,
@@ -430,8 +466,8 @@ async function finishNodeCreatePreparation(ctx, draft, backend) {
     backend
   };
   await checkDisjointnessConstraint(constraintContext, kind, id);
-  await chunkJ7LXTUTP_cjs.checkUniquenessConstraints(
-    chunkJ7LXTUTP_cjs.createUniquenessContext(ctx.graphId, ctx.registry, backend),
+  await chunkTTAITEPJ_cjs.checkUniquenessConstraints(
+    chunkTTAITEPJ_cjs.createUniquenessContext(ctx.graphId, ctx.registry, backend),
     kind,
     id,
     validatedProps,
@@ -440,6 +476,8 @@ async function finishNodeCreatePreparation(ctx, draft, backend) {
   return {
     kind,
     id,
+    idProvided: draft.idProvided,
+    tombstone: existingNode,
     nodeKind: draft.nodeKind,
     validatedProps,
     uniqueConstraints,
@@ -461,8 +499,8 @@ async function validateAndPrepareNodeCreate(ctx, input, id, backend, options) {
   );
 }
 async function finalizeNodeCreateBatch(ctx, preparedCreates, backend, lock) {
-  await chunkJ7LXTUTP_cjs.applyNodeInsertSideEffectsBatch(
-    chunkJ7LXTUTP_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
+  await chunkTTAITEPJ_cjs.applyNodeInsertSideEffectsBatch(
+    chunkTTAITEPJ_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
     preparedCreates.map((prepared) => ({
       kind: prepared.kind,
       id: prepared.id,
@@ -473,9 +511,12 @@ async function finalizeNodeCreateBatch(ctx, preparedCreates, backend, lock) {
     backend
   );
 }
+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 chunkJ7LXTUTP_cjs.applyNodeInsertSideEffects(
-    chunkJ7LXTUTP_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
+  await chunkTTAITEPJ_cjs.applyNodeInsertSideEffects(
+    chunkTTAITEPJ_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
     {
       kind: prepared.kind,
       id: prepared.id,
@@ -488,7 +529,7 @@ async function finalizeNodeCreate(ctx, prepared, backend, lock) {
 }
 function computeNodeUpdate(ctx, kind, id, existingProps, inputProps) {
   const registration = getNodeRegistration(ctx.graph, kind);
-  const validatedProps = chunkKKYELPZ2_cjs.validateNodeProps(
+  const validatedProps = chunkXNLIZYRZ_cjs.validateNodeProps(
     registration.type.schema,
     { ...existingProps, ...inputProps },
     { kind, operation: "update", id }
@@ -496,7 +537,7 @@ function computeNodeUpdate(ctx, kind, id, existingProps, inputProps) {
   return { registration, validatedProps };
 }
 function resolveNodeUpdateProps(ctx, existing, inputProps) {
-  const existingProps = chunkEKFUG4G7_cjs.rowPropsToObject(existing.props);
+  const existingProps = chunkXBYVV3MP_cjs.rowPropsToObject(existing.props);
   const { registration, validatedProps } = computeNodeUpdate(
     ctx,
     existing.kind,
@@ -516,43 +557,111 @@ function nodeUpsertDirtyCheck(ctx, kind, id, existingProps, inputProps) {
   );
   return {
     validatedProps,
-    unchanged: chunkACSVZPK7_cjs.canonicalEqual(validatedProps, existingProps)
+    unchanged: chunkPWLJ77UV_cjs.canonicalEqual(validatedProps, existingProps)
   };
 }
 async function performNodeUpdate(ctx, input, backend, lock, options) {
   const { kind, id } = input;
   const existing = await backend.getNode(ctx.graphId, kind, id);
-  if (!existing) throw new chunkC4F7VJ5D_cjs.NodeNotFoundError(kind, id);
+  if (!existing) throw new chunkNI72YOJB_cjs.NodeNotFoundError(kind, id);
   const { registration, validatedProps } = resolveNodeUpdateProps(
     ctx,
     existing,
     input.props
   );
   const nodeKind = registration.type;
-  const validTo = chunkZTAJL4DT_cjs.validateOptionalCanonicalIsoDate(input.validTo, "validTo");
-  const writeContext = chunkJ7LXTUTP_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock);
+  const validFrom = chunkQ7Q4WSLJ_cjs.validateOptionalCanonicalIsoDate(
+    input.validFrom,
+    "validFrom"
+  );
+  const validTo = chunkQ7Q4WSLJ_cjs.validateOptionalCanonicalIsoDate(input.validTo, "validTo");
+  const resurrectionInstant = options?.clearDeleted === true && existing.deleted_at !== void 0 ? chunkQ7Q4WSLJ_cjs.nowIso() : void 0;
+  const windowVerdict = chunkQ7Q4WSLJ_cjs.assertWritableValidityWindow(
+    `${kind} "${id}"`,
+    validFrom,
+    resurrectionInstant === void 0 ? {
+      effectiveValidFrom: existing.valid_from,
+      appliesStatedValidFrom: false,
+      effectiveBoundIsStored: true
+    } : {
+      effectiveValidFrom: resurrectionInstant,
+      appliesStatedValidFrom: true,
+      // The instant this write is about to stamp, not a bound the row holds.
+      effectiveBoundIsStored: false
+    },
+    validTo
+  );
+  const writeContext = chunkTTAITEPJ_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock);
+  const effectiveValidFrom = validFrom ?? resurrectionInstant;
   const shared = {
     schema: nodeKind.schema,
     validatedProps,
     uniqueConstraints: registration.unique ?? [],
-    ...validTo !== void 0 && { validTo }
+    ...effectiveValidFrom !== void 0 && { validFrom: effectiveValidFrom },
+    ...validTo !== void 0 && { validTo },
+    // 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
   };
   if (options?.clearDeleted) {
-    const row2 = await chunkJ7LXTUTP_cjs.applyNodeUpdate(
+    const row2 = await chunkTTAITEPJ_cjs.applyNodeUpdate(
       writeContext,
       { ...shared, existing, clearDeleted: true },
       backend
     );
     return rowToNode(row2);
   }
-  if (!chunkEKFUG4G7_cjs.isLiveNodeRow(existing)) throw new chunkC4F7VJ5D_cjs.NodeNotFoundError(kind, id);
-  const row = await chunkJ7LXTUTP_cjs.applyNodeUpdate(
+  if (!chunkXBYVV3MP_cjs.isLiveNodeRow(existing)) throw new chunkNI72YOJB_cjs.NodeNotFoundError(kind, id);
+  const row = await chunkTTAITEPJ_cjs.applyNodeUpdate(
     writeContext,
     { ...shared, existing },
     backend
   );
   return rowToNode(row);
 }
+var NODE_UPDATE_ATTEMPTS = 2;
+async function performNodeUpdateWithResurrectionRecovery(ctx, input, target, lock, options) {
+  for (let attempt = 1; attempt <= NODE_UPDATE_ATTEMPTS; attempt += 1) {
+    try {
+      return await performNodeUpdate(
+        ctx,
+        input,
+        target,
+        lock,
+        attempt === 1 ? options : void 0
+      );
+    } catch (error) {
+      if (!isNodeUpdateNoRowError(error) || attempt === NODE_UPDATE_ATTEMPTS) {
+        throw nodeUpdateRaceError(input, error);
+      }
+      const current = await target.getNode(ctx.graphId, input.kind, input.id);
+      if (current === void 0 || current.deleted_at !== void 0) {
+        throw new chunkNI72YOJB_cjs.NodeNotFoundError(input.kind, input.id);
+      }
+    }
+  }
+  throw new chunkNI72YOJB_cjs.NodeNotFoundError(input.kind, input.id);
+}
+function nodeUpdateRaceError(input, error) {
+  if (!isNodeUpdateNoRowError(error)) return error;
+  return new chunkNI72YOJB_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",
+      entity: "node",
+      attempted: [{ kind: input.kind, id: input.id }]
+    },
+    { cause: error }
+  );
+}
 async function primeBatchValidationCaches(ctx, drafts, backend, seams) {
   if (backend.getNodes !== void 0) {
     const idsByKind = /* @__PURE__ */ new Map();
@@ -574,19 +683,19 @@ async function primeBatchValidationCaches(ctx, drafts, backend, seams) {
     const groups = /* @__PURE__ */ new Map();
     for (const draft of drafts) {
       for (const constraint of draft.uniqueConstraints) {
-        if (!chunkJ7LXTUTP_cjs.checkWherePredicate(constraint, draft.validatedProps)) continue;
-        const key = chunkJ7LXTUTP_cjs.computeUniqueKey(
+        if (!chunkE4WNQBEF_cjs.checkWherePredicate(constraint, draft.validatedProps)) continue;
+        const key = chunkE4WNQBEF_cjs.computeUniqueKey(
           draft.validatedProps,
           constraint.fields,
           constraint.collation
         );
-        const kindsToCheck = chunkJ7LXTUTP_cjs.getKindsForUniquenessCheck(
+        const kindsToCheck = chunkE4WNQBEF_cjs.getKindsForUniquenessCheck(
           draft.kind,
           constraint.scope,
           ctx.registry
         );
         for (const kindToCheck of kindsToCheck) {
-          const groupKey = kindToCheck + CACHE_KEY_SEPARATOR + constraint.name;
+          const groupKey = chunkXNLIZYRZ_cjs.encodeTupleKey([kindToCheck, constraint.name]);
           const group = groups.get(groupKey) ?? {
             nodeKind: kindToCheck,
             constraintName: constraint.name,
@@ -626,7 +735,7 @@ async function prepareBatchCreates(ctx, inputs, backend, options) {
     seedUniqueRow
   } = createNodeBatchValidationBackend(ctx.graphId, ctx.registry, backend);
   const drafts = inputs.map(
-    (input) => draftNodeCreate(ctx, input, input.id ?? chunkJ7LXTUTP_cjs.generateId(), options)
+    (input) => draftNodeCreate(ctx, input, input.id ?? chunkXMQSEJCF_cjs.generateId(), options)
   );
   await primeBatchValidationCaches(ctx, drafts, backend, {
     seedNodeRow,
@@ -648,10 +757,60 @@ async function prepareBatchCreates(ctx, inputs, backend, options) {
       prepared.uniqueConstraints
     );
   }
-  const batchInsertParams = preparedCreates.map(
-    (prepared) => prepared.insertParams
-  );
-  return { preparedCreates, batchInsertParams };
+  return preparedCreates;
+}
+function partitionCreates(preparedCreates) {
+  const inserts = [];
+  const resurrections = [];
+  for (const prepared of preparedCreates) {
+    if (prepared.tombstone === void 0) {
+      inserts.push(prepared);
+    } else {
+      resurrections.push(prepared);
+    }
+  }
+  return { inserts, resurrections };
+}
+function isNodeUpdateNoRowError(error) {
+  return error instanceof chunkNI72YOJB_cjs.DatabaseOperationError && error.details.operation === "update" && error.details.entity === "node" && error.details.reason === "no_row_returned";
+}
+async function resurrectPreparedNode(ctx, target, lock, prepared) {
+  const current = await target.getNode(ctx.graphId, prepared.kind, prepared.id);
+  if (current === void 0) {
+    throw new chunkNI72YOJB_cjs.DatabaseOperationError(
+      `Node tombstone disappeared before resurrection: ${prepared.kind} ${prepared.id}`,
+      { operation: "update", entity: "node" }
+    );
+  }
+  if (current.deleted_at === void 0) {
+    throw createAlreadyExistsError("node", prepared.kind, prepared.id);
+  }
+  try {
+    return await chunkTTAITEPJ_cjs.applyNodeUpdate(
+      chunkTTAITEPJ_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
+      {
+        existing: current,
+        clearDeleted: true,
+        schema: prepared.nodeKind.schema,
+        validatedProps: prepared.validatedProps,
+        uniqueConstraints: prepared.uniqueConstraints,
+        ...prepared.insertParams.validFrom === void 0 ? {} : { validFrom: prepared.insertParams.validFrom },
+        ...prepared.insertParams.validTo === void 0 ? {} : { validTo: prepared.insertParams.validTo }
+      },
+      target
+    );
+  } catch (error) {
+    if (!isNodeUpdateNoRowError(error)) throw error;
+    const afterFailure = await target.getNode(
+      ctx.graphId,
+      prepared.kind,
+      prepared.id
+    );
+    if (afterFailure !== void 0 && afterFailure.deleted_at === void 0) {
+      throw createAlreadyExistsError("node", prepared.kind, prepared.id);
+    }
+    throw error;
+  }
 }
 async function findUniqueRowAcrossKinds(backend, graphId, constraintName, key, kindsToCheck, includeDeleted) {
   for (const kindToCheck of kindsToCheck) {
@@ -702,14 +861,16 @@ async function batchCheckUniqueAcrossKinds(backend, graphId, constraintName, uni
 }
 async function executeNodeCreateInternal(ctx, input, backend, options) {
   const kind = input.kind;
-  const id = input.id ?? chunkJ7LXTUTP_cjs.generateId();
+  const id = input.id ?? chunkXMQSEJCF_cjs.generateId();
   const opContext = ctx.createOperationContext("create", "node", kind, id);
   const shouldReturnRow = options?.returnRow ?? true;
-  return runHookedWriteOperation(
+  return chunkXNLIZYRZ_cjs.runHookedWriteOperation(
     ctx,
     opContext,
     backend,
     async (target, lock) => {
+      const identity = ctx.identity;
+      if (identity !== void 0) await identity.lock(target);
       const prepared = await validateAndPrepareNodeCreate(
         ctx,
         input,
@@ -717,18 +878,36 @@ async function executeNodeCreateInternal(ctx, input, backend, options) {
         target,
         options
       );
-      let row;
-      if (shouldReturnRow) {
-        row = await target.insertNode(prepared.insertParams);
-      } else {
-        await chunkJ7LXTUTP_cjs.runInsertNoReturn(
-          chunkJ7LXTUTP_cjs.nodeInsertDispatch(target),
-          prepared.insertParams
+      const existing = prepared.tombstone;
+      if (existing !== void 0) {
+        const resurrected = await resurrectPreparedNode(
+          ctx,
+          target,
+          lock,
+          prepared
         );
+        if (identity !== void 0) {
+          await identity.foldCreated(target, foldReferences([prepared]));
+        }
+        return shouldReturnRow ? rowToNode(resurrected) : void 0;
       }
+      const row = await withAlreadyExistsTranslation("node", async () => {
+        if (shouldReturnRow) return target.insertNode(prepared.insertParams);
+        await chunkXMQSEJCF_cjs.runInsertNoReturn(
+          chunkXMQSEJCF_cjs.nodeInsertDispatch(target),
+          prepared.insertParams
+        );
+        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")
     }
   );
 }
@@ -738,7 +917,7 @@ async function executeNodeCreate(ctx, input, backend, options) {
     ...options
   });
   if (!result) {
-    throw new chunkC4F7VJ5D_cjs.DatabaseOperationError(
+    throw new chunkNI72YOJB_cjs.DatabaseOperationError(
       "Node create failed: expected created node row",
       { operation: "insert", entity: "node" }
     );
@@ -747,32 +926,92 @@ async function executeNodeCreate(ctx, input, backend, options) {
 }
 async function executeNodeCreateNoReturnBatch(ctx, inputs, backend) {
   if (inputs.length === 0) return;
-  await runInWriteTransaction(ctx, backend, async (target, lock) => {
-    const { preparedCreates, batchInsertParams } = await prepareBatchCreates(
-      ctx,
-      inputs,
-      target
-    );
-    await chunkJ7LXTUTP_cjs.runInsertBatch(chunkJ7LXTUTP_cjs.nodeInsertDispatch(target), batchInsertParams);
-    await finalizeNodeCreateBatch(ctx, preparedCreates, target, lock);
-  });
+  await chunkXNLIZYRZ_cjs.runInWriteTransaction(
+    ctx,
+    backend,
+    async (target, lock) => {
+      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",
+        () => chunkXMQSEJCF_cjs.runInsertBatch(
+          chunkXMQSEJCF_cjs.nodeInsertDispatch(target),
+          partition.inserts.map((prepared) => prepared.insertParams)
+        )
+      );
+      for (const prepared of partition.resurrections) {
+        await resurrectPreparedNode(ctx, target, lock, 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, backend, async (target, lock) => {
-    const { preparedCreates, batchInsertParams } = await prepareBatchCreates(
-      ctx,
-      inputs,
-      target,
-      options
-    );
-    const rows = await chunkJ7LXTUTP_cjs.runInsertBatchReturning(
-      chunkJ7LXTUTP_cjs.nodeInsertDispatch(target),
-      batchInsertParams
-    );
-    await finalizeNodeCreateBatch(ctx, preparedCreates, target, lock);
-    return rows.map((row) => rowToNode(row));
-  });
+  return chunkXNLIZYRZ_cjs.runInWriteTransaction(
+    ctx,
+    backend,
+    async (target, lock) => {
+      const identity = ctx.identity;
+      if (identity !== void 0) await identity.lock(target);
+      const preparedCreates = await prepareBatchCreates(
+        ctx,
+        inputs,
+        target,
+        options
+      );
+      const partition = partitionCreates(preparedCreates);
+      const inserted = await withAlreadyExistsTranslation(
+        "node",
+        () => chunkXMQSEJCF_cjs.runInsertBatchReturning(
+          chunkXMQSEJCF_cjs.nodeInsertDispatch(target),
+          partition.inserts.map((prepared) => prepared.insertParams)
+        )
+      );
+      const resurrected = [];
+      for (const prepared of partition.resurrections) {
+        resurrected.push(
+          await resurrectPreparedNode(ctx, target, lock, prepared)
+        );
+      }
+      await finalizeNodeCreateBatch(ctx, partition.inserts, target, lock);
+      const byReference = new Map(
+        [...inserted, ...resurrected].map((row) => [
+          chunkXNLIZYRZ_cjs.refKey({ kind: row.kind, id: row.id }),
+          row
+        ])
+      );
+      const rows = preparedCreates.map(
+        (prepared) => chunkN66HCGCY_cjs.requireDefined(
+          byReference.get(chunkXNLIZYRZ_cjs.refKey({ kind: prepared.kind, id: prepared.id })),
+          `Missing written row for ${prepared.kind} ${prepared.id}`
+        )
+      );
+      if (identity !== void 0) {
+        await identity.foldCreated(target, foldReferences(preparedCreates));
+      }
+      return rows.map((row) => rowToNode(row));
+    },
+    {
+      fencesConstraintProbe: nodeBatchFencesConstraintProbe(
+        ctx,
+        inputs,
+        "create"
+      )
+    }
+  );
 }
 async function executeNodeUpdate(ctx, input, backend, options) {
   const opContext = ctx.createOperationContext(
@@ -781,11 +1020,36 @@ async function executeNodeUpdate(ctx, input, backend, options) {
     input.kind,
     input.id
   );
-  return runHookedWriteOperation(
+  return chunkXNLIZYRZ_cjs.runHookedWriteOperation(
     ctx,
     opContext,
     backend,
-    (target, lock) => performNodeUpdate(ctx, input, target, lock, options)
+    async (target, lock) => {
+      const identity = ctx.identity;
+      if (options?.clearDeleted && identity !== void 0) {
+        await identity.lock(target);
+      }
+      const node = await performNodeUpdateWithResurrectionRecovery(
+        ctx,
+        input,
+        target,
+        lock,
+        options
+      );
+      if (options?.clearDeleted && identity !== void 0) {
+        await identity.foldCreated(target, [
+          { kind: input.kind, id: input.id }
+        ]);
+      }
+      return node;
+    },
+    {
+      fencesConstraintProbe: nodeFencesConstraintProbe(
+        ctx,
+        input.kind,
+        "update"
+      )
+    }
   );
 }
 async function executeNodeUpdateWhere(ctx, kind, inputPatch, candidateIds, candidateIdColumn, backend) {
@@ -793,19 +1057,19 @@ async function executeNodeUpdateWhere(ctx, kind, inputPatch, candidateIds, candi
   const schema = registration.type.schema;
   const uniqueConstraints = registration.unique ?? [];
   if (!backend.capabilities.transactions) {
-    throw new chunkC4F7VJ5D_cjs.ConfigurationError(
+    throw new chunkNI72YOJB_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 chunkC4F7VJ5D_cjs.ConfigurationError(
+    throw new chunkNI72YOJB_cjs.ConfigurationError(
       "This backend does not support set-based node updates",
       { code: "SET_UPDATE_UNSUPPORTED", kind }
     );
   }
   if (Object.keys(inputPatch).length === 0) {
-    throw new chunkC4F7VJ5D_cjs.ValidationError("updateWhere() patch must not be empty", {
+    throw new chunkNI72YOJB_cjs.ValidationError("updateWhere() patch must not be empty", {
       entityType: "node",
       kind,
       operation: "update",
@@ -816,7 +1080,7 @@ async function executeNodeUpdateWhere(ctx, kind, inputPatch, candidateIds, candi
     (property) => !Object.hasOwn(schema.shape, property)
   );
   if (unknownProperty !== void 0) {
-    throw new chunkC4F7VJ5D_cjs.ValidationError(
+    throw new chunkNI72YOJB_cjs.ValidationError(
       `Unknown ${kind} property in updateWhere() patch: ${unknownProperty}`,
       {
         entityType: "node",
@@ -831,22 +1095,22 @@ async function executeNodeUpdateWhere(ctx, kind, inputPatch, candidateIds, candi
       }
     );
   }
-  const parsedPatch = chunkKKYELPZ2_cjs.validateNodeProps(schema.partial(), inputPatch, {
+  const parsedPatch = chunkXNLIZYRZ_cjs.validateNodeProps(schema.partial(), inputPatch, {
     kind,
     operation: "update"
   });
-  const patch = {};
+  const patch = chunkN66HCGCY_cjs.createDataKeyedBag();
   const unsetProperties = [];
   for (const [property, value] of Object.entries(parsedPatch)) {
     if (value === void 0) {
       unsetProperties.push(property);
       continue;
     }
-    chunkD54WH24V_cjs.assertJsonValue(value, property, `Node "${kind}" updateWhere patch`);
+    chunkLBJKZXDE_cjs.assertJsonValue(value, property, `Node "${kind}" updateWhere patch`);
     patch[property] = value;
   }
   if (Object.keys(patch).length === 0 && unsetProperties.length === 0) {
-    throw new chunkC4F7VJ5D_cjs.ValidationError(
+    throw new chunkNI72YOJB_cjs.ValidationError(
       "updateWhere() patch has no recognized properties",
       {
         entityType: "node",
@@ -859,19 +1123,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 chunkC4F7VJ5D_cjs.ConfigurationError(
+    throw new chunkNI72YOJB_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 chunkC4F7VJ5D_cjs.ConfigurationError(
+    throw new chunkNI72YOJB_cjs.ConfigurationError(
       "updateWhere() requires batched fulltext sidecar operations for searchable nodes",
       { code: "SET_UPDATE_FULLTEXT_UNSUPPORTED", kind }
     );
   }
-  if (chunkJ7LXTUTP_cjs.getEmbeddingFields(schema).length > 0 && (backend.upsertEmbedding === void 0 || backend.deleteEmbedding === void 0 || backend.upsertEmbeddingBatch === void 0 || backend.deleteEmbeddingBatch === void 0)) {
-    throw new chunkC4F7VJ5D_cjs.ConfigurationError(
+  if (chunkTTAITEPJ_cjs.getEmbeddingFields(schema).length > 0 && (backend.upsertEmbedding === void 0 || backend.deleteEmbedding === void 0 || backend.upsertEmbeddingBatch === void 0 || backend.deleteEmbeddingBatch === void 0)) {
+    throw new chunkNI72YOJB_cjs.ConfigurationError(
       "updateWhere() requires batched vector sidecar operations for embedded nodes",
       { code: "SET_UPDATE_VECTOR_UNSUPPORTED", kind }
     );
@@ -879,32 +1143,32 @@ async function executeNodeUpdateWhere(ctx, kind, inputPatch, candidateIds, candi
   const hookContext = ctx.createBulkOperationContext("updateWhere", kind);
   return ctx.withBulkOperationHooks(
     hookContext,
-    () => runInWriteTransaction(
+    () => chunkXNLIZYRZ_cjs.runInWriteTransaction(
       ctx,
       backend,
       async (target, lock) => {
         const updateNodeSet = target.updateNodeSet;
         if (updateNodeSet === void 0) {
-          throw new chunkC4F7VJ5D_cjs.ConfigurationError(
+          throw new chunkNI72YOJB_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 chunkC4F7VJ5D_cjs.ConfigurationError(
+          throw new chunkNI72YOJB_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 chunkC4F7VJ5D_cjs.ConfigurationError(
+          throw new chunkNI72YOJB_cjs.ConfigurationError(
             "The transaction backend lacks batched fulltext operations",
             { code: "SET_UPDATE_FULLTEXT_UNSUPPORTED", kind }
           );
         }
-        if (chunkJ7LXTUTP_cjs.getEmbeddingFields(schema).length > 0 && (target.upsertEmbedding === void 0 || target.deleteEmbedding === void 0 || target.upsertEmbeddingBatch === void 0 || target.deleteEmbeddingBatch === void 0)) {
-          throw new chunkC4F7VJ5D_cjs.ConfigurationError(
+        if (chunkTTAITEPJ_cjs.getEmbeddingFields(schema).length > 0 && (target.upsertEmbedding === void 0 || target.deleteEmbedding === void 0 || target.upsertEmbeddingBatch === void 0 || target.deleteEmbeddingBatch === void 0)) {
+          throw new chunkNI72YOJB_cjs.ConfigurationError(
             "The transaction backend lacks batched vector operations",
             { code: "SET_UPDATE_VECTOR_UNSUPPORTED", kind }
           );
@@ -919,14 +1183,14 @@ async function executeNodeUpdateWhere(ctx, kind, inputPatch, candidateIds, candi
         });
         if (result.affectedCount === 0) return { affectedCount: 0 };
         const sidecarItems = result.rows.map((row) => {
-          const props = chunkEKFUG4G7_cjs.rowPropsToObject(row.props);
-          const validatedProps = chunkKKYELPZ2_cjs.validateNodeProps(schema, props, {
+          const props = chunkXBYVV3MP_cjs.rowPropsToObject(row.props);
+          const validatedProps = chunkXNLIZYRZ_cjs.validateNodeProps(schema, props, {
             kind,
             operation: "update",
             id: row.id
           });
-          if (!chunkACSVZPK7_cjs.canonicalEqual(validatedProps, props)) {
-            throw new chunkC4F7VJ5D_cjs.ValidationError(
+          if (!chunkPWLJ77UV_cjs.canonicalEqual(validatedProps, props)) {
+            throw new chunkNI72YOJB_cjs.ValidationError(
               `Set update would persist a non-canonical ${kind} row`,
               {
                 entityType: "node",
@@ -955,15 +1219,15 @@ async function executeNodeUpdateWhere(ctx, kind, inputPatch, candidateIds, candi
           for (const constraint of uniqueConstraints) {
             const keyToId = /* @__PURE__ */ new Map();
             for (const item of sidecarItems) {
-              if (!chunkJ7LXTUTP_cjs.checkWherePredicate(constraint, item.props)) continue;
-              const key = chunkJ7LXTUTP_cjs.computeUniqueKey(
+              if (!chunkE4WNQBEF_cjs.checkWherePredicate(constraint, item.props)) continue;
+              const key = chunkE4WNQBEF_cjs.computeUniqueKey(
                 item.props,
                 constraint.fields,
                 constraint.collation
               );
               const priorId = keyToId.get(key);
               if (priorId !== void 0 && priorId !== item.id) {
-                throw new chunkC4F7VJ5D_cjs.UniquenessError({
+                throw new chunkNI72YOJB_cjs.UniquenessError({
                   constraintName: constraint.name,
                   kind,
                   existingId: priorId,
@@ -975,12 +1239,12 @@ async function executeNodeUpdateWhere(ctx, kind, inputPatch, candidateIds, candi
             }
             const keys = [...keyToId.keys()];
             if (keys.length === 0) continue;
-            for (const kindToCheck of chunkJ7LXTUTP_cjs.getKindsForUniquenessCheck(
+            for (const kindToCheck of chunkE4WNQBEF_cjs.getKindsForUniquenessCheck(
               kind,
               constraint.scope,
               ctx.registry
             )) {
-              const existingRows = await chunk764JHTLT_cjs.requireDefined(
+              const existingRows = await chunkN66HCGCY_cjs.requireDefined(
                 target.checkUniqueBatch
               )({
                 graphId: ctx.graphId,
@@ -992,54 +1256,87 @@ async function executeNodeUpdateWhere(ctx, kind, inputPatch, candidateIds, candi
                 if (existing.concrete_kind === kind && affectedIds.has(existing.node_id)) {
                   continue;
                 }
-                throw new chunkC4F7VJ5D_cjs.UniquenessError({
+                throw new chunkNI72YOJB_cjs.UniquenessError({
                   constraintName: constraint.name,
                   kind: kindToCheck,
                   existingId: existing.node_id,
-                  newId: chunk764JHTLT_cjs.requireDefined(keyToId.get(existing.key)),
+                  newId: chunkN66HCGCY_cjs.requireDefined(keyToId.get(existing.key)),
                   fields: constraint.fields
                 });
               }
             }
           }
-          await chunk764JHTLT_cjs.requireDefined(hardDeleteUniquesByNodeIds)({
+          await chunkN66HCGCY_cjs.requireDefined(hardDeleteUniquesByNodeIds)({
             graphId: ctx.graphId,
             concreteKind: kind,
             nodeIds: result.rows.map((row) => row.id)
           });
         }
-        await chunkJ7LXTUTP_cjs.applyNodeInsertSideEffectsBatch(
-          chunkJ7LXTUTP_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
+        await chunkTTAITEPJ_cjs.applyNodeInsertSideEffectsBatch(
+          chunkTTAITEPJ_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
           sidecarItems,
           target
         );
         return { affectedCount: result.affectedCount };
       },
-      { didWrite: (result) => result.affectedCount > 0 }
+      {
+        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")
+      }
     )
   );
 }
 async function executeNodeUpsertUpdate(ctx, input, backend, options) {
-  return runInWriteTransaction(
+  return chunkXNLIZYRZ_cjs.runInWriteTransaction(
     ctx,
     backend,
-    (target, lock) => performNodeUpdate(ctx, input, target, lock, options)
+    async (target, lock) => {
+      const identity = ctx.identity;
+      if (options?.clearDeleted && identity !== void 0) {
+        await identity.lock(target);
+      }
+      const node = await performNodeUpdateWithResurrectionRecovery(
+        ctx,
+        input,
+        target,
+        lock,
+        options
+      );
+      if (options?.clearDeleted && identity !== void 0) {
+        await identity.foldCreated(target, [
+          { kind: input.kind, id: input.id }
+        ]);
+      }
+      return node;
+    },
+    {
+      fencesConstraintProbe: nodeFencesConstraintProbe(
+        ctx,
+        input.kind,
+        "update"
+      )
+    }
   );
 }
 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(
+  return chunkXNLIZYRZ_cjs.runHookedWriteOperation(
     ctx,
     opContext,
     backend,
     async (target, lock) => {
+      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 || !chunkEKFUG4G7_cjs.isLiveNodeRow(preflight)) return;
-      await chunkJ7LXTUTP_cjs.applyNodeSoftDelete(
-        chunkJ7LXTUTP_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
+      if (!preflight || !chunkXBYVV3MP_cjs.isLiveNodeRow(preflight)) return;
+      await chunkTTAITEPJ_cjs.applyNodeSoftDelete(
+        chunkTTAITEPJ_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
         {
           existing: preflight,
           schema: registration.type.schema,
@@ -1048,21 +1345,63 @@ async function executeNodeDelete(ctx, kind, id, backend) {
         },
         target
       );
+      if (identity !== void 0) {
+        await identity.detachDeleted(target, { kind, id }, "soft");
+      }
     }
   );
 }
+async function executeNodeDeleteBatch(ctx, kind, ids, backend) {
+  await chunkXNLIZYRZ_cjs.runInWriteTransaction(
+    ctx,
+    backend,
+    async (target, lock) => {
+      const identity = ctx.identity;
+      if (identity !== void 0) await identity.lock(target);
+      const registration = getNodeRegistration(ctx.graph, kind);
+      const writeContext = chunkTTAITEPJ_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 || !chunkXBYVV3MP_cjs.isLiveNodeRow(preflight)) continue;
+        await chunkTTAITEPJ_cjs.applyNodeSoftDelete(
+          writeContext,
+          {
+            existing: preflight,
+            schema: registration.type.schema,
+            uniqueConstraints: registration.unique ?? [],
+            onDelete: registration.onDelete
+          },
+          target
+        );
+        if (identity !== void 0) {
+          await identity.detachDeleted(target, { kind, id }, "soft");
+        }
+        affectedCount += 1;
+      }
+      return affectedCount;
+    },
+    { didWrite: (affectedCount) => affectedCount > 0 }
+  );
+}
 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(
+  return chunkXNLIZYRZ_cjs.runHookedWriteOperation(
     ctx,
     opContext,
     backend,
     async (target, lock) => {
+      const identity = ctx.identity;
+      if (identity !== void 0) await identity.lock(target);
       const registration = getNodeRegistration(ctx.graph, kind);
-      await chunkJ7LXTUTP_cjs.applyNodeHardDelete(
-        chunkJ7LXTUTP_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
+      await chunkTTAITEPJ_cjs.applyNodeHardDelete(
+        chunkTTAITEPJ_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
         {
           kind,
           id,
@@ -1071,6 +1410,9 @@ async function executeNodeHardDelete(ctx, kind, id, backend) {
         },
         target
       );
+      if (identity !== void 0) {
+        await identity.detachDeleted(target, { kind, id }, "hard");
+      }
     }
   );
 }
@@ -1078,12 +1420,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 = chunkKKYELPZ2_cjs.validateNodeProps(nodeKind.schema, props, {
+  const validatedProps = chunkXNLIZYRZ_cjs.validateNodeProps(nodeKind.schema, props, {
     kind,
     operation: "create"
   });
   const constraint = resolveConstraint(ctx.graph, kind, constraintName);
-  if (!chunkJ7LXTUTP_cjs.checkWherePredicate(constraint, validatedProps)) {
+  if (!chunkE4WNQBEF_cjs.checkWherePredicate(constraint, validatedProps)) {
     const node = await executeNodeCreate(
       ctx,
       { kind, props: validatedProps },
@@ -1092,12 +1434,12 @@ async function executeNodeGetOrCreateByConstraint(ctx, kind, constraintName, pro
     );
     return { node, action: "created" };
   }
-  const key = chunkJ7LXTUTP_cjs.computeUniqueKey(
+  const key = chunkE4WNQBEF_cjs.computeUniqueKey(
     validatedProps,
     constraint.fields,
     constraint.collation
   );
-  const kindsToCheck = chunkJ7LXTUTP_cjs.getKindsForUniquenessCheck(
+  const kindsToCheck = chunkE4WNQBEF_cjs.getKindsForUniquenessCheck(
     kind,
     constraint.scope,
     ctx.registry
@@ -1154,25 +1496,25 @@ async function executeNodeGetOrCreateByConstraint(ctx, kind, constraintName, pro
   try {
     return await attempt();
   } catch (error) {
-    if (!(error instanceof chunkC4F7VJ5D_cjs.UniquenessError)) throw error;
+    if (!(error instanceof chunkNI72YOJB_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 = chunkKKYELPZ2_cjs.validateNodeProps(nodeKind.schema, props, {
+  const validatedProps = chunkXNLIZYRZ_cjs.validateNodeProps(nodeKind.schema, props, {
     kind,
     operation: "create"
   });
   const constraint = resolveConstraint(ctx.graph, kind, constraintName);
-  if (!chunkJ7LXTUTP_cjs.checkWherePredicate(constraint, validatedProps)) return void 0;
-  const key = chunkJ7LXTUTP_cjs.computeUniqueKey(
+  if (!chunkE4WNQBEF_cjs.checkWherePredicate(constraint, validatedProps)) return void 0;
+  const key = chunkE4WNQBEF_cjs.computeUniqueKey(
     validatedProps,
     constraint.fields,
     constraint.collation
   );
-  const kindsToCheck = chunkJ7LXTUTP_cjs.getKindsForUniquenessCheck(
+  const kindsToCheck = chunkE4WNQBEF_cjs.getKindsForUniquenessCheck(
     kind,
     constraint.scope,
     ctx.registry
@@ -1198,12 +1540,12 @@ async function executeNodeFindByConstraint(ctx, kind, constraintName, props, bac
 function validateAndComputeKeys(nodeKind, kind, constraint, items) {
   const validated = [];
   for (const item of items) {
-    const validatedProps = chunkKKYELPZ2_cjs.validateNodeProps(nodeKind.schema, item.props, {
+    const validatedProps = chunkXNLIZYRZ_cjs.validateNodeProps(nodeKind.schema, item.props, {
       kind,
       operation: "create"
     });
-    const applies = chunkJ7LXTUTP_cjs.checkWherePredicate(constraint, validatedProps);
-    const key = applies ? chunkJ7LXTUTP_cjs.computeUniqueKey(
+    const applies = chunkE4WNQBEF_cjs.checkWherePredicate(constraint, validatedProps);
+    const key = applies ? chunkE4WNQBEF_cjs.computeUniqueKey(
       validatedProps,
       constraint.fields,
       constraint.collation
@@ -1226,7 +1568,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 = chunkJ7LXTUTP_cjs.getKindsForUniquenessCheck(
+  const kindsToCheck = chunkE4WNQBEF_cjs.getKindsForUniquenessCheck(
     kind,
     constraint.scope,
     ctx.registry
@@ -1276,10 +1618,10 @@ function resolveNodeIndex(graph, kind, indexName) {
     (candidate) => candidate.entity === "node" && candidate.kind === kind && candidate.name === indexName
   );
   if (declaration?.entity !== "node") {
-    throw new chunkC4F7VJ5D_cjs.NodeIndexNotFoundError(indexName, kind);
+    throw new chunkNI72YOJB_cjs.NodeIndexNotFoundError(indexName, kind);
   }
   if (declaration.method !== void 0) {
-    throw new chunkC4F7VJ5D_cjs.ConfigurationError(
+    throw new chunkNI72YOJB_cjs.ConfigurationError(
       `bulkFindByIndex cannot probe index "${indexName}" (method "${declaration.method}"): only btree indexes serve equality probes.`,
       { indexName, kind, method: declaration.method }
     );
@@ -1317,7 +1659,7 @@ function validateIndexProbeValue(value, valueType, pointer, kind) {
   }
 }
 function indexProbeTypeError(pointer, kind, expected, value) {
-  return new chunkC4F7VJ5D_cjs.ValidationError(
+  return new chunkNI72YOJB_cjs.ValidationError(
     `Index probe value for "${pointer}" on node kind "${kind}" has an incompatible type`,
     {
       entityType: "node",
@@ -1351,7 +1693,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 chunkC4F7VJ5D_cjs.ConfigurationError(
+    throw new chunkNI72YOJB_cjs.ConfigurationError(
       `bulkFindByIndex requires an index with at least one prop-based field on index "${indexName}" (node kind "${kind}")`,
       { indexName, kind },
       {
@@ -1360,7 +1702,7 @@ async function executeNodeBulkFindByIndex(ctx, kind, indexName, items, backend,
     );
   }
   if (index.fieldValueTypes.includes("date")) {
-    throw new chunkC4F7VJ5D_cjs.ConfigurationError(
+    throw new chunkNI72YOJB_cjs.ConfigurationError(
       `bulkFindByIndex does not support date-typed key fields on index "${indexName}" (node kind "${kind}")`,
       { indexName, kind },
       {
@@ -1370,7 +1712,7 @@ async function executeNodeBulkFindByIndex(ctx, kind, indexName, items, backend,
   }
   const limitPerInput = options?.limitPerInput;
   if (limitPerInput !== void 0 && (!Number.isInteger(limitPerInput) || limitPerInput <= 0)) {
-    throw new chunkC4F7VJ5D_cjs.ValidationError(
+    throw new chunkNI72YOJB_cjs.ValidationError(
       "bulkFindByIndex limitPerInput must be a positive integer",
       {
         entityType: "node",
@@ -1385,10 +1727,10 @@ async function executeNodeBulkFindByIndex(ctx, kind, indexName, items, backend,
       }
     );
   }
-  const adapter = chunkJXUTCSXX_cjs.getDialect(backend.dialect);
+  const adapter = chunk4UGOKMI5_cjs.getDialect(backend.dialect);
   const probes = items.map(
     (item) => index.fields.map((pointer, position) => {
-      const value = chunkTDXIBCGY_cjs.resolveJsonPointer(item.props, pointer);
+      const value = chunkA7J2YDDI_cjs.resolveJsonPointer(item.props, pointer);
       validateIndexProbeValue(
         value,
         index.fieldValueTypes[position],
@@ -1412,47 +1754,47 @@ async function executeNodeBulkFindByIndex(ctx, kind, indexName, items, backend,
     }
     groupToInputs[existing]?.push(inputIndex);
   }
-  const schema = backend.tableNames ? chunkCPEL3YIR_cjs.createSqlSchema(backend.tableNames) : chunkCPEL3YIR_cjs.DEFAULT_SQL_SCHEMA;
+  const schema = backend.tableNames ? chunkNFCVHQ5P_cjs.createSqlSchema(backend.tableNames) : chunkNFCVHQ5P_cjs.DEFAULT_SQL_SCHEMA;
   const compileContext = {
     dialect: backend.dialect,
-    propsColumn: chunkU5W4LKZV_cjs.sql.raw(`"props"`),
-    systemColumn: (column) => chunkU5W4LKZV_cjs.sql.raw(`"${column}"`)
+    propsColumn: chunkVCRRKBLN_cjs.sql.raw(`"props"`),
+    systemColumn: (column) => chunkVCRRKBLN_cjs.sql.raw(`"${column}"`)
   };
-  const fieldKeys = chunkJXUTCSXX_cjs.compileNodeIndexFieldKeys(index, compileContext);
+  const fieldKeys = chunk4UGOKMI5_cjs.compileNodeIndexFieldKeys(index, compileContext);
   const groupPredicates = groupProbes.map(
-    (probe) => chunkU5W4LKZV_cjs.sql`(${chunkU5W4LKZV_cjs.sql.join(
+    (probe) => chunkVCRRKBLN_cjs.sql`(${chunkVCRRKBLN_cjs.sql.join(
       fieldKeys.map((fieldKey, position) => {
         const value = probe[position];
         if (value === void 0 || value === null) {
-          return chunkU5W4LKZV_cjs.sql`${fieldKey} IS NULL`;
+          return chunkVCRRKBLN_cjs.sql`${fieldKey} IS NULL`;
         }
         return adapter.nullSafeEquals(
           fieldKey,
-          chunkU5W4LKZV_cjs.sql`${coerceIndexProbeBind(value, adapter)}`
+          chunkVCRRKBLN_cjs.sql`${coerceIndexProbeBind(value, adapter)}`
         );
       }),
-      chunkU5W4LKZV_cjs.sql` AND `
+      chunkVCRRKBLN_cjs.sql` AND `
     )})`
   );
   const caseBranches = groupPredicates.map(
-    (predicate, group) => chunkU5W4LKZV_cjs.sql`WHEN ${predicate} THEN ${chunkU5W4LKZV_cjs.sql.raw(String(group))}`
+    (predicate, group) => chunkVCRRKBLN_cjs.sql`WHEN ${predicate} THEN ${chunkVCRRKBLN_cjs.sql.raw(String(group))}`
   );
-  const probeIndexExpr = chunkU5W4LKZV_cjs.sql`CASE ${chunkU5W4LKZV_cjs.sql.join(caseBranches, chunkU5W4LKZV_cjs.sql` `)} ELSE NULL END`;
+  const probeIndexExpr = chunkVCRRKBLN_cjs.sql`CASE ${chunkVCRRKBLN_cjs.sql.join(caseBranches, chunkVCRRKBLN_cjs.sql` `)} ELSE NULL END`;
   const conditions = [
-    chunkU5W4LKZV_cjs.sql`"graph_id" = ${ctx.graphId}`,
-    chunkU5W4LKZV_cjs.sql`"kind" = ${kind}`,
-    chunkU5W4LKZV_cjs.sql`"deleted_at" IS NULL`
+    chunkVCRRKBLN_cjs.sql`"graph_id" = ${ctx.graphId}`,
+    chunkVCRRKBLN_cjs.sql`"kind" = ${kind}`,
+    chunkVCRRKBLN_cjs.sql`"deleted_at" IS NULL`
   ];
   if (index.where !== void 0) {
-    conditions.push(chunkJXUTCSXX_cjs.compileIndexWhere(compileContext, index.where));
+    conditions.push(chunk4UGOKMI5_cjs.compileIndexWhere(compileContext, index.where));
   }
-  conditions.push(chunkU5W4LKZV_cjs.sql`(${chunkU5W4LKZV_cjs.sql.join(groupPredicates, chunkU5W4LKZV_cjs.sql` OR `)})`);
-  const whereClause = chunkU5W4LKZV_cjs.sql.join(conditions, chunkU5W4LKZV_cjs.sql` AND `);
-  const probedSelect = chunkU5W4LKZV_cjs.sql`SELECT "id", ${probeIndexExpr} AS probe_idx FROM ${schema.nodesTable} WHERE ${whereClause}`;
+  conditions.push(chunkVCRRKBLN_cjs.sql`(${chunkVCRRKBLN_cjs.sql.join(groupPredicates, chunkVCRRKBLN_cjs.sql` OR `)})`);
+  const whereClause = chunkVCRRKBLN_cjs.sql.join(conditions, chunkVCRRKBLN_cjs.sql` AND `);
+  const probedSelect = chunkVCRRKBLN_cjs.sql`SELECT "id", ${probeIndexExpr} AS probe_idx FROM ${schema.nodesTable} WHERE ${whereClause}`;
   const capInSql = limitPerInput !== void 0 && backend.capabilities.windowFunctions;
-  const query = capInSql ? chunkU5W4LKZV_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"` : chunkU5W4LKZV_cjs.sql`${probedSelect} ORDER BY probe_idx, "id"`;
+  const query = capInSql ? chunkVCRRKBLN_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"` : chunkVCRRKBLN_cjs.sql`${probedSelect} ORDER BY probe_idx, "id"`;
   const rawMatches = await backend.execute(
-    chunkU5W4LKZV_cjs.asCompiledRowsSql(query)
+    chunkVCRRKBLN_cjs.asCompiledRowsSql(query)
   );
   const matches = limitPerInput !== void 0 && !capInSql ? capMatchesPerGroup(rawMatches, limitPerInput) : rawMatches;
   const nodesById = await hydrateNodesById(
@@ -1485,7 +1827,7 @@ function capMatchesPerGroup(matches, limitPerInput) {
   return capped;
 }
 async function hydrateNodesById(backend, graphId, kind, ids) {
-  const rowsById = await chunkJ7LXTUTP_cjs.getNodeRowsByIds(backend, graphId, kind, ids);
+  const rowsById = await chunkXMQSEJCF_cjs.getNodeRowsByIds(backend, graphId, kind, ids);
   const nodesById = /* @__PURE__ */ new Map();
   for (const [id, row] of rowsById) {
     if (row.deleted_at !== void 0) continue;
@@ -1501,108 +1843,117 @@ 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 = chunkJ7LXTUTP_cjs.getKindsForUniquenessCheck(
+  const kindsToCheck = chunkE4WNQBEF_cjs.getKindsForUniquenessCheck(
     kind,
     constraint.scope,
     ctx.registry
   );
-  const existingByKey = uniqueKeys.length > 0 ? await batchCheckUniqueAcrossKinds(
-    backend,
-    ctx.graphId,
-    constraint.name,
-    uniqueKeys,
-    kindsToCheck,
-    true
-  ) : /* @__PURE__ */ new Map();
-  const toCreate = [];
-  const toFetch = [];
-  const duplicateOf = [];
-  const seenKeys = /* @__PURE__ */ new Map();
-  for (const [index, { validatedProps, key }] of validated.entries()) {
-    if (key === void 0) {
-      toCreate.push({ index, input: { kind, props: validatedProps } });
-      continue;
-    }
-    const previousIndex = seenKeys.get(key);
-    if (previousIndex !== void 0) {
-      duplicateOf.push({ index, sourceIndex: previousIndex });
-      continue;
-    }
-    seenKeys.set(key, index);
-    const existing = existingByKey.get(key);
-    if (existing === void 0) {
-      toCreate.push({ index, input: { kind, props: validatedProps } });
-    } else {
-      toFetch.push({
-        index,
-        nodeId: existing.node_id,
-        concreteKind: existing.concrete_kind,
-        validatedProps,
-        isSoftDeleted: existing.deleted_at !== void 0
-      });
-    }
-  }
-  const results = Array.from({ length: items.length });
-  if (toCreate.length > 0) {
-    const createInputs = toCreate.map((entry) => entry.input);
-    const createdNodes = await executeNodeCreateBatch(
-      ctx,
-      createInputs,
+  async function attempt() {
+    const existingByKey = uniqueKeys.length > 0 ? await batchCheckUniqueAcrossKinds(
       backend,
-      { propsPreValidated: true }
-    );
-    for (const [batchIndex, entry] of toCreate.entries()) {
-      results[entry.index] = {
-        node: chunk764JHTLT_cjs.requireDefined(createdNodes[batchIndex]),
-        action: "created"
-      };
-    }
-  }
-  for (const entry of toFetch) {
-    const { index, concreteKind, validatedProps, isSoftDeleted, nodeId } = entry;
-    const existingRow = await backend.getNode(
       ctx.graphId,
-      concreteKind,
-      nodeId
-    );
-    if (existingRow === void 0) {
-      const node = await executeNodeCreate(
+      constraint.name,
+      uniqueKeys,
+      kindsToCheck,
+      true
+    ) : /* @__PURE__ */ new Map();
+    const toCreate = [];
+    const toFetch = [];
+    const duplicateOf = [];
+    const seenKeys = /* @__PURE__ */ new Map();
+    for (const [index, { validatedProps, key }] of validated.entries()) {
+      if (key === void 0) {
+        toCreate.push({ index, input: { kind, props: validatedProps } });
+        continue;
+      }
+      const previousIndex = seenKeys.get(key);
+      if (previousIndex !== void 0) {
+        duplicateOf.push({ index, sourceIndex: previousIndex });
+        continue;
+      }
+      seenKeys.set(key, index);
+      const existing = existingByKey.get(key);
+      if (existing === void 0) {
+        toCreate.push({ index, input: { kind, props: validatedProps } });
+      } else {
+        toFetch.push({
+          index,
+          nodeId: existing.node_id,
+          concreteKind: existing.concrete_kind,
+          validatedProps
+        });
+      }
+    }
+    const results = Array.from({ length: items.length });
+    if (toCreate.length > 0) {
+      const createInputs = toCreate.map((entry) => entry.input);
+      const createdNodes = await executeNodeCreateBatch(
         ctx,
-        { kind, props: validatedProps },
+        createInputs,
         backend,
         { propsPreValidated: true }
       );
-      results[index] = { node, action: "created" };
-      continue;
+      for (const [batchIndex, entry] of toCreate.entries()) {
+        results[entry.index] = {
+          node: chunkN66HCGCY_cjs.requireDefined(createdNodes[batchIndex]),
+          action: "created"
+        };
+      }
     }
-    if (isSoftDeleted || ifExists === "update") {
-      const node = await executeNodeUpsertUpdate(
-        ctx,
-        {
-          kind: concreteKind,
-          id: existingRow.id,
-          props: validatedProps
-        },
-        backend,
-        { clearDeleted: isSoftDeleted }
+    for (const entry of toFetch) {
+      const { index, concreteKind, validatedProps, nodeId } = entry;
+      const existingRow = await backend.getNode(
+        ctx.graphId,
+        concreteKind,
+        nodeId
       );
-      results[index] = {
-        node,
-        action: isSoftDeleted ? "resurrected" : "updated"
-      };
-    } else {
-      results[index] = { node: rowToNode(existingRow), action: "found" };
+      if (existingRow === void 0) {
+        const node = await executeNodeCreate(
+          ctx,
+          { kind, props: validatedProps },
+          backend,
+          { propsPreValidated: true }
+        );
+        results[index] = { node, action: "created" };
+        continue;
+      }
+      const isSoftDeleted = existingRow.deleted_at !== void 0;
+      if (isSoftDeleted || ifExists === "update") {
+        const node = await executeNodeUpsertUpdate(
+          ctx,
+          {
+            kind: concreteKind,
+            id: existingRow.id,
+            props: validatedProps
+          },
+          backend,
+          { clearDeleted: isSoftDeleted }
+        );
+        results[index] = {
+          node,
+          action: isSoftDeleted ? "resurrected" : "updated"
+        };
+      } else {
+        results[index] = { node: rowToNode(existingRow), action: "found" };
+      }
     }
+    for (const { index, sourceIndex } of duplicateOf) {
+      const sourceResult = chunkN66HCGCY_cjs.requireDefined(results[sourceIndex]);
+      results[index] = { node: sourceResult.node, action: "found" };
+    }
+    return results;
   }
-  for (const { index, sourceIndex } of duplicateOf) {
-    const sourceResult = chunk764JHTLT_cjs.requireDefined(results[sourceIndex]);
-    results[index] = { node: sourceResult.node, action: "found" };
+  try {
+    return await attempt();
+  } catch (error) {
+    if (!(error instanceof chunkNI72YOJB_cjs.UniquenessError)) throw error;
+    return attempt();
   }
-  return results;
 }
 
 exports.checkCardinalityConstraint = checkCardinalityConstraint;
 exports.createNodeBatchValidationBackend = createNodeBatchValidationBackend;
+exports.edgeWriteNeedsConstraintFence = edgeWriteNeedsConstraintFence;
 exports.executeNodeBulkFindByConstraint = executeNodeBulkFindByConstraint;
 exports.executeNodeBulkFindByIndex = executeNodeBulkFindByIndex;
 exports.executeNodeBulkGetOrCreateByConstraint = executeNodeBulkGetOrCreateByConstraint;
@@ -1610,20 +1961,19 @@ exports.executeNodeCreate = executeNodeCreate;
 exports.executeNodeCreateBatch = executeNodeCreateBatch;
 exports.executeNodeCreateNoReturnBatch = executeNodeCreateNoReturnBatch;
 exports.executeNodeDelete = executeNodeDelete;
+exports.executeNodeDeleteBatch = executeNodeDeleteBatch;
 exports.executeNodeFindByConstraint = executeNodeFindByConstraint;
 exports.executeNodeGetOrCreateByConstraint = executeNodeGetOrCreateByConstraint;
 exports.executeNodeHardDelete = executeNodeHardDelete;
 exports.executeNodeUpdate = executeNodeUpdate;
 exports.executeNodeUpdateWhere = executeNodeUpdateWhere;
 exports.executeNodeUpsertUpdate = executeNodeUpsertUpdate;
-exports.lockSchemaVersionForStoreWrite = lockSchemaVersionForStoreWrite;
 exports.nodeUpsertDirtyCheck = nodeUpsertDirtyCheck;
 exports.primeBatchValidationCaches = primeBatchValidationCaches;
 exports.rowToEdge = rowToEdge;
 exports.rowToEdgeMeta = rowToEdgeMeta;
 exports.rowToNode = rowToNode;
 exports.rowToNodeMeta = rowToNodeMeta;
-exports.runHookedWriteOperation = runHookedWriteOperation;
-exports.runInWriteTransaction = runInWriteTransaction;
-//# sourceMappingURL=chunk-UCQ3BFSY.cjs.map
-//# sourceMappingURL=chunk-UCQ3BFSY.cjs.map
+exports.withAlreadyExistsTranslation = withAlreadyExistsTranslation;
+//# sourceMappingURL=chunk-7GT72YHH.cjs.map
+//# sourceMappingURL=chunk-7GT72YHH.cjs.map