@nicia-ai/typegraph 0.45.0 → 0.46.0

package/dist/{chunk-Q6EDCUXV.js → chunk-QWX5YA3K.js}

@@ -1,16 +1,18 @@
-import { lockRecordedGraphWrite, uncapturedGraphWriteLock, advanceRevisionClock, checkCardinality, checkUniqueEdge, checkWherePredicate, computeUniqueKey, getKindsForUniquenessCheck, runInsertBatch, nodeInsertDispatch, runInsertBatchReturning, getEmbeddingFields, applyNodeInsertSideEffectsBatch, createNodeWriteContext, applyNodeSoftDelete, applyNodeHardDelete, getNodeRowsByIds, generateId, runInsertNoReturn, applyNodeUpdate, applyNodeInsertSideEffects, checkUniquenessConstraints, createUniquenessContext, checkDisjointness } from './chunk-TKORQCG4.js';
-import { createSqlSchema, DEFAULT_SQL_SCHEMA } from './chunk-MIJKEVV7.js';
-import { rowPropsToObject, runOptionallyInTransaction, createBackendOverlay, isLiveNodeRow } from './chunk-55ITBQJI.js';
-import { validateNodeProps } from './chunk-DK2S42XB.js';
-import { canonicalEqual } from './chunk-UR7W5YQK.js';
-import { validateOptionalCanonicalIsoDate } from './chunk-KCO5EFJU.js';
-import { getDialect, compileNodeIndexFieldKeys, compileIndexWhere } from './chunk-PVUI6KGR.js';
-import { sql, asCompiledRowsSql } from './chunk-6DCB664D.js';
-import { requireDefined } from './chunk-QMQLUA66.js';
+import { getEmbeddingFields, applyNodeInsertSideEffectsBatch, createNodeWriteContext, applyNodeSoftDelete, applyNodeHardDelete, applyNodeUpdate, applyNodeInsertSideEffects, checkUniquenessConstraints, createUniquenessContext } from './chunk-WEVQJ5LH.js';
+import { encodeTupleKey, runInWriteTransaction, refKey, runHookedWriteOperation, validateNodeProps } from './chunk-JIVMTW7W.js';
+import { runInsertBatch, nodeInsertDispatch, runInsertBatchReturning, getNodeRowsByIds, generateId, runInsertNoReturn } from './chunk-NQ6BRJBE.js';
+import { canonicalEqual } from './chunk-JBQQ7THH.js';
+import { createSqlSchema, DEFAULT_SQL_SCHEMA } from './chunk-MSY7FSX4.js';
+import { rowPropsToObject, createBackendOverlay, isLiveNodeRow } from './chunk-AKLS3BYZ.js';
+import { checkCardinality, checkUniqueEdge, checkWherePredicate, computeUniqueKey, getKindsForUniquenessCheck, checkDisjointness } from './chunk-WDGA7IYB.js';
+import { validateOptionalCanonicalIsoDate, assertOrderedValidityWindow, nowIso, assertWritableValidityWindow } from './chunk-DLNROMQ7.js';
+import { getDialect, compileNodeIndexFieldKeys, compileIndexWhere } from './chunk-YDFDBE6D.js';
+import { sql, asCompiledRowsSql } from './chunk-PQBQG7IM.js';
 import { getSearchableFields } from './chunk-PC2UBAUB.js';
-import { filterReservedKeys, RESERVED_NODE_KEYS, RESERVED_EDGE_KEYS, assertJsonValue } from './chunk-42PYUGLS.js';
-import { ConfigurationError, DatabaseOperationError, ValidationError, UniquenessError, NodeNotFoundError, KindNotFoundError, NodeConstraintNotFoundError, NodeIndexNotFoundError } from './chunk-4MB3AQAQ.js';
-import { resolveJsonPointer } from './chunk-G6Q5UM7U.js';
+import { filterReservedKeys, RESERVED_NODE_KEYS, RESERVED_EDGE_KEYS, assertJsonValue } from './chunk-K5ELX2GT.js';
+import { DatabaseOperationError, ConfigurationError, ValidationError, UniquenessError, NodeNotFoundError, KindNotFoundError, NodeConstraintNotFoundError, NodeIndexNotFoundError, ENTITY_ALREADY_EXISTS_CODE } from './chunk-J3WZ3FA2.js';
+import { resolveJsonPointer } from './chunk-FWJKWH6U.js';
+import { requireDefined, createDataKeyedBag, hasOwnKey } from './chunk-DYATYRY4.js';
 
 // src/store/row-mappers.ts
 function nullToUndefined(value) {
@@ -60,59 +62,19 @@ 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 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 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 runOptionallyInTransaction(backend, async (target) => {
-    await lockSchemaVersionForStoreWrite(ctx, target);
-    const lock = ctx.historyEnabled || ctx.revisionTrackingEnabled ? await lockRecordedGraphWrite(target, ctx.graphId) : uncapturedGraphWriteLock();
-    const result = await fn(target, lock);
-    if (ctx.revisionTrackingEnabled && !ctx.historyEnabled && (options?.didWrite?.(result) ?? true)) {
-      await 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) => 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) {
@@ -191,31 +153,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 ValidationError(
+    `${label.title} already exists: ${detail}`,
+    {
+      entityType: entity,
+      kind,
+      operation: "create",
+      ...id === void 0 ? {} : { id },
+      issues: [
+        {
+          path: "id",
+          code: 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 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 (!hasOwnKey(graph.nodes, kind)) throw new KindNotFoundError(kind, "node");
   const registration = graph.nodes[kind];
   if (registration === void 0) throw new KindNotFoundError(kind, "node");
   return registration;
 }
-var CACHE_KEY_SEPARATOR = "\0";
+function nodeFencesConstraintProbe(ctx, kind, operation) {
+  if (!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 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 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 encodeTupleKey([graphId, nodeKind, constraintName, key]);
 }
 function buildInsertNodeParams(graphId, kind, id, props, validFrom, validTo) {
   const insertParams = {
@@ -406,21 +435,28 @@ function draftNodeCreate(ctx, input, id, options) {
     kind,
     operation: "create"
   });
+  const validFrom = validateOptionalCanonicalIsoDate(
+    input.validFrom,
+    "validFrom"
+  );
+  const validTo = validateOptionalCanonicalIsoDate(input.validTo, "validTo");
+  assertOrderedValidityWindow(`${kind} "${id}"`, validFrom, validTo);
   return {
     kind,
     id,
+    idProvided: input.id !== void 0,
     nodeKind,
     uniqueConstraints: registration.unique ?? [],
     validatedProps,
-    validFrom: validateOptionalCanonicalIsoDate(input.validFrom, "validFrom"),
-    validTo: 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,
@@ -438,6 +474,8 @@ async function finishNodeCreatePreparation(ctx, draft, backend) {
   return {
     kind,
     id,
+    idProvided: draft.idProvided,
+    tombstone: existingNode,
     nodeKind: draft.nodeKind,
     validatedProps,
     uniqueConstraints,
@@ -471,6 +509,9 @@ 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 applyNodeInsertSideEffects(
     createNodeWriteContext(ctx.graphId, ctx.registry, lock),
@@ -527,13 +568,46 @@ async function performNodeUpdate(ctx, input, backend, lock, options) {
     input.props
   );
   const nodeKind = registration.type;
+  const validFrom = validateOptionalCanonicalIsoDate(
+    input.validFrom,
+    "validFrom"
+  );
   const validTo = validateOptionalCanonicalIsoDate(input.validTo, "validTo");
+  const resurrectionInstant = options?.clearDeleted === true && existing.deleted_at !== void 0 ? nowIso() : void 0;
+  const windowVerdict = 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 = 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 applyNodeUpdate(
@@ -551,6 +625,41 @@ async function performNodeUpdate(ctx, input, backend, lock, options) {
   );
   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 NodeNotFoundError(input.kind, input.id);
+      }
+    }
+  }
+  throw new NodeNotFoundError(input.kind, input.id);
+}
+function nodeUpdateRaceError(input, error) {
+  if (!isNodeUpdateNoRowError(error)) return error;
+  return new 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();
@@ -584,7 +693,7 @@ async function primeBatchValidationCaches(ctx, drafts, backend, seams) {
           ctx.registry
         );
         for (const kindToCheck of kindsToCheck) {
-          const groupKey = kindToCheck + CACHE_KEY_SEPARATOR + constraint.name;
+          const groupKey = encodeTupleKey([kindToCheck, constraint.name]);
           const group = groups.get(groupKey) ?? {
             nodeKind: kindToCheck,
             constraintName: constraint.name,
@@ -646,10 +755,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 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 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 applyNodeUpdate(
+      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) {
@@ -708,6 +867,8 @@ async function executeNodeCreateInternal(ctx, input, backend, options) {
     opContext,
     backend,
     async (target, lock) => {
+      const identity = ctx.identity;
+      if (identity !== void 0) await identity.lock(target);
       const prepared = await validateAndPrepareNodeCreate(
         ctx,
         input,
@@ -715,18 +876,36 @@ async function executeNodeCreateInternal(ctx, input, backend, options) {
         target,
         options
       );
-      let row;
-      if (shouldReturnRow) {
-        row = await target.insertNode(prepared.insertParams);
-      } else {
+      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 runInsertNoReturn(
           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")
     }
   );
 }
@@ -745,32 +924,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 runInsertBatch(nodeInsertDispatch(target), batchInsertParams);
-    await finalizeNodeCreateBatch(ctx, preparedCreates, target, lock);
-  });
+  await 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",
+        () => runInsertBatch(
+          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 runInsertBatchReturning(
-      nodeInsertDispatch(target),
-      batchInsertParams
-    );
-    await finalizeNodeCreateBatch(ctx, preparedCreates, target, lock);
-    return rows.map((row) => rowToNode(row));
-  });
+  return 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",
+        () => runInsertBatchReturning(
+          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) => [
+          refKey({ kind: row.kind, id: row.id }),
+          row
+        ])
+      );
+      const rows = preparedCreates.map(
+        (prepared) => requireDefined(
+          byReference.get(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(
@@ -783,7 +1022,32 @@ async function executeNodeUpdate(ctx, input, backend, options) {
     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) {
@@ -833,7 +1097,7 @@ async function executeNodeUpdateWhere(ctx, kind, inputPatch, candidateIds, candi
     kind,
     operation: "update"
   });
-  const patch = {};
+  const patch = createDataKeyedBag();
   const unsetProperties = [];
   for (const [property, value] of Object.entries(parsedPatch)) {
     if (value === void 0) {
@@ -1013,7 +1277,13 @@ async function executeNodeUpdateWhere(ctx, kind, inputPatch, candidateIds, candi
         );
         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")
+      }
     )
   );
 }
@@ -1021,7 +1291,32 @@ async function executeNodeUpsertUpdate(ctx, input, backend, options) {
   return 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) {
@@ -1033,6 +1328,8 @@ async function executeNodeDelete(ctx, kind, id, backend) {
     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 || !isLiveNodeRow(preflight)) return;
@@ -1046,9 +1343,49 @@ 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 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 = 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
+        );
+        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;
@@ -1058,6 +1395,8 @@ async function executeNodeHardDelete(ctx, kind, id, backend) {
     opContext,
     backend,
     async (target, lock) => {
+      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),
@@ -1069,6 +1408,9 @@ async function executeNodeHardDelete(ctx, kind, id, backend) {
         },
         target
       );
+      if (identity !== void 0) {
+        await identity.detachDeleted(target, { kind, id }, "hard");
+      }
     }
   );
 }
@@ -1504,101 +1846,109 @@ async function executeNodeBulkGetOrCreateByConstraint(ctx, kind, constraintName,
     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: 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: 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 = requireDefined(results[sourceIndex]);
+      results[index] = { node: sourceResult.node, action: "found" };
     }
+    return results;
   }
-  for (const { index, sourceIndex } of duplicateOf) {
-    const sourceResult = requireDefined(results[sourceIndex]);
-    results[index] = { node: sourceResult.node, action: "found" };
+  try {
+    return await attempt();
+  } catch (error) {
+    if (!(error instanceof UniquenessError)) throw error;
+    return attempt();
   }
-  return results;
 }
 
-export { checkCardinalityConstraint, createNodeBatchValidationBackend, executeNodeBulkFindByConstraint, executeNodeBulkFindByIndex, executeNodeBulkGetOrCreateByConstraint, executeNodeCreate, executeNodeCreateBatch, executeNodeCreateNoReturnBatch, executeNodeDelete, executeNodeFindByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeUpdate, executeNodeUpdateWhere, executeNodeUpsertUpdate, lockSchemaVersionForStoreWrite, nodeUpsertDirtyCheck, primeBatchValidationCaches, rowToEdge, rowToEdgeMeta, rowToNode, rowToNodeMeta, runHookedWriteOperation, runInWriteTransaction };
-//# sourceMappingURL=chunk-Q6EDCUXV.js.map
-//# sourceMappingURL=chunk-Q6EDCUXV.js.map
+export { checkCardinalityConstraint, createNodeBatchValidationBackend, edgeWriteNeedsConstraintFence, executeNodeBulkFindByConstraint, executeNodeBulkFindByIndex, executeNodeBulkGetOrCreateByConstraint, executeNodeCreate, executeNodeCreateBatch, executeNodeCreateNoReturnBatch, executeNodeDelete, executeNodeDeleteBatch, executeNodeFindByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeUpdate, executeNodeUpdateWhere, executeNodeUpsertUpdate, nodeUpsertDirtyCheck, primeBatchValidationCaches, rowToEdge, rowToEdgeMeta, rowToNode, rowToNodeMeta, withAlreadyExistsTranslation };
+//# sourceMappingURL=chunk-QWX5YA3K.js.map
+//# sourceMappingURL=chunk-QWX5YA3K.js.map