@nicia-ai/typegraph 0.49.0 → 0.51.0

package/dist/chunk-KF6K7TGH.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/store/row-mappers.ts","../src/store/constraints.ts","../src/store/validity-end.ts","../src/store/operations/already-exists.ts","../src/store/operations/node-operations.ts"],"names":["row"],"mappings":"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","file":"chunk-KF6K7TGH.js","sourcesContent":["/**\n * Row Mappers for Store\n *\n * Transforms database rows into typed Node and Edge objects.\n */\nimport {\n  type EdgeRow as BackendEdgeRow,\n  type NodeRow as BackendNodeRow,\n  rowPropsToObject,\n} from \"../backend/types\";\nimport {\n  filterReservedKeys,\n  RESERVED_EDGE_KEYS,\n  RESERVED_NODE_KEYS,\n} from \"./reserved-keys\";\nimport { type Edge, type EdgeMeta, type Node, type NodeMeta } from \"./types\";\n\n/**\n * Raw node row from database (without graph_id).\n * Derived from BackendNodeRow so BackendNodeRow is assignable without casts.\n */\nexport type NodeRow = Omit<BackendNodeRow, \"graph_id\">;\n\n/**\n * Raw edge row from database (without graph_id).\n * Derived from BackendEdgeRow so BackendEdgeRow is assignable without casts.\n */\nexport type EdgeRow = Omit<BackendEdgeRow, \"graph_id\">;\n\n/**\n * Converts null to undefined for consistent typing.\n * Database backends return null for missing values, but our types use undefined.\n */\nfunction nullToUndefined<T>(value: T | null | undefined): T | undefined {\n  return value === null ? undefined : value;\n}\n\n/**\n * Transforms a database row into a typed Node object.\n *\n * Props are spread at top level, metadata goes under `meta`.\n * Reserved keys (id, kind, meta) in props are filtered out to prevent collisions.\n * Null values from database are normalized to undefined.\n */\nexport function rowToNode(row: NodeRow): Node {\n  const rawProps = rowPropsToObject(row.props);\n  const props = filterReservedKeys(rawProps, RESERVED_NODE_KEYS);\n  return {\n    kind: row.kind,\n    id: row.id as Node[\"id\"],\n    meta: rowToNodeMeta(row),\n    ...props,\n  };\n}\n\nexport function rowToNodeMeta(\n  row: Pick<\n    NodeRow,\n    | \"version\"\n    | \"valid_from\"\n    | \"valid_to\"\n    | \"created_at\"\n    | \"updated_at\"\n    | \"deleted_at\"\n  >,\n): NodeMeta {\n  return {\n    version: row.version,\n    validFrom: nullToUndefined(row.valid_from),\n    validTo: nullToUndefined(row.valid_to),\n    createdAt: row.created_at,\n    updatedAt: row.updated_at,\n    deletedAt: nullToUndefined(row.deleted_at),\n  };\n}\n\n/**\n * Transforms a database row into a typed Edge object.\n *\n * Props are spread at top level, metadata goes under `meta`.\n * Reserved keys in props are filtered out to prevent collisions.\n * Null values from database are normalized to undefined.\n */\nexport function rowToEdge(row: EdgeRow): Edge {\n  const rawProps = rowPropsToObject(row.props);\n  const props = filterReservedKeys(rawProps, RESERVED_EDGE_KEYS);\n  return {\n    id: row.id,\n    kind: row.kind,\n    fromKind: row.from_kind,\n    fromId: row.from_id,\n    toKind: row.to_kind,\n    toId: row.to_id,\n    meta: rowToEdgeMeta(row),\n    ...props,\n  } as Edge;\n}\n\nexport function rowToEdgeMeta(\n  row: Pick<\n    EdgeRow,\n    \"valid_from\" | \"valid_to\" | \"created_at\" | \"updated_at\" | \"deleted_at\"\n  >,\n): EdgeMeta {\n  return {\n    validFrom: nullToUndefined(row.valid_from),\n    validTo: nullToUndefined(row.valid_to),\n    createdAt: row.created_at,\n    updatedAt: row.updated_at,\n    deletedAt: nullToUndefined(row.deleted_at),\n  };\n}\n","/**\n * Constraint Checking for Store Operations\n *\n * Handles checking disjointness and cardinality constraints.\n *\n * ## The invariant these probes depend on\n *\n * **A declared constraint's probe and the write it guards commit under one\n * per-graph mutual exclusion, on every backend.** Every check in this module is\n * an APPLICATION probe: it reads, decides, and returns, and the caller then\n * writes. Nothing in the schema re-decides at write time, because for each of\n * these constraints the available key covers a different axis than the\n * constraint declares:\n *\n * - edge cardinality `one` / `unique` / `oneActive` is a predicate over\n *   `(kind, from)` or `(kind, from, to)`, while the edges table's only\n *   uniqueness is its `(graph_id, id)` primary key;\n * - disjointness is a predicate over `(graph_id, id)` ACROSS kinds, while the\n *   nodes primary key is `(graph_id, kind, id)` — the same id under a disjoint\n *   kind is a different row by construction;\n * - `scope: \"kindWithSubClasses\"` uniqueness probes the root kind and every\n *   descendant, while `insertUniquenessEntries` reserves one row under the\n *   node's OWN kind and the uniques primary key is\n *   `(graph_id, node_kind, constraint_name, key)` — sibling kinds are distinct\n *   rows that can never collide (see {@link file://./uniqueness.ts}).\n *\n * So the probe is only as good as the serialization around it. SQLite supplies\n * that for free (`BEGIN IMMEDIATE` admits one writer per database). PostgreSQL\n * supplied it only when history or revision tracking was enabled, because only\n * those took the per-graph advisory lock — leaving a default PostgreSQL store\n * open to two writers that both read \"no conflict\" and both commit.\n * {@link edgeWriteNeedsConstraintFence} / {@link nodeWriteNeedsConstraintFence}\n * are what the write paths ask so they take that same per-graph lock whenever\n * one of these probes is in play, and only then.\n */\nimport { type GraphBackend, type TransactionBackend } from \"../backend/types\";\nimport {\n  checkCardinality,\n  checkDisjointness,\n  checkUniqueEdge,\n  getKindsForUniquenessCheck,\n} from \"../constraints\";\nimport { type Cardinality, type UniqueConstraint } from \"../core/types\";\nimport { type KindRegistry } from \"../registry/kind-registry\";\n\n/**\n * Context for constraint operations.\n */\nexport type ConstraintContext = Readonly<{\n  graphId: string;\n  registry: KindRegistry;\n  backend: GraphBackend | TransactionBackend;\n}>;\n\n/**\n * WHICH declared constraint makes a write constrained.\n *\n * The classification names the reason rather than answering yes/no, because\n * the reason is load-bearing twice over: it is what the fence is taken FOR, and\n * — on a backend that cannot hold the fence — it is what the refusal has to\n * tell the caller. \"This backend cannot fence constrained writes\" is unusable\n * advice; \"your `cardinality: 'one'` edge cannot be enforced here\" is\n * actionable, and only the classifier knows which it was.\n */\nexport type ConstraintFenceReason =\n  /** Edge cardinality `one` / `unique` / `oneActive`. */\n  | \"edgeCardinality\"\n  /** `getOrCreateByEndpoints` converging on a match key no key backs. */\n  | \"edgeMatchKeyConvergence\"\n  /** A `disjointWith` axiom, probed across kinds the node PK cannot span. */\n  | \"nodeDisjointness\"\n  /** A unique constraint whose scope spans more than the node's own kind. */\n  | \"nodeUniquenessScope\";\n\n/**\n * The constraint that makes an edge write of this cardinality constrained, or\n * `undefined` when it is not.\n *\n * `many` declares no constraint, so its create runs no cardinality probe and\n * must NOT pay for the lock — the fence is for writes that check something, not\n * for writes in general. Every other cardinality counts or existence-tests\n * sibling edges before inserting, and nothing in the schema repeats that test.\n *\n * The one owner of this classification: `checkCardinalityConstraint`'s `many`\n * arm and this predicate are the same decision seen from two sides, and a\n * second inline `!== \"many\"` at a write path would be the copy that drifts.\n */\nexport function edgeWriteNeedsConstraintFence(\n  cardinality: Cardinality,\n): ConstraintFenceReason | undefined {\n  return cardinality === \"many\" ? undefined : \"edgeCardinality\";\n}\n\n/**\n * The constraint that makes a node write of this kind constrained, or\n * `undefined` when it is not. A kind can qualify on both counts; the reason\n * reported is the first that applies, which is enough to name the class in a\n * refusal.\n *\n * Two probe families qualify, and they are reached by different operations:\n *\n * - **Disjointness** is probed only where a node comes into existence under a\n *   kind — the create/resurrect preparation. An in-place update cannot change a\n *   node's kind, so it re-derives no cross-kind verdict and needs no fence for\n *   this reason.\n * - **Shared-scope uniqueness** is probed by create AND update. It qualifies\n *   only when the constraint's scope actually spans more than the node's own\n *   kind: a single-kind scope probes exactly the `(graph_id, node_kind,\n *   constraint_name, key)` row that `insertUnique` then reserves, so the\n *   uniques primary key IS the fence and the write needs no other. Deciding\n *   this by expanding the scope — rather than by testing `scope !== \"kind\"` —\n *   keeps the answer true for a `kindWithSubClasses` constraint on a kind that\n *   has no hierarchy, which is backed by its own key exactly like a `kind`\n *   scope.\n */\nexport function nodeWriteNeedsConstraintFence(\n  registry: KindRegistry,\n  kind: string,\n  uniqueConstraints: readonly UniqueConstraint[],\n  operation: \"create\" | \"update\",\n): ConstraintFenceReason | undefined {\n  if (operation === \"create\" && registry.getDisjointKinds(kind).length > 0) {\n    return \"nodeDisjointness\";\n  }\n  const sharedScope = uniqueConstraints.some(\n    (constraint) =>\n      getKindsForUniquenessCheck(kind, constraint.scope, registry).length > 1,\n  );\n  return sharedScope ? \"nodeUniquenessScope\" : undefined;\n}\n\n/**\n * Checks disjointness constraints for a node.\n *\n * Ensures that a node with a given ID doesn't exist in any disjoint kinds.\n *\n * @throws ValidationError if disjointness constraint is violated\n */\nexport async function checkDisjointnessConstraint(\n  ctx: ConstraintContext,\n  kind: string,\n  id: string,\n): Promise<void> {\n  // Get all kinds that are disjoint with this kind\n  const disjointKinds = ctx.registry.getDisjointKinds(kind);\n\n  // For each disjoint kind, check if a node with this ID exists\n  for (const disjointKind of disjointKinds) {\n    const existing = await ctx.backend.getNode(ctx.graphId, disjointKind, id);\n    if (existing && !existing.deleted_at) {\n      const error = checkDisjointness(id, kind, [disjointKind], ctx.registry);\n      if (error) throw error;\n    }\n  }\n}\n\n/**\n * Checks cardinality constraints for an edge.\n *\n * @throws CardinalityError if cardinality constraint is violated\n */\nexport async function checkCardinalityConstraint(\n  ctx: ConstraintContext,\n  edgeKind: string,\n  cardinality: \"many\" | \"one\" | \"unique\" | \"oneActive\",\n  fromKind: string,\n  fromId: string,\n  toKind: string,\n  toId: string,\n  validTo: string | undefined,\n): Promise<void> {\n  switch (cardinality) {\n    case \"many\": {\n      // No constraint - allow any number of edges\n      return;\n    }\n\n    case \"one\": {\n      // At most one edge of this kind from this source\n      const count = await ctx.backend.countEdgesFrom({\n        graphId: ctx.graphId,\n        edgeKind,\n        fromKind,\n        fromId,\n      });\n      const error = checkCardinality(\n        edgeKind,\n        fromKind,\n        fromId,\n        \"one\",\n        count,\n        false,\n      );\n      if (error) throw error;\n      return;\n    }\n\n    case \"unique\": {\n      // At most one edge between this specific source-target pair\n      const exists = await ctx.backend.edgeExistsBetween({\n        graphId: ctx.graphId,\n        edgeKind,\n        fromKind,\n        fromId,\n        toKind,\n        toId,\n      });\n      const error = checkUniqueEdge(\n        edgeKind,\n        fromKind,\n        fromId,\n        toKind,\n        toId,\n        exists ? 1 : 0,\n      );\n      if (error) throw error;\n      return;\n    }\n\n    case \"oneActive\": {\n      // At most one active edge (valid_to IS NULL) from this source\n      // Only check if the new edge will be active (validTo is not set)\n      if (validTo !== undefined) {\n        // New edge is already ended, no active constraint to check\n        return;\n      }\n      const count = await ctx.backend.countEdgesFrom({\n        graphId: ctx.graphId,\n        edgeKind,\n        fromKind,\n        fromId,\n        activeOnly: true,\n      });\n      const error = checkCardinality(\n        edgeKind,\n        fromKind,\n        fromId,\n        \"oneActive\",\n        count,\n        count > 0,\n      );\n      if (error) throw error;\n      return;\n    }\n  }\n}\n","import type { GraphBackend, TransactionBackend } from \"../backend/types\";\nimport type { KindEntity } from \"../core/types\";\nimport { ConfigurationError, ValidationError } from \"../errors\";\n\nexport type ValidityEndMutationInput = Readonly<{\n  validTo?: string;\n  clearValidTo?: true;\n}>;\n\n/** One owner for the mutually-exclusive validity-end write contract. */\nexport function assertValidityEndMutation(\n  input: ValidityEndMutationInput,\n  context: Readonly<{ entityType: KindEntity; kind: string; id?: string }>,\n): void {\n  if (input.validTo === undefined || input.clearValidTo !== true) return;\n  throw new ValidationError(\n    '\"validTo\" and \"clearValidTo\" are mutually exclusive',\n    {\n      ...context,\n      operation: \"update\",\n      issues: [\n        {\n          path: \"clearValidTo\",\n          message: 'Pass either \"validTo\" or \"clearValidTo\", not both',\n        },\n      ],\n    },\n  );\n}\n\n/** The end a row will hold after applying this mutation. */\nexport function validityEndAfterMutation(\n  input: ValidityEndMutationInput,\n  current: string | undefined,\n): string | undefined {\n  if (input.clearValidTo === true) return undefined;\n  return input.validTo ?? current;\n}\n\n/**\n * Custom backends explicitly opt in to clearing. The store refuses before\n * invoking a backend that has not promised to apply the new state.\n */\nexport function assertClearValidToSupported(\n  backend: GraphBackend | TransactionBackend,\n  entityType: KindEntity,\n): void {\n  if (backend.capabilities.clearValidTo === true) return;\n  throw new ConfigurationError(\n    `This backend does not support clearing ${entityType} validTo`,\n    {\n      code: \"CLEAR_VALID_TO_UNSUPPORTED\",\n      entityType,\n    },\n  );\n}\n","/**\n * The create API's \"this identity is already taken\" refusal, and the one\n * translation that turns a driver's duplicate-key report into it.\n *\n * A create learns an id is taken one of two ways: its own existence probe sees\n * the row, or the engine refuses the INSERT. The engine's report used to escape\n * as a `DrizzleQueryError` whose `.message` is the raw SQL text (issue #410), so\n * one condition surfaced as a typed user error down one path and an opaque system\n * error down the other, and a caller could not branch on it at all. Both paths\n * now raise the SAME error, carrying {@link ENTITY_ALREADY_EXISTS_CODE} on its\n * issue.\n *\n * The engine's path is reached two ways, and the second is not a race:\n *\n *  - A NODE create probes first, but the probe and the INSERT are two statements.\n *    PostgreSQL under its default READ COMMITTED does not serialize two write\n *    transactions, so both can probe an absent row and both can then insert it,\n *    and the loser finds out from the INSERT. SQLite cannot reach this shape:\n *    `BEGIN IMMEDIATE` gives the writer slot to one transaction at a time (pinned\n *    by the business-transaction write-lock cases in\n *    `tests/backends/sqlite/sqlite-backend.test.ts`), so the loser's probe runs\n *    after the winner committed and its verdict stands.\n *  - An EDGE create has no existence probe at all — its id is caller-supplied or\n *    freshly generated — so the engine's refusal is the ONLY report on EVERY\n *    backend, race or no race. That is why the classification covers both\n *    dialects and not just PostgreSQL.\n *\n * The backend does the classification (it owns the relation and constraint names\n * the engine reports); this module owns the store-level judgement of what that\n * classification means to a caller.\n */\nimport { type KindEntity } from \"../../core/types\";\nimport {\n  DatabaseOperationError,\n  ENTITY_ALREADY_EXISTS_CODE,\n  ValidationError,\n} from \"../../errors\";\n\n/** An entity the refused statement tried to create. */\ntype AttemptedCreate = Readonly<{ kind: string; id: string }>;\n\n/** Sentence-initial and mid-sentence names for each entity. */\nconst ENTITY_LABELS = {\n  node: { title: \"Node\", article: \"A node\" },\n  edge: { title: \"Edge\", article: \"An edge\" },\n} as const satisfies Record<\n  KindEntity,\n  Readonly<{ title: string; article: string }>\n>;\n\nfunction alreadyExistsError(\n  entity: KindEntity,\n  kind: string,\n  id: string | undefined,\n  detail: string,\n  cause: unknown,\n): ValidationError {\n  const label = ENTITY_LABELS[entity];\n  return new ValidationError(\n    `${label.title} already exists: ${detail}`,\n    {\n      entityType: entity,\n      kind,\n      operation: \"create\",\n      ...(id === undefined ? {} : { id }),\n      issues: [\n        {\n          path: \"id\",\n          code: ENTITY_ALREADY_EXISTS_CODE,\n          message: `${label.article} with this ID already exists`,\n        },\n      ],\n    },\n    {\n      suggestion: `Use a different ID or update the existing ${entity}.`,\n      ...(cause === undefined ? {} : { cause }),\n    },\n  );\n}\n\n/**\n * The refusal a create raises for a taken id: the probe path's error, and the\n * target of the driver-report translation below.\n */\nexport function createAlreadyExistsError(\n  entity: KindEntity,\n  kind: string,\n  id: string,\n): ValidationError {\n  return alreadyExistsError(entity, kind, id, `${kind}/${id}`, undefined);\n}\n\nfunction isDuplicateKeyInsertError(\n  error: unknown,\n  entity: KindEntity,\n): error is DatabaseOperationError {\n  return (\n    error instanceof DatabaseOperationError &&\n    error.details.operation === \"insert\" &&\n    error.details.entity === entity &&\n    error.details.reason === \"duplicate_key\"\n  );\n}\n\n/**\n * Rethrows a classified duplicate-key insert as {@link createAlreadyExistsError},\n * and anything else untouched.\n *\n * A single insert names the row it lost on exactly. A multi-row one cannot: the\n * engine reports that the statement collided without saying which row did, and\n * the transaction is already aborted, so there is nothing left to probe. The\n * refusal then names the statement instead of inventing an attribution — same\n * error type, same issue code, `details.id` simply absent. The count is the\n * refused STATEMENT's rows, which is the caller's batch only until the backend\n * chunks it, so the message claims no more than that. Every batch here comes\n * from one collection, so the kind is always known.\n */\nfunction rethrowAsAlreadyExists(error: unknown, entity: KindEntity): never {\n  if (!isDuplicateKeyInsertError(error, entity)) throw error;\n  const attempted: readonly AttemptedCreate[] = error.details.attempted ?? [];\n  const first = attempted[0];\n  if (first === undefined) throw error;\n  if (attempted.length === 1) {\n    throw alreadyExistsError(\n      entity,\n      first.kind,\n      first.id,\n      `${first.kind}/${first.id}`,\n      error,\n    );\n  }\n  throw alreadyExistsError(\n    entity,\n    first.kind,\n    undefined,\n    `one of the ${attempted.length} ${first.kind} ids in the refused insert`,\n    error,\n  );\n}\n\n/**\n * Runs an insert (or a group of inserts issued as one unit) and converts a\n * duplicate-key refusal into the create API's already-exists error.\n */\nexport async function withAlreadyExistsTranslation<T>(\n  entity: KindEntity,\n  run: () => Promise<T>,\n): Promise<T> {\n  try {\n    return await run();\n  } catch (error) {\n    rethrowAsAlreadyExists(error, entity);\n  }\n}\n","/**\n * Node Operations for Store\n *\n * Handles node CRUD operations: create, update, delete.\n *\n * ## A write asserts every component its verdict READ\n *\n * `performNodeUpdate` is a probe-and-write pair: it reads the row, decides from\n * what it finds, and then writes. Under PostgreSQL READ COMMITTED a concurrent\n * `hardDelete` + recreate re-resolves `(graph_id, kind, id)` between the two,\n * so anything the decision consumed and the statement does not restate is a\n * decision that can land on a row it was never computed for — and the write\n * reports success. Every value read off the probed row, and where it is\n * asserted:\n *\n *  - `kind` / `id` — the write key itself, restated in every UPDATE's `WHERE`.\n *  - `deleted_at` (which leg runs, and whether to sample a resurrection\n *    instant) — asserted as `deleted_at IS NULL` on the in-place leg and\n *    `IS NOT NULL` on the resurrecting one, so each leg can only hit a row in\n *    the state it was chosen for.\n *  - `valid_from` — asserted via `UpdateNodeParams.expectedValidFrom` WHEN the\n *    window verdict read it ({@link ValidityWindowVerdict}): the caller stated\n *    a `validFrom` to compare against the row's, or a lone `validTo` to invert\n *    against it. A plain `update({ props })` states no window, so the verdict\n *    is independent of the row's bound and the write carries no predicate for\n *    it — the same \"only what it asserted\" rule the edge identity components\n *    follow, and for the same reason: inventing a predicate for a component the\n *    caller made no claim about refuses writes that are legitimate. A\n *    resurrection is judged against the write instant rather than the row's\n *    bound, so it asserts none either; its own tombstone predicate fences it.\n *  - `props` — read twice, as the merge base for the caller's partial update\n *    and as the `oldProps` side of the uniqueness diff — and NOT assertable: a\n *    props blob is TEXT on SQLite and `jsonb` on PostgreSQL, and neither\n *    comparison is stable under key reordering. Bounded instead, two ways: the\n *    sidecar writes are gated on the primary UPDATE's rowcount (see\n *    `applyNodeUpdate`), and\n *    {@link performNodeUpdateWithResurrectionRecovery} re-reads and re-merges\n *    whenever a predicate catches a replaced row.\n *  - the uniques-table row behind `getOrCreateByConstraint` — read to resolve\n *    WHICH node the key names. Not assertable by the node UPDATE (it is a\n *    different table); bounded by the constraint write fence, which makes the\n *    probe and the write it authorizes commit under one per-graph mutual\n *    exclusion. Its `deleted_at`, however, is NOT the owner of \"does this write\n *    resurrect\" — both the single and bulk paths read that from the node row\n *    they are about to write, because one decision with two owners drifts.\n */\nimport { deriveBackend } from \"../../backend/derive-backend\";\nimport {\n  type GraphBackend,\n  type InsertNodeParams,\n  isLiveNodeRow,\n  type NodeRow as BackendNodeRow,\n  rowPropsToObject,\n  type TransactionBackend,\n  type UniqueRow,\n} from \"../../backend/types\";\nimport {\n  checkWherePredicate,\n  computeUniqueKey,\n  getKindsForUniquenessCheck,\n} from \"../../constraints\";\nimport { type GraphDef } from \"../../core/define-graph\";\nimport { assertJsonValue } from \"../../core/json-value\";\nimport {\n  type JsonValue,\n  type KindEntity,\n  type NodeType,\n  type UniqueConstraint,\n} from \"../../core/types\";\nimport {\n  ConfigurationError,\n  DatabaseOperationError,\n  KindNotFoundError,\n  NodeConstraintNotFoundError,\n  NodeIndexNotFoundError,\n  NodeNotFoundError,\n  UniquenessError,\n  ValidationError,\n} from \"../../errors\";\nimport { validateNodeProps } from \"../../errors/validation\";\nimport { refKey } from \"../../identity/service\";\nimport {\n  compileIndexWhere,\n  compileNodeIndexFieldKeys,\n  type IndexCompilationContext,\n} from \"../../indexes/compiler\";\nimport { type NodeIndexDeclaration } from \"../../indexes/types\";\nimport { type ValueType } from \"../../query/ast\";\nimport {\n  createSqlSchema,\n  DEFAULT_SQL_SCHEMA,\n  type SqlSchema,\n} from \"../../query/compiler/schema\";\nimport { getDialect } from \"../../query/dialect\";\nimport { type DialectAdapter } from \"../../query/dialect/types\";\nimport { type JsonPointer, resolveJsonPointer } from \"../../query/json-pointer\";\nimport { sql, type SqlFragment } from \"../../query/sql-fragment\";\nimport type { CompiledSelectSql } from \"../../query/sql-intent\";\nimport { asCompiledRowsSql } from \"../../query/sql-intent\";\nimport { type KindRegistry } from \"../../registry/kind-registry\";\nimport { canonicalEqual } from \"../../schema/canonical\";\nimport {\n  assertOrderedValidityWindow,\n  assertWritableValidityWindow,\n  nowIso,\n  preservesImmutableLowerBound,\n  resolveStampedValidityLowerBound,\n  validateOptionalCanonicalIsoDate,\n} from \"../../utils/date\";\nimport { generateId } from \"../../utils/id\";\nimport { createDataKeyedBag, hasOwnKey } from \"../../utils/object\";\nimport { requireDefined } from \"../../utils/presence\";\nimport { encodeTupleKey } from \"../../utils/tuple-key\";\nimport { type UpsertDirtyCheck } from \"../collections/coalesce\";\nimport { type UpsertUpdateNodeInput } from \"../collections/node-collection\";\nimport {\n  checkDisjointnessConstraint,\n  type ConstraintContext,\n  type ConstraintFenceReason,\n  nodeWriteNeedsConstraintFence,\n} from \"../constraints\";\nimport { getEmbeddingFields } from \"../embedding-sync\";\nimport { getSearchableFields } from \"../fulltext-sync\";\nimport {\n  nodeInsertDispatch,\n  runInsertBatch,\n  runInsertBatchReturning,\n  runInsertNoReturn,\n} from \"../insert-dispatch\";\nimport { getNodeRowsByIds } from \"../node-fetch\";\nimport { type GraphWriteLock } from \"../recorded-capture/clock\";\nimport { type NodeRow, rowToNode } from \"../row-mappers\";\nimport {\n  type BulkOperationHookContext,\n  type CreateNodeInput,\n  type GetOrCreateAction,\n  type Node,\n  type NodeBulkFindByIndexOptions,\n  type NodeGetOrCreateByConstraintOptions,\n  type OperationHookContext,\n  type UpdateNodeInput,\n} from \"../types\";\nimport {\n  checkUniquenessConstraints,\n  createUniquenessContext,\n  validateResolvedNodeUniqueness,\n} from \"../uniqueness\";\nimport {\n  assertClearValidToSupported,\n  assertValidityEndMutation,\n} from \"../validity-end\";\nimport {\n  createAlreadyExistsError,\n  withAlreadyExistsTranslation,\n} from \"./already-exists\";\nimport {\n  applyNodeHardDelete,\n  applyNodeInsertSideEffects,\n  applyNodeInsertSideEffectsBatch,\n  applyNodeSoftDelete,\n  applyNodeUpdate,\n  createNodeWriteContext,\n} from \"./node-write-pipeline\";\nimport {\n  runHookedWriteOperation,\n  runInWriteTransaction,\n} from \"./write-transaction\";\n\n// ============================================================\n// Types\n// ============================================================\n\nexport type NodeOperationContext<G extends GraphDef> = Readonly<{\n  graph: G;\n  graphId: string;\n  schemaVersion: number | undefined;\n  historyEnabled: boolean;\n  revisionTrackingEnabled: boolean;\n  coalesceUnchangedUpsertsEnabled: boolean;\n  revisionSchema: SqlSchema;\n  registry: KindRegistry;\n  createOperationContext: (\n    operation: \"create\" | \"update\" | \"delete\",\n    entity: KindEntity,\n    kind: string,\n    id: string,\n  ) => OperationHookContext;\n  withOperationHooks: <T>(\n    ctx: OperationHookContext,\n    fn: () => Promise<T>,\n  ) => Promise<T>;\n  createBulkOperationContext: (\n    operation: \"updateWhere\",\n    kind: string,\n  ) => BulkOperationHookContext;\n  withBulkOperationHooks: <T extends Readonly<{ affectedCount: number }>>(\n    ctx: BulkOperationHookContext,\n    fn: () => Promise<T>,\n  ) => Promise<T>;\n  identity?: Readonly<{\n    lock: (target: GraphBackend | TransactionBackend) => Promise<void>;\n    foldCreated: (\n      target: GraphBackend | TransactionBackend,\n      references: readonly Readonly<{ kind: string; id: string }>[],\n    ) => Promise<void>;\n    detachDeleted: (\n      target: GraphBackend | TransactionBackend,\n      ref: Readonly<{ kind: string; id: string }>,\n      mode: \"soft\" | \"hard\",\n    ) => Promise<void>;\n    requireValidityEndCompatible: (\n      target: GraphBackend | TransactionBackend,\n      ref: Readonly<{ kind: string; id: string }>,\n      validTo: string,\n    ) => Promise<void>;\n  }>;\n}>;\n\ntype NodeCreatePrepared = Readonly<{\n  kind: string;\n  id: string;\n  nodeKind: NodeType;\n  validatedProps: Record<string, unknown>;\n  uniqueConstraints: readonly UniqueConstraint[];\n  insertParams: InsertNodeParams;\n  /**\n   * `true` when the caller supplied `input.id`. A generated id cannot\n   * already exist under another kind, so identity folding can skip its\n   * cross-kind probe entirely for those rows.\n   */\n  idProvided: boolean;\n  /**\n   * The soft-deleted row occupying this id, or `undefined` when the id is\n   * free. Named for what it can hold rather than what it was read as: the\n   * duplicate-existence probe in {@link finishNodeCreatePreparation} throws\n   * on a LIVE row, so what survives is always a tombstone awaiting\n   * resurrection. Carrying it here is what lets the create path route\n   * insert-vs-resurrect without re-reading the same (graph, kind, id).\n   */\n  tombstone: BackendNodeRow | undefined;\n}>;\n\ntype CachedNodeRow = Awaited<ReturnType<GraphBackend[\"getNode\"]>>;\ntype CachedUniqueRow = Awaited<ReturnType<GraphBackend[\"checkUnique\"]>>;\n\n// ============================================================\n// Helper Functions\n// ============================================================\n\n// Own-key membership, matching `store.getNodePropsSchema` and the collections\n// proxy: kind names are arbitrary identifiers, so a `toString`-named kind that\n// is NOT registered would otherwise read the inherited function as its\n// registration and fail with a `TypeError` off `registration.type` instead of\n// the `KindNotFoundError` this guard exists to raise.\nfunction getNodeRegistration<G extends GraphDef>(graph: G, kind: string) {\n  if (!hasOwnKey(graph.nodes, kind)) throw new KindNotFoundError(kind, \"node\");\n  const registration = graph.nodes[kind];\n  if (registration === undefined) throw new KindNotFoundError(kind, \"node\");\n  return registration;\n}\n\n/**\n * WHICH constraint makes this node write one whose probe no database key\n * repeats at write time, so it must take the per-graph write fence — or be\n * refused where no fence exists. The classification itself lives with the\n * constraints ({@link file://../constraints.ts nodeWriteNeedsConstraintFence});\n * this is only the graph-def lookup that feeds it.\n *\n * A kind this graph does not define answers `undefined`: choosing the fence\n * must not become the thing that reports an unknown kind, which the write path\n * raises from inside its hooked transaction where `onError` observes it.\n */\nfunction nodeFencesConstraintProbe<G extends GraphDef>(\n  ctx: Pick<NodeOperationContext<G>, \"graph\" | \"registry\">,\n  kind: string,\n  operation: \"create\" | \"update\",\n): ConstraintFenceReason | undefined {\n  if (!hasOwnKey(ctx.graph.nodes, kind)) return undefined;\n  return nodeWriteNeedsConstraintFence(\n    ctx.registry,\n    kind,\n    getNodeRegistration(ctx.graph, kind).unique ?? [],\n    operation,\n  );\n}\n\n/**\n * A batch fences when ANY item does — one transaction, so one constrained\n * member makes the whole write constrained, and the first such member names the\n * class a refusal would report.\n */\nfunction nodeBatchFencesConstraintProbe<G extends GraphDef>(\n  ctx: Pick<NodeOperationContext<G>, \"graph\" | \"registry\">,\n  inputs: readonly Readonly<{ kind: string }>[],\n  operation: \"create\" | \"update\",\n): ConstraintFenceReason | undefined {\n  for (const input of inputs) {\n    const reason = nodeFencesConstraintProbe(ctx, input.kind, operation);\n    if (reason !== undefined) return reason;\n  }\n  return undefined;\n}\n\nfunction buildNodeCacheKey(graphId: string, kind: string, id: string): string {\n  return encodeTupleKey([graphId, kind, id]);\n}\n\nfunction buildUniqueCacheKey(\n  graphId: string,\n  nodeKind: string,\n  constraintName: string,\n  key: string,\n): string {\n  return encodeTupleKey([graphId, nodeKind, constraintName, key]);\n}\n\nfunction buildInsertNodeParams(\n  graphId: string,\n  kind: string,\n  id: string,\n  props: Record<string, unknown>,\n  validFrom: string | undefined,\n  validTo: string | undefined,\n): InsertNodeParams {\n  const insertParams: {\n    graphId: string;\n    kind: string;\n    id: string;\n    props: Record<string, unknown>;\n    validFrom?: string;\n    validTo?: string;\n  } = {\n    graphId,\n    kind,\n    id,\n    props,\n  };\n  if (validFrom !== undefined) insertParams.validFrom = validFrom;\n  if (validTo !== undefined) insertParams.validTo = validTo;\n  return insertParams;\n}\n\nfunction createPendingUniqueRow(\n  graphId: string,\n  nodeKind: string,\n  constraintName: string,\n  key: string,\n  nodeId: string,\n): UniqueRow {\n  return {\n    graph_id: graphId,\n    node_kind: nodeKind,\n    constraint_name: constraintName,\n    key,\n    node_id: nodeId,\n    concrete_kind: nodeKind,\n    deleted_at: undefined,\n  };\n}\n\nfunction resolveConstraint<G extends GraphDef>(\n  graph: G,\n  kind: string,\n  constraintName: string,\n): UniqueConstraint {\n  const registration = getNodeRegistration(graph, kind);\n  const constraints = registration.unique ?? [];\n  const constraint = constraints.find(\n    (candidate) => candidate.name === constraintName,\n  );\n  if (constraint === undefined) {\n    throw new NodeConstraintNotFoundError(constraintName, kind);\n  }\n  return constraint;\n}\n\n// ============================================================\n// Batch Validation Cache\n//\n// During batch operations, multiple items may reference the same\n// nodes/unique keys. This cache avoids redundant backend lookups\n// and tracks pending (not-yet-flushed) inserts so that later items\n// in the batch can see earlier ones during validation.\n// ============================================================\n\nexport function createNodeBatchValidationBackend(\n  graphId: string,\n  registry: KindRegistry,\n  backend: GraphBackend | TransactionBackend,\n): Readonly<{\n  backend: GraphBackend | TransactionBackend;\n  registerPendingNode: (params: InsertNodeParams) => void;\n  registerPendingUniqueEntries: (\n    kind: string,\n    id: string,\n    props: Record<string, unknown>,\n    constraints: readonly UniqueConstraint[],\n  ) => void;\n  registerAppliedNodeUpdate: (\n    kind: string,\n    id: string,\n    oldProps: Record<string, unknown>,\n    newProps: Record<string, unknown>,\n    constraints: readonly UniqueConstraint[],\n  ) => void;\n  seedNodeRow: (kind: string, id: string, row: CachedNodeRow) => void;\n  seedUniqueRow: (\n    kind: string,\n    constraintName: string,\n    key: string,\n    row: CachedUniqueRow,\n  ) => void;\n}> {\n  const nodeCache = new Map<string, CachedNodeRow>();\n  const pendingNodes = new Map<string, NonNullable<CachedNodeRow>>();\n  const uniqueCache = new Map<string, CachedUniqueRow>();\n  const pendingUniqueOwners = new Map<string, string>();\n\n  async function getNodeCached(\n    lookupGraphId: string,\n    kind: string,\n    id: string,\n  ): Promise<CachedNodeRow> {\n    const cacheKey = buildNodeCacheKey(lookupGraphId, kind, id);\n    const pendingNode = pendingNodes.get(cacheKey);\n    if (pendingNode !== undefined) return pendingNode;\n    if (nodeCache.has(cacheKey)) return nodeCache.get(cacheKey);\n    const existing = await backend.getNode(lookupGraphId, kind, id);\n    nodeCache.set(cacheKey, existing);\n    return existing;\n  }\n\n  async function checkUniqueCached(\n    params: Parameters<GraphBackend[\"checkUnique\"]>[0],\n  ): Promise<CachedUniqueRow> {\n    const cacheKey = buildUniqueCacheKey(\n      params.graphId,\n      params.nodeKind,\n      params.constraintName,\n      params.key,\n    );\n    const pendingOwner = pendingUniqueOwners.get(cacheKey);\n    if (pendingOwner !== undefined) {\n      return createPendingUniqueRow(\n        params.graphId,\n        params.nodeKind,\n        params.constraintName,\n        params.key,\n        pendingOwner,\n      );\n    }\n    if (uniqueCache.has(cacheKey)) return uniqueCache.get(cacheKey);\n    const existing = await backend.checkUnique(params);\n    uniqueCache.set(cacheKey, existing);\n    return existing;\n  }\n\n  function registerPendingNode(params: InsertNodeParams): void {\n    const cacheKey = buildNodeCacheKey(params.graphId, params.kind, params.id);\n    pendingNodes.set(cacheKey, {\n      graph_id: params.graphId,\n      kind: params.kind,\n      id: params.id,\n      props: JSON.stringify(params.props),\n      version: 1,\n      // The simulated cached row only needs a NodeRow-shaped valid_from\n      // (string | undefined, never null) for existence/uniqueness checks,\n      // which don't inspect its value — normalize import's explicit-NULL\n      // sentinel away rather than widen this cache's row shape.\n      valid_from: params.validFrom ?? undefined,\n      valid_to: params.validTo,\n      created_at: \"\",\n      updated_at: \"\",\n      deleted_at: undefined,\n    });\n  }\n\n  function registerPendingUniqueEntries(\n    kind: string,\n    id: string,\n    props: Record<string, unknown>,\n    constraints: readonly UniqueConstraint[],\n  ): void {\n    for (const constraint of constraints) {\n      if (!checkWherePredicate(constraint, props)) continue;\n\n      const key = computeUniqueKey(\n        props,\n        constraint.fields,\n        constraint.collation,\n      );\n      const concreteEntryKey = buildUniqueCacheKey(\n        graphId,\n        kind,\n        constraint.name,\n        key,\n      );\n      pendingUniqueOwners.set(concreteEntryKey, id);\n\n      if (constraint.scope !== \"kind\") {\n        const kindsToCheck = getKindsForUniquenessCheck(\n          kind,\n          constraint.scope,\n          registry,\n        );\n        for (const kindToCheck of kindsToCheck) {\n          const inheritedEntryKey = buildUniqueCacheKey(\n            graphId,\n            kindToCheck,\n            constraint.name,\n            key,\n          );\n          pendingUniqueOwners.set(inheritedEntryKey, id);\n        }\n      }\n    }\n  }\n\n  // Reflects a completed in-slice node update in the uniqueness caches so a\n  // later row's pre-check sees the post-update reservation state — the state\n  // the sequential path's per-row backend read would observe. The batch path\n  // primes the caches ONCE before routing, but an in-slice update mutates the\n  // real backend's uniqueness rows directly; without reconciling here a later\n  // create either (a) claims a value this update just freed yet gets rejected\n  // against the stale reservation, or (b) passes the stale \"free\" cache for a\n  // value this update just took and then violates the real constraint at\n  // flush, aborting the whole import. Mirrors updateUniquenessEntries' key\n  // diff: for each constraint whose key changed, the released old key becomes\n  // free and the reserved new key becomes owned by this node, across every\n  // kind the constraint's scope checks.\n  function registerAppliedNodeUpdate(\n    kind: string,\n    id: string,\n    oldProps: Record<string, unknown>,\n    newProps: Record<string, unknown>,\n    constraints: readonly UniqueConstraint[],\n  ): void {\n    for (const constraint of constraints) {\n      const oldApplies = checkWherePredicate(constraint, oldProps);\n      const newApplies = checkWherePredicate(constraint, newProps);\n      const oldKey =\n        oldApplies ?\n          computeUniqueKey(oldProps, constraint.fields, constraint.collation)\n        : undefined;\n      const newKey =\n        newApplies ?\n          computeUniqueKey(newProps, constraint.fields, constraint.collation)\n        : undefined;\n      if (oldKey === newKey) continue;\n\n      const kindsToCheck = getKindsForUniquenessCheck(\n        kind,\n        constraint.scope,\n        registry,\n      );\n\n      if (oldKey !== undefined) {\n        for (const kindToCheck of kindsToCheck) {\n          const cacheKey = buildUniqueCacheKey(\n            graphId,\n            kindToCheck,\n            constraint.name,\n            oldKey,\n          );\n          // This node released the key on the real backend, so it is now\n          // free. Clear any pending reservation and record the known-free\n          // state (overwriting a stale seeded owner) so a later create's\n          // pre-check sees a vacancy instead of a redundant backend read.\n          pendingUniqueOwners.delete(cacheKey);\n          uniqueCache.set(cacheKey, undefined);\n        }\n      }\n      if (newKey !== undefined) {\n        for (const kindToCheck of kindsToCheck) {\n          const cacheKey = buildUniqueCacheKey(\n            graphId,\n            kindToCheck,\n            constraint.name,\n            newKey,\n          );\n          // This node now holds the key on the real backend. A pending owner\n          // shadows the seeded uniqueCache entry (checkUniqueCached consults\n          // it first), matching registerPendingUniqueEntries' reservation.\n          pendingUniqueOwners.set(cacheKey, id);\n        }\n      }\n    }\n  }\n\n  // Seed functions let batch preparation prime the caches from one\n  // getNodes / checkUniqueBatch round trip instead of a per-row probe.\n  // Seeding an absent result (`undefined`) is meaningful — it marks the\n  // key as known-missing so the per-row check skips the backend read.\n  // Existing entries are never overwritten: a pending registration or an\n  // earlier lookup always wins.\n  function seedNodeRow(kind: string, id: string, row: CachedNodeRow): void {\n    const cacheKey = buildNodeCacheKey(graphId, kind, id);\n    if (nodeCache.has(cacheKey)) return;\n    nodeCache.set(cacheKey, row);\n  }\n\n  function seedUniqueRow(\n    kind: string,\n    constraintName: string,\n    key: string,\n    row: CachedUniqueRow,\n  ): void {\n    const cacheKey = buildUniqueCacheKey(graphId, kind, constraintName, key);\n    if (uniqueCache.has(cacheKey)) return;\n    uniqueCache.set(cacheKey, row);\n  }\n\n  const validationBackend = deriveBackend(backend, {\n    getNode: getNodeCached,\n    checkUnique: checkUniqueCached,\n  } satisfies Partial<GraphBackend | TransactionBackend>);\n\n  return {\n    backend: validationBackend,\n    registerPendingNode,\n    registerPendingUniqueEntries,\n    registerAppliedNodeUpdate,\n    seedNodeRow,\n    seedUniqueRow,\n  };\n}\n\n// ============================================================\n// Shared Create Pipeline\n// ============================================================\n\n/**\n * The synchronous half of create preparation: kind resolution, Zod\n * validation, and date validation. Produces everything the async\n * constraint checks need, so batch preparation can validate every input\n * first and then prime the validation caches with batched reads before\n * running {@link finishNodeCreatePreparation} per row.\n */\n/**\n * Internal create options threaded from operations that validated props\n * BEFORE calling into the create path. Never exposed on the public store\n * surface.\n */\ntype NodeCreateInternalOptions = Readonly<{\n  /** `input.props` is already the output of `validateNodeProps`. */\n  propsPreValidated?: boolean;\n}>;\n\nexport type NodeCreateDraft = Readonly<{\n  kind: string;\n  id: string;\n  idProvided: boolean;\n  nodeKind: NodeType;\n  uniqueConstraints: readonly UniqueConstraint[];\n  validatedProps: Record<string, unknown>;\n  validFrom: string | undefined;\n  validTo: string | undefined;\n}>;\n\nfunction draftNodeCreate<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  input: CreateNodeInput,\n  id: string,\n  options?: NodeCreateInternalOptions,\n): NodeCreateDraft {\n  const kind = input.kind;\n  const registration = getNodeRegistration(ctx.graph, kind);\n  const nodeKind = registration.type;\n\n  // getOrCreate / findByConstraint variants validate props up front (the\n  // key computation needs the PARSED shape), then hand the validated\n  // object here — re-running the full Zod parse on it would double the\n  // validation cost of every create leg for no additional safety (hooks\n  // wrap the transaction and cannot transform inputs in between).\n  const validatedProps =\n    options?.propsPreValidated === true ?\n      input.props\n    : validateNodeProps(nodeKind.schema, input.props, {\n        kind,\n        operation: \"create\",\n      });\n\n  const validFrom = validateOptionalCanonicalIsoDate(\n    input.validFrom,\n    \"validFrom\",\n  );\n  const validTo = validateOptionalCanonicalIsoDate(input.validTo, \"validTo\");\n  // A stated pair must be ordered, and on an insert that is the COMPLETE rule.\n  // A lone historical validTo is NOT an error — it means \"born already ended\"\n  // (see assertWritableValidityWindow), and the insert stores no lower bound for\n  // it rather than one past the stated end, so there is no effective bound left\n  // for this layer to judge. Both create paths (single and batch) draft through\n  // here, so this is the only insert-side check needed.\n  assertOrderedValidityWindow(`${kind} \"${id}\"`, validFrom, validTo);\n\n  return {\n    kind,\n    id,\n    idProvided: input.id !== undefined,\n    nodeKind,\n    uniqueConstraints: registration.unique ?? [],\n    validatedProps,\n    validFrom,\n    validTo,\n  };\n}\n\n/**\n * The async half: existence, disjointness, and uniqueness checks.\n *\n * The existence probe's row is returned on the prepared record so fresh\n * inserts avoid a second read. Resurrection is the rare exception: it\n * re-checks the row immediately before writing because another transaction\n * may have resurrected it after preparation.\n */\nasync function finishNodeCreatePreparation<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  draft: NodeCreateDraft,\n  backend: GraphBackend | TransactionBackend,\n): Promise<NodeCreatePrepared> {\n  const { kind, id, validatedProps, uniqueConstraints } = draft;\n\n  // This is the fast-path existence gate. Resurrection repeats it immediately\n  // before the update because the row can change while constraints are checked.\n  const existingNode = await backend.getNode(ctx.graphId, kind, id);\n  if (existingNode && !existingNode.deleted_at) {\n    throw createAlreadyExistsError(\"node\", kind, id);\n  }\n\n  const constraintContext: ConstraintContext = {\n    graphId: ctx.graphId,\n    registry: ctx.registry,\n    backend,\n  };\n  await checkDisjointnessConstraint(constraintContext, kind, id);\n\n  await checkUniquenessConstraints(\n    createUniquenessContext(ctx.graphId, ctx.registry, backend),\n    kind,\n    id,\n    validatedProps,\n    uniqueConstraints,\n  );\n\n  return {\n    kind,\n    id,\n    idProvided: draft.idProvided,\n    tombstone: existingNode,\n    nodeKind: draft.nodeKind,\n    validatedProps,\n    uniqueConstraints,\n    insertParams: buildInsertNodeParams(\n      ctx.graphId,\n      kind,\n      id,\n      validatedProps,\n      draft.validFrom,\n      draft.validTo,\n    ),\n  };\n}\n\nasync function validateAndPrepareNodeCreate<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  input: CreateNodeInput,\n  id: string,\n  backend: GraphBackend | TransactionBackend,\n  options?: NodeCreateInternalOptions,\n): Promise<NodeCreatePrepared> {\n  return finishNodeCreatePreparation(\n    ctx,\n    draftNodeCreate(ctx, input, id, options),\n    backend,\n  );\n}\n\n/**\n * Batched {@link finalizeNodeCreate}: applies every prepared create's\n * side effects through the batch pipeline (one uniqueness batch, one\n * fulltext/embedding batch per kind) instead of a per-row statement fan.\n */\nasync function finalizeNodeCreateBatch<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  preparedCreates: readonly NodeCreatePrepared[],\n  backend: GraphBackend | TransactionBackend,\n  lock: GraphWriteLock,\n): Promise<void> {\n  await applyNodeInsertSideEffectsBatch(\n    createNodeWriteContext(ctx.graphId, ctx.registry, lock),\n    preparedCreates.map((prepared) => ({\n      kind: prepared.kind,\n      id: prepared.id,\n      schema: prepared.nodeKind.schema,\n      props: prepared.validatedProps,\n      uniqueConstraints: prepared.uniqueConstraints,\n    })),\n    backend,\n  );\n}\n\n/**\n * The created references identity folding actually has to consider.\n *\n * Folding looks for a live node carrying the SAME id under a DIFFERENT kind.\n * A generated id is fresh — nothing can already hold it — so only\n * caller-supplied ids can participate, and a batch of purely auto-id creates\n * needs no cross-kind probe at all.\n */\nfunction foldReferences(\n  preparedCreates: readonly NodeCreatePrepared[],\n): readonly Readonly<{ kind: string; id: string }>[] {\n  return preparedCreates\n    .filter((prepared) => prepared.idProvided)\n    .map((prepared) => ({ kind: prepared.kind, id: prepared.id }));\n}\n\nasync function finalizeNodeCreate<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  prepared: NodeCreatePrepared,\n  backend: GraphBackend | TransactionBackend,\n  lock: GraphWriteLock,\n): Promise<void> {\n  await applyNodeInsertSideEffects(\n    createNodeWriteContext(ctx.graphId, ctx.registry, lock),\n    {\n      kind: prepared.kind,\n      id: prepared.id,\n      schema: prepared.nodeKind.schema,\n      props: prepared.validatedProps,\n      uniqueConstraints: prepared.uniqueConstraints,\n    },\n    backend,\n  );\n}\n\n// ============================================================\n// Shared Update Pipeline\n//\n// executeNodeUpdate wraps this in operation hooks.\n// executeNodeUpsertUpdate calls it directly (no hooks) for\n// getOrCreate resurrections.\n// ============================================================\n\n/**\n * The exact props an update would persist: the caller's partial input merged\n * over the current props and run through the kind's Zod schema (defaults\n * applied, values normalized). Also returns the resolved registration so\n * callers need not look it up again. Operates on PARSED props so both the write\n * path (which parses the row) and the coalesce dirty-check (which may compare\n * against a batch-local running value, never a row) share one validation.\n */\nfunction computeNodeUpdate<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  kind: string,\n  id: string,\n  existingProps: Record<string, unknown>,\n  inputProps: Partial<Record<string, unknown>>,\n) {\n  const registration = getNodeRegistration(ctx.graph, kind);\n  const validatedProps = validateNodeProps(\n    registration.type.schema,\n    { ...existingProps, ...inputProps },\n    { kind, operation: \"update\", id },\n  );\n  return { registration, validatedProps };\n}\n\n/**\n * Row-based wrapper over {@link computeNodeUpdate} for the write path. Reads the\n * kind/id off the row (a `getNode(kind, id)` result always carries the\n * requested kind), matching {@link resolveEdgeUpdateProps}.\n */\nfunction resolveNodeUpdateProps<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  existing: Pick<NodeRow, \"kind\" | \"id\" | \"props\">,\n  inputProps: Partial<Record<string, unknown>>,\n) {\n  const existingProps = rowPropsToObject(existing.props);\n  const { registration, validatedProps } = computeNodeUpdate(\n    ctx,\n    existing.kind,\n    existing.id,\n    existingProps,\n    inputProps,\n  );\n  return { registration, existingProps, validatedProps };\n}\n\n/**\n * The coalesce dirty-check: returns the props an `upsertById` would persist and\n * whether they equal `existingProps` (so the write can be skipped). Compares on\n * the storage-normalized representation (validated, key-order-independent), so\n * it answers exactly \"would the persisted JSON differ?\". `existingProps` is the\n * PARSED current props — the row's, or the batch-local running value for a\n * repeated id in `bulkUpsertById`.\n */\nexport function nodeUpsertDirtyCheck<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  kind: string,\n  id: string,\n  existingProps: Record<string, unknown>,\n  inputProps: Record<string, unknown>,\n): UpsertDirtyCheck {\n  const { validatedProps } = computeNodeUpdate(\n    ctx,\n    kind,\n    id,\n    existingProps,\n    inputProps,\n  );\n  return {\n    validatedProps,\n    unchanged: canonicalEqual(validatedProps, existingProps),\n  };\n}\n\nasync function performNodeUpdate<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  input: UpsertUpdateNodeInput,\n  backend: GraphBackend | TransactionBackend,\n  lock: GraphWriteLock,\n  options?: Readonly<{ clearDeleted?: boolean }>,\n): Promise<Node> {\n  const { kind, id } = input;\n\n  assertValidityEndMutation(input, { entityType: \"node\", kind, id });\n\n  const existing = await backend.getNode(ctx.graphId, kind, id);\n  if (!existing) throw new NodeNotFoundError(kind, id);\n\n  const { registration, validatedProps } = resolveNodeUpdateProps(\n    ctx,\n    existing,\n    input.props,\n  );\n  const nodeKind = registration.type;\n\n  const validTo = validateOptionalCanonicalIsoDate(input.validTo, \"validTo\");\n  // A node resurrection RESETS `valid_from` (see `buildUpdateNode`), so its\n  // effective lower bound is one this write stamps rather than the row's stored\n  // one. The instant is sampled HERE and the bound resolved from it travels to\n  // the backend as an explicit `validFrom`, because the guard has to measure\n  // the bound the write will actually store: left to default, the builder's own\n  // `resolveStampedValidityLowerBound` call would judge the backend's strictly\n  // later sample, and a `validTo` at this instant would pass the guard as\n  // zero-width and land as a different shape a millisecond later (issue #413).\n  // An in-place update keeps the row's stored bound, which no write rewrites and\n  // so needs no prediction.\n  const resurrectionInstant =\n    options?.clearDeleted === true && existing.deleted_at !== undefined ?\n      nowIso()\n    : undefined;\n  // Event materializers may state the source row's lower bound on every\n  // delivery while asking a live update to preserve the bound already stored.\n  // This is explicit create/resurrection-only input, not the old silent drop:\n  // the default remains `\"refuse\"`, and a resurrection still validates and\n  // stores the stated value below.\n  const preservesLiveLowerBound =\n    resurrectionInstant === undefined &&\n    preservesImmutableLowerBound(input.onImmutableLowerBound);\n  const statedValidFrom = validateOptionalCanonicalIsoDate(\n    input.validFrom,\n    \"validFrom\",\n  );\n  const validFrom = preservesLiveLowerBound ? undefined : statedValidFrom;\n  // The bound this resurrection will STORE, decided by the same owner every\n  // insert builder decides through, against the instant sampled above. Asking\n  // the owner rather than assuming `resurrectionInstant` is what makes a\n  // resurrection carrying only a historical `validTo` reach the shape a create\n  // reaches — no lower bound, \"ended at T, start unknown\" — instead of being\n  // refused for inverting against an instant the write would never have stored\n  // (I12). `undefined` here means \"no bound\", which is nothing to invert\n  // against, so the verdict below judges exactly what lands.\n  const resurrectionBound =\n    resurrectionInstant === undefined ? undefined : (\n      resolveStampedValidityLowerBound(validFrom, validTo, resurrectionInstant)\n    );\n  // A resurrection STORES a stated `validFrom` (it rewrites the whole window);\n  // an in-place update never does, so one that differs from the row's stored\n  // bound is refused rather than accepted and dropped.\n  const windowVerdict = assertWritableValidityWindow(\n    `${kind} \"${id}\"`,\n    validFrom,\n    resurrectionInstant === undefined ?\n      {\n        effectiveValidFrom: existing.valid_from,\n        appliesStatedValidFrom: false,\n        effectiveBoundIsStored: true,\n      }\n    : {\n        effectiveValidFrom: resurrectionBound,\n        appliesStatedValidFrom: true,\n        // The bound this write is about to stamp, not one the row holds.\n        effectiveBoundIsStored: false,\n      },\n    validTo,\n  );\n\n  const writeContext = createNodeWriteContext(ctx.graphId, ctx.registry, lock);\n  const shared = {\n    schema: nodeKind.schema,\n    validatedProps,\n    uniqueConstraints: registration.unique ?? [],\n    ...(validTo !== undefined && { validTo }),\n    ...(input.clearValidTo === true && { clearValidTo: true as const }),\n    // The bound the verdict above READ, carried into the UPDATE's own `WHERE`\n    // so the row this writes is the row that was judged. The verdict hands over\n    // the predicate rather than a flag, so both conditions that decide it — did\n    // the verdict consult the effective bound, and WAS that bound the row's\n    // stored one — are answered where they are known. A plain\n    // `update({ props })` states no window, reads no bound, and stays unfenced:\n    // the same rule `UpdateEdgeParams`'s identity components follow, for the\n    // same reason. The resurrecting leg is judged against `resurrectionInstant`\n    // and so fences on `deleted_at IS NOT NULL` alone, converging through the\n    // recovery below.\n    ...windowVerdict.storedLowerBoundFence,\n  };\n\n  // A resurrecting upsert (clearDeleted) may target a tombstoned row; a plain\n  // update must prove the row live — see NodeUpdateTarget.\n  if (options?.clearDeleted) {\n    // Keyed on the SAME condition the verdict was, because only that condition\n    // produces a verdict to state. With `resurrectionInstant` defined this is\n    // the DECISION, never an absence: omitting the key would let\n    // `buildUpdateNode` re-derive the bound against the backend's own, strictly\n    // later `timestamp`, so the two layers would agree only while the two clocks\n    // do — the #413 hazard, one layer out. `null` is how `UpdateNodeParams`\n    // spells \"store no lower bound\", which is what this decision resolves to for\n    // a resurrection that ends at or before the instant it judged.\n    //\n    // With it UNDEFINED this read found the row live — a peer resurrected it\n    // between the collection's probe and here — so the verdict judged the row's\n    // stored bound and stamped nothing. There is no decision to state, and\n    // stating one anyway would write away a `validFrom` the guard just ACCEPTED\n    // as equal to that stored bound. The statement usually matches no row\n    // (`deleted_at IS NOT NULL`) and the recovery below re-reads, but a peer that\n    // re-tombstones before the UPDATE makes it match, so this leg carries the\n    // stated bound exactly as the in-place leg does.\n    const resurrectionLowerBound =\n      resurrectionInstant === undefined ?\n        validFrom !== undefined && { validFrom }\n        // eslint-disable-next-line unicorn/no-null -- `validFrom: null` means \"store NULL\"; omitting the key means \"decide for me\", and this path has already decided. See UpdateNodeParams.validFrom.\n      : { validFrom: resurrectionBound ?? null };\n    const row = await applyNodeUpdate(\n      writeContext,\n      { ...shared, existing, clearDeleted: true, ...resurrectionLowerBound },\n      backend,\n    );\n    return rowToNode(row);\n  }\n\n  if (!isLiveNodeRow(existing)) throw new NodeNotFoundError(kind, id);\n  const row = await applyNodeUpdate(\n    writeContext,\n    // An in-place update must not rewrite the stored bound, so it keeps the\n    // conditional spread: `buildUpdateNode` ignores `validFrom` off the\n    // resurrection leg, and stating one here would claim a rewrite that no\n    // statement performs.\n    { ...shared, existing, ...(validFrom !== undefined && { validFrom }) },\n    backend,\n  );\n  return rowToNode(row);\n}\n\n/**\n * How many probe-and-write rounds a node update gets before it stops trying to\n * converge. One retry: enough to absorb a single concurrent recreate, bounded\n * so a peer that keeps replacing the row cannot livelock this caller (the same\n * shape, and the same reasoning, as `getOrCreateByEndpoints`'s bounded loop).\n */\nconst NODE_UPDATE_ATTEMPTS = 2;\n\n/**\n * Runs a node update and CONVERGES on the row that is actually there when a\n * predicated UPDATE matches nothing.\n *\n * `performNodeUpdate` is a probe-and-write pair, and both of the predicates its\n * statement carries beyond `(graph_id, kind, id)` can stop matching between the\n * two under PostgreSQL READ COMMITTED:\n *\n *  - `deleted_at IS NOT NULL` on the resurrecting leg — a peer resurrected the\n *    tombstone first;\n *  - `expectedValidFrom` on the in-place leg — a peer hard-deleted and\n *    recreated the row, so the bound this update's window verdict was computed\n *    against is gone.\n *\n * Both are the SAME event from the caller's side: the row moved under a\n * decision already made. Neither may surface as the zero-row\n * `DatabaseOperationError` the backend raises, which is an internal sentinel\n * and names nothing a caller can act on. So this re-reads and re-derives:\n *\n *  - row gone, or tombstoned where the leg needs a live one — `NodeNotFoundError`,\n *    exactly what the pre-write probe would have thrown;\n *  - row live — retry the whole thing. The retry re-reads, re-merges the\n *    caller's partial props over the CURRENT props, and re-judges the window\n *    against the CURRENT bound, so a stated window that no longer fits is\n *    refused with the same typed `ValidationError` the first attempt would have\n *    raised. A resurrection that lost its race converges to an ordinary update,\n *    which is upsert's documented semantics: the peer owns the new window, this\n *    late writer owns the properties — and a caller that STATED a lower bound\n *    for the resurrection it lost is therefore refused rather than silently\n *    updated without it.\n *\n * Retrying rather than refusing is what keeps the fence from being a behavior\n * regression: the losing writer still lands its properties, on the row that is\n * really there, judged against the bounds that row really carries.\n */\nasync function performNodeUpdateWithResurrectionRecovery<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  input: UpsertUpdateNodeInput,\n  target: GraphBackend | TransactionBackend,\n  lock: GraphWriteLock,\n  options?: Readonly<{ clearDeleted?: boolean }>,\n): Promise<Node> {\n  for (let attempt = 1; attempt <= NODE_UPDATE_ATTEMPTS; attempt += 1) {\n    try {\n      // Only the FIRST attempt may resurrect: reaching a retry means the row is\n      // live, and an ordinary update is what converges on it.\n      return await performNodeUpdate(\n        ctx,\n        input,\n        target,\n        lock,\n        attempt === 1 ? options : undefined,\n      );\n    } catch (error) {\n      if (!isNodeUpdateNoRowError(error) || attempt === NODE_UPDATE_ATTEMPTS) {\n        throw nodeUpdateRaceError(input, error);\n      }\n      const current = await target.getNode(ctx.graphId, input.kind, input.id);\n      if (current === undefined || current.deleted_at !== undefined) {\n        throw new NodeNotFoundError(input.kind, input.id);\n      }\n    }\n  }\n  // Unreachable: the loop either returns or throws on its last attempt.\n  throw new NodeNotFoundError(input.kind, input.id);\n}\n\n/**\n * The error a caller sees when a node update exhausts its attempts, or fails\n * with something that is not the zero-row sentinel.\n *\n * A non-sentinel error passes through untouched. The sentinel does not: it says\n * \"the statement matched nothing\", which after {@link NODE_UPDATE_ATTEMPTS}\n * rounds means a peer is replacing this row faster than this writer can read\n * it. That is a contention fact, and it is reported as one rather than as a\n * missing node — the node is present, it just is not staying still.\n */\nfunction nodeUpdateRaceError(\n  input: UpsertUpdateNodeInput,\n  error: unknown,\n): unknown {\n  if (!isNodeUpdateNoRowError(error)) return error;\n  return new DatabaseOperationError(\n    `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.`,\n    {\n      operation: \"update\",\n      entity: \"node\",\n      attempted: [{ kind: input.kind, id: input.id }],\n    },\n    { cause: error },\n  );\n}\n\n// ============================================================\n// Shared Batch Preparation\n//\n// Both returning and non-returning batch creates share the same\n// validate-and-register loop. This extracts it.\n// ============================================================\n\n/**\n * Primes the batch validation caches with batched reads: one `getNodes`\n * per kind for existence probes and one `checkUniqueBatch` per\n * (constraint, kind) for uniqueness pre-checks. The per-row checks in\n * {@link finishNodeCreatePreparation} then hit memory instead of issuing\n * one probe per row. Backends without the batch primitives skip priming\n * and keep the per-row fallback.\n */\nexport async function primeBatchValidationCaches(\n  ctx: Readonly<{ graphId: string; registry: KindRegistry }>,\n  drafts: readonly NodeCreateDraft[],\n  backend: GraphBackend | TransactionBackend,\n  seams: Readonly<{\n    seedNodeRow: (kind: string, id: string, row: CachedNodeRow) => void;\n    seedUniqueRow: (\n      kind: string,\n      constraintName: string,\n      key: string,\n      row: CachedUniqueRow,\n    ) => void;\n  }>,\n): Promise<void> {\n  if (backend.getNodes !== undefined) {\n    const idsByKind = new Map<string, Set<string>>();\n    for (const draft of drafts) {\n      const ids = idsByKind.get(draft.kind) ?? new Set<string>();\n      ids.add(draft.id);\n      idsByKind.set(draft.kind, ids);\n    }\n    for (const [kind, ids] of idsByKind) {\n      const orderedIds = [...ids];\n      const rows = await backend.getNodes(ctx.graphId, kind, orderedIds);\n      const rowsById = new Map(rows.map((row) => [row.id, row]));\n      for (const id of orderedIds) {\n        seams.seedNodeRow(kind, id, rowsById.get(id));\n      }\n    }\n  }\n\n  if (backend.checkUniqueBatch !== undefined) {\n    interface ProbeGroup {\n      nodeKind: string;\n      constraintName: string;\n      keys: Set<string>;\n    }\n    const groups = new Map<string, ProbeGroup>();\n    for (const draft of drafts) {\n      for (const constraint of draft.uniqueConstraints) {\n        if (!checkWherePredicate(constraint, draft.validatedProps)) continue;\n        const key = computeUniqueKey(\n          draft.validatedProps,\n          constraint.fields,\n          constraint.collation,\n        );\n        const kindsToCheck = getKindsForUniquenessCheck(\n          draft.kind,\n          constraint.scope,\n          ctx.registry,\n        );\n        for (const kindToCheck of kindsToCheck) {\n          const groupKey = encodeTupleKey([kindToCheck, constraint.name]);\n          const group = groups.get(groupKey) ?? {\n            nodeKind: kindToCheck,\n            constraintName: constraint.name,\n            keys: new Set<string>(),\n          };\n          group.keys.add(key);\n          groups.set(groupKey, group);\n        }\n      }\n    }\n    for (const group of groups.values()) {\n      const orderedKeys = [...group.keys];\n      const rows = await backend.checkUniqueBatch({\n        graphId: ctx.graphId,\n        nodeKind: group.nodeKind,\n        constraintName: group.constraintName,\n        keys: orderedKeys,\n      });\n      const rowsByKey = new Map(rows.map((row) => [row.key, row]));\n      for (const key of orderedKeys) {\n        seams.seedUniqueRow(\n          group.nodeKind,\n          group.constraintName,\n          key,\n          rowsByKey.get(key),\n        );\n      }\n    }\n  }\n}\n\nasync function prepareBatchCreates<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  inputs: readonly CreateNodeInput[],\n  backend: GraphBackend | TransactionBackend,\n  options?: NodeCreateInternalOptions,\n): Promise<readonly NodeCreatePrepared[]> {\n  const {\n    backend: validationBackend,\n    registerPendingNode,\n    registerPendingUniqueEntries,\n    seedNodeRow,\n    seedUniqueRow,\n  } = createNodeBatchValidationBackend(ctx.graphId, ctx.registry, backend);\n\n  // Pass 1 (synchronous): validate every input and assign ids. This\n  // surfaces a later row's validation error before an earlier row's\n  // constraint error — both fail the whole batch, so ordering across\n  // error categories is not part of the contract.\n  const drafts = inputs.map((input) =>\n    draftNodeCreate(ctx, input, input.id ?? generateId(), options),\n  );\n\n  await primeBatchValidationCaches(ctx, drafts, backend, {\n    seedNodeRow,\n    seedUniqueRow,\n  });\n\n  // Pass 2: per-row constraint checks against the primed caches, in input\n  // order, registering pendings so later rows see earlier ones.\n  const preparedCreates: NodeCreatePrepared[] = [];\n  for (const draft of drafts) {\n    const prepared = await finishNodeCreatePreparation(\n      ctx,\n      draft,\n      validationBackend,\n    );\n    preparedCreates.push(prepared);\n    registerPendingNode(prepared.insertParams);\n    registerPendingUniqueEntries(\n      prepared.kind,\n      prepared.id,\n      prepared.validatedProps,\n      prepared.uniqueConstraints,\n    );\n  }\n\n  return preparedCreates;\n}\n\ntype CreatePartition = Readonly<{\n  inserts: readonly NodeCreatePrepared[];\n  resurrections: readonly NodeCreatePrepared[];\n}>;\n\n/**\n * Splits prepared creates into fresh inserts and tombstone resurrections.\n *\n * Purely in-memory: preparation already read each id's row under this write\n * lock (batched through `getNodes` when the backend has it, per-row through\n * the validation cache otherwise) and carried it on the prepared record, so\n * routing costs no additional round trip.\n */\nfunction partitionCreates(\n  preparedCreates: readonly NodeCreatePrepared[],\n): CreatePartition {\n  const inserts: NodeCreatePrepared[] = [];\n  const resurrections: NodeCreatePrepared[] = [];\n\n  for (const prepared of preparedCreates) {\n    if (prepared.tombstone === undefined) {\n      inserts.push(prepared);\n    } else {\n      resurrections.push(prepared);\n    }\n  }\n  return { inserts, resurrections };\n}\n\nfunction isNodeUpdateNoRowError(\n  error: unknown,\n): error is DatabaseOperationError {\n  return (\n    error instanceof DatabaseOperationError &&\n    error.details.operation === \"update\" &&\n    error.details.entity === \"node\" &&\n    error.details.reason === \"no_row_returned\"\n  );\n}\n\nasync function resurrectPreparedNode<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  target: GraphBackend | TransactionBackend,\n  lock: GraphWriteLock,\n  prepared: NodeCreatePrepared,\n): Promise<BackendNodeRow> {\n  const current = await target.getNode(ctx.graphId, prepared.kind, prepared.id);\n  if (current === undefined) {\n    throw new DatabaseOperationError(\n      `Node tombstone disappeared before resurrection: ${prepared.kind} ${prepared.id}`,\n      { operation: \"update\", entity: \"node\" },\n    );\n  }\n  if (current.deleted_at === undefined) {\n    throw createAlreadyExistsError(\"node\", prepared.kind, prepared.id);\n  }\n  // A create landing on a tombstone RESETS the window, so this leg stamps a\n  // bound whenever the caller stated none — and it decides which one through\n  // the same owner `performNodeUpdate`'s resurrection leg and every insert\n  // builder use, against an instant sampled HERE. Two consequences. The stored\n  // bound is the one this layer judged rather than the backend's strictly later\n  // sample, so one write has one instant (issue #413). And a create carrying\n  // only a historical `validTo` reaches the same stored shape on a tombstoned\n  // id as on a fresh one — no lower bound (I12).\n  const resurrectionInstant = nowIso();\n  const resurrectionBound = resolveStampedValidityLowerBound(\n    prepared.insertParams.validFrom,\n    prepared.insertParams.validTo,\n    resurrectionInstant,\n  );\n  try {\n    return await applyNodeUpdate(\n      createNodeWriteContext(ctx.graphId, ctx.registry, lock),\n      {\n        existing: current,\n        clearDeleted: true,\n        schema: prepared.nodeKind.schema,\n        validatedProps: prepared.validatedProps,\n        uniqueConstraints: prepared.uniqueConstraints,\n        // The decision itself, never an absence — see the same spelling on\n        // `performNodeUpdate`'s resurrection leg.\n        // eslint-disable-next-line unicorn/no-null -- `validFrom: null` means \"store NULL\"; omitting the key means \"decide for me\", and this path has already decided. See UpdateNodeParams.validFrom.\n        validFrom: resurrectionBound ?? null,\n        ...(prepared.insertParams.validTo === undefined ?\n          {}\n        : { validTo: prepared.insertParams.validTo }),\n      },\n      target,\n    );\n  } catch (error) {\n    if (!isNodeUpdateNoRowError(error)) throw error;\n    // The UPDATE itself has a tombstone predicate, closing the remaining gap\n    // between the re-read and write. Translate a peer resurrection into the\n    // create API's stable duplicate error instead of leaking a 0-row update.\n    const afterFailure = await target.getNode(\n      ctx.graphId,\n      prepared.kind,\n      prepared.id,\n    );\n    if (afterFailure !== undefined && afterFailure.deleted_at === undefined) {\n      throw createAlreadyExistsError(\"node\", prepared.kind, prepared.id);\n    }\n    throw error;\n  }\n}\n\n// ============================================================\n// Shared Constraint Lookup\n//\n// Both single and bulk find/getOrCreate operations need to look up\n// unique constraint entries across all applicable kinds.\n// ============================================================\n\nasync function findUniqueRowAcrossKinds(\n  backend: GraphBackend | TransactionBackend,\n  graphId: string,\n  constraintName: string,\n  key: string,\n  kindsToCheck: readonly string[],\n  includeDeleted: boolean,\n): Promise<\n  | { node_id: string; concrete_kind: string; deleted_at: string | undefined }\n  | undefined\n> {\n  for (const kindToCheck of kindsToCheck) {\n    const row = await backend.checkUnique({\n      graphId,\n      nodeKind: kindToCheck,\n      constraintName,\n      key,\n      includeDeleted,\n    });\n    if (row !== undefined) return row;\n  }\n  return undefined;\n}\n\ninterface UniqueMatchRow {\n  node_id: string;\n  concrete_kind: string;\n  deleted_at: string | undefined;\n}\n\nasync function batchCheckUniqueAcrossKinds(\n  backend: GraphBackend | TransactionBackend,\n  graphId: string,\n  constraintName: string,\n  uniqueKeys: readonly string[],\n  kindsToCheck: readonly string[],\n  includeDeleted: boolean,\n): Promise<Map<string, UniqueMatchRow>> {\n  const existingByKey = new Map<string, UniqueMatchRow>();\n\n  for (const kindToCheck of kindsToCheck) {\n    if (backend.checkUniqueBatch === undefined) {\n      for (const key of uniqueKeys) {\n        if (existingByKey.has(key)) continue;\n        const row = await backend.checkUnique({\n          graphId,\n          nodeKind: kindToCheck,\n          constraintName,\n          key,\n          includeDeleted,\n        });\n        if (row !== undefined) {\n          existingByKey.set(row.key, row);\n        }\n      }\n    } else {\n      const rows = await backend.checkUniqueBatch({\n        graphId,\n        nodeKind: kindToCheck,\n        constraintName,\n        keys: uniqueKeys,\n        includeDeleted,\n      });\n      for (const row of rows) {\n        if (!existingByKey.has(row.key)) {\n          existingByKey.set(row.key, row);\n        }\n      }\n    }\n  }\n\n  return existingByKey;\n}\n\n// ============================================================\n// Node Create Operations\n// ============================================================\n\nasync function executeNodeCreateInternal<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  input: CreateNodeInput,\n  backend: GraphBackend | TransactionBackend,\n  options?: Readonly<{ returnRow?: boolean }> & NodeCreateInternalOptions,\n): Promise<Node | undefined> {\n  const kind = input.kind;\n  const id = input.id ?? generateId();\n  const opContext = ctx.createOperationContext(\"create\", \"node\", kind, id);\n  const shouldReturnRow = options?.returnRow ?? true;\n\n  return runHookedWriteOperation(\n    ctx,\n    opContext,\n    backend,\n    async (target, lock) => {\n      const identity = ctx.identity;\n      if (identity !== undefined) await identity.lock(target);\n      const prepared = await validateAndPrepareNodeCreate(\n        ctx,\n        input,\n        id,\n        target,\n        options,\n      );\n\n      const existing = prepared.tombstone;\n      if (existing !== undefined) {\n        const resurrected = await resurrectPreparedNode(\n          ctx,\n          target,\n          lock,\n          prepared,\n        );\n        if (identity !== undefined) {\n          await identity.foldCreated(target, foldReferences([prepared]));\n        }\n        return shouldReturnRow ? rowToNode(resurrected) : undefined;\n      }\n\n      // The existence probe above is not the last word: on an engine that does\n      // not serialize the two writers, a concurrent create of the same new id\n      // can commit between the probe and this INSERT, and only the engine's\n      // refusal reports it. Both routes to that conclusion raise the same error.\n      const row = await withAlreadyExistsTranslation(\"node\", async () => {\n        if (shouldReturnRow) return target.insertNode(prepared.insertParams);\n        await runInsertNoReturn(\n          nodeInsertDispatch(target),\n          prepared.insertParams,\n        );\n        return;\n      });\n\n      await finalizeNodeCreate(ctx, prepared, target, lock);\n      if (identity !== undefined) {\n        await identity.foldCreated(target, foldReferences([prepared]));\n      }\n\n      if (row === undefined) return;\n      return rowToNode(row);\n    },\n    {\n      fencesConstraintProbe: nodeFencesConstraintProbe(ctx, kind, \"create\"),\n    },\n  );\n}\n\nexport async function executeNodeCreate<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  input: CreateNodeInput,\n  backend: GraphBackend | TransactionBackend,\n  options?: NodeCreateInternalOptions,\n): Promise<Node> {\n  const result = await executeNodeCreateInternal(ctx, input, backend, {\n    returnRow: true,\n    ...options,\n  });\n  if (!result) {\n    throw new DatabaseOperationError(\n      \"Node create failed: expected created node row\",\n      { operation: \"insert\", entity: \"node\" },\n    );\n  }\n  return result;\n}\n\nexport async function executeNodeCreateNoReturn<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  input: CreateNodeInput,\n  backend: GraphBackend | TransactionBackend,\n): Promise<void> {\n  await executeNodeCreateInternal(ctx, input, backend, { returnRow: false });\n}\n\n/**\n * Executes batched node creates without returning inserted node payloads.\n *\n * Note: `withOperationHooks` is intentionally skipped for batch throughput.\n * Per-item hooks would negate the performance benefit of batching.\n */\nexport async function executeNodeCreateNoReturnBatch<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  inputs: readonly CreateNodeInput[],\n  backend: GraphBackend | TransactionBackend,\n): Promise<void> {\n  if (inputs.length === 0) return;\n\n  await runInWriteTransaction(\n    ctx,\n    backend,\n    async (target, lock) => {\n      const identity = ctx.identity;\n      if (identity !== undefined) await identity.lock(target);\n      const preparedCreates = await prepareBatchCreates(ctx, inputs, target);\n\n      const partition = partitionCreates(preparedCreates);\n      await withAlreadyExistsTranslation(\"node\", () =>\n        runInsertBatch(\n          nodeInsertDispatch(target),\n          partition.inserts.map((prepared) => prepared.insertParams),\n        ),\n      );\n      for (const prepared of partition.resurrections) {\n        await resurrectPreparedNode(ctx, target, lock, prepared);\n      }\n      await finalizeNodeCreateBatch(ctx, partition.inserts, target, lock);\n      if (identity !== undefined) {\n        await identity.foldCreated(target, foldReferences(preparedCreates));\n      }\n    },\n    {\n      fencesConstraintProbe: nodeBatchFencesConstraintProbe(\n        ctx,\n        inputs,\n        \"create\",\n      ),\n    },\n  );\n}\n\n/**\n * Executes batched node creates and returns the inserted node payloads.\n *\n * Uses batch validation caching and a single multi-row INSERT with RETURNING\n * when the backend supports it. Falls back to sequential inserts otherwise.\n *\n * Note: `withOperationHooks` is intentionally skipped for batch throughput.\n * Per-item hooks would negate the performance benefit of batching.\n */\nexport async function executeNodeCreateBatch<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  inputs: readonly CreateNodeInput[],\n  backend: GraphBackend | TransactionBackend,\n  options?: NodeCreateInternalOptions,\n): Promise<readonly Node[]> {\n  if (inputs.length === 0) return [];\n\n  return runInWriteTransaction(\n    ctx,\n    backend,\n    async (target, lock) => {\n      const identity = ctx.identity;\n      if (identity !== undefined) await identity.lock(target);\n      const preparedCreates = await prepareBatchCreates(\n        ctx,\n        inputs,\n        target,\n        options,\n      );\n\n      const partition = partitionCreates(preparedCreates);\n      const inserted = await withAlreadyExistsTranslation(\"node\", () =>\n        runInsertBatchReturning(\n          nodeInsertDispatch(target),\n          partition.inserts.map((prepared) => prepared.insertParams),\n        ),\n      );\n      const resurrected: BackendNodeRow[] = [];\n      for (const prepared of partition.resurrections) {\n        resurrected.push(\n          await resurrectPreparedNode(ctx, target, lock, prepared),\n        );\n      }\n      await finalizeNodeCreateBatch(ctx, partition.inserts, target, lock);\n      const byReference = new Map(\n        [...inserted, ...resurrected].map((row) => [\n          refKey({ kind: row.kind, id: row.id }),\n          row,\n        ]),\n      );\n      const rows = preparedCreates.map((prepared) =>\n        requireDefined(\n          byReference.get(refKey({ kind: prepared.kind, id: prepared.id })),\n          `Missing written row for ${prepared.kind} ${prepared.id}`,\n        ),\n      );\n      if (identity !== undefined) {\n        await identity.foldCreated(target, foldReferences(preparedCreates));\n      }\n\n      return rows.map((row) => rowToNode(row));\n    },\n    {\n      fencesConstraintProbe: nodeBatchFencesConstraintProbe(\n        ctx,\n        inputs,\n        \"create\",\n      ),\n    },\n  );\n}\n\n// ============================================================\n// Node Update Operations\n// ============================================================\n\nexport async function executeNodeUpdate<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  input: UpsertUpdateNodeInput,\n  backend: GraphBackend | TransactionBackend,\n  options?: Readonly<{ clearDeleted?: boolean }>,\n): Promise<Node> {\n  const opContext = ctx.createOperationContext(\n    \"update\",\n    \"node\",\n    input.kind,\n    input.id,\n  );\n  return runHookedWriteOperation(\n    ctx,\n    opContext,\n    backend,\n    async (target, lock) => {\n      if (input.clearValidTo === true) {\n        assertClearValidToSupported(backend, \"node\");\n      }\n      const validTo = validateOptionalCanonicalIsoDate(\n        input.validTo,\n        \"validTo\",\n      );\n      const identity = ctx.identity;\n      if (\n        identity !== undefined &&\n        (options?.clearDeleted === true || input.validTo !== undefined)\n      ) {\n        await identity.lock(target);\n      }\n      if (identity !== undefined && validTo !== undefined) {\n        await identity.requireValidityEndCompatible(\n          target,\n          { kind: input.kind, id: input.id },\n          validTo,\n        );\n      }\n      const node = await performNodeUpdateWithResurrectionRecovery(\n        ctx,\n        input,\n        target,\n        lock,\n        options,\n      );\n      if (options?.clearDeleted && identity !== undefined) {\n        await identity.foldCreated(target, [\n          { kind: input.kind, id: input.id },\n        ]);\n      }\n      return node;\n    },\n    {\n      fencesConstraintProbe: nodeFencesConstraintProbe(\n        ctx,\n        input.kind,\n        \"update\",\n      ),\n    },\n  );\n}\n\n/**\n * Executes an atomic, set-based update of current nodes. The backend returns\n * every after-image so the Store can validate the complete rows before\n * rebuilding all derived sidecars inside the same transaction.\n */\nexport async function executeNodeUpdateWhere<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  kind: string,\n  inputPatch: Record<string, unknown>,\n  candidateIds: CompiledSelectSql,\n  candidateIdColumn: string,\n  backend: GraphBackend | TransactionBackend,\n): Promise<Readonly<{ affectedCount: number }>> {\n  const registration = getNodeRegistration(ctx.graph, kind);\n  const schema = registration.type.schema;\n  const uniqueConstraints = registration.unique ?? [];\n\n  if (!backend.capabilities.transactions) {\n    throw new ConfigurationError(\n      \"updateWhere() requires a transactional backend so validation and sidecars are atomic\",\n      { code: \"SET_UPDATE_TRANSACTIONS_REQUIRED\", kind },\n    );\n  }\n  if (backend.updateNodeSet === undefined) {\n    throw new ConfigurationError(\n      \"This backend does not support set-based node updates\",\n      { code: \"SET_UPDATE_UNSUPPORTED\", kind },\n    );\n  }\n  if (Object.keys(inputPatch).length === 0) {\n    throw new ValidationError(\"updateWhere() patch must not be empty\", {\n      entityType: \"node\",\n      kind,\n      operation: \"update\",\n      issues: [{ path: \"patch\", message: \"Provide at least one property\" }],\n    });\n  }\n  const unknownProperty = Object.keys(inputPatch).find(\n    (property) => !Object.hasOwn(schema.shape, property),\n  );\n  if (unknownProperty !== undefined) {\n    throw new ValidationError(\n      `Unknown ${kind} property in updateWhere() patch: ${unknownProperty}`,\n      {\n        entityType: \"node\",\n        kind,\n        operation: \"update\",\n        issues: [\n          {\n            path: unknownProperty,\n            message: \"Property is not declared by the node schema\",\n          },\n        ],\n      },\n    );\n  }\n\n  const parsedPatch = validateNodeProps(schema.partial(), inputPatch, {\n    kind,\n    operation: \"update\",\n  });\n  // Data-keyed: `property` comes from the caller's patch object.\n  const patch = createDataKeyedBag<JsonValue>();\n  const unsetProperties: string[] = [];\n  for (const [property, value] of Object.entries(parsedPatch)) {\n    if (value === undefined) {\n      unsetProperties.push(property);\n      continue;\n    }\n    assertJsonValue(value, property, `Node \"${kind}\" updateWhere patch`);\n    patch[property] = value as JsonValue;\n  }\n  if (Object.keys(patch).length === 0 && unsetProperties.length === 0) {\n    throw new ValidationError(\n      \"updateWhere() patch has no recognized properties\",\n      {\n        entityType: \"node\",\n        kind,\n        operation: \"update\",\n        issues: [\n          { path: \"patch\", message: \"Provide a declared node property\" },\n        ],\n      },\n    );\n  }\n\n  if (\n    uniqueConstraints.length > 0 &&\n    (backend.hardDeleteUniquesByNodeIds === undefined ||\n      backend.insertUniqueBatch === undefined ||\n      backend.checkUniqueBatch === undefined)\n  ) {\n    throw new ConfigurationError(\n      \"updateWhere() requires batched uniqueness sidecar operations for constrained nodes\",\n      { code: \"SET_UPDATE_UNIQUENESS_UNSUPPORTED\", kind },\n    );\n  }\n  if (\n    getSearchableFields(schema).length > 0 &&\n    (backend.upsertFulltext === undefined ||\n      backend.deleteFulltext === undefined ||\n      backend.upsertFulltextBatch === undefined ||\n      backend.deleteFulltextBatch === undefined)\n  ) {\n    throw new ConfigurationError(\n      \"updateWhere() requires batched fulltext sidecar operations for searchable nodes\",\n      { code: \"SET_UPDATE_FULLTEXT_UNSUPPORTED\", kind },\n    );\n  }\n  if (\n    getEmbeddingFields(schema).length > 0 &&\n    (backend.upsertEmbedding === undefined ||\n      backend.deleteEmbedding === undefined ||\n      backend.upsertEmbeddingBatch === undefined ||\n      backend.deleteEmbeddingBatch === undefined)\n  ) {\n    throw new ConfigurationError(\n      \"updateWhere() requires batched vector sidecar operations for embedded nodes\",\n      { code: \"SET_UPDATE_VECTOR_UNSUPPORTED\", kind },\n    );\n  }\n\n  const hookContext = ctx.createBulkOperationContext(\"updateWhere\", kind);\n  return ctx.withBulkOperationHooks(hookContext, () =>\n    runInWriteTransaction(\n      ctx,\n      backend,\n      async (target, lock) => {\n        const updateNodeSet = target.updateNodeSet;\n        if (updateNodeSet === undefined) {\n          throw new ConfigurationError(\n            \"The transaction backend does not support set-based node updates\",\n            { code: \"SET_UPDATE_UNSUPPORTED\", kind },\n          );\n        }\n        const hardDeleteUniquesByNodeIds = target.hardDeleteUniquesByNodeIds;\n        if (\n          uniqueConstraints.length > 0 &&\n          (hardDeleteUniquesByNodeIds === undefined ||\n            target.insertUniqueBatch === undefined ||\n            target.checkUniqueBatch === undefined)\n        ) {\n          throw new ConfigurationError(\n            \"The transaction backend lacks batched uniqueness operations\",\n            { code: \"SET_UPDATE_UNIQUENESS_UNSUPPORTED\", kind },\n          );\n        }\n        if (\n          getSearchableFields(schema).length > 0 &&\n          (target.upsertFulltext === undefined ||\n            target.deleteFulltext === undefined ||\n            target.upsertFulltextBatch === undefined ||\n            target.deleteFulltextBatch === undefined)\n        ) {\n          throw new ConfigurationError(\n            \"The transaction backend lacks batched fulltext operations\",\n            { code: \"SET_UPDATE_FULLTEXT_UNSUPPORTED\", kind },\n          );\n        }\n        if (\n          getEmbeddingFields(schema).length > 0 &&\n          (target.upsertEmbedding === undefined ||\n            target.deleteEmbedding === undefined ||\n            target.upsertEmbeddingBatch === undefined ||\n            target.deleteEmbeddingBatch === undefined)\n        ) {\n          throw new ConfigurationError(\n            \"The transaction backend lacks batched vector operations\",\n            { code: \"SET_UPDATE_VECTOR_UNSUPPORTED\", kind },\n          );\n        }\n        const result = await updateNodeSet({\n          graphId: ctx.graphId,\n          kind,\n          patch,\n          unsetProperties,\n          candidateIds,\n          candidateIdColumn,\n        });\n        if (result.affectedCount === 0) return { affectedCount: 0 };\n\n        const sidecarItems = result.rows.map((row) => {\n          const props = rowPropsToObject(row.props);\n          const validatedProps = validateNodeProps(schema, props, {\n            kind,\n            operation: \"update\",\n            id: row.id,\n          });\n          if (!canonicalEqual(validatedProps, props)) {\n            throw new ValidationError(\n              `Set update would persist a non-canonical ${kind} row`,\n              {\n                entityType: \"node\",\n                kind,\n                operation: \"update\",\n                id: row.id,\n                issues: [\n                  {\n                    path: \"props\",\n                    message: \"The complete row requires schema normalization\",\n                  },\n                ],\n              },\n            );\n          }\n          return {\n            kind,\n            id: row.id,\n            schema,\n            props: validatedProps,\n            uniqueConstraints,\n          };\n        });\n\n        if (uniqueConstraints.length > 0) {\n          await validateResolvedNodeUniqueness(\n            createUniquenessContext(ctx.graphId, ctx.registry, target),\n            sidecarItems.map((item) => ({\n              kind: item.kind,\n              id: item.id,\n              props: item.props,\n              constraints: item.uniqueConstraints,\n            })),\n          );\n          await requireDefined(hardDeleteUniquesByNodeIds)({\n            graphId: ctx.graphId,\n            concreteKind: kind,\n            nodeIds: result.rows.map((row) => row.id),\n          });\n        }\n        await applyNodeInsertSideEffectsBatch(\n          createNodeWriteContext(ctx.graphId, ctx.registry, lock),\n          sidecarItems,\n          target,\n        );\n        return { affectedCount: result.affectedCount };\n      },\n      {\n        didWrite: (result) => result.affectedCount > 0,\n        // The set update re-checks every changed unique key across the\n        // constraint's scope before rebuilding the sidecars, so a shared-scope\n        // constraint makes it a constrained write like any other update.\n        fencesConstraintProbe: nodeFencesConstraintProbe(ctx, kind, \"update\"),\n      },\n    ),\n  );\n}\n\n/**\n * Executes a node update for upsert — bypasses operation hooks\n * and allows updating soft-deleted nodes when clearDeleted is set.\n */\nexport async function executeNodeUpsertUpdate<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  input: UpsertUpdateNodeInput,\n  backend: GraphBackend | TransactionBackend,\n  options?: Readonly<{ clearDeleted?: boolean }>,\n): Promise<Node> {\n  if (input.clearValidTo === true) {\n    assertClearValidToSupported(backend, \"node\");\n  }\n  return runInWriteTransaction(\n    ctx,\n    backend,\n    async (target, lock) => {\n      const validTo = validateOptionalCanonicalIsoDate(\n        input.validTo,\n        \"validTo\",\n      );\n      const identity = ctx.identity;\n      if (\n        identity !== undefined &&\n        (options?.clearDeleted === true || input.validTo !== undefined)\n      ) {\n        await identity.lock(target);\n      }\n      if (identity !== undefined && validTo !== undefined) {\n        await identity.requireValidityEndCompatible(\n          target,\n          { kind: input.kind, id: input.id },\n          validTo,\n        );\n      }\n      const node = await performNodeUpdateWithResurrectionRecovery(\n        ctx,\n        input,\n        target,\n        lock,\n        options,\n      );\n      if (options?.clearDeleted && identity !== undefined) {\n        await identity.foldCreated(target, [\n          { kind: input.kind, id: input.id },\n        ]);\n      }\n      return node;\n    },\n    {\n      fencesConstraintProbe: nodeFencesConstraintProbe(\n        ctx,\n        input.kind,\n        \"update\",\n      ),\n    },\n  );\n}\n\n// ============================================================\n// Node Delete Operations\n// ============================================================\n\nexport async function executeNodeDelete<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  kind: string,\n  id: string,\n  backend: GraphBackend | TransactionBackend,\n): Promise<void> {\n  // Gate outside hooks and transaction (matching edge deletes): an absent or\n  // already-tombstoned node is a no-op, so it neither fires hooks nor opens a\n  // write transaction (empty transactions are costly on libsql). The cascade\n  // re-reads inside the transaction, so a node concurrently deleted between\n  // this gate and the write lock is still handled correctly.\n  const gate = await backend.getNode(ctx.graphId, kind, id);\n  if (!gate || gate.deleted_at) return;\n\n  const opContext = ctx.createOperationContext(\"delete\", \"node\", kind, id);\n\n  return runHookedWriteOperation(\n    ctx,\n    opContext,\n    backend,\n    async (target, lock) => {\n      const identity = ctx.identity;\n      if (identity !== undefined) await identity.lock(target);\n      const registration = getNodeRegistration(ctx.graph, kind);\n      // This preflight is NOT removable round-trip fat: the soft-delete\n      // pipeline consumes the pre-image (uniqueness entries are keyed by\n      // props-derived constraint keys), and this in-transaction read is\n      // the concurrency-correct source for it.\n      const preflight = await target.getNode(ctx.graphId, kind, id);\n      if (!preflight || !isLiveNodeRow(preflight)) return;\n\n      // The cascade (connected edges, uniques, embeddings, fulltext, node) is\n      // not individually atomic, so it runs in one write transaction. Under\n      // recorded-time capture this also collapses the cascade into a single\n      // recorded commit instant instead of one instant per sub-write.\n      await applyNodeSoftDelete(\n        createNodeWriteContext(ctx.graphId, ctx.registry, lock),\n        {\n          existing: preflight,\n          schema: registration.type.schema,\n          uniqueConstraints: registration.unique ?? [],\n          onDelete: registration.onDelete,\n        },\n        target,\n      );\n      if (identity !== undefined) {\n        await identity.detachDeleted(target, { kind, id }, \"soft\");\n      }\n    },\n  );\n}\n\n/**\n * Soft-deletes a batch without per-item operation hooks.\n *\n * Batch collection methods deliberately omit per-item hooks for throughput.\n * Owning the write transaction here also prevents a per-item success from\n * being reported before the batch's outer COMMIT.\n */\nexport async function executeNodeDeleteBatch<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  kind: string,\n  ids: readonly string[],\n  backend: GraphBackend | TransactionBackend,\n): Promise<void> {\n  await runInWriteTransaction(\n    ctx,\n    backend,\n    async (target, lock) => {\n      const identity = ctx.identity;\n      if (identity !== undefined) await identity.lock(target);\n      const registration = getNodeRegistration(ctx.graph, kind);\n      const writeContext = createNodeWriteContext(\n        ctx.graphId,\n        ctx.registry,\n        lock,\n      );\n      let affectedCount = 0;\n\n      for (const id of ids) {\n        // This is both the existence gate and the concurrency-correct\n        // pre-image consumed by uniqueness cleanup. It must stay inside the\n        // batch transaction after the graph write lock is held.\n        const preflight = await target.getNode(ctx.graphId, kind, id);\n        if (!preflight || !isLiveNodeRow(preflight)) continue;\n\n        await applyNodeSoftDelete(\n          writeContext,\n          {\n            existing: preflight,\n            schema: registration.type.schema,\n            uniqueConstraints: registration.unique ?? [],\n            onDelete: registration.onDelete,\n          },\n          target,\n        );\n        if (identity !== undefined) {\n          await identity.detachDeleted(target, { kind, id }, \"soft\");\n        }\n        affectedCount += 1;\n      }\n\n      return affectedCount;\n    },\n    { didWrite: (affectedCount) => affectedCount > 0 },\n  );\n}\n\n/**\n * Executes a node hard delete operation (permanent removal).\n *\n * Unlike soft delete, this permanently removes the node and all\n * associated data (uniqueness entries, embeddings) from the database.\n */\nexport async function executeNodeHardDelete<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  kind: string,\n  id: string,\n  backend: GraphBackend | TransactionBackend,\n): Promise<void> {\n  // Gate outside hooks and transaction so an absent node neither fires hooks\n  // nor opens an empty transaction (see executeNodeDelete). The cascade\n  // re-reads inside the transaction.\n  const gate = await backend.getNode(ctx.graphId, kind, id);\n  if (!gate) return;\n\n  const opContext = ctx.createOperationContext(\"delete\", \"node\", kind, id);\n\n  return runHookedWriteOperation(\n    ctx,\n    opContext,\n    backend,\n    async (target, lock) => {\n      const identity = ctx.identity;\n      if (identity !== undefined) await identity.lock(target);\n      const registration = getNodeRegistration(ctx.graph, kind);\n      // No in-transaction preflight (unlike soft delete, whose pipeline\n      // consumes the pre-image for uniqueness-key cleanup): every hard\n      // cascade member is id-keyed and idempotent — the delete-behavior\n      // check re-reads edges itself, `hardDeleteNode` deletes by primary\n      // key, and embeddings clean up by id — so a node concurrently\n      // removed between the gate and the write lock makes each statement\n      // a 0-row no-op.\n\n      // The cascade (edges, node, embeddings) is not individually atomic, so\n      // it runs in one write transaction. Embeddings live in strategy-owned\n      // per-`(kind, field)` tables, so they are cleaned up here rather than\n      // in the backend's graph-agnostic `hardDeleteNode` cascade.\n      await applyNodeHardDelete(\n        createNodeWriteContext(ctx.graphId, ctx.registry, lock),\n        {\n          kind,\n          id,\n          schema: registration.type.schema,\n          onDelete: registration.onDelete,\n        },\n        target,\n      );\n      if (identity !== undefined) {\n        await identity.detachDeleted(target, { kind, id }, \"hard\");\n      }\n    },\n  );\n}\n\n// ============================================================\n// Get-Or-Create Operations\n// ============================================================\n\nexport async function executeNodeGetOrCreateByConstraint<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  kind: string,\n  constraintName: string,\n  props: Record<string, unknown>,\n  backend: GraphBackend | TransactionBackend,\n  options?: NodeGetOrCreateByConstraintOptions,\n): Promise<Readonly<{ node: Node; action: GetOrCreateAction }>> {\n  const ifExists = options?.ifExists ?? \"return\";\n\n  const registration = getNodeRegistration(ctx.graph, kind);\n  const nodeKind = registration.type;\n  const validatedProps = validateNodeProps(nodeKind.schema, props, {\n    kind,\n    operation: \"create\",\n  });\n\n  const constraint = resolveConstraint(ctx.graph, kind, constraintName);\n\n  if (!checkWherePredicate(constraint, validatedProps)) {\n    const node = await executeNodeCreate(\n      ctx,\n      { kind, props: validatedProps },\n      backend,\n      { propsPreValidated: true },\n    );\n    return { node, action: \"created\" };\n  }\n\n  const key = computeUniqueKey(\n    validatedProps,\n    constraint.fields,\n    constraint.collation,\n  );\n\n  const kindsToCheck = getKindsForUniquenessCheck(\n    kind,\n    constraint.scope,\n    ctx.registry,\n  );\n\n  // The probe runs outside any transaction (the found path is a pure read),\n  // and each write leg opens its own hooked transaction. A concurrent create\n  // can therefore reserve the key between the probe and the create — that\n  // surfaces as UniquenessError, and the caller retries the probe once to\n  // converge on the row the winner created.\n  async function attempt(): Promise<\n    Readonly<{ node: Node; action: GetOrCreateAction }>\n  > {\n    const existingUniqueRow = await findUniqueRowAcrossKinds(\n      backend,\n      ctx.graphId,\n      constraint.name,\n      key,\n      kindsToCheck,\n      true,\n    );\n\n    if (existingUniqueRow === undefined) {\n      const node = await executeNodeCreate(\n        ctx,\n        { kind, props: validatedProps },\n        backend,\n        { propsPreValidated: true },\n      );\n      return { node, action: \"created\" };\n    }\n\n    // Fetch using concrete_kind (may differ from requested kind\n    // when scope is \"kindWithSubClasses\" and the match is on a sibling/parent kind)\n    const existingRow = await backend.getNode(\n      ctx.graphId,\n      existingUniqueRow.concrete_kind,\n      existingUniqueRow.node_id,\n    );\n\n    if (existingRow === undefined) {\n      const node = await executeNodeCreate(\n        ctx,\n        { kind, props: validatedProps },\n        backend,\n        { propsPreValidated: true },\n      );\n      return { node, action: \"created\" };\n    }\n\n    const isSoftDeleted = existingRow.deleted_at !== undefined;\n\n    if (isSoftDeleted || ifExists === \"update\") {\n      const concreteKind = existingUniqueRow.concrete_kind;\n      const node = await executeNodeUpsertUpdate(\n        ctx,\n        {\n          kind: concreteKind,\n          id: existingRow.id as UpdateNodeInput[\"id\"],\n          props: validatedProps,\n        },\n        backend,\n        { clearDeleted: isSoftDeleted },\n      );\n      return { node, action: isSoftDeleted ? \"resurrected\" : \"updated\" };\n    }\n\n    return { node: rowToNode(existingRow), action: \"found\" };\n  }\n\n  try {\n    return await attempt();\n  } catch (error) {\n    if (!(error instanceof UniquenessError)) throw error;\n    return attempt();\n  }\n}\n\n// ============================================================\n// Find-By-Constraint Operations\n// ============================================================\n\nexport async function executeNodeFindByConstraint<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  kind: string,\n  constraintName: string,\n  props: Record<string, unknown>,\n  backend: GraphBackend | TransactionBackend,\n): Promise<Node | undefined> {\n  const registration = getNodeRegistration(ctx.graph, kind);\n  const nodeKind = registration.type;\n  const validatedProps = validateNodeProps(nodeKind.schema, props, {\n    kind,\n    operation: \"create\",\n  });\n\n  const constraint = resolveConstraint(ctx.graph, kind, constraintName);\n  if (!checkWherePredicate(constraint, validatedProps)) return undefined;\n\n  const key = computeUniqueKey(\n    validatedProps,\n    constraint.fields,\n    constraint.collation,\n  );\n\n  const kindsToCheck = getKindsForUniquenessCheck(\n    kind,\n    constraint.scope,\n    ctx.registry,\n  );\n\n  const existingUniqueRow = await findUniqueRowAcrossKinds(\n    backend,\n    ctx.graphId,\n    constraint.name,\n    key,\n    kindsToCheck,\n    false,\n  );\n\n  if (existingUniqueRow === undefined) return undefined;\n\n  const existingRow = await backend.getNode(\n    ctx.graphId,\n    existingUniqueRow.concrete_kind,\n    existingUniqueRow.node_id,\n  );\n\n  if (existingRow === undefined || existingRow.deleted_at !== undefined)\n    return undefined;\n\n  return rowToNode(existingRow);\n}\n\n// ============================================================\n// Bulk Find-By-Constraint\n// ============================================================\n\n/**\n * Validates all items and computes unique constraint keys.\n * Shared by both bulk find and bulk getOrCreate.\n */\nfunction validateAndComputeKeys(\n  nodeKind: NodeType,\n  kind: string,\n  constraint: UniqueConstraint,\n  items: readonly Readonly<{ props: Record<string, unknown> }>[],\n): { validatedProps: Record<string, unknown>; key: string | undefined }[] {\n  const validated: {\n    validatedProps: Record<string, unknown>;\n    key: string | undefined;\n  }[] = [];\n\n  for (const item of items) {\n    const validatedProps = validateNodeProps(nodeKind.schema, item.props, {\n      kind,\n      operation: \"create\",\n    });\n    const applies = checkWherePredicate(constraint, validatedProps);\n    const key =\n      applies ?\n        computeUniqueKey(\n          validatedProps,\n          constraint.fields,\n          constraint.collation,\n        )\n      : undefined;\n    validated.push({ validatedProps, key });\n  }\n\n  return validated;\n}\n\nfunction collectUniqueKeys(\n  validated: readonly { key: string | undefined }[],\n): string[] {\n  return [\n    ...new Set(\n      validated\n        .map((entry) => entry.key)\n        .filter((key): key is string => key !== undefined),\n    ),\n  ];\n}\n\nexport async function executeNodeBulkFindByConstraint<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  kind: string,\n  constraintName: string,\n  items: readonly Readonly<{ props: Record<string, unknown> }>[],\n  backend: GraphBackend | TransactionBackend,\n): Promise<(Node | undefined)[]> {\n  if (items.length === 0) return [];\n\n  const registration = getNodeRegistration(ctx.graph, kind);\n  const nodeKind = registration.type;\n  const constraint = resolveConstraint(ctx.graph, kind, constraintName);\n\n  const validated = validateAndComputeKeys(nodeKind, kind, constraint, items);\n  const uniqueKeys = collectUniqueKeys(validated);\n\n  const kindsToCheck = getKindsForUniquenessCheck(\n    kind,\n    constraint.scope,\n    ctx.registry,\n  );\n\n  const existingByKey =\n    uniqueKeys.length > 0 ?\n      await batchCheckUniqueAcrossKinds(\n        backend,\n        ctx.graphId,\n        constraint.name,\n        uniqueKeys,\n        kindsToCheck,\n        false,\n      )\n    : new Map<string, { node_id: string; concrete_kind: string }>();\n\n  // Assemble results, deduplicating keys seen within the batch\n  const results: (Node | undefined)[] = Array.from({ length: items.length });\n  const seenKeys = new Map<string, number>();\n\n  for (const [index, { key }] of validated.entries()) {\n    if (key === undefined) {\n      results[index] = undefined;\n      continue;\n    }\n\n    const previousIndex = seenKeys.get(key);\n    if (previousIndex !== undefined) {\n      results[index] = results[previousIndex];\n      continue;\n    }\n    seenKeys.set(key, index);\n\n    const existing = existingByKey.get(key);\n    if (existing === undefined) {\n      results[index] = undefined;\n      continue;\n    }\n\n    const existingRow = await backend.getNode(\n      ctx.graphId,\n      existing.concrete_kind,\n      existing.node_id,\n    );\n\n    if (existingRow === undefined || existingRow.deleted_at !== undefined) {\n      results[index] = undefined;\n      continue;\n    }\n\n    results[index] = rowToNode(existingRow);\n  }\n\n  return results;\n}\n\n// ============================================================\n// Bulk Find-By-Index\n// ============================================================\n\n/**\n * Resolves a declared node index by name, validating the kind first.\n *\n * @throws {KindNotFoundError} when the node kind is not registered\n * @throws {NodeIndexNotFoundError} when no node index of that name exists\n */\nfunction resolveNodeIndex<G extends GraphDef>(\n  graph: G,\n  kind: string,\n  indexName: string,\n): NodeIndexDeclaration {\n  getNodeRegistration(graph, kind);\n\n  const declaration = graph.indexes?.find(\n    (candidate) =>\n      candidate.entity === \"node\" &&\n      candidate.kind === kind &&\n      candidate.name === indexName,\n  );\n\n  if (declaration?.entity !== \"node\") {\n    throw new NodeIndexNotFoundError(indexName, kind);\n  }\n\n  // GIN-family indexes serve containment / substring predicates, not the\n  // equality probes bulkFindByIndex compiles — targeting one here would\n  // silently probe with the wrong extraction semantics.\n  if (declaration.method !== undefined) {\n    throw new ConfigurationError(\n      `bulkFindByIndex cannot probe index \"${indexName}\" (method ` +\n        `\"${declaration.method}\"): only btree indexes serve equality probes.`,\n      { indexName, kind, method: declaration.method },\n    );\n  }\n\n  return declaration;\n}\n\nconst INDEX_PROBE_EXPECTED_TYPEOF: Partial<Record<ValueType, string>> = {\n  string: \"string\",\n  number: \"number\",\n  boolean: \"boolean\",\n};\n\n/**\n * Validates a single probe value against its declared index-field type.\n * Missing/null values are valid (null probes); only a present, scalar\n * value of the wrong type is rejected.\n */\nfunction validateIndexProbeValue(\n  value: unknown,\n  valueType: ValueType | undefined,\n  pointer: JsonPointer,\n  kind: string,\n): void {\n  if (value === undefined || value === null) return;\n\n  // Index keys are scalar; a non-scalar probe can't be bound and must fail\n  // with a typed error rather than a cryptic driver bind error downstream.\n  if (\n    typeof value !== \"string\" &&\n    typeof value !== \"number\" &&\n    typeof value !== \"boolean\" &&\n    !(value instanceof Date)\n  ) {\n    throw indexProbeTypeError(\n      pointer,\n      kind,\n      \"a scalar (string, number, boolean, or Date)\",\n      value,\n    );\n  }\n\n  if (valueType === \"date\") {\n    if (value instanceof Date || typeof value === \"string\") return;\n    throw indexProbeTypeError(\n      pointer,\n      kind,\n      \"date (Date or ISO string)\",\n      value,\n    );\n  }\n\n  const expected = INDEX_PROBE_EXPECTED_TYPEOF[valueType ?? \"unknown\"];\n  if (expected === undefined) return;\n  if (typeof value !== expected) {\n    throw indexProbeTypeError(pointer, kind, expected, value);\n  }\n}\n\nfunction indexProbeTypeError(\n  pointer: JsonPointer,\n  kind: string,\n  expected: string,\n  value: unknown,\n): ValidationError {\n  return new ValidationError(\n    `Index probe value for \"${pointer}\" on node kind \"${kind}\" has an incompatible type`,\n    {\n      entityType: \"node\",\n      kind,\n      issues: [\n        {\n          path: pointer,\n          message: `Expected ${expected}, received ${typeof value}`,\n          code: \"invalid_type\",\n        },\n      ],\n    },\n  );\n}\n\n/** Coerces a non-null probe value into a driver-bindable scalar. */\nfunction coerceIndexProbeBind(\n  value: unknown,\n  adapter: DialectAdapter,\n): unknown {\n  return adapter.bindValue(normalizeProbeScalar(value as ProbeScalar));\n}\n\ntype ProbeScalar = string | number | boolean | Date;\n\n/**\n * Canonical scalar form of a validated probe value, shared by the dedup key\n * and the bound SQL value so the two can never drift (a Date and its ISO\n * string normalize identically — and produce identical predicates).\n */\nfunction normalizeProbeScalar(value: ProbeScalar): string | number | boolean {\n  return value instanceof Date ? value.toISOString() : value;\n}\n\nconst PROBE_NULL_TAG = 0;\nconst PROBE_VALUE_TAG = 1;\n\n/**\n * Stable dedup key for a probe tuple. Each slot is tagged so a null/undefined\n * value can never collide with a string that happens to equal a sentinel -\n * null maps to [0], a present scalar to [1, normalized].\n */\nfunction canonicalIndexProbeKey(probe: readonly unknown[]): string {\n  return JSON.stringify(\n    probe.map((value) =>\n      value === undefined || value === null ?\n        [PROBE_NULL_TAG]\n      : [PROBE_VALUE_TAG, normalizeProbeScalar(value as ProbeScalar)],\n    ),\n  );\n}\n\n/**\n * Batched candidate retrieval against a declared node index.\n *\n * Emits a single query against the nodes table: each input's indexed-field\n * values become a probe predicate (null-safe equality, reusing the index's\n * own extraction expressions so the planner can use the physical index), and\n * a `CASE` selector tags each matched row with the deduped probe group it\n * satisfies. Rows are grouped back to input positions in order; each input's\n * candidate set is ordered by node id.\n */\nexport async function executeNodeBulkFindByIndex<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  kind: string,\n  indexName: string,\n  items: readonly Readonly<{ props: Record<string, unknown> }>[],\n  backend: GraphBackend | TransactionBackend,\n  options?: NodeBulkFindByIndexOptions,\n): Promise<Node[][]> {\n  if (items.length === 0) return [];\n\n  const index = resolveNodeIndex(ctx.graph, kind, indexName);\n\n  if (index.fields.length === 0) {\n    throw new ConfigurationError(\n      `bulkFindByIndex requires an index with at least one prop-based field on index \"${indexName}\" (node kind \"${kind}\")`,\n      { indexName, kind },\n      {\n        suggestion:\n          \"bulkFindByIndex probes by prop values from each item; an index declared with only keySystemColumns/coveringFields (no fields) has nothing to probe by.\",\n      },\n    );\n  }\n\n  // Date-typed lookup keys can't satisfy the cross-backend parity guarantee:\n  // SQLite compares stored ISO text byte-wise while Postgres compares\n  // timestamptz instants, so equal instants in different ISO forms diverge.\n  // Declare the gap rather than return backend-dependent results.\n  if (index.fieldValueTypes.includes(\"date\")) {\n    throw new ConfigurationError(\n      `bulkFindByIndex does not support date-typed key fields on index \"${indexName}\" (node kind \"${kind}\")`,\n      { indexName, kind },\n      {\n        suggestion:\n          \"Date index keys compare differently across SQLite and PostgreSQL. Use a string-encoded key field, or query date predicates via store.query(...).where(...).\",\n      },\n    );\n  }\n\n  const limitPerInput = options?.limitPerInput;\n  if (\n    limitPerInput !== undefined &&\n    (!Number.isInteger(limitPerInput) || limitPerInput <= 0)\n  ) {\n    throw new ValidationError(\n      \"bulkFindByIndex limitPerInput must be a positive integer\",\n      {\n        entityType: \"node\",\n        kind,\n        issues: [\n          {\n            path: \"limitPerInput\",\n            message: `Expected a positive integer, received ${String(limitPerInput)}`,\n            code: \"invalid_value\",\n          },\n        ],\n      },\n    );\n  }\n\n  const adapter = getDialect(backend.dialect);\n\n  // 1. Extract + validate each input's indexed-field probe tuple.\n  const probes: unknown[][] = items.map((item) =>\n    index.fields.map((pointer, position) => {\n      const value = resolveJsonPointer(item.props, pointer);\n      validateIndexProbeValue(\n        value,\n        index.fieldValueTypes[position],\n        pointer,\n        kind,\n      );\n      return value;\n    }),\n  );\n\n  // 2. Dedupe probe tuples; map each distinct tuple to its input positions.\n  const groupByKey = new Map<string, number>();\n  const groupProbes: unknown[][] = [];\n  const groupToInputs: number[][] = [];\n  for (const [inputIndex, probe] of probes.entries()) {\n    const key = canonicalIndexProbeKey(probe);\n    const existing = groupByKey.get(key);\n    if (existing === undefined) {\n      groupByKey.set(key, groupProbes.length);\n      groupProbes.push(probe);\n      groupToInputs.push([inputIndex]);\n      continue;\n    }\n    groupToInputs[existing]?.push(inputIndex);\n  }\n\n  // 3. Build probe predicates shared by the CASE selector and WHERE filter.\n  const schema =\n    backend.tableNames ?\n      createSqlSchema(backend.tableNames)\n    : DEFAULT_SQL_SCHEMA;\n  const compileContext: IndexCompilationContext = {\n    dialect: backend.dialect,\n    propsColumn: sql.raw(`\"props\"`),\n    systemColumn: (column) => sql.raw(`\"${column}\"`),\n  };\n  const fieldKeys = compileNodeIndexFieldKeys(index, compileContext);\n\n  const groupPredicates = groupProbes.map(\n    (probe) =>\n      sql`(${sql.join(\n        fieldKeys.map((fieldKey, position) => {\n          const value = probe[position];\n          if (value === undefined || value === null) {\n            return sql`${fieldKey} IS NULL`;\n          }\n          return adapter.nullSafeEquals(\n            fieldKey,\n            sql`${coerceIndexProbeBind(value, adapter)}`,\n          );\n        }),\n        sql` AND `,\n      )})`,\n  );\n\n  const caseBranches = groupPredicates.map(\n    (predicate, group) => sql`WHEN ${predicate} THEN ${sql.raw(String(group))}`,\n  );\n  const probeIndexExpr = sql`CASE ${sql.join(caseBranches, sql` `)} ELSE NULL END`;\n\n  const conditions: SqlFragment[] = [\n    sql`\"graph_id\" = ${ctx.graphId}`,\n    sql`\"kind\" = ${kind}`,\n    sql`\"deleted_at\" IS NULL`,\n  ];\n  if (index.where !== undefined) {\n    conditions.push(compileIndexWhere(compileContext, index.where));\n  }\n  conditions.push(sql`(${sql.join(groupPredicates, sql` OR `)})`);\n  const whereClause = sql.join(conditions, sql` AND `);\n\n  // The probe matching runs against the nodes table; rows are hydrated\n  // separately via the backend's normalized node reads so the returned\n  // shape is identical to every other node API (props/timestamp\n  // normalization is backend-owned, not re-derived from raw driver rows).\n  const probedSelect = sql`SELECT \"id\", ${probeIndexExpr} AS probe_idx FROM ${schema.nodesTable} WHERE ${whereClause}`;\n\n  // limitPerInput caps each input's candidates per probe group. When the\n  // backend supports window functions we cap in SQL (`ROW_NUMBER()`), which\n  // also avoids transferring excess ids on low-selectivity keys. Otherwise we\n  // degrade gracefully: fetch all matching ids and cap per group in JS before\n  // hydration — the cap stays correct, only the id transfer is unbounded.\n  const capInSql =\n    limitPerInput !== undefined && backend.capabilities.windowFunctions;\n\n  const query =\n    capInSql ?\n      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\"`\n    : sql`${probedSelect} ORDER BY probe_idx, \"id\"`;\n\n  // 4. Execute, hydrate matched nodes, and group back to input positions.\n  const rawMatches = await backend.execute<ProbeMatch>(\n    asCompiledRowsSql(query),\n  );\n  const matches =\n    limitPerInput !== undefined && !capInSql ?\n      capMatchesPerGroup(rawMatches, limitPerInput)\n    : rawMatches;\n\n  const nodesById = await hydrateNodesById(\n    backend,\n    ctx.graphId,\n    kind,\n    matches.map((match) => match.id),\n  );\n\n  const results: Node[][] = Array.from({ length: items.length }, () => []);\n  for (const match of matches) {\n    const node = nodesById.get(match.id);\n    if (node === undefined) continue;\n    const inputs = groupToInputs[match.probe_idx];\n    if (inputs === undefined) continue;\n    for (const inputIndex of inputs) {\n      results[inputIndex]?.push(node);\n    }\n  }\n\n  return results;\n}\n\ntype ProbeMatch = Readonly<{ id: string; probe_idx: number }>;\n\n/**\n * Caps matches to the first `limitPerInput` per probe group (the JS-side\n * equivalent of the `ROW_NUMBER()` window). Relies on `matches` already being\n * ordered by `(probe_idx, id)`, so the kept rows are the lowest ids per group.\n */\nfunction capMatchesPerGroup(\n  matches: readonly ProbeMatch[],\n  limitPerInput: number,\n): ProbeMatch[] {\n  const perGroupCount = new Map<number, number>();\n  const capped: ProbeMatch[] = [];\n  for (const match of matches) {\n    const count = perGroupCount.get(match.probe_idx) ?? 0;\n    if (count >= limitPerInput) continue;\n    perGroupCount.set(match.probe_idx, count + 1);\n    capped.push(match);\n  }\n  return capped;\n}\n\n/** Hydrates live nodes by id via the backend's normalized node reads. */\nasync function hydrateNodesById(\n  backend: GraphBackend | TransactionBackend,\n  graphId: string,\n  kind: string,\n  ids: readonly string[],\n): Promise<Map<string, Node>> {\n  const rowsById = await getNodeRowsByIds(backend, graphId, kind, ids);\n  const nodesById = new Map<string, Node>();\n  for (const [id, row] of rowsById) {\n    if (row.deleted_at !== undefined) continue;\n    nodesById.set(id, rowToNode(row));\n  }\n  return nodesById;\n}\n\n// ============================================================\n// Bulk Get-Or-Create-By-Constraint\n// ============================================================\n\nexport async function executeNodeBulkGetOrCreateByConstraint<\n  G extends GraphDef,\n>(\n  ctx: NodeOperationContext<G>,\n  kind: string,\n  constraintName: string,\n  items: readonly Readonly<{ props: Record<string, unknown> }>[],\n  backend: GraphBackend | TransactionBackend,\n  options?: NodeGetOrCreateByConstraintOptions,\n): Promise<Readonly<{ node: Node; action: GetOrCreateAction }>[]> {\n  if (items.length === 0) return [];\n\n  const ifExists = options?.ifExists ?? \"return\";\n  const registration = getNodeRegistration(ctx.graph, kind);\n  const nodeKind = registration.type;\n  const constraint = resolveConstraint(ctx.graph, kind, constraintName);\n\n  // Step 1: Validate all props and compute keys\n  const validated = validateAndComputeKeys(nodeKind, kind, constraint, items);\n  const uniqueKeys = collectUniqueKeys(validated);\n\n  const kindsToCheck = getKindsForUniquenessCheck(\n    kind,\n    constraint.scope,\n    ctx.registry,\n  );\n\n  type Result = Readonly<{ node: Node; action: GetOrCreateAction }>;\n\n  // Steps 2-6 are one convergence attempt: the batch probe runs outside any\n  // transaction and each write leg opens its own, so a concurrent create can\n  // reserve a key between them. The uniques primary key catches that and raises\n  // `UniquenessError`; re-running the whole attempt converges on the winner's\n  // row. Without this the single-item path retried and the batch failed\n  // outright, which is the asymmetry #428 called out.\n  async function attempt(): Promise<Result[]> {\n    // Step 2: Batch-check existing keys\n    const existingByKey =\n      uniqueKeys.length > 0 ?\n        await batchCheckUniqueAcrossKinds(\n          backend,\n          ctx.graphId,\n          constraint.name,\n          uniqueKeys,\n          kindsToCheck,\n          true,\n        )\n      : new Map<\n          string,\n          {\n            node_id: string;\n            concrete_kind: string;\n            deleted_at: string | undefined;\n          }\n        >();\n\n    // Step 3: Partition into toCreate, toFetch, and duplicates\n    const toCreate: { index: number; input: CreateNodeInput }[] = [];\n    const toFetch: {\n      index: number;\n      nodeId: string;\n      concreteKind: string;\n      validatedProps: Record<string, unknown>;\n    }[] = [];\n    const duplicateOf: { index: number; sourceIndex: number }[] = [];\n    const seenKeys = new Map<string, number>();\n\n    for (const [index, { validatedProps, key }] of validated.entries()) {\n      if (key === undefined) {\n        toCreate.push({ index, input: { kind, props: validatedProps } });\n        continue;\n      }\n\n      const previousIndex = seenKeys.get(key);\n      if (previousIndex !== undefined) {\n        duplicateOf.push({ index, sourceIndex: previousIndex });\n        continue;\n      }\n\n      seenKeys.set(key, index);\n\n      const existing = existingByKey.get(key);\n      if (existing === undefined) {\n        toCreate.push({ index, input: { kind, props: validatedProps } });\n      } else {\n        toFetch.push({\n          index,\n          nodeId: existing.node_id,\n          concreteKind: existing.concrete_kind,\n          validatedProps,\n        });\n      }\n    }\n\n    const results: Result[] = Array.from({ length: items.length });\n\n    // Step 4: Execute creates\n    if (toCreate.length > 0) {\n      const createInputs = toCreate.map((entry) => entry.input);\n      const createdNodes = await executeNodeCreateBatch(\n        ctx,\n        createInputs,\n        backend,\n        { propsPreValidated: true },\n      );\n      for (const [batchIndex, entry] of toCreate.entries()) {\n        results[entry.index] = {\n          node: requireDefined(createdNodes[batchIndex]),\n          action: \"created\",\n        };\n      }\n    }\n\n    // Step 5: Handle existing nodes (fetch/update/resurrect)\n    for (const entry of toFetch) {\n      const { index, concreteKind, validatedProps, nodeId } = entry;\n\n      const existingRow = await backend.getNode(\n        ctx.graphId,\n        concreteKind,\n        nodeId,\n      );\n\n      if (existingRow === undefined) {\n        const node = await executeNodeCreate(\n          ctx,\n          { kind, props: validatedProps },\n          backend,\n          { propsPreValidated: true },\n        );\n        results[index] = { node, action: \"created\" };\n        continue;\n      }\n\n      // Read from the NODE ROW this loop just fetched, not from the uniques row\n      // the batch probe captured back in step 2 — the single-item path has\n      // always derived it here (see `executeNodeGetOrCreateByConstraint`), and\n      // one decision with two owners drifts. The uniques copy is also the\n      // staler of the two: step 4's creates run between the probe and this\n      // read, and a peer can soft-delete or resurrect the node in that window.\n      // Whether this write RESURRECTS has to come from the row it will target.\n      const isSoftDeleted = existingRow.deleted_at !== undefined;\n\n      if (isSoftDeleted || ifExists === \"update\") {\n        const node = await executeNodeUpsertUpdate(\n          ctx,\n          {\n            kind: concreteKind,\n            id: existingRow.id as UpdateNodeInput[\"id\"],\n            props: validatedProps,\n          },\n          backend,\n          { clearDeleted: isSoftDeleted },\n        );\n        results[index] = {\n          node,\n          action: isSoftDeleted ? \"resurrected\" : \"updated\",\n        };\n      } else {\n        results[index] = { node: rowToNode(existingRow), action: \"found\" };\n      }\n    }\n\n    // Step 6: Resolve within-batch duplicates by copying the first occurrence's result\n    for (const { index, sourceIndex } of duplicateOf) {\n      const sourceResult = requireDefined(results[sourceIndex]);\n      results[index] = { node: sourceResult.node, action: \"found\" };\n    }\n\n    return results;\n  }\n\n  try {\n    return await attempt();\n  } catch (error) {\n    if (!(error instanceof UniquenessError)) throw error;\n    return attempt();\n  }\n}\n"]}