@nicia-ai/typegraph 0.44.0 → 0.46.0

package/dist/chunk-7GT72YHH.cjs

@@ -0,0 +1,1979 @@
+'use strict';
+
+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 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 = chunkXBYVV3MP_cjs.rowPropsToObject(row.props);
+  const props = chunkLBJKZXDE_cjs.filterReservedKeys(rawProps, chunkLBJKZXDE_cjs.RESERVED_NODE_KEYS);
+  return {
+    kind: row.kind,
+    id: row.id,
+    meta: rowToNodeMeta(row),
+    ...props
+  };
+}
+function rowToNodeMeta(row) {
+  return {
+    version: row.version,
+    validFrom: nullToUndefined(row.valid_from),
+    validTo: nullToUndefined(row.valid_to),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    deletedAt: nullToUndefined(row.deleted_at)
+  };
+}
+function rowToEdge(row) {
+  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,
+    fromKind: row.from_kind,
+    fromId: row.from_id,
+    toKind: row.to_kind,
+    toId: row.to_id,
+    meta: rowToEdgeMeta(row),
+    ...props
+  };
+}
+function rowToEdgeMeta(row) {
+  return {
+    validFrom: nullToUndefined(row.valid_from),
+    validTo: nullToUndefined(row.valid_to),
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    deletedAt: nullToUndefined(row.deleted_at)
+  };
+}
+
+// src/store/constraints.ts
+function edgeWriteNeedsConstraintFence(cardinality) {
+  return cardinality === "many" ? void 0 : "edgeCardinality";
+}
+function nodeWriteNeedsConstraintFence(registry, kind, uniqueConstraints, operation) {
+  if (operation === "create" && registry.getDisjointKinds(kind).length > 0) {
+    return "nodeDisjointness";
+  }
+  const sharedScope = uniqueConstraints.some(
+    (constraint) => chunkE4WNQBEF_cjs.getKindsForUniquenessCheck(kind, constraint.scope, registry).length > 1
+  );
+  return sharedScope ? "nodeUniquenessScope" : void 0;
+}
+async function checkDisjointnessConstraint(ctx, kind, id) {
+  const disjointKinds = ctx.registry.getDisjointKinds(kind);
+  for (const disjointKind of disjointKinds) {
+    const existing = await ctx.backend.getNode(ctx.graphId, disjointKind, id);
+    if (existing && !existing.deleted_at) {
+      const error = chunkE4WNQBEF_cjs.checkDisjointness(id, kind, [disjointKind], ctx.registry);
+      if (error) throw error;
+    }
+  }
+}
+async function checkCardinalityConstraint(ctx, edgeKind, cardinality, fromKind, fromId, toKind, toId, validTo) {
+  switch (cardinality) {
+    case "many": {
+      return;
+    }
+    case "one": {
+      const count = await ctx.backend.countEdgesFrom({
+        graphId: ctx.graphId,
+        edgeKind,
+        fromKind,
+        fromId
+      });
+      const error = chunkE4WNQBEF_cjs.checkCardinality(
+        edgeKind,
+        fromKind,
+        fromId,
+        "one",
+        count,
+        false
+      );
+      if (error) throw error;
+      return;
+    }
+    case "unique": {
+      const exists = await ctx.backend.edgeExistsBetween({
+        graphId: ctx.graphId,
+        edgeKind,
+        fromKind,
+        fromId,
+        toKind,
+        toId
+      });
+      const error = chunkE4WNQBEF_cjs.checkUniqueEdge(
+        edgeKind,
+        fromKind,
+        fromId,
+        toKind,
+        toId,
+        exists ? 1 : 0
+      );
+      if (error) throw error;
+      return;
+    }
+    case "oneActive": {
+      if (validTo !== void 0) {
+        return;
+      }
+      const count = await ctx.backend.countEdgesFrom({
+        graphId: ctx.graphId,
+        edgeKind,
+        fromKind,
+        fromId,
+        activeOnly: true
+      });
+      const error = chunkE4WNQBEF_cjs.checkCardinality(
+        edgeKind,
+        fromKind,
+        fromId,
+        "oneActive",
+        count,
+        count > 0
+      );
+      if (error) throw error;
+      return;
+    }
+  }
+}
+
+// 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 chunkNI72YOJB_cjs.KindNotFoundError(kind, "node");
+  return registration;
+}
+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 chunkXNLIZYRZ_cjs.encodeTupleKey([graphId, kind, id]);
+}
+function buildUniqueCacheKey(graphId, nodeKind, constraintName, key) {
+  return chunkXNLIZYRZ_cjs.encodeTupleKey([graphId, nodeKind, constraintName, key]);
+}
+function buildInsertNodeParams(graphId, kind, id, props, validFrom, validTo) {
+  const insertParams = {
+    graphId,
+    kind,
+    id,
+    props
+  };
+  if (validFrom !== void 0) insertParams.validFrom = validFrom;
+  if (validTo !== void 0) insertParams.validTo = validTo;
+  return insertParams;
+}
+function createPendingUniqueRow(graphId, nodeKind, constraintName, key, nodeId) {
+  return {
+    graph_id: graphId,
+    node_kind: nodeKind,
+    constraint_name: constraintName,
+    key,
+    node_id: nodeId,
+    concrete_kind: nodeKind,
+    deleted_at: void 0
+  };
+}
+function resolveConstraint(graph, kind, constraintName) {
+  const registration = getNodeRegistration(graph, kind);
+  const constraints = registration.unique ?? [];
+  const constraint = constraints.find(
+    (candidate) => candidate.name === constraintName
+  );
+  if (constraint === void 0) {
+    throw new chunkNI72YOJB_cjs.NodeConstraintNotFoundError(constraintName, kind);
+  }
+  return constraint;
+}
+function createNodeBatchValidationBackend(graphId, registry, backend) {
+  const nodeCache = /* @__PURE__ */ new Map();
+  const pendingNodes = /* @__PURE__ */ new Map();
+  const uniqueCache = /* @__PURE__ */ new Map();
+  const pendingUniqueOwners = /* @__PURE__ */ new Map();
+  async function getNodeCached(lookupGraphId, kind, id) {
+    const cacheKey = buildNodeCacheKey(lookupGraphId, kind, id);
+    const pendingNode = pendingNodes.get(cacheKey);
+    if (pendingNode !== void 0) return pendingNode;
+    if (nodeCache.has(cacheKey)) return nodeCache.get(cacheKey);
+    const existing = await backend.getNode(lookupGraphId, kind, id);
+    nodeCache.set(cacheKey, existing);
+    return existing;
+  }
+  async function checkUniqueCached(params) {
+    const cacheKey = buildUniqueCacheKey(
+      params.graphId,
+      params.nodeKind,
+      params.constraintName,
+      params.key
+    );
+    const pendingOwner = pendingUniqueOwners.get(cacheKey);
+    if (pendingOwner !== void 0) {
+      return createPendingUniqueRow(
+        params.graphId,
+        params.nodeKind,
+        params.constraintName,
+        params.key,
+        pendingOwner
+      );
+    }
+    if (uniqueCache.has(cacheKey)) return uniqueCache.get(cacheKey);
+    const existing = await backend.checkUnique(params);
+    uniqueCache.set(cacheKey, existing);
+    return existing;
+  }
+  function registerPendingNode(params) {
+    const cacheKey = buildNodeCacheKey(params.graphId, params.kind, params.id);
+    pendingNodes.set(cacheKey, {
+      graph_id: params.graphId,
+      kind: params.kind,
+      id: params.id,
+      props: JSON.stringify(params.props),
+      version: 1,
+      // The simulated cached row only needs a NodeRow-shaped valid_from
+      // (string | undefined, never null) for existence/uniqueness checks,
+      // which don't inspect its value — normalize import's explicit-NULL
+      // sentinel away rather than widen this cache's row shape.
+      valid_from: params.validFrom ?? void 0,
+      valid_to: params.validTo,
+      created_at: "",
+      updated_at: "",
+      deleted_at: void 0
+    });
+  }
+  function registerPendingUniqueEntries(kind, id, props, constraints) {
+    for (const constraint of constraints) {
+      if (!chunkE4WNQBEF_cjs.checkWherePredicate(constraint, props)) continue;
+      const key = chunkE4WNQBEF_cjs.computeUniqueKey(
+        props,
+        constraint.fields,
+        constraint.collation
+      );
+      const concreteEntryKey = buildUniqueCacheKey(
+        graphId,
+        kind,
+        constraint.name,
+        key
+      );
+      pendingUniqueOwners.set(concreteEntryKey, id);
+      if (constraint.scope !== "kind") {
+        const kindsToCheck = chunkE4WNQBEF_cjs.getKindsForUniquenessCheck(
+          kind,
+          constraint.scope,
+          registry
+        );
+        for (const kindToCheck of kindsToCheck) {
+          const inheritedEntryKey = buildUniqueCacheKey(
+            graphId,
+            kindToCheck,
+            constraint.name,
+            key
+          );
+          pendingUniqueOwners.set(inheritedEntryKey, id);
+        }
+      }
+    }
+  }
+  function registerAppliedNodeUpdate(kind, id, oldProps, newProps, constraints) {
+    for (const constraint of constraints) {
+      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 = chunkE4WNQBEF_cjs.getKindsForUniquenessCheck(
+        kind,
+        constraint.scope,
+        registry
+      );
+      if (oldKey !== void 0) {
+        for (const kindToCheck of kindsToCheck) {
+          const cacheKey = buildUniqueCacheKey(
+            graphId,
+            kindToCheck,
+            constraint.name,
+            oldKey
+          );
+          pendingUniqueOwners.delete(cacheKey);
+          uniqueCache.set(cacheKey, void 0);
+        }
+      }
+      if (newKey !== void 0) {
+        for (const kindToCheck of kindsToCheck) {
+          const cacheKey = buildUniqueCacheKey(
+            graphId,
+            kindToCheck,
+            constraint.name,
+            newKey
+          );
+          pendingUniqueOwners.set(cacheKey, id);
+        }
+      }
+    }
+  }
+  function seedNodeRow(kind, id, row) {
+    const cacheKey = buildNodeCacheKey(graphId, kind, id);
+    if (nodeCache.has(cacheKey)) return;
+    nodeCache.set(cacheKey, row);
+  }
+  function seedUniqueRow(kind, constraintName, key, row) {
+    const cacheKey = buildUniqueCacheKey(graphId, kind, constraintName, key);
+    if (uniqueCache.has(cacheKey)) return;
+    uniqueCache.set(cacheKey, row);
+  }
+  const validationBackend = chunkXBYVV3MP_cjs.createBackendOverlay(backend, {
+    getNode: getNodeCached,
+    checkUnique: checkUniqueCached
+  });
+  return {
+    backend: validationBackend,
+    registerPendingNode,
+    registerPendingUniqueEntries,
+    registerAppliedNodeUpdate,
+    seedNodeRow,
+    seedUniqueRow
+  };
+}
+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 : 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,
+    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 createAlreadyExistsError("node", kind, id);
+  }
+  const constraintContext = {
+    graphId: ctx.graphId,
+    registry: ctx.registry,
+    backend
+  };
+  await checkDisjointnessConstraint(constraintContext, kind, id);
+  await chunkTTAITEPJ_cjs.checkUniquenessConstraints(
+    chunkTTAITEPJ_cjs.createUniquenessContext(ctx.graphId, ctx.registry, backend),
+    kind,
+    id,
+    validatedProps,
+    uniqueConstraints
+  );
+  return {
+    kind,
+    id,
+    idProvided: draft.idProvided,
+    tombstone: existingNode,
+    nodeKind: draft.nodeKind,
+    validatedProps,
+    uniqueConstraints,
+    insertParams: buildInsertNodeParams(
+      ctx.graphId,
+      kind,
+      id,
+      validatedProps,
+      draft.validFrom,
+      draft.validTo
+    )
+  };
+}
+async function validateAndPrepareNodeCreate(ctx, input, id, backend, options) {
+  return finishNodeCreatePreparation(
+    ctx,
+    draftNodeCreate(ctx, input, id, options),
+    backend
+  );
+}
+async function finalizeNodeCreateBatch(ctx, preparedCreates, backend, lock) {
+  await chunkTTAITEPJ_cjs.applyNodeInsertSideEffectsBatch(
+    chunkTTAITEPJ_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
+    preparedCreates.map((prepared) => ({
+      kind: prepared.kind,
+      id: prepared.id,
+      schema: prepared.nodeKind.schema,
+      props: prepared.validatedProps,
+      uniqueConstraints: prepared.uniqueConstraints
+    })),
+    backend
+  );
+}
+function foldReferences(preparedCreates) {
+  return preparedCreates.filter((prepared) => prepared.idProvided).map((prepared) => ({ kind: prepared.kind, id: prepared.id }));
+}
+async function finalizeNodeCreate(ctx, prepared, backend, lock) {
+  await chunkTTAITEPJ_cjs.applyNodeInsertSideEffects(
+    chunkTTAITEPJ_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
+    {
+      kind: prepared.kind,
+      id: prepared.id,
+      schema: prepared.nodeKind.schema,
+      props: prepared.validatedProps,
+      uniqueConstraints: prepared.uniqueConstraints
+    },
+    backend
+  );
+}
+function computeNodeUpdate(ctx, kind, id, existingProps, inputProps) {
+  const registration = getNodeRegistration(ctx.graph, kind);
+  const validatedProps = chunkXNLIZYRZ_cjs.validateNodeProps(
+    registration.type.schema,
+    { ...existingProps, ...inputProps },
+    { kind, operation: "update", id }
+  );
+  return { registration, validatedProps };
+}
+function resolveNodeUpdateProps(ctx, existing, inputProps) {
+  const existingProps = chunkXBYVV3MP_cjs.rowPropsToObject(existing.props);
+  const { registration, validatedProps } = computeNodeUpdate(
+    ctx,
+    existing.kind,
+    existing.id,
+    existingProps,
+    inputProps
+  );
+  return { registration, existingProps, validatedProps };
+}
+function nodeUpsertDirtyCheck(ctx, kind, id, existingProps, inputProps) {
+  const { validatedProps } = computeNodeUpdate(
+    ctx,
+    kind,
+    id,
+    existingProps,
+    inputProps
+  );
+  return {
+    validatedProps,
+    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 chunkNI72YOJB_cjs.NodeNotFoundError(kind, id);
+  const { registration, validatedProps } = resolveNodeUpdateProps(
+    ctx,
+    existing,
+    input.props
+  );
+  const nodeKind = registration.type;
+  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 ?? [],
+    ...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 chunkTTAITEPJ_cjs.applyNodeUpdate(
+      writeContext,
+      { ...shared, existing, clearDeleted: true },
+      backend
+    );
+    return rowToNode(row2);
+  }
+  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();
+    for (const draft of drafts) {
+      const ids = idsByKind.get(draft.kind) ?? /* @__PURE__ */ new Set();
+      ids.add(draft.id);
+      idsByKind.set(draft.kind, ids);
+    }
+    for (const [kind, ids] of idsByKind) {
+      const orderedIds = [...ids];
+      const rows = await backend.getNodes(ctx.graphId, kind, orderedIds);
+      const rowsById = new Map(rows.map((row) => [row.id, row]));
+      for (const id of orderedIds) {
+        seams.seedNodeRow(kind, id, rowsById.get(id));
+      }
+    }
+  }
+  if (backend.checkUniqueBatch !== void 0) {
+    const groups = /* @__PURE__ */ new Map();
+    for (const draft of drafts) {
+      for (const constraint of draft.uniqueConstraints) {
+        if (!chunkE4WNQBEF_cjs.checkWherePredicate(constraint, draft.validatedProps)) continue;
+        const key = chunkE4WNQBEF_cjs.computeUniqueKey(
+          draft.validatedProps,
+          constraint.fields,
+          constraint.collation
+        );
+        const kindsToCheck = chunkE4WNQBEF_cjs.getKindsForUniquenessCheck(
+          draft.kind,
+          constraint.scope,
+          ctx.registry
+        );
+        for (const kindToCheck of kindsToCheck) {
+          const groupKey = chunkXNLIZYRZ_cjs.encodeTupleKey([kindToCheck, constraint.name]);
+          const group = groups.get(groupKey) ?? {
+            nodeKind: kindToCheck,
+            constraintName: constraint.name,
+            keys: /* @__PURE__ */ new Set()
+          };
+          group.keys.add(key);
+          groups.set(groupKey, group);
+        }
+      }
+    }
+    for (const group of groups.values()) {
+      const orderedKeys = [...group.keys];
+      const rows = await backend.checkUniqueBatch({
+        graphId: ctx.graphId,
+        nodeKind: group.nodeKind,
+        constraintName: group.constraintName,
+        keys: orderedKeys
+      });
+      const rowsByKey = new Map(rows.map((row) => [row.key, row]));
+      for (const key of orderedKeys) {
+        seams.seedUniqueRow(
+          group.nodeKind,
+          group.constraintName,
+          key,
+          rowsByKey.get(key)
+        );
+      }
+    }
+  }
+}
+async function prepareBatchCreates(ctx, inputs, backend, options) {
+  const {
+    backend: validationBackend,
+    registerPendingNode,
+    registerPendingUniqueEntries,
+    seedNodeRow,
+    seedUniqueRow
+  } = createNodeBatchValidationBackend(ctx.graphId, ctx.registry, backend);
+  const drafts = inputs.map(
+    (input) => draftNodeCreate(ctx, input, input.id ?? chunkXMQSEJCF_cjs.generateId(), options)
+  );
+  await primeBatchValidationCaches(ctx, drafts, backend, {
+    seedNodeRow,
+    seedUniqueRow
+  });
+  const preparedCreates = [];
+  for (const draft of drafts) {
+    const prepared = await finishNodeCreatePreparation(
+      ctx,
+      draft,
+      validationBackend
+    );
+    preparedCreates.push(prepared);
+    registerPendingNode(prepared.insertParams);
+    registerPendingUniqueEntries(
+      prepared.kind,
+      prepared.id,
+      prepared.validatedProps,
+      prepared.uniqueConstraints
+    );
+  }
+  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) {
+    const row = await backend.checkUnique({
+      graphId,
+      nodeKind: kindToCheck,
+      constraintName,
+      key,
+      includeDeleted
+    });
+    if (row !== void 0) return row;
+  }
+  return void 0;
+}
+async function batchCheckUniqueAcrossKinds(backend, graphId, constraintName, uniqueKeys, kindsToCheck, includeDeleted) {
+  const existingByKey = /* @__PURE__ */ new Map();
+  for (const kindToCheck of kindsToCheck) {
+    if (backend.checkUniqueBatch === void 0) {
+      for (const key of uniqueKeys) {
+        if (existingByKey.has(key)) continue;
+        const row = await backend.checkUnique({
+          graphId,
+          nodeKind: kindToCheck,
+          constraintName,
+          key,
+          includeDeleted
+        });
+        if (row !== void 0) {
+          existingByKey.set(row.key, row);
+        }
+      }
+    } else {
+      const rows = await backend.checkUniqueBatch({
+        graphId,
+        nodeKind: kindToCheck,
+        constraintName,
+        keys: uniqueKeys,
+        includeDeleted
+      });
+      for (const row of rows) {
+        if (!existingByKey.has(row.key)) {
+          existingByKey.set(row.key, row);
+        }
+      }
+    }
+  }
+  return existingByKey;
+}
+async function executeNodeCreateInternal(ctx, input, backend, options) {
+  const kind = input.kind;
+  const id = input.id ?? chunkXMQSEJCF_cjs.generateId();
+  const opContext = ctx.createOperationContext("create", "node", kind, id);
+  const shouldReturnRow = options?.returnRow ?? true;
+  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,
+        id,
+        target,
+        options
+      );
+      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")
+    }
+  );
+}
+async function executeNodeCreate(ctx, input, backend, options) {
+  const result = await executeNodeCreateInternal(ctx, input, backend, {
+    returnRow: true,
+    ...options
+  });
+  if (!result) {
+    throw new chunkNI72YOJB_cjs.DatabaseOperationError(
+      "Node create failed: expected created node row",
+      { operation: "insert", entity: "node" }
+    );
+  }
+  return result;
+}
+async function executeNodeCreateNoReturnBatch(ctx, inputs, backend) {
+  if (inputs.length === 0) return;
+  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 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(
+    "update",
+    "node",
+    input.kind,
+    input.id
+  );
+  return chunkXNLIZYRZ_cjs.runHookedWriteOperation(
+    ctx,
+    opContext,
+    backend,
+    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) {
+  const registration = getNodeRegistration(ctx.graph, kind);
+  const schema = registration.type.schema;
+  const uniqueConstraints = registration.unique ?? [];
+  if (!backend.capabilities.transactions) {
+    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 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 chunkNI72YOJB_cjs.ValidationError("updateWhere() patch must not be empty", {
+      entityType: "node",
+      kind,
+      operation: "update",
+      issues: [{ path: "patch", message: "Provide at least one property" }]
+    });
+  }
+  const unknownProperty = Object.keys(inputPatch).find(
+    (property) => !Object.hasOwn(schema.shape, property)
+  );
+  if (unknownProperty !== void 0) {
+    throw new chunkNI72YOJB_cjs.ValidationError(
+      `Unknown ${kind} property in updateWhere() patch: ${unknownProperty}`,
+      {
+        entityType: "node",
+        kind,
+        operation: "update",
+        issues: [
+          {
+            path: unknownProperty,
+            message: "Property is not declared by the node schema"
+          }
+        ]
+      }
+    );
+  }
+  const parsedPatch = chunkXNLIZYRZ_cjs.validateNodeProps(schema.partial(), inputPatch, {
+    kind,
+    operation: "update"
+  });
+  const patch = chunkN66HCGCY_cjs.createDataKeyedBag();
+  const unsetProperties = [];
+  for (const [property, value] of Object.entries(parsedPatch)) {
+    if (value === void 0) {
+      unsetProperties.push(property);
+      continue;
+    }
+    chunkLBJKZXDE_cjs.assertJsonValue(value, property, `Node "${kind}" updateWhere patch`);
+    patch[property] = value;
+  }
+  if (Object.keys(patch).length === 0 && unsetProperties.length === 0) {
+    throw new chunkNI72YOJB_cjs.ValidationError(
+      "updateWhere() patch has no recognized properties",
+      {
+        entityType: "node",
+        kind,
+        operation: "update",
+        issues: [
+          { path: "patch", message: "Provide a declared node property" }
+        ]
+      }
+    );
+  }
+  if (uniqueConstraints.length > 0 && (backend.hardDeleteUniquesByNodeIds === void 0 || backend.insertUniqueBatch === void 0 || backend.checkUniqueBatch === void 0)) {
+    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 chunkNI72YOJB_cjs.ConfigurationError(
+      "updateWhere() requires batched fulltext sidecar operations for searchable nodes",
+      { code: "SET_UPDATE_FULLTEXT_UNSUPPORTED", kind }
+    );
+  }
+  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 }
+    );
+  }
+  const hookContext = ctx.createBulkOperationContext("updateWhere", kind);
+  return ctx.withBulkOperationHooks(
+    hookContext,
+    () => chunkXNLIZYRZ_cjs.runInWriteTransaction(
+      ctx,
+      backend,
+      async (target, lock) => {
+        const updateNodeSet = target.updateNodeSet;
+        if (updateNodeSet === void 0) {
+          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 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 chunkNI72YOJB_cjs.ConfigurationError(
+            "The transaction backend lacks batched fulltext operations",
+            { code: "SET_UPDATE_FULLTEXT_UNSUPPORTED", kind }
+          );
+        }
+        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 }
+          );
+        }
+        const result = await updateNodeSet({
+          graphId: ctx.graphId,
+          kind,
+          patch,
+          unsetProperties,
+          candidateIds,
+          candidateIdColumn
+        });
+        if (result.affectedCount === 0) return { affectedCount: 0 };
+        const sidecarItems = result.rows.map((row) => {
+          const props = chunkXBYVV3MP_cjs.rowPropsToObject(row.props);
+          const validatedProps = chunkXNLIZYRZ_cjs.validateNodeProps(schema, props, {
+            kind,
+            operation: "update",
+            id: row.id
+          });
+          if (!chunkPWLJ77UV_cjs.canonicalEqual(validatedProps, props)) {
+            throw new chunkNI72YOJB_cjs.ValidationError(
+              `Set update would persist a non-canonical ${kind} row`,
+              {
+                entityType: "node",
+                kind,
+                operation: "update",
+                id: row.id,
+                issues: [
+                  {
+                    path: "props",
+                    message: "The complete row requires schema normalization"
+                  }
+                ]
+              }
+            );
+          }
+          return {
+            kind,
+            id: row.id,
+            schema,
+            props: validatedProps,
+            uniqueConstraints
+          };
+        });
+        if (uniqueConstraints.length > 0) {
+          const affectedIds = new Set(result.rows.map((row) => row.id));
+          for (const constraint of uniqueConstraints) {
+            const keyToId = /* @__PURE__ */ new Map();
+            for (const item of sidecarItems) {
+              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 chunkNI72YOJB_cjs.UniquenessError({
+                  constraintName: constraint.name,
+                  kind,
+                  existingId: priorId,
+                  newId: item.id,
+                  fields: constraint.fields
+                });
+              }
+              keyToId.set(key, item.id);
+            }
+            const keys = [...keyToId.keys()];
+            if (keys.length === 0) continue;
+            for (const kindToCheck of chunkE4WNQBEF_cjs.getKindsForUniquenessCheck(
+              kind,
+              constraint.scope,
+              ctx.registry
+            )) {
+              const existingRows = await chunkN66HCGCY_cjs.requireDefined(
+                target.checkUniqueBatch
+              )({
+                graphId: ctx.graphId,
+                nodeKind: kindToCheck,
+                constraintName: constraint.name,
+                keys
+              });
+              for (const existing of existingRows) {
+                if (existing.concrete_kind === kind && affectedIds.has(existing.node_id)) {
+                  continue;
+                }
+                throw new chunkNI72YOJB_cjs.UniquenessError({
+                  constraintName: constraint.name,
+                  kind: kindToCheck,
+                  existingId: existing.node_id,
+                  newId: chunkN66HCGCY_cjs.requireDefined(keyToId.get(existing.key)),
+                  fields: constraint.fields
+                });
+              }
+            }
+          }
+          await chunkN66HCGCY_cjs.requireDefined(hardDeleteUniquesByNodeIds)({
+            graphId: ctx.graphId,
+            concreteKind: kind,
+            nodeIds: result.rows.map((row) => row.id)
+          });
+        }
+        await chunkTTAITEPJ_cjs.applyNodeInsertSideEffectsBatch(
+          chunkTTAITEPJ_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
+          sidecarItems,
+          target
+        );
+        return { affectedCount: result.affectedCount };
+      },
+      {
+        didWrite: (result) => result.affectedCount > 0,
+        // The set update re-checks every changed unique key across the
+        // constraint's scope before rebuilding the sidecars, so a shared-scope
+        // constraint makes it a constrained write like any other update.
+        fencesConstraintProbe: nodeFencesConstraintProbe(ctx, kind, "update")
+      }
+    )
+  );
+}
+async function executeNodeUpsertUpdate(ctx, input, backend, options) {
+  return chunkXNLIZYRZ_cjs.runInWriteTransaction(
+    ctx,
+    backend,
+    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 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 || !chunkXBYVV3MP_cjs.isLiveNodeRow(preflight)) return;
+      await chunkTTAITEPJ_cjs.applyNodeSoftDelete(
+        chunkTTAITEPJ_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
+        {
+          existing: preflight,
+          schema: registration.type.schema,
+          uniqueConstraints: registration.unique ?? [],
+          onDelete: registration.onDelete
+        },
+        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 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 chunkTTAITEPJ_cjs.applyNodeHardDelete(
+        chunkTTAITEPJ_cjs.createNodeWriteContext(ctx.graphId, ctx.registry, lock),
+        {
+          kind,
+          id,
+          schema: registration.type.schema,
+          onDelete: registration.onDelete
+        },
+        target
+      );
+      if (identity !== void 0) {
+        await identity.detachDeleted(target, { kind, id }, "hard");
+      }
+    }
+  );
+}
+async function executeNodeGetOrCreateByConstraint(ctx, kind, constraintName, props, backend, options) {
+  const ifExists = options?.ifExists ?? "return";
+  const registration = getNodeRegistration(ctx.graph, kind);
+  const nodeKind = registration.type;
+  const validatedProps = chunkXNLIZYRZ_cjs.validateNodeProps(nodeKind.schema, props, {
+    kind,
+    operation: "create"
+  });
+  const constraint = resolveConstraint(ctx.graph, kind, constraintName);
+  if (!chunkE4WNQBEF_cjs.checkWherePredicate(constraint, validatedProps)) {
+    const node = await executeNodeCreate(
+      ctx,
+      { kind, props: validatedProps },
+      backend,
+      { propsPreValidated: true }
+    );
+    return { node, action: "created" };
+  }
+  const key = chunkE4WNQBEF_cjs.computeUniqueKey(
+    validatedProps,
+    constraint.fields,
+    constraint.collation
+  );
+  const kindsToCheck = chunkE4WNQBEF_cjs.getKindsForUniquenessCheck(
+    kind,
+    constraint.scope,
+    ctx.registry
+  );
+  async function attempt() {
+    const existingUniqueRow = await findUniqueRowAcrossKinds(
+      backend,
+      ctx.graphId,
+      constraint.name,
+      key,
+      kindsToCheck,
+      true
+    );
+    if (existingUniqueRow === void 0) {
+      const node = await executeNodeCreate(
+        ctx,
+        { kind, props: validatedProps },
+        backend,
+        { propsPreValidated: true }
+      );
+      return { node, action: "created" };
+    }
+    const existingRow = await backend.getNode(
+      ctx.graphId,
+      existingUniqueRow.concrete_kind,
+      existingUniqueRow.node_id
+    );
+    if (existingRow === void 0) {
+      const node = await executeNodeCreate(
+        ctx,
+        { kind, props: validatedProps },
+        backend,
+        { propsPreValidated: true }
+      );
+      return { node, action: "created" };
+    }
+    const isSoftDeleted = existingRow.deleted_at !== void 0;
+    if (isSoftDeleted || ifExists === "update") {
+      const concreteKind = existingUniqueRow.concrete_kind;
+      const node = await executeNodeUpsertUpdate(
+        ctx,
+        {
+          kind: concreteKind,
+          id: existingRow.id,
+          props: validatedProps
+        },
+        backend,
+        { clearDeleted: isSoftDeleted }
+      );
+      return { node, action: isSoftDeleted ? "resurrected" : "updated" };
+    }
+    return { node: rowToNode(existingRow), action: "found" };
+  }
+  try {
+    return await attempt();
+  } catch (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 = chunkXNLIZYRZ_cjs.validateNodeProps(nodeKind.schema, props, {
+    kind,
+    operation: "create"
+  });
+  const constraint = resolveConstraint(ctx.graph, kind, constraintName);
+  if (!chunkE4WNQBEF_cjs.checkWherePredicate(constraint, validatedProps)) return void 0;
+  const key = chunkE4WNQBEF_cjs.computeUniqueKey(
+    validatedProps,
+    constraint.fields,
+    constraint.collation
+  );
+  const kindsToCheck = chunkE4WNQBEF_cjs.getKindsForUniquenessCheck(
+    kind,
+    constraint.scope,
+    ctx.registry
+  );
+  const existingUniqueRow = await findUniqueRowAcrossKinds(
+    backend,
+    ctx.graphId,
+    constraint.name,
+    key,
+    kindsToCheck,
+    false
+  );
+  if (existingUniqueRow === void 0) return void 0;
+  const existingRow = await backend.getNode(
+    ctx.graphId,
+    existingUniqueRow.concrete_kind,
+    existingUniqueRow.node_id
+  );
+  if (existingRow === void 0 || existingRow.deleted_at !== void 0)
+    return void 0;
+  return rowToNode(existingRow);
+}
+function validateAndComputeKeys(nodeKind, kind, constraint, items) {
+  const validated = [];
+  for (const item of items) {
+    const validatedProps = chunkXNLIZYRZ_cjs.validateNodeProps(nodeKind.schema, item.props, {
+      kind,
+      operation: "create"
+    });
+    const applies = chunkE4WNQBEF_cjs.checkWherePredicate(constraint, validatedProps);
+    const key = applies ? chunkE4WNQBEF_cjs.computeUniqueKey(
+      validatedProps,
+      constraint.fields,
+      constraint.collation
+    ) : void 0;
+    validated.push({ validatedProps, key });
+  }
+  return validated;
+}
+function collectUniqueKeys(validated) {
+  return [
+    ...new Set(
+      validated.map((entry) => entry.key).filter((key) => key !== void 0)
+    )
+  ];
+}
+async function executeNodeBulkFindByConstraint(ctx, kind, constraintName, items, backend) {
+  if (items.length === 0) return [];
+  const registration = getNodeRegistration(ctx.graph, kind);
+  const nodeKind = registration.type;
+  const constraint = resolveConstraint(ctx.graph, kind, constraintName);
+  const validated = validateAndComputeKeys(nodeKind, kind, constraint, items);
+  const uniqueKeys = collectUniqueKeys(validated);
+  const kindsToCheck = chunkE4WNQBEF_cjs.getKindsForUniquenessCheck(
+    kind,
+    constraint.scope,
+    ctx.registry
+  );
+  const existingByKey = uniqueKeys.length > 0 ? await batchCheckUniqueAcrossKinds(
+    backend,
+    ctx.graphId,
+    constraint.name,
+    uniqueKeys,
+    kindsToCheck,
+    false
+  ) : /* @__PURE__ */ new Map();
+  const results = Array.from({ length: items.length });
+  const seenKeys = /* @__PURE__ */ new Map();
+  for (const [index, { key }] of validated.entries()) {
+    if (key === void 0) {
+      results[index] = void 0;
+      continue;
+    }
+    const previousIndex = seenKeys.get(key);
+    if (previousIndex !== void 0) {
+      results[index] = results[previousIndex];
+      continue;
+    }
+    seenKeys.set(key, index);
+    const existing = existingByKey.get(key);
+    if (existing === void 0) {
+      results[index] = void 0;
+      continue;
+    }
+    const existingRow = await backend.getNode(
+      ctx.graphId,
+      existing.concrete_kind,
+      existing.node_id
+    );
+    if (existingRow === void 0 || existingRow.deleted_at !== void 0) {
+      results[index] = void 0;
+      continue;
+    }
+    results[index] = rowToNode(existingRow);
+  }
+  return results;
+}
+function resolveNodeIndex(graph, kind, indexName) {
+  getNodeRegistration(graph, kind);
+  const declaration = graph.indexes?.find(
+    (candidate) => candidate.entity === "node" && candidate.kind === kind && candidate.name === indexName
+  );
+  if (declaration?.entity !== "node") {
+    throw new chunkNI72YOJB_cjs.NodeIndexNotFoundError(indexName, kind);
+  }
+  if (declaration.method !== void 0) {
+    throw new chunkNI72YOJB_cjs.ConfigurationError(
+      `bulkFindByIndex cannot probe index "${indexName}" (method "${declaration.method}"): only btree indexes serve equality probes.`,
+      { indexName, kind, method: declaration.method }
+    );
+  }
+  return declaration;
+}
+var INDEX_PROBE_EXPECTED_TYPEOF = {
+  string: "string",
+  number: "number",
+  boolean: "boolean"
+};
+function validateIndexProbeValue(value, valueType, pointer, kind) {
+  if (value === void 0 || value === null) return;
+  if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean" && !(value instanceof Date)) {
+    throw indexProbeTypeError(
+      pointer,
+      kind,
+      "a scalar (string, number, boolean, or Date)",
+      value
+    );
+  }
+  if (valueType === "date") {
+    if (value instanceof Date || typeof value === "string") return;
+    throw indexProbeTypeError(
+      pointer,
+      kind,
+      "date (Date or ISO string)",
+      value
+    );
+  }
+  const expected = INDEX_PROBE_EXPECTED_TYPEOF[valueType ?? "unknown"];
+  if (expected === void 0) return;
+  if (typeof value !== expected) {
+    throw indexProbeTypeError(pointer, kind, expected, value);
+  }
+}
+function indexProbeTypeError(pointer, kind, expected, value) {
+  return new chunkNI72YOJB_cjs.ValidationError(
+    `Index probe value for "${pointer}" on node kind "${kind}" has an incompatible type`,
+    {
+      entityType: "node",
+      kind,
+      issues: [
+        {
+          path: pointer,
+          message: `Expected ${expected}, received ${typeof value}`,
+          code: "invalid_type"
+        }
+      ]
+    }
+  );
+}
+function coerceIndexProbeBind(value, adapter) {
+  return adapter.bindValue(normalizeProbeScalar(value));
+}
+function normalizeProbeScalar(value) {
+  return value instanceof Date ? value.toISOString() : value;
+}
+var PROBE_NULL_TAG = 0;
+var PROBE_VALUE_TAG = 1;
+function canonicalIndexProbeKey(probe) {
+  return JSON.stringify(
+    probe.map(
+      (value) => value === void 0 || value === null ? [PROBE_NULL_TAG] : [PROBE_VALUE_TAG, normalizeProbeScalar(value)]
+    )
+  );
+}
+async function executeNodeBulkFindByIndex(ctx, kind, indexName, items, backend, options) {
+  if (items.length === 0) return [];
+  const index = resolveNodeIndex(ctx.graph, kind, indexName);
+  if (index.fields.length === 0) {
+    throw new chunkNI72YOJB_cjs.ConfigurationError(
+      `bulkFindByIndex requires an index with at least one prop-based field on index "${indexName}" (node kind "${kind}")`,
+      { indexName, kind },
+      {
+        suggestion: "bulkFindByIndex probes by prop values from each item; an index declared with only keySystemColumns/coveringFields (no fields) has nothing to probe by."
+      }
+    );
+  }
+  if (index.fieldValueTypes.includes("date")) {
+    throw new chunkNI72YOJB_cjs.ConfigurationError(
+      `bulkFindByIndex does not support date-typed key fields on index "${indexName}" (node kind "${kind}")`,
+      { indexName, kind },
+      {
+        suggestion: "Date index keys compare differently across SQLite and PostgreSQL. Use a string-encoded key field, or query date predicates via store.query(...).where(...)."
+      }
+    );
+  }
+  const limitPerInput = options?.limitPerInput;
+  if (limitPerInput !== void 0 && (!Number.isInteger(limitPerInput) || limitPerInput <= 0)) {
+    throw new chunkNI72YOJB_cjs.ValidationError(
+      "bulkFindByIndex limitPerInput must be a positive integer",
+      {
+        entityType: "node",
+        kind,
+        issues: [
+          {
+            path: "limitPerInput",
+            message: `Expected a positive integer, received ${String(limitPerInput)}`,
+            code: "invalid_value"
+          }
+        ]
+      }
+    );
+  }
+  const adapter = chunk4UGOKMI5_cjs.getDialect(backend.dialect);
+  const probes = items.map(
+    (item) => index.fields.map((pointer, position) => {
+      const value = chunkA7J2YDDI_cjs.resolveJsonPointer(item.props, pointer);
+      validateIndexProbeValue(
+        value,
+        index.fieldValueTypes[position],
+        pointer,
+        kind
+      );
+      return value;
+    })
+  );
+  const groupByKey = /* @__PURE__ */ new Map();
+  const groupProbes = [];
+  const groupToInputs = [];
+  for (const [inputIndex, probe] of probes.entries()) {
+    const key = canonicalIndexProbeKey(probe);
+    const existing = groupByKey.get(key);
+    if (existing === void 0) {
+      groupByKey.set(key, groupProbes.length);
+      groupProbes.push(probe);
+      groupToInputs.push([inputIndex]);
+      continue;
+    }
+    groupToInputs[existing]?.push(inputIndex);
+  }
+  const schema = backend.tableNames ? chunkNFCVHQ5P_cjs.createSqlSchema(backend.tableNames) : chunkNFCVHQ5P_cjs.DEFAULT_SQL_SCHEMA;
+  const compileContext = {
+    dialect: backend.dialect,
+    propsColumn: chunkVCRRKBLN_cjs.sql.raw(`"props"`),
+    systemColumn: (column) => chunkVCRRKBLN_cjs.sql.raw(`"${column}"`)
+  };
+  const fieldKeys = chunk4UGOKMI5_cjs.compileNodeIndexFieldKeys(index, compileContext);
+  const groupPredicates = groupProbes.map(
+    (probe) => chunkVCRRKBLN_cjs.sql`(${chunkVCRRKBLN_cjs.sql.join(
+      fieldKeys.map((fieldKey, position) => {
+        const value = probe[position];
+        if (value === void 0 || value === null) {
+          return chunkVCRRKBLN_cjs.sql`${fieldKey} IS NULL`;
+        }
+        return adapter.nullSafeEquals(
+          fieldKey,
+          chunkVCRRKBLN_cjs.sql`${coerceIndexProbeBind(value, adapter)}`
+        );
+      }),
+      chunkVCRRKBLN_cjs.sql` AND `
+    )})`
+  );
+  const caseBranches = groupPredicates.map(
+    (predicate, group) => chunkVCRRKBLN_cjs.sql`WHEN ${predicate} THEN ${chunkVCRRKBLN_cjs.sql.raw(String(group))}`
+  );
+  const probeIndexExpr = chunkVCRRKBLN_cjs.sql`CASE ${chunkVCRRKBLN_cjs.sql.join(caseBranches, chunkVCRRKBLN_cjs.sql` `)} ELSE NULL END`;
+  const conditions = [
+    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(chunk4UGOKMI5_cjs.compileIndexWhere(compileContext, index.where));
+  }
+  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 ? 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(
+    chunkVCRRKBLN_cjs.asCompiledRowsSql(query)
+  );
+  const matches = limitPerInput !== void 0 && !capInSql ? capMatchesPerGroup(rawMatches, limitPerInput) : rawMatches;
+  const nodesById = await hydrateNodesById(
+    backend,
+    ctx.graphId,
+    kind,
+    matches.map((match) => match.id)
+  );
+  const results = Array.from({ length: items.length }, () => []);
+  for (const match of matches) {
+    const node = nodesById.get(match.id);
+    if (node === void 0) continue;
+    const inputs = groupToInputs[match.probe_idx];
+    if (inputs === void 0) continue;
+    for (const inputIndex of inputs) {
+      results[inputIndex]?.push(node);
+    }
+  }
+  return results;
+}
+function capMatchesPerGroup(matches, limitPerInput) {
+  const perGroupCount = /* @__PURE__ */ new Map();
+  const capped = [];
+  for (const match of matches) {
+    const count = perGroupCount.get(match.probe_idx) ?? 0;
+    if (count >= limitPerInput) continue;
+    perGroupCount.set(match.probe_idx, count + 1);
+    capped.push(match);
+  }
+  return capped;
+}
+async function hydrateNodesById(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;
+    nodesById.set(id, rowToNode(row));
+  }
+  return nodesById;
+}
+async function executeNodeBulkGetOrCreateByConstraint(ctx, kind, constraintName, items, backend, options) {
+  if (items.length === 0) return [];
+  const ifExists = options?.ifExists ?? "return";
+  const registration = getNodeRegistration(ctx.graph, kind);
+  const nodeKind = registration.type;
+  const constraint = resolveConstraint(ctx.graph, kind, constraintName);
+  const validated = validateAndComputeKeys(nodeKind, kind, constraint, items);
+  const uniqueKeys = collectUniqueKeys(validated);
+  const kindsToCheck = chunkE4WNQBEF_cjs.getKindsForUniquenessCheck(
+    kind,
+    constraint.scope,
+    ctx.registry
+  );
+  async function attempt() {
+    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
+        });
+      }
+    }
+    const results = Array.from({ length: items.length });
+    if (toCreate.length > 0) {
+      const createInputs = toCreate.map((entry) => entry.input);
+      const createdNodes = await executeNodeCreateBatch(
+        ctx,
+        createInputs,
+        backend,
+        { propsPreValidated: true }
+      );
+      for (const [batchIndex, entry] of toCreate.entries()) {
+        results[entry.index] = {
+          node: chunkN66HCGCY_cjs.requireDefined(createdNodes[batchIndex]),
+          action: "created"
+        };
+      }
+    }
+    for (const entry of toFetch) {
+      const { index, concreteKind, validatedProps, nodeId } = entry;
+      const existingRow = await backend.getNode(
+        ctx.graphId,
+        concreteKind,
+        nodeId
+      );
+      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;
+  }
+  try {
+    return await attempt();
+  } catch (error) {
+    if (!(error instanceof chunkNI72YOJB_cjs.UniquenessError)) throw error;
+    return attempt();
+  }
+}
+
+exports.checkCardinalityConstraint = checkCardinalityConstraint;
+exports.createNodeBatchValidationBackend = createNodeBatchValidationBackend;
+exports.edgeWriteNeedsConstraintFence = edgeWriteNeedsConstraintFence;
+exports.executeNodeBulkFindByConstraint = executeNodeBulkFindByConstraint;
+exports.executeNodeBulkFindByIndex = executeNodeBulkFindByIndex;
+exports.executeNodeBulkGetOrCreateByConstraint = executeNodeBulkGetOrCreateByConstraint;
+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.nodeUpsertDirtyCheck = nodeUpsertDirtyCheck;
+exports.primeBatchValidationCaches = primeBatchValidationCaches;
+exports.rowToEdge = rowToEdge;
+exports.rowToEdgeMeta = rowToEdgeMeta;
+exports.rowToNode = rowToNode;
+exports.rowToNodeMeta = rowToNodeMeta;
+exports.withAlreadyExistsTranslation = withAlreadyExistsTranslation;
+//# sourceMappingURL=chunk-7GT72YHH.cjs.map
+//# sourceMappingURL=chunk-7GT72YHH.cjs.map