@nicia-ai/typegraph 0.43.0 → 0.44.0

package/dist/chunk-64LERBFM.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/interchange/types.ts","../src/interchange/export.ts","../src/interchange/import.ts"],"names":["z","isCanonicalIsoDate","storeBackend","getNodeKinds","getEdgeKinds","nowIso","rowPropsToObject","requireDefined","runInWriteTransaction","createNodeBatchValidationBackend","primeBatchValidationCaches","isLiveNodeRow","applyNodeUpdate","checkUniquenessConstraints","applyNodeInsertSideEffectsBatch","UniquenessError","validateOptionalCanonicalIsoDate","applyNodeInsertSideEffects","validateEdgeEndpoints","result"],"mappings":"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","file":"chunk-64LERBFM.cjs","sourcesContent":["/**\n * Graph interchange format types.\n *\n * Defines Zod schemas for importing and exporting graph data.\n * The format is designed to be:\n * - JSON-serializable for API transport\n * - Validated via Zod at runtime\n * - Exportable as JSON Schema for LLM/API documentation\n */\nimport { z } from \"zod\";\n\nimport { isCanonicalIsoDate } from \"../utils/date\";\n\n// ============================================================\n// Format Version\n// ============================================================\n\n/**\n * Current interchange format version.\n * Increment for breaking changes to the format.\n */\nexport const FORMAT_VERSION = \"1.0\" as const;\n\n/**\n * A stored validity-window timestamp (`validFrom` / `validTo`). Must be a\n * canonical fixed-width UTC ISO-8601 string (`YYYY-MM-DDTHH:mm:ss.sssZ`) — the\n * same contract `create` / `update` enforce — because temporal filters compare\n * it as text against the `asOf` read coordinate, and a variable-width value\n * (date-only, offset, missing/variable milliseconds) would mis-sort and\n * silently include or exclude the wrong rows. Convert non-canonical inputs with\n * `new Date(value).toISOString()`.\n */\nconst ValidityTimestampSchema = z.iso\n  .datetime()\n  .refine((value) => isCanonicalIsoDate(value), {\n    message:\n      \"Expected canonical UTC ISO 8601 (YYYY-MM-DDTHH:mm:ss.sssZ); convert with new Date(value).toISOString().\",\n  });\n\n// ============================================================\n// Node Interchange\n// ============================================================\n\n/**\n * Interchange format for a node.\n *\n * Properties are stored as a record to allow schema-agnostic transport.\n * Validation against the actual schema happens during import.\n */\nexport const InterchangeNodeSchema = z.object({\n  kind: z.string().min(1),\n  id: z.string().min(1),\n  properties: z.record(z.string(), z.unknown()),\n  /**\n   * `undefined` (key absent): not requested (`includeTemporal: false`) —\n   * import defaults it to the import's own creation timestamp. `null`:\n   * requested and confirmed the row has no lower bound (e.g. a legacy row\n   * predating the \"omitted validFrom defaults to creation time\" fix) —\n   * import preserves that open-left validity instead of re-stamping it.\n   */\n  validFrom: ValidityTimestampSchema.nullable().optional(),\n  validTo: ValidityTimestampSchema.optional(),\n  meta: z\n    .object({\n      version: z.number().int().positive().optional(),\n      createdAt: z.iso.datetime().optional(),\n      updatedAt: z.iso.datetime().optional(),\n    })\n    .optional(),\n});\n\nexport type InterchangeNode = z.infer<typeof InterchangeNodeSchema>;\n\n// ============================================================\n// Edge Interchange\n// ============================================================\n\n/**\n * Interchange format for an edge.\n *\n * Endpoint references are objects with kind and id, rather than\n * composite strings, for clarity and type safety.\n */\nexport const InterchangeEdgeSchema = z.object({\n  kind: z.string().min(1),\n  id: z.string().min(1),\n  from: z.object({\n    kind: z.string().min(1),\n    id: z.string().min(1),\n  }),\n  to: z.object({\n    kind: z.string().min(1),\n    id: z.string().min(1),\n  }),\n  properties: z.record(z.string(), z.unknown()).default({}),\n  /** See {@link InterchangeNodeSchema}'s `validFrom` for the null/undefined contract. */\n  validFrom: ValidityTimestampSchema.nullable().optional(),\n  validTo: ValidityTimestampSchema.optional(),\n  meta: z\n    .object({\n      createdAt: z.iso.datetime().optional(),\n      updatedAt: z.iso.datetime().optional(),\n    })\n    .optional(),\n});\n\nexport type InterchangeEdge = z.infer<typeof InterchangeEdgeSchema>;\n\n// ============================================================\n// Import Configuration\n// ============================================================\n\n/**\n * Strategy for handling conflicts when a node/edge ID already exists.\n *\n * - `skip`: Keep existing, ignore incoming\n * - `update`: Merge incoming properties into existing\n * - `error`: Throw an error on conflict\n */\nexport const ConflictStrategySchema = z.enum([\"skip\", \"update\", \"error\"]);\nexport type ConflictStrategy = z.infer<typeof ConflictStrategySchema>;\n\n/**\n * Strategy for handling properties not defined in the schema.\n *\n * - `error`: Throw a validation error\n * - `strip`: Remove unknown properties silently\n * - `allow`: Pass through to storage (relies on backend behavior)\n */\nexport const UnknownPropertyStrategySchema = z.enum([\n  \"error\",\n  \"strip\",\n  \"allow\",\n]);\nexport type UnknownPropertyStrategy = z.infer<\n  typeof UnknownPropertyStrategySchema\n>;\n\n/**\n * Options for importing graph data.\n */\nexport const ImportOptionsSchema = z.object({\n  /** How to handle existing nodes/edges with the same ID */\n  onConflict: ConflictStrategySchema,\n  /** How to handle properties not in the schema */\n  onUnknownProperty: UnknownPropertyStrategySchema.default(\"error\"),\n  /** Whether to validate that edge endpoints exist */\n  validateReferences: z.boolean().default(true),\n  /**\n   * Number of items to process in each batch. Each batch pays fixed\n   * per-round-trip costs (existence probe, unique check, one multi-row\n   * insert), so undersized batches dominate import time on client/server\n   * engines: measured on PostgreSQL, 20k nodes + 5k edges import in\n   * 1,515ms at 100 vs 781ms at 1,000. Above ~1,000 the multi-row insert\n   * itself dominates and larger batches stop paying; SQLite is\n   * insensitive to the value (in-process, no round trips). The backend\n   * further splits inserts by its bind-parameter budget, so a large\n   * batch never overruns driver limits.\n   */\n  batchSize: z.number().int().positive().default(1000),\n  /**\n   * Refresh planner statistics (ANALYZE) after an import that created or\n   * updated rows. Bulk loads otherwise run against stale statistics until\n   * the engine catches up on its own. Default: true.\n   */\n  refreshStatistics: z.boolean().optional(),\n  /**\n   * How a streamed import reacts when one chunk reports entity-level errors.\n   * `abort` is the safe default: earlier chunks are already committed, so\n   * callers must not mistake a partial stream for a successful retryable load.\n   * `continue` is reserved for explicit best-effort ingestion.\n   */\n  onStreamChunkError: z.enum([\"abort\", \"continue\"]).default(\"abort\"),\n});\n\n/**\n * Caller-facing options: fields with schema defaults are optional.\n * `importGraph` parses these once at its boundary; internal stages\n * consume {@link ResolvedImportOptions} with every default applied.\n */\nexport type ImportOptions = z.input<typeof ImportOptionsSchema>;\n\n/** {@link ImportOptions} after schema parsing — all defaults resolved. */\nexport type ResolvedImportOptions = z.infer<typeof ImportOptionsSchema>;\n\n// ============================================================\n// Graph Data Source\n// ============================================================\n\n/**\n * Source metadata for graph data.\n *\n * Uses discriminated union to capture different origin types:\n * - `typegraph-export`: Exported from a TypeGraph store\n * - `external`: From a third-party system\n */\nexport const GraphDataSourceSchema = z.discriminatedUnion(\"type\", [\n  z.object({\n    type: z.literal(\"typegraph-export\"),\n    graphId: z.string(),\n    schemaVersion: z.number().int().positive(),\n  }),\n  z.object({\n    type: z.literal(\"external\"),\n    description: z.string().optional(),\n  }),\n]);\n\nexport type GraphDataSource = z.infer<typeof GraphDataSourceSchema>;\n\n// ============================================================\n// Graph Data Envelope\n// ============================================================\n\n/**\n * Complete graph data interchange format.\n *\n * The envelope contains metadata about the data source and format version,\n * plus arrays of nodes and edges to import.\n */\nexport const GraphDataSchema = z.object({\n  formatVersion: z.literal(FORMAT_VERSION),\n  exportedAt: z.iso.datetime(),\n  source: GraphDataSourceSchema,\n  nodes: z.array(InterchangeNodeSchema),\n  edges: z.array(InterchangeEdgeSchema),\n});\n\nexport type GraphData = z.infer<typeof GraphDataSchema>;\n\n/** The metadata envelope emitted before streamed graph entities. */\nexport const GraphDataHeaderSchema = GraphDataSchema.omit({\n  nodes: true,\n  edges: true,\n});\n\nexport type GraphDataHeader = z.infer<typeof GraphDataHeaderSchema>;\n\n/**\n * One bounded unit in the streamed interchange protocol. Nodes always precede\n * edges, so an importer can validate endpoints from rows already written to its\n * target without retaining all prior nodes in memory.\n */\nexport const GraphInterchangeChunkSchema = z.discriminatedUnion(\"type\", [\n  z.object({ type: z.literal(\"header\"), header: GraphDataHeaderSchema }),\n  z.object({ type: z.literal(\"nodes\"), nodes: z.array(InterchangeNodeSchema) }),\n  z.object({ type: z.literal(\"edges\"), edges: z.array(InterchangeEdgeSchema) }),\n]);\n\nexport type GraphInterchangeChunk = z.infer<typeof GraphInterchangeChunkSchema>;\n\n// ============================================================\n// Import Result\n// ============================================================\n\n/**\n * An error that occurred during import.\n */\nexport const ImportErrorSchema = z.object({\n  entityType: z.enum([\"node\", \"edge\"]),\n  kind: z.string(),\n  id: z.string(),\n  error: z.string(),\n});\n\nexport type ImportError = z.infer<typeof ImportErrorSchema>;\n\n/**\n * Result of an import operation.\n *\n * Contains counts of created/updated/skipped entities and any errors.\n */\nexport const ImportResultSchema = z.object({\n  success: z.boolean(),\n  nodes: z.object({\n    created: z.number().int().nonnegative(),\n    updated: z.number().int().nonnegative(),\n    skipped: z.number().int().nonnegative(),\n  }),\n  edges: z.object({\n    created: z.number().int().nonnegative(),\n    updated: z.number().int().nonnegative(),\n    skipped: z.number().int().nonnegative(),\n  }),\n  errors: z.array(ImportErrorSchema),\n});\n\nexport type ImportResult = z.infer<typeof ImportResultSchema>;\n\n// ============================================================\n// Export Options\n// ============================================================\n\n/**\n * Options for exporting graph data.\n */\nexport const ExportOptionsSchema = z.object({\n  /** Filter to specific node kinds (undefined = all) */\n  nodeKinds: z.array(z.string()).optional(),\n  /** Filter to specific edge kinds (undefined = all) */\n  edgeKinds: z.array(z.string()).optional(),\n  /** Include temporal fields (validFrom, validTo) */\n  includeTemporal: z.boolean().default(false),\n  /** Include metadata (version, timestamps) */\n  includeMeta: z.boolean().default(false),\n  /** Include soft-deleted records */\n  includeDeleted: z.boolean().default(false),\n});\n\n/** Export options with defaults applied (output type) */\nexport type ExportOptions = z.infer<typeof ExportOptionsSchema>;\n\n/** Export options as accepted by exportGraph (input type with optional defaults) */\nexport type ExportOptionsInput = z.input<typeof ExportOptionsSchema>;\n\n/**\n * Export options for {@link exportGraphStream}. `batchSize` bounds the number\n * of node or edge entities retained for one yielded chunk.\n */\nexport const ExportStreamOptionsSchema = ExportOptionsSchema.extend({\n  batchSize: z.number().int().positive().default(1000),\n});\n\nexport type ExportStreamOptions = z.infer<typeof ExportStreamOptionsSchema>;\nexport type ExportStreamOptionsInput = z.input<\n  typeof ExportStreamOptionsSchema\n>;\n","/**\n * Graph data export functionality.\n *\n * Exports nodes and edges from a store to the interchange format.\n */\nimport { type GraphBackend, rowPropsToObject } from \"../backend/types\";\nimport {\n  getEdgeKinds,\n  getNodeKinds,\n  type GraphDef,\n} from \"../core/define-graph\";\nimport { storeBackend } from \"../store/runtime-port\";\nimport { type Store } from \"../store/store\";\nimport { nowIso } from \"../utils/date\";\nimport { requireDefined } from \"../utils/presence\";\nimport {\n  type ExportOptionsInput,\n  type ExportStreamOptionsInput,\n  ExportStreamOptionsSchema,\n  FORMAT_VERSION,\n  type GraphData,\n  type GraphDataHeader,\n  type GraphInterchangeChunk,\n  type InterchangeEdge,\n  type InterchangeNode,\n} from \"./types\";\n\n// ============================================================\n// Export Function\n// ============================================================\n\n/**\n * Export graph data from a store.\n *\n * @param store - The graph store to export from\n * @param options - Export configuration\n * @returns Graph data in interchange format\n *\n * @example\n * ```typescript\n * const data = await exportGraph(store, {\n *   nodeKinds: [\"Person\", \"Organization\"],\n *   includeMeta: true,\n * });\n *\n * // Write to file\n * await fs.writeFile(\"backup.json\", JSON.stringify(data, null, 2));\n * ```\n */\nexport async function exportGraph<G extends GraphDef>(\n  store: Store<G>,\n  options?: ExportOptionsInput,\n): Promise<GraphData> {\n  const nodes: InterchangeNode[] = [];\n  const edges: InterchangeEdge[] = [];\n  let header: GraphDataHeader | undefined;\n  for await (const chunk of exportGraphStream(store, options)) {\n    switch (chunk.type) {\n      case \"header\": {\n        header = chunk.header;\n        break;\n      }\n      case \"nodes\": {\n        nodes.push(...chunk.nodes);\n        break;\n      }\n      case \"edges\": {\n        edges.push(...chunk.edges);\n        break;\n      }\n    }\n  }\n  if (header === undefined) {\n    throw new Error(\"Graph export stream ended before emitting its header.\");\n  }\n  return { ...header, nodes, edges };\n}\n\n/**\n * Exports a graph as bounded node and edge chunks. The stream always yields one\n * header, then every node chunk, then every edge chunk. Consumers that write to\n * a network, file, or fresh working copy can process one chunk at a time rather\n * than materializing a graph-sized {@link GraphData} value.\n */\nexport async function* exportGraphStream<G extends GraphDef>(\n  store: Store<G>,\n  options?: ExportStreamOptionsInput,\n): AsyncIterable<GraphInterchangeChunk> {\n  const resolved = ExportStreamOptionsSchema.parse(options ?? {});\n  const graphId = store.graphId;\n  const backend = storeBackend(store);\n  const nodeKinds = resolved.nodeKinds ?? getNodeKinds(store.graph);\n  const edgeKinds = resolved.edgeKinds ?? getEdgeKinds(store.graph);\n  const schemaVersion = await backend.getActiveSchema(graphId);\n\n  yield {\n    type: \"header\",\n    header: {\n      formatVersion: FORMAT_VERSION,\n      exportedAt: nowIso(),\n      source: {\n        type: \"typegraph-export\",\n        graphId,\n        schemaVersion: schemaVersion?.version ?? 1,\n      },\n    },\n  };\n\n  for (const kind of nodeKinds) {\n    yield* exportNodeChunks(backend, graphId, kind, resolved);\n  }\n  for (const kind of edgeKinds) {\n    yield* exportEdgeChunks(backend, graphId, kind, resolved);\n  }\n}\n\n// ============================================================\n// Node Export\n// ============================================================\n\ntype ExportOptions_ = Readonly<{\n  includeTemporal: boolean;\n  includeMeta: boolean;\n  includeDeleted: boolean;\n}>;\n\nasync function* exportNodeChunks(\n  backend: GraphBackend,\n  graphId: string,\n  kind: string,\n  options: ExportOptions_ & Readonly<{ batchSize: number }>,\n): AsyncIterable<GraphInterchangeChunk> {\n  let after: string | undefined;\n  for (;;) {\n    const rows = await backend.findNodesByKind({\n      graphId,\n      kind,\n      excludeDeleted: !options.includeDeleted,\n      orderBy: \"id\",\n      limit: options.batchSize,\n      ...(after === undefined ? {} : { after }),\n    });\n    if (rows.length === 0) return;\n    const nodes = rows.map((row) => {\n      const node: InterchangeNode = {\n        kind: row.kind,\n        id: row.id,\n        properties: rowPropsToObject(row.props),\n      };\n\n      if (options.includeTemporal) {\n        // validFrom is always emitted (as `null` when the row has no lower\n        // bound) so import can tell \"confirmed open-left\" apart from \"not\n        // requested\" and preserve it instead of defaulting to import time —\n        // see the schema doc on InterchangeNodeSchema.validFrom. validTo has\n        // no such ambiguity (it was never defaulted), so it stays gated.\n        // `null` (not `undefined`) is the wire-protocol signal here — JSON has\n        // no other way to say \"explicitly cleared\" vs. \"field absent\".\n        const validFrom =\n          // eslint-disable-next-line unicorn/no-null\n          row.valid_from ?? null;\n        (node as { validFrom?: string | null }).validFrom = validFrom;\n        if (row.valid_to) {\n          (node as { validTo?: string }).validTo = row.valid_to;\n        }\n      }\n\n      if (options.includeMeta) {\n        (node as { meta?: InterchangeNode[\"meta\"] }).meta = {\n          version: row.version,\n          createdAt: row.created_at,\n          updatedAt: row.updated_at,\n        };\n      }\n\n      return node;\n    });\n    yield { type: \"nodes\", nodes };\n    if (rows.length < options.batchSize) return;\n    after = requireDefined(rows.at(-1)).id;\n  }\n}\n\n// ============================================================\n// Edge Export\n// ============================================================\n\nasync function* exportEdgeChunks(\n  backend: GraphBackend,\n  graphId: string,\n  kind: string,\n  options: ExportOptions_ & Readonly<{ batchSize: number }>,\n): AsyncIterable<GraphInterchangeChunk> {\n  let after: string | undefined;\n  for (;;) {\n    const rows = await backend.findEdgesByKind({\n      graphId,\n      kind,\n      excludeDeleted: !options.includeDeleted,\n      orderBy: \"id\",\n      limit: options.batchSize,\n      ...(after === undefined ? {} : { after }),\n    });\n    if (rows.length === 0) return;\n    const edges = rows.map((row) => {\n      const edge: InterchangeEdge = {\n        kind: row.kind,\n        id: row.id,\n        from: {\n          kind: row.from_kind,\n          id: row.from_id,\n        },\n        to: {\n          kind: row.to_kind,\n          id: row.to_id,\n        },\n        properties: rowPropsToObject(row.props),\n      };\n\n      if (options.includeTemporal) {\n        // See exportNodesOfKind's validFrom comment: always emitted (as\n        // `null` when open-left) so import can distinguish \"confirmed no\n        // lower bound\" from \"not requested\".\n        const validFrom =\n          // eslint-disable-next-line unicorn/no-null\n          row.valid_from ?? null;\n        (edge as { validFrom?: string | null }).validFrom = validFrom;\n        if (row.valid_to) {\n          (edge as { validTo?: string }).validTo = row.valid_to;\n        }\n      }\n\n      if (options.includeMeta) {\n        (edge as { meta?: InterchangeEdge[\"meta\"] }).meta = {\n          createdAt: row.created_at,\n          updatedAt: row.updated_at,\n        };\n      }\n\n      return edge;\n    });\n    yield { type: \"edges\", edges };\n    if (rows.length < options.batchSize) return;\n    after = requireDefined(rows.at(-1)).id;\n  }\n}\n","/**\n * Graph data import functionality.\n *\n * Imports nodes and edges from the interchange format into a store,\n * with configurable conflict resolution and validation.\n */\nimport type { z } from \"zod\";\n\nimport {\n  type GraphBackend,\n  isLiveNodeRow,\n  rowPropsToObject,\n  type TransactionBackend,\n} from \"../backend/types\";\nimport { validateEdgeEndpoints } from \"../constraints\";\nimport {\n  getEdgeKinds,\n  getNodeKinds,\n  type GraphDef,\n} from \"../core/define-graph\";\nimport { type EdgeRegistration, type NodeRegistration } from \"../core/types\";\nimport { UniquenessError } from \"../errors\";\nimport { type KindRegistry } from \"../registry/kind-registry\";\nimport {\n  createNodeBatchValidationBackend,\n  type NodeCreateDraft,\n  primeBatchValidationCaches,\n} from \"../store/operations/node-operations\";\nimport {\n  applyNodeInsertSideEffects,\n  applyNodeInsertSideEffectsBatch,\n  applyNodeUpdate,\n} from \"../store/operations/node-write-pipeline\";\nimport { runInWriteTransaction } from \"../store/operations/write-transaction\";\nimport { type GraphWriteLock } from \"../store/recorded-capture/clock\";\nimport { storeBackend } from \"../store/runtime-port\";\nimport { type Store } from \"../store/store\";\nimport { checkUniquenessConstraints } from \"../store/uniqueness\";\nimport { validateOptionalCanonicalIsoDate } from \"../utils/date\";\nimport {\n  type GraphData,\n  type GraphDataHeader,\n  type GraphInterchangeChunk,\n  type ImportError,\n  type ImportOptions,\n  ImportOptionsSchema,\n  type ImportResult,\n  type InterchangeEdge,\n  type InterchangeNode,\n  type ResolvedImportOptions,\n  type UnknownPropertyStrategy,\n} from \"./types\";\n\n// ============================================================\n// Import Function\n// ============================================================\n\n/**\n * Import graph data into a store.\n *\n * Nodes are imported first to satisfy edge reference validation.\n * The import runs within a transaction for atomicity when supported.\n *\n * @param store - The graph store to import into\n * @param data - Graph data in interchange format\n * @param options - Import configuration\n * @returns Import statistics and any errors\n *\n * @example\n * ```typescript\n * const result = await importGraph(store, data, {\n *   onConflict: \"update\",\n *   onUnknownProperty: \"strip\",\n * });\n *\n * console.log(`Created ${result.nodes.created} nodes`);\n * ```\n */\nexport async function importGraph<G extends GraphDef>(\n  store: Store<G>,\n  data: GraphData,\n  rawOptions: ImportOptions,\n): Promise<ImportResult> {\n  // Parse ONCE at the public boundary: schema defaults (batchSize, ...)\n  // only exist after parsing, and every internal stage reads them\n  // directly.\n  const options = ImportOptionsSchema.parse(rawOptions);\n  const result = emptyImportResult();\n\n  const errors: ImportError[] = [];\n  const graph = store.graph;\n  const graphId = store.graphId;\n  const backend = storeBackend(store);\n  const registry = store.registry;\n\n  // Build lookup maps for schema validation\n  const nodeSchemas = buildNodeSchemaMap(graph);\n  const edgeSchemas = buildEdgeSchemaMap(graph);\n\n  // Track imported node IDs for reference validation\n  const importedNodeIds = new Set<string>();\n\n  // One transaction on a transactional backend; runs directly otherwise, with\n  // the per-graph write lock taken before any row work — see\n  // runInWriteTransaction for the shared lock-before-rows contract every\n  // writer follows.\n  await runInWriteTransaction(store, backend, async (target, lock) => {\n    await processNodes(\n      target,\n      graphId,\n      registry,\n      data.nodes,\n      nodeSchemas,\n      options,\n      result,\n      errors,\n      importedNodeIds,\n      lock,\n    );\n    await processEdges(\n      target,\n      graphId,\n      registry,\n      data.edges,\n      edgeSchemas,\n      nodeSchemas,\n      options,\n      result,\n      errors,\n      importedNodeIds,\n    );\n  });\n\n  // A bulk load runs against stale planner statistics until ANALYZE runs\n  // (documented regressions: 0.5ms → 5ms traversals on Postgres, 0.9ms →\n  // 23ms fulltext on SQLite), so a mutating import refreshes them once,\n  // after the transaction commits.\n  //\n  // Best-effort: by this point the import is committed, so a failed\n  // statistics refresh must not convert the completed (non-atomic on some\n  // backends, non-retryable) import into a thrown failure — it degrades to\n  // a warning, and the caller can run `store.refreshStatistics()`.\n  await refreshStatisticsAfterImport(store, options, result, \"importGraph\");\n\n  return {\n    ...result,\n    success: errors.length === 0,\n    errors,\n  };\n}\n\n/**\n * Imports a header-first stream of bounded interchange chunks.\n *\n * Each chunk is committed through the same {@link importGraph} implementation\n * as an in-memory import, so validation and conflict semantics stay identical.\n * Chunks are individually atomic on transactional backends; a consumer needing\n * all-or-nothing behavior can import into a disposable working-copy backend and\n * publish it only after this function succeeds.\n *\n * Nodes must precede edges. Once a node chunk commits, edge validation reads the\n * target store rather than retaining every imported node id in memory.\n */\nexport async function importGraphStream<G extends GraphDef>(\n  store: Store<G>,\n  chunks: AsyncIterable<GraphInterchangeChunk>,\n  rawOptions: ImportOptions,\n): Promise<ImportResult> {\n  const options = ImportOptionsSchema.parse(rawOptions);\n  const result = emptyImportResult();\n  let header: GraphDataHeader | undefined;\n  let receivedEdges = false;\n\n  for await (const chunk of chunks) {\n    switch (chunk.type) {\n      case \"header\": {\n        if (header !== undefined) {\n          throw new Error(\n            \"Graph interchange stream emitted more than one header.\",\n          );\n        }\n        header = chunk.header;\n        break;\n      }\n      case \"nodes\": {\n        if (header === undefined) {\n          throw new Error(\"Graph interchange stream must start with a header.\");\n        }\n        if (receivedEdges) {\n          throw new Error(\n            \"Graph interchange stream cannot emit nodes after edges.\",\n          );\n        }\n        if (chunk.nodes.length === 0) break;\n        mergeImportResult(\n          result,\n          await importGraph(store, graphDataForChunk(header, chunk.nodes, []), {\n            ...options,\n            refreshStatistics: false,\n          }),\n        );\n        throwIfStreamChunkFailed(result, options);\n        break;\n      }\n      case \"edges\": {\n        if (header === undefined) {\n          throw new Error(\"Graph interchange stream must start with a header.\");\n        }\n        receivedEdges = true;\n        if (chunk.edges.length === 0) break;\n        mergeImportResult(\n          result,\n          await importGraph(store, graphDataForChunk(header, [], chunk.edges), {\n            ...options,\n            refreshStatistics: false,\n          }),\n        );\n        throwIfStreamChunkFailed(result, options);\n        break;\n      }\n    }\n  }\n\n  if (header === undefined) {\n    throw new Error(\"Graph interchange stream ended before emitting a header.\");\n  }\n  await refreshStatisticsAfterImport(\n    store,\n    options,\n    result,\n    \"importGraphStream\",\n  );\n  return { ...result, success: result.errors.length === 0 };\n}\n\nfunction throwIfStreamChunkFailed(\n  result: ImportResult,\n  options: ResolvedImportOptions,\n): void {\n  if (options.onStreamChunkError === \"continue\" || result.errors.length === 0) {\n    return;\n  }\n  throw new Error(\n    \"Graph interchange stream aborted after a chunk reported import errors. \" +\n      'Earlier chunks remain committed; use onStreamChunkError: \"continue\" for best-effort ingestion.',\n  );\n}\n\nfunction emptyImportResult(): ImportResult {\n  return {\n    success: true,\n    nodes: { created: 0, updated: 0, skipped: 0 },\n    edges: { created: 0, updated: 0, skipped: 0 },\n    errors: [],\n  };\n}\n\nfunction graphDataForChunk(\n  header: GraphDataHeader,\n  nodes: GraphData[\"nodes\"],\n  edges: GraphData[\"edges\"],\n): GraphData {\n  return { ...header, nodes, edges };\n}\nfunction mergeImportResult(target: ImportResult, source: ImportResult): void {\n  target.nodes.created += source.nodes.created;\n  target.nodes.updated += source.nodes.updated;\n  target.nodes.skipped += source.nodes.skipped;\n  target.edges.created += source.edges.created;\n  target.edges.updated += source.edges.updated;\n  target.edges.skipped += source.edges.skipped;\n  target.errors.push(...source.errors);\n}\n\nasync function refreshStatisticsAfterImport<G extends GraphDef>(\n  store: Store<G>,\n  options: ResolvedImportOptions,\n  result: ImportResult,\n  surface: \"importGraph\" | \"importGraphStream\",\n): Promise<void> {\n  const mutationCount =\n    result.nodes.created +\n    result.nodes.updated +\n    result.edges.created +\n    result.edges.updated;\n  if ((options.refreshStatistics ?? true) && mutationCount > 0) {\n    try {\n      await store.refreshStatistics();\n    } catch (error) {\n      if (\n        typeof console !== \"undefined\" &&\n        typeof console.warn === \"function\"\n      ) {\n        console.warn(\n          `[typegraph] ${surface} committed its rows but the follow-up ` +\n            \"statistics refresh failed; run store.refreshStatistics() to \" +\n            \"give the planner fresh statistics.\",\n          error,\n        );\n      }\n    }\n  }\n}\n\n// ============================================================\n// Schema Maps\n// ============================================================\n\ntype NodeSchemaEntry = Readonly<{\n  registration: NodeRegistration;\n  schema: z.ZodObject<z.ZodRawShape>;\n}>;\n\ntype EdgeSchemaEntry = Readonly<{\n  registration: EdgeRegistration;\n  schema: z.ZodObject<z.ZodRawShape>;\n}>;\n\nfunction buildNodeSchemaMap(\n  graph: GraphDef,\n): ReadonlyMap<string, NodeSchemaEntry> {\n  const map = new Map<string, NodeSchemaEntry>();\n\n  for (const kindName of getNodeKinds(graph)) {\n    const registration = graph.nodes[kindName] as NodeRegistration;\n    map.set(kindName, {\n      registration,\n      schema: registration.type.schema,\n    });\n  }\n\n  return map;\n}\n\nfunction buildEdgeSchemaMap(\n  graph: GraphDef,\n): ReadonlyMap<string, EdgeSchemaEntry> {\n  const map = new Map<string, EdgeSchemaEntry>();\n\n  for (const kindName of getEdgeKinds(graph)) {\n    const registration = graph.edges[kindName] as EdgeRegistration;\n    map.set(kindName, {\n      registration,\n      schema: registration.type.schema,\n    });\n  }\n\n  return map;\n}\n\n// ============================================================\n// Node Processing\n// ============================================================\n\nasync function processNodes(\n  backend: GraphBackend | TransactionBackend,\n  graphId: string,\n  registry: KindRegistry,\n  nodes: readonly InterchangeNode[],\n  schemas: ReadonlyMap<string, NodeSchemaEntry>,\n  options: ResolvedImportOptions,\n  result: ImportResult,\n  errors: ImportError[],\n  importedNodeIds: Set<string>,\n  lock: GraphWriteLock,\n): Promise<void> {\n  const batchSize = options.batchSize;\n\n  for (let index = 0; index < nodes.length; index += batchSize) {\n    const batch = nodes.slice(index, index + batchSize);\n    await processNodeSlice(\n      backend,\n      graphId,\n      registry,\n      batch,\n      schemas,\n      options,\n      result,\n      errors,\n      importedNodeIds,\n      lock,\n    );\n  }\n}\n\nfunction recordNodeOutcome(\n  node: InterchangeNode,\n  outcome: ProcessResult,\n  result: ImportResult,\n  errors: ImportError[],\n  importedNodeIds: Set<string>,\n): void {\n  switch (outcome.status) {\n    case \"created\": {\n      result.nodes.created++;\n      importedNodeIds.add(makeNodeKey(node.kind, node.id));\n      break;\n    }\n    case \"updated\": {\n      result.nodes.updated++;\n      importedNodeIds.add(makeNodeKey(node.kind, node.id));\n      break;\n    }\n    case \"skipped\": {\n      result.nodes.skipped++;\n      // A live skipped row is still a valid edge endpoint; a tombstone\n      // is not.\n      if (outcome.liveTarget) {\n        importedNodeIds.add(makeNodeKey(node.kind, node.id));\n      }\n      break;\n    }\n    case \"error\": {\n      errors.push({\n        entityType: \"node\",\n        kind: node.kind,\n        id: node.id,\n        error: outcome.error,\n      });\n      break;\n    }\n  }\n}\n\ntype NodeImportCandidate = Readonly<{\n  node: InterchangeNode;\n  schemaEntry: NodeSchemaEntry;\n  props: Record<string, unknown>;\n  draft: NodeCreateDraft;\n}>;\n\n/**\n * Processes one batchSize slice of nodes with batched round trips:\n * one `getNodes` per kind for existence, one `checkUniqueBatch` per\n * (constraint, kind) for uniqueness pre-checks (both priming the shared\n * batch validation caches), then one multi-row insert and one batched\n * side-effect pass for the accepted creates. Per-row semantics are\n * unchanged — conflicts route by `onConflict`, a uniqueness conflict is a\n * per-row error entry, and rows repeating an id already seen in the slice\n * defer to the per-row path after the flush (so they observe the first\n * occurrence's row exactly as the sequential implementation did).\n */\nasync function processNodeSlice(\n  backend: GraphBackend | TransactionBackend,\n  graphId: string,\n  registry: KindRegistry,\n  batch: readonly InterchangeNode[],\n  schemas: ReadonlyMap<string, NodeSchemaEntry>,\n  options: ResolvedImportOptions,\n  result: ImportResult,\n  errors: ImportError[],\n  importedNodeIds: Set<string>,\n  lock: GraphWriteLock,\n): Promise<void> {\n  const record = (node: InterchangeNode, outcome: ProcessResult): void => {\n    recordNodeOutcome(node, outcome, result, errors, importedNodeIds);\n  };\n\n  // Pass 1 (synchronous): kind + property + validity validation, and\n  // in-slice duplicate deferral.\n  const candidates: NodeImportCandidate[] = [];\n  const deferred: InterchangeNode[] = [];\n  const seenKeys = new Set<string>();\n  for (const node of batch) {\n    const schemaEntry = schemas.get(node.kind);\n    if (!schemaEntry) {\n      record(node, {\n        status: \"error\",\n        error: `Unknown node kind: ${node.kind}`,\n      });\n      continue;\n    }\n    const propsResult = validateProperties(\n      node.properties,\n      schemaEntry.schema,\n      options.onUnknownProperty,\n    );\n    if (!propsResult.success) {\n      record(node, { status: \"error\", error: propsResult.error });\n      continue;\n    }\n    const validityError = validateValidityWindow(node);\n    if (validityError !== undefined) {\n      record(node, { status: \"error\", error: validityError });\n      continue;\n    }\n    const key = makeNodeKey(node.kind, node.id);\n    if (seenKeys.has(key)) {\n      deferred.push(node);\n      continue;\n    }\n    seenKeys.add(key);\n    candidates.push({\n      node,\n      schemaEntry,\n      props: propsResult.data,\n      draft: {\n        kind: node.kind,\n        id: node.id,\n        nodeKind: schemaEntry.registration.type,\n        uniqueConstraints: schemaEntry.registration.unique ?? [],\n        validatedProps: propsResult.data,\n        // NodeCreateDraft.validFrom is string | undefined (never null) — it\n        // only feeds batch validation-cache priming, which never inspects\n        // it, so normalizing the explicit-NULL sentinel away here is inert.\n        // The actual insert (buildImportInsertParams) reads node.validFrom\n        // directly and preserves the null.\n        validFrom: node.validFrom ?? undefined,\n        validTo: node.validTo,\n      },\n    });\n  }\n\n  // Prime the validation caches with batched reads, then route each row\n  // against memory in input order.\n  const {\n    backend: validationBackend,\n    registerPendingNode,\n    registerPendingUniqueEntries,\n    registerAppliedNodeUpdate,\n    seedNodeRow,\n    seedUniqueRow,\n  } = createNodeBatchValidationBackend(graphId, registry, backend);\n  await primeBatchValidationCaches(\n    { graphId, registry },\n    candidates.map((candidate) => candidate.draft),\n    backend,\n    { seedNodeRow, seedUniqueRow },\n  );\n\n  const writeContext = { graphId, registry, lock };\n  const accepted: NodeImportCandidate[] = [];\n  for (const candidate of candidates) {\n    const { node, schemaEntry, props } = candidate;\n    const uniqueConstraints = schemaEntry.registration.unique ?? [];\n    const existing = await validationBackend.getNode(\n      graphId,\n      node.kind,\n      node.id,\n    );\n\n    if (existing) {\n      switch (options.onConflict) {\n        case \"skip\": {\n          record(node, {\n            status: \"skipped\",\n            liveTarget: isLiveNodeRow(existing),\n          });\n          break;\n        }\n        case \"error\": {\n          record(node, {\n            status: \"error\",\n            error: `Node already exists: ${node.kind}:${node.id}`,\n          });\n          break;\n        }\n        case \"update\": {\n          if (!isLiveNodeRow(existing)) {\n            // Import never resurrects a tombstone — see processNode.\n            record(node, { status: \"skipped\", liveTarget: false });\n            break;\n          }\n          const updateResult = await catchUniquenessError(() =>\n            applyNodeUpdate(\n              writeContext,\n              {\n                existing,\n                schema: schemaEntry.registration.type.schema,\n                validatedProps: props,\n                uniqueConstraints,\n                ...(node.validTo !== undefined && { validTo: node.validTo }),\n              },\n              // The pending-aware overlay, not the raw backend: the update's\n              // uniqueness pre-check must see a unique value already reserved by\n              // an unflushed create EARLIER in this slice, so it degrades to a\n              // per-row error exactly as the sequential path does — rather than\n              // claiming the key on the real backend and colliding with that\n              // create at flush (which would throw and roll back the whole\n              // import). Writes still delegate to the real backend.\n              validationBackend,\n            ),\n          );\n          if (updateResult.ok) {\n            // The update mutated the real backend's uniqueness rows directly;\n            // reconcile the shared prime caches so a later create in this\n            // slice sees the post-update reservation state (matching the\n            // sequential path). See registerAppliedNodeUpdate.\n            registerAppliedNodeUpdate(\n              node.kind,\n              node.id,\n              rowPropsToObject(existing.props),\n              props,\n              uniqueConstraints,\n            );\n          }\n          record(\n            node,\n            updateResult.ok ?\n              { status: \"updated\" }\n            : { status: \"error\", error: updateResult.error },\n          );\n          break;\n        }\n      }\n      continue;\n    }\n\n    const uniquenessResult = await catchUniquenessError(() =>\n      checkUniquenessConstraints(\n        { graphId, registry, backend: validationBackend },\n        node.kind,\n        node.id,\n        props,\n        uniqueConstraints,\n      ),\n    );\n    if (!uniquenessResult.ok) {\n      record(node, { status: \"error\", error: uniquenessResult.error });\n      continue;\n    }\n\n    registerPendingNode(buildImportInsertParams(graphId, candidate));\n    registerPendingUniqueEntries(node.kind, node.id, props, uniqueConstraints);\n    accepted.push(candidate);\n  }\n\n  // Flush the accepted creates: one multi-row insert, then the batched\n  // side effects (uniqueness entries, fulltext, embeddings).\n  if (accepted.length > 0) {\n    const insertParamsList = accepted.map((candidate) =>\n      buildImportInsertParams(graphId, candidate),\n    );\n    if (backend.insertNodesBatch === undefined) {\n      for (const params of insertParamsList) {\n        await backend.insertNode(params);\n      }\n    } else {\n      await backend.insertNodesBatch(insertParamsList);\n    }\n    await applyNodeInsertSideEffectsBatch(\n      writeContext,\n      accepted.map((candidate) => ({\n        kind: candidate.node.kind,\n        id: candidate.node.id,\n        schema: candidate.schemaEntry.registration.type.schema,\n        props: candidate.props,\n        uniqueConstraints: candidate.schemaEntry.registration.unique ?? [],\n      })),\n      backend,\n    );\n    for (const candidate of accepted) {\n      record(candidate.node, { status: \"created\" });\n    }\n  }\n\n  // In-slice duplicate ids run per-row AFTER the flush so they observe the\n  // first occurrence's committed row, exactly as the sequential path did.\n  for (const node of deferred) {\n    record(\n      node,\n      await processNode(\n        backend,\n        graphId,\n        registry,\n        node,\n        schemas,\n        options,\n        lock,\n      ),\n    );\n  }\n}\n\nfunction buildImportInsertParams(\n  graphId: string,\n  candidate: NodeImportCandidate,\n): Parameters<GraphBackend[\"insertNode\"]>[0] {\n  const { node, props } = candidate;\n  return {\n    graphId,\n    kind: node.kind,\n    id: node.id,\n    props,\n    ...(node.validFrom !== undefined && { validFrom: node.validFrom }),\n    ...(node.validTo !== undefined && { validTo: node.validTo }),\n  };\n}\n\ntype ProcessResult =\n  | { status: \"created\" }\n  | { status: \"updated\" }\n  /**\n   * `liveTarget` distinguishes \"skipped because a LIVE row already exists\"\n   * (a valid edge endpoint) from \"skipped because the row is a tombstone\"\n   * (which must NOT be recorded as available — a live edge pointing at a\n   * soft-deleted node violates the endpoint-liveness invariant the\n   * collection API enforces).\n   */\n  | { status: \"skipped\"; liveTarget: boolean }\n  | { status: \"error\"; error: string };\n\ntype UniquenessGuardResult<T> =\n  Readonly<{ ok: true; value: T }> | Readonly<{ ok: false; error: string }>;\n\n/**\n * Runs `fn` and reports a `UniquenessError` as a per-row result instead of\n * letting it abort the whole import — the same recovery both the node\n * uniqueness pre-check and the update path need. Any other error still\n * propagates.\n */\nasync function catchUniquenessError<T>(\n  fn: () => Promise<T>,\n): Promise<UniquenessGuardResult<T>> {\n  try {\n    return { ok: true, value: await fn() };\n  } catch (error) {\n    if (error instanceof UniquenessError) {\n      return { ok: false, error: error.message };\n    }\n    throw error;\n  }\n}\n\n/**\n * Validates an entity's validity-window timestamps against the canonical\n * fixed-width UTC ISO-8601 contract that `create` / `update` enforce, so no\n * import write path can persist a non-canonical `valid_from` / `valid_to` that\n * later mis-sorts as text against an `asOf` read coordinate. The interchange\n * schema enforces the same contract at the parse boundary, but `importGraph`\n * accepts a pre-typed `GraphData` and does not re-parse it, so this is the\n * guarantee for callers that bypass the schema. Returns a per-row error message\n * (recorded in the import result) instead of throwing, so one malformed row\n * does not abort the whole import.\n */\nfunction validateValidityWindow(\n  entity: Readonly<{\n    validFrom?: string | null | undefined;\n    validTo?: string | undefined;\n  }>,\n): string | undefined {\n  try {\n    // null is a confirmed open-left window (see InterchangeNodeSchema's\n    // validFrom doc), not a value to format-check — treat it like\n    // \"not provided\" here, same as the canonical-date validator does.\n    validateOptionalCanonicalIsoDate(\n      entity.validFrom ?? undefined,\n      \"validFrom\",\n    );\n    validateOptionalCanonicalIsoDate(entity.validTo, \"validTo\");\n    return undefined;\n  } catch (error) {\n    return error instanceof Error ? error.message : String(error);\n  }\n}\n\nasync function processNode(\n  backend: GraphBackend | TransactionBackend,\n  graphId: string,\n  registry: KindRegistry,\n  node: InterchangeNode,\n  schemas: ReadonlyMap<string, NodeSchemaEntry>,\n  options: ResolvedImportOptions,\n  lock: GraphWriteLock,\n): Promise<ProcessResult> {\n  // Validate kind exists\n  const schemaEntry = schemas.get(node.kind);\n  if (!schemaEntry) {\n    return { status: \"error\", error: `Unknown node kind: ${node.kind}` };\n  }\n\n  // Validate and transform properties\n  const propsResult = validateProperties(\n    node.properties,\n    schemaEntry.schema,\n    options.onUnknownProperty,\n  );\n\n  if (!propsResult.success) {\n    return { status: \"error\", error: propsResult.error };\n  }\n\n  const validityError = validateValidityWindow(node);\n  if (validityError !== undefined) {\n    return { status: \"error\", error: validityError };\n  }\n\n  const { registration } = schemaEntry;\n  const uniqueConstraints = registration.unique ?? [];\n  const writeContext = { graphId, registry, lock };\n\n  // Check if node already exists\n  const existing = await backend.getNode(graphId, node.kind, node.id);\n\n  if (existing) {\n    switch (options.onConflict) {\n      case \"skip\": {\n        return { status: \"skipped\", liveTarget: isLiveNodeRow(existing) };\n      }\n      case \"error\": {\n        return {\n          status: \"error\",\n          error: `Node already exists: ${node.kind}:${node.id}`,\n        };\n      }\n      case \"update\": {\n        if (!isLiveNodeRow(existing)) {\n          // A soft-deleted node is not updatable: import never resurrects a\n          // tombstone, and running the live-row update pipeline here would\n          // recreate uniqueness/embedding/fulltext rows for a node that\n          // stays invisible — a uniqueness reservation held by a tombstoned\n          // node would block live creates of the same value.\n          return { status: \"skipped\", liveTarget: false };\n        }\n        // Route through the shared write step so the update maintains\n        // uniqueness entries, embeddings, and fulltext — the collection API's\n        // integrity, which a raw backend.updateNode would skip. A uniqueness\n        // conflict is reported per-row (updateUniquenessEntries throws before\n        // the row is written, so no partial write escapes).\n        const updateResult = await catchUniquenessError(() =>\n          applyNodeUpdate(\n            writeContext,\n            {\n              existing,\n              schema: registration.type.schema,\n              validatedProps: propsResult.data,\n              uniqueConstraints,\n              ...(node.validTo !== undefined && { validTo: node.validTo }),\n            },\n            backend,\n          ),\n        );\n        if (!updateResult.ok) {\n          return { status: \"error\", error: updateResult.error };\n        }\n        return { status: \"updated\" };\n      }\n    }\n  }\n\n  // Create new node. Pre-check uniqueness (as the collection create does) so a\n  // conflict is a per-row error rather than an orphaned node row, then apply the\n  // integrity side effects the raw backend.insertNode would otherwise bypass.\n  const uniquenessResult = await catchUniquenessError(() =>\n    checkUniquenessConstraints(\n      { graphId, registry, backend },\n      node.kind,\n      node.id,\n      propsResult.data,\n      uniqueConstraints,\n    ),\n  );\n  if (!uniquenessResult.ok) {\n    return { status: \"error\", error: uniquenessResult.error };\n  }\n\n  await backend.insertNode({\n    graphId,\n    kind: node.kind,\n    id: node.id,\n    props: propsResult.data,\n    ...(node.validFrom !== undefined && { validFrom: node.validFrom }),\n    ...(node.validTo !== undefined && { validTo: node.validTo }),\n  });\n  await applyNodeInsertSideEffects(\n    writeContext,\n    {\n      kind: node.kind,\n      id: node.id,\n      schema: registration.type.schema,\n      props: propsResult.data,\n      uniqueConstraints,\n    },\n    backend,\n  );\n\n  return { status: \"created\" };\n}\n\n// ============================================================\n// Edge Processing\n// ============================================================\n\nasync function processEdges(\n  backend: GraphBackend | TransactionBackend,\n  graphId: string,\n  registry: KindRegistry,\n  edges: readonly InterchangeEdge[],\n  edgeSchemas: ReadonlyMap<string, EdgeSchemaEntry>,\n  nodeSchemas: ReadonlyMap<string, NodeSchemaEntry>,\n  options: ResolvedImportOptions,\n  result: ImportResult,\n  errors: ImportError[],\n  importedNodeIds: Set<string>,\n): Promise<void> {\n  const batchSize = options.batchSize;\n\n  for (let index = 0; index < edges.length; index += batchSize) {\n    const batch = edges.slice(index, index + batchSize);\n    await processEdgeSlice(\n      backend,\n      graphId,\n      registry,\n      batch,\n      edgeSchemas,\n      nodeSchemas,\n      options,\n      result,\n      errors,\n      importedNodeIds,\n    );\n  }\n}\n\nfunction recordEdgeOutcome(\n  edge: InterchangeEdge,\n  outcome: ProcessResult,\n  result: ImportResult,\n  errors: ImportError[],\n): void {\n  switch (outcome.status) {\n    case \"created\": {\n      result.edges.created++;\n      break;\n    }\n    case \"updated\": {\n      result.edges.updated++;\n      break;\n    }\n    case \"skipped\": {\n      result.edges.skipped++;\n      break;\n    }\n    case \"error\": {\n      errors.push({\n        entityType: \"edge\",\n        kind: edge.kind,\n        id: edge.id,\n        error: outcome.error,\n      });\n      break;\n    }\n  }\n}\n\ntype EdgeImportCandidate = Readonly<{\n  edge: InterchangeEdge;\n  props: Record<string, unknown>;\n}>;\n\n/**\n * Processes one batchSize slice of edges with batched round trips: one\n * `getNodes` per endpoint kind for reference liveness, one `getEdges` for\n * existence, and one multi-row insert for the accepted creates. Per-row\n * semantics are unchanged; duplicate ids within a slice defer to the\n * per-row path after the flush.\n */\nasync function processEdgeSlice(\n  backend: GraphBackend | TransactionBackend,\n  graphId: string,\n  registry: KindRegistry,\n  batch: readonly InterchangeEdge[],\n  edgeSchemas: ReadonlyMap<string, EdgeSchemaEntry>,\n  nodeSchemas: ReadonlyMap<string, NodeSchemaEntry>,\n  options: ResolvedImportOptions,\n  result: ImportResult,\n  errors: ImportError[],\n  importedNodeIds: Set<string>,\n): Promise<void> {\n  const record = (edge: InterchangeEdge, outcome: ProcessResult): void => {\n    recordEdgeOutcome(edge, outcome, result, errors);\n  };\n\n  // Pass 1 (synchronous): kind, endpoint-kind, endpoint-assignability,\n  // property, and validity validation, plus in-slice duplicate deferral.\n  const candidates: EdgeImportCandidate[] = [];\n  const deferred: InterchangeEdge[] = [];\n  const seenIds = new Set<string>();\n  for (const edge of batch) {\n    const schemaEntry = edgeSchemas.get(edge.kind);\n    if (!schemaEntry) {\n      record(edge, {\n        status: \"error\",\n        error: `Unknown edge kind: ${edge.kind}`,\n      });\n      continue;\n    }\n    if (!nodeSchemas.has(edge.from.kind)) {\n      record(edge, {\n        status: \"error\",\n        error: `Unknown from node kind: ${edge.from.kind}`,\n      });\n      continue;\n    }\n    if (!nodeSchemas.has(edge.to.kind)) {\n      record(edge, {\n        status: \"error\",\n        error: `Unknown to node kind: ${edge.to.kind}`,\n      });\n      continue;\n    }\n    const endpointError = validateEdgeEndpoints(\n      edge.kind,\n      edge.from.kind,\n      edge.to.kind,\n      schemaEntry.registration,\n      registry,\n    );\n    if (endpointError !== undefined) {\n      record(edge, { status: \"error\", error: endpointError.message });\n      continue;\n    }\n    const propsResult = validateProperties(\n      edge.properties,\n      schemaEntry.schema,\n      options.onUnknownProperty,\n    );\n    if (!propsResult.success) {\n      record(edge, { status: \"error\", error: propsResult.error });\n      continue;\n    }\n    const validityError = validateValidityWindow(edge);\n    if (validityError !== undefined) {\n      record(edge, { status: \"error\", error: validityError });\n      continue;\n    }\n    if (seenIds.has(edge.id)) {\n      deferred.push(edge);\n      continue;\n    }\n    seenIds.add(edge.id);\n    candidates.push({ edge, props: propsResult.data });\n  }\n\n  // Batch the endpoint-liveness reads: one getNodes per endpoint kind for\n  // every key the import itself didn't create. Falls back to per-row\n  // getNode inside the routing loop when the backend lacks getNodes.\n  const liveEndpointKeys = new Set<string>();\n  const checkedEndpointKeys = new Set<string>();\n  if (options.validateReferences && backend.getNodes !== undefined) {\n    const idsByKind = new Map<string, Set<string>>();\n    for (const { edge } of candidates) {\n      for (const endpoint of [edge.from, edge.to]) {\n        const key = makeNodeKey(endpoint.kind, endpoint.id);\n        if (importedNodeIds.has(key) || checkedEndpointKeys.has(key)) continue;\n        checkedEndpointKeys.add(key);\n        const ids = idsByKind.get(endpoint.kind) ?? new Set<string>();\n        ids.add(endpoint.id);\n        idsByKind.set(endpoint.kind, ids);\n      }\n    }\n    for (const [kind, ids] of idsByKind) {\n      const rows = await backend.getNodes(graphId, kind, [...ids]);\n      for (const row of rows) {\n        if (isLiveNodeRow(row)) {\n          liveEndpointKeys.add(makeNodeKey(kind, row.id));\n        }\n      }\n    }\n  }\n\n  const endpointIsLive = async (endpoint: {\n    kind: string;\n    id: string;\n  }): Promise<boolean> => {\n    const key = makeNodeKey(endpoint.kind, endpoint.id);\n    if (importedNodeIds.has(key)) return true;\n    if (checkedEndpointKeys.has(key)) return liveEndpointKeys.has(key);\n    const row = await backend.getNode(graphId, endpoint.kind, endpoint.id);\n    return row !== undefined && isLiveNodeRow(row);\n  };\n\n  // Batch the existence reads. Falls back to per-row getEdge when the\n  // backend lacks getEdges.\n  const existingById = new Map<\n    string,\n    Awaited<ReturnType<GraphBackend[\"getEdge\"]>>\n  >();\n  if (candidates.length > 0 && backend.getEdges !== undefined) {\n    const rows = await backend.getEdges(\n      graphId,\n      candidates.map((candidate) => candidate.edge.id),\n    );\n    for (const row of rows) {\n      existingById.set(row.id, row);\n    }\n    for (const { edge } of candidates) {\n      if (!existingById.has(edge.id)) existingById.set(edge.id, undefined);\n    }\n  }\n\n  const accepted: EdgeImportCandidate[] = [];\n  for (const candidate of candidates) {\n    const { edge, props } = candidate;\n\n    if (options.validateReferences) {\n      if (!(await endpointIsLive(edge.from))) {\n        record(edge, {\n          status: \"error\",\n          error: `From node not found: ${edge.from.kind}:${edge.from.id}`,\n        });\n        continue;\n      }\n      if (!(await endpointIsLive(edge.to))) {\n        record(edge, {\n          status: \"error\",\n          error: `To node not found: ${edge.to.kind}:${edge.to.id}`,\n        });\n        continue;\n      }\n    }\n\n    const existing =\n      existingById.has(edge.id) ?\n        existingById.get(edge.id)\n      : await backend.getEdge(graphId, edge.id);\n\n    if (existing) {\n      switch (options.onConflict) {\n        case \"skip\": {\n          record(edge, {\n            status: \"skipped\",\n            liveTarget: existing.deleted_at === undefined,\n          });\n          break;\n        }\n        case \"error\": {\n          record(edge, {\n            status: \"error\",\n            error: `Edge already exists: ${edge.id}`,\n          });\n          break;\n        }\n        case \"update\": {\n          if (existing.deleted_at !== undefined) {\n            record(edge, { status: \"skipped\", liveTarget: false });\n            break;\n          }\n          await backend.updateEdge({\n            graphId,\n            id: edge.id,\n            props,\n            ...(edge.validTo !== undefined && { validTo: edge.validTo }),\n          });\n          record(edge, { status: \"updated\" });\n          break;\n        }\n      }\n      continue;\n    }\n\n    accepted.push(candidate);\n  }\n\n  if (accepted.length > 0) {\n    const insertParamsList = accepted.map(({ edge, props }) => ({\n      graphId,\n      id: edge.id,\n      kind: edge.kind,\n      fromKind: edge.from.kind,\n      fromId: edge.from.id,\n      toKind: edge.to.kind,\n      toId: edge.to.id,\n      props,\n      ...(edge.validFrom !== undefined && { validFrom: edge.validFrom }),\n      ...(edge.validTo !== undefined && { validTo: edge.validTo }),\n    }));\n    if (backend.insertEdgesBatch === undefined) {\n      for (const params of insertParamsList) {\n        await backend.insertEdge(params);\n      }\n    } else {\n      await backend.insertEdgesBatch(insertParamsList);\n    }\n    for (const candidate of accepted) {\n      record(candidate.edge, { status: \"created\" });\n    }\n  }\n\n  for (const edge of deferred) {\n    record(\n      edge,\n      await processEdge(\n        backend,\n        graphId,\n        registry,\n        edge,\n        edgeSchemas,\n        nodeSchemas,\n        options,\n        importedNodeIds,\n      ),\n    );\n  }\n}\n\nasync function processEdge(\n  backend: GraphBackend | TransactionBackend,\n  graphId: string,\n  registry: KindRegistry,\n  edge: InterchangeEdge,\n  edgeSchemas: ReadonlyMap<string, EdgeSchemaEntry>,\n  nodeSchemas: ReadonlyMap<string, NodeSchemaEntry>,\n  options: ResolvedImportOptions,\n  importedNodeIds: Set<string>,\n): Promise<ProcessResult> {\n  // Validate edge kind exists\n  const schemaEntry = edgeSchemas.get(edge.kind);\n  if (!schemaEntry) {\n    return { status: \"error\", error: `Unknown edge kind: ${edge.kind}` };\n  }\n\n  // Validate endpoint kinds exist\n  if (!nodeSchemas.has(edge.from.kind)) {\n    return {\n      status: \"error\",\n      error: `Unknown from node kind: ${edge.from.kind}`,\n    };\n  }\n  if (!nodeSchemas.has(edge.to.kind)) {\n    return { status: \"error\", error: `Unknown to node kind: ${edge.to.kind}` };\n  }\n\n  // Validate endpoint kinds are allowed for this edge type. Uses the shared,\n  // subclass-aware check (registry.isAssignableTo) that the collection API uses,\n  // so an edge whose endpoint is a subclass of a declared kind — legal in the\n  // store and emitted verbatim by export — imports cleanly instead of being\n  // rejected by an exact-kind comparison.\n  const endpointError = validateEdgeEndpoints(\n    edge.kind,\n    edge.from.kind,\n    edge.to.kind,\n    schemaEntry.registration,\n    registry,\n  );\n  if (endpointError !== undefined) {\n    return { status: \"error\", error: endpointError.message };\n  }\n\n  // Validate references exist (in DB or in import batch)\n  if (options.validateReferences) {\n    const fromKey = makeNodeKey(edge.from.kind, edge.from.id);\n    const toKey = makeNodeKey(edge.to.kind, edge.to.id);\n\n    // Check import batch first, then DB. The DB row must be LIVE: getNode\n    // returns tombstones, and inserting an edge whose endpoint is\n    // soft-deleted would bypass the endpoint-liveness invariant the\n    // collection API enforces.\n    if (!importedNodeIds.has(fromKey)) {\n      const fromExists = await backend.getNode(\n        graphId,\n        edge.from.kind,\n        edge.from.id,\n      );\n      if (fromExists === undefined || !isLiveNodeRow(fromExists)) {\n        return {\n          status: \"error\",\n          error: `From node not found: ${edge.from.kind}:${edge.from.id}`,\n        };\n      }\n    }\n\n    if (!importedNodeIds.has(toKey)) {\n      const toExists = await backend.getNode(graphId, edge.to.kind, edge.to.id);\n      if (toExists === undefined || !isLiveNodeRow(toExists)) {\n        return {\n          status: \"error\",\n          error: `To node not found: ${edge.to.kind}:${edge.to.id}`,\n        };\n      }\n    }\n  }\n\n  // Validate and transform properties\n  const propsResult = validateProperties(\n    edge.properties,\n    schemaEntry.schema,\n    options.onUnknownProperty,\n  );\n\n  if (!propsResult.success) {\n    return { status: \"error\", error: propsResult.error };\n  }\n\n  const validityError = validateValidityWindow(edge);\n  if (validityError !== undefined) {\n    return { status: \"error\", error: validityError };\n  }\n\n  // Check if edge already exists\n  const existing = await backend.getEdge(graphId, edge.id);\n\n  if (existing) {\n    switch (options.onConflict) {\n      case \"skip\": {\n        return {\n          status: \"skipped\",\n          liveTarget: existing.deleted_at === undefined,\n        };\n      }\n      case \"error\": {\n        return { status: \"error\", error: `Edge already exists: ${edge.id}` };\n      }\n      case \"update\": {\n        // Same contract as nodes: import never resurrects a tombstone, and\n        // the backend's update targets live rows only.\n        if (existing.deleted_at !== undefined) {\n          return { status: \"skipped\", liveTarget: false };\n        }\n        await backend.updateEdge({\n          graphId,\n          id: edge.id,\n          props: propsResult.data,\n          ...(edge.validTo !== undefined && { validTo: edge.validTo }),\n        });\n        return { status: \"updated\" };\n      }\n    }\n  }\n\n  // Create new edge\n  await backend.insertEdge({\n    graphId,\n    id: edge.id,\n    kind: edge.kind,\n    fromKind: edge.from.kind,\n    fromId: edge.from.id,\n    toKind: edge.to.kind,\n    toId: edge.to.id,\n    props: propsResult.data,\n    ...(edge.validFrom !== undefined && { validFrom: edge.validFrom }),\n    ...(edge.validTo !== undefined && { validTo: edge.validTo }),\n  });\n\n  return { status: \"created\" };\n}\n\n// ============================================================\n// Property Validation\n// ============================================================\n\ntype ValidationResult =\n  | { success: true; data: Record<string, unknown> }\n  | { success: false; error: string };\n\nfunction validateProperties(\n  properties: Record<string, unknown>,\n  schema: z.ZodObject<z.ZodRawShape>,\n  unknownStrategy: UnknownPropertyStrategy,\n): ValidationResult {\n  try {\n    // Get the schema's known keys\n    const knownKeys = new Set(Object.keys(schema.shape));\n\n    // Check for unknown properties\n    const unknownKeys = Object.keys(properties).filter(\n      (key) => !knownKeys.has(key),\n    );\n\n    if (unknownKeys.length > 0) {\n      switch (unknownStrategy) {\n        case \"error\": {\n          return {\n            success: false,\n            error: `Unknown properties: ${unknownKeys.join(\", \")}`,\n          };\n        }\n        case \"strip\": {\n          // Remove unknown properties\n          const stripped: Record<string, unknown> = {};\n          for (const key of knownKeys) {\n            if (key in properties) {\n              stripped[key] = properties[key];\n            }\n          }\n          // Validate stripped properties\n          const result = schema.safeParse(stripped);\n          if (!result.success) {\n            return {\n              success: false,\n              error: formatZodError(result.error),\n            };\n          }\n          return {\n            success: true,\n            data: result.data,\n          };\n        }\n        case \"allow\": {\n          // Validate the known fields, then return the ORIGINAL properties\n          // verbatim — unknown keys preserved, known values byte-for-byte.\n          // Exported data already carries post-transform values, so\n          // re-applying schema transforms here would corrupt every\n          // export→import round trip whose transforms are not idempotent.\n          // \"allow\" is the fidelity-preserving strategy; \"strip\" (and the\n          // create path) remain the normalizing ones.\n          const result = schema.safeParse(properties);\n          if (!result.success) {\n            return {\n              success: false,\n              error: formatZodError(result.error),\n            };\n          }\n          return { success: true, data: properties };\n        }\n      }\n    }\n\n    // No unknown properties - standard validation\n    const result = schema.safeParse(properties);\n    if (!result.success) {\n      return { success: false, error: formatZodError(result.error) };\n    }\n\n    return { success: true, data: result.data };\n  } catch (error) {\n    const message = error instanceof Error ? error.message : String(error);\n    return { success: false, error: `Validation error: ${message}` };\n  }\n}\n\nfunction formatZodError(error: z.ZodError): string {\n  return error.issues\n    .map((issue) => {\n      const path = issue.path.join(\".\");\n      return path ? `${path}: ${issue.message}` : issue.message;\n    })\n    .join(\"; \");\n}\n\n// ============================================================\n// Helpers\n// ============================================================\n\nfunction makeNodeKey(kind: string, id: string): string {\n  return `${kind}:${id}`;\n}\n"]}

package/dist/chunk-BLBG2VZ5.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/store/row-mappers.ts","../src/store/operations/write-transaction.ts","../src/store/constraints.ts","../src/store/operations/node-operations.ts"],"names":["rowPropsToObject","filterReservedKeys","RESERVED_NODE_KEYS","RESERVED_EDGE_KEYS","runOptionallyInTransaction","lockRecordedGraphWrite","uncapturedGraphWriteLock","advanceRevisionClock","checkDisjointness","checkCardinality","checkUniqueEdge","KindNotFoundError","ValidationError","NodeConstraintNotFoundError","checkWherePredicate","computeUniqueKey","getKindsForUniquenessCheck","createBackendOverlay","validateNodeProps","validateOptionalCanonicalIsoDate","checkUniquenessConstraints","createUniquenessContext","applyNodeInsertSideEffectsBatch","createNodeWriteContext","applyNodeInsertSideEffects","canonicalEqual","NodeNotFoundError","row","applyNodeUpdate","isLiveNodeRow","generateId","runInsertNoReturn","nodeInsertDispatch","DatabaseOperationError","runInsertBatch","runInsertBatchReturning","applyNodeSoftDelete","applyNodeHardDelete","UniquenessError","NodeIndexNotFoundError","ConfigurationError","getDialect","resolveJsonPointer","createSqlSchema","DEFAULT_SQL_SCHEMA","sql","compileNodeIndexFieldKeys","compileIndexWhere","asCompiledRowsSql","getNodeRowsByIds","requireDefined"],"mappings":"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","file":"chunk-BLBG2VZ5.cjs","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 * Shared transaction boundary for graph-entity mutations.\n *\n * A node/edge mutation is a cascade of steps — the core row write plus its\n * integrity side effects (uniqueness, embeddings, fulltext) or its delete\n * behavior (restrict / cascade / disconnect). Those steps are individually\n * atomic but not collectively atomic, so the cascade runs inside one top-level\n * transaction whether or not recorded-time capture is enabled: a mid-cascade\n * failure then rolls back the whole operation instead of leaving a half-applied\n * write (e.g. an inserted node whose uniqueness/embedding/fulltext rows were\n * never written, or a uniqueness conflict that leaves an orphaned node row).\n * Under history capture the per-graph write lock is additionally taken inside\n * that transaction so recorded capture serializes.\n *\n * Both {@link NodeOperationContext} and {@link EdgeOperationContext} route their\n * mutations through this one helper, replacing the byte-identical per-file\n * copies that previously drifted independently.\n */\nimport {\n  type GraphBackend,\n  runOptionallyInTransaction,\n  type TransactionBackend,\n} from \"../../backend/types\";\nimport { type SqlSchema } from \"../../query/compiler/schema\";\nimport {\n  advanceRevisionClock,\n  lockRecordedGraphWrite,\n} from \"../recorded-capture\";\nimport {\n  type GraphWriteLock,\n  uncapturedGraphWriteLock,\n} from \"../recorded-capture/clock\";\nimport { type OperationHookContext } from \"../types\";\n\n/**\n * The slice of an operation context {@link runInWriteTransaction} needs: the\n * graph id (for the capture lock) and whether recorded-time capture is on.\n * Both {@link NodeOperationContext} and {@link EdgeOperationContext} satisfy it.\n */\nexport type WriteTransactionContext = Readonly<{\n  graphId: string;\n  historyEnabled: boolean;\n  revisionTrackingEnabled: boolean;\n  revisionSchema: SqlSchema;\n}>;\n\n/**\n * Runs a graph-entity mutation cascade inside a single top-level transaction.\n *\n * On a transactional backend the cascade shares one transaction so it commits\n * or rolls back atomically. A nested {@link TransactionBackend} (already inside\n * `store.transaction(...)`) omits `.transaction`, so\n * {@link runOptionallyInTransaction} runs `fn` directly against it rather than\n * opening a nested transaction. Non-transactional backends (Cloudflare D1,\n * `drizzle-orm/neon-http`) also run `fn` directly — they cannot offer\n * atomicity, which is documented on the store's write surface.\n *\n * Under history capture the per-graph write lock is taken inside the\n * transaction before any row work, matching the acquire order the recorded\n * clock lock depends on to avoid a circular wait.\n */\nexport function runInWriteTransaction<T>(\n  ctx: WriteTransactionContext,\n  backend: GraphBackend | TransactionBackend,\n  fn: (\n    target: GraphBackend | TransactionBackend,\n    lock: GraphWriteLock,\n  ) => Promise<T>,\n): Promise<T> {\n  const ownsWriteLock =\n    \"transaction\" in backend && backend.capabilities.transactions;\n  return runOptionallyInTransaction(backend, async (target) => {\n    const lock =\n      ctx.historyEnabled || ctx.revisionTrackingEnabled ?\n        await lockRecordedGraphWrite(target, ctx.graphId)\n      : uncapturedGraphWriteLock();\n    const result = await fn(target, lock);\n    // History capture advances the same clock when it flushes its recorded\n    // after-images. Live stores opt into revisions independently, so advance\n    // only there and only after every row/sidecar write succeeded.\n    if (ctx.revisionTrackingEnabled && !ctx.historyEnabled) {\n      await advanceRevisionClock(\n        target,\n        ctx.revisionSchema,\n        ctx.graphId,\n        ownsWriteLock,\n      );\n    }\n    return result;\n  });\n}\n\n/**\n * The slice of an operation context {@link runHookedWriteOperation} needs:\n * the {@link WriteTransactionContext} plus the hook wrapper. Both\n * `NodeOperationContext` and `EdgeOperationContext` satisfy it.\n */\nexport type HookedWriteOperationContext = WriteTransactionContext &\n  Readonly<{\n    withOperationHooks: <T>(\n      ctx: OperationHookContext,\n      fn: () => Promise<T>,\n    ) => Promise<T>;\n  }>;\n\n/**\n * The one sanctioned composition for a hooked, non-batch write operation:\n * operation hooks WRAP the write transaction, so `onOperationEnd` observes a\n * durably committed result and a failed COMMIT surfaces through `onError` —\n * a hook that fired inside the transaction would report success for a write\n * the rollback then discards. Every hooked node/edge mutation routes through\n * this helper; composing `withOperationHooks` and `runInWriteTransaction` by\n * hand invites exactly the inverted nesting this exists to prevent.\n * (Batch operations skip hooks deliberately and call\n * {@link runInWriteTransaction} directly.)\n */\nexport function runHookedWriteOperation<T>(\n  ctx: HookedWriteOperationContext,\n  opContext: OperationHookContext,\n  backend: GraphBackend | TransactionBackend,\n  body: (\n    target: GraphBackend | TransactionBackend,\n    lock: GraphWriteLock,\n  ) => Promise<T>,\n): Promise<T> {\n  return ctx.withOperationHooks(opContext, () =>\n    runInWriteTransaction(ctx, backend, body),\n  );\n}\n","/**\n * Constraint Checking for Store Operations\n *\n * Handles checking disjointness and cardinality constraints.\n */\nimport { type GraphBackend, type TransactionBackend } from \"../backend/types\";\nimport {\n  checkCardinality,\n  checkDisjointness,\n  checkUniqueEdge,\n} from \"../constraints\";\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 * 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","/**\n * Node Operations for Store\n *\n * Handles node CRUD operations: create, update, delete.\n */\nimport {\n  createBackendOverlay,\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 {\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 {\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 { asCompiledRowsSql } from \"../../query/sql-intent\";\nimport { type KindRegistry } from \"../../registry/kind-registry\";\nimport { canonicalEqual } from \"../../schema/canonical\";\nimport { validateOptionalCanonicalIsoDate } from \"../../utils/date\";\nimport { generateId } from \"../../utils/id\";\nimport { requireDefined } from \"../../utils/presence\";\nimport { type UpsertDirtyCheck } from \"../collections/coalesce\";\nimport {\n  checkDisjointnessConstraint,\n  type ConstraintContext,\n} from \"../constraints\";\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 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} from \"../uniqueness\";\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  historyEnabled: boolean;\n  revisionTrackingEnabled: 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}>;\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\ntype CachedNodeRow = Awaited<ReturnType<GraphBackend[\"getNode\"]>>;\ntype CachedUniqueRow = Awaited<ReturnType<GraphBackend[\"checkUnique\"]>>;\n\n// ============================================================\n// Helper Functions\n// ============================================================\n\nfunction getNodeRegistration<G extends GraphDef>(graph: G, kind: string) {\n  const registration = graph.nodes[kind];\n  if (registration === undefined) throw new KindNotFoundError(kind, \"node\");\n  return registration;\n}\n\nconst CACHE_KEY_SEPARATOR = \"\\u0000\";\n\nfunction buildNodeCacheKey(graphId: string, kind: string, id: string): string {\n  return `${graphId}${CACHE_KEY_SEPARATOR}${kind}${CACHE_KEY_SEPARATOR}${id}`;\n}\n\nfunction buildUniqueCacheKey(\n  graphId: string,\n  nodeKind: string,\n  constraintName: string,\n  key: string,\n): string {\n  return `${graphId}${CACHE_KEY_SEPARATOR}${nodeKind}${CACHE_KEY_SEPARATOR}${constraintName}${CACHE_KEY_SEPARATOR}${key}`;\n}\n\nfunction createNodeAlreadyExistsError(\n  kind: string,\n  id: string,\n): ValidationError {\n  return new ValidationError(\n    `Node already exists: ${kind}/${id}`,\n    {\n      entityType: \"node\",\n      kind,\n      operation: \"create\",\n      id,\n      issues: [{ path: \"id\", message: \"A node with this ID already exists\" }],\n    },\n    { suggestion: `Use a different ID or update the existing node.` },\n  );\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 = createBackendOverlay(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  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  return {\n    kind,\n    id,\n    nodeKind,\n    uniqueConstraints: registration.unique ?? [],\n    validatedProps,\n    validFrom: validateOptionalCanonicalIsoDate(input.validFrom, \"validFrom\"),\n    validTo: validateOptionalCanonicalIsoDate(input.validTo, \"validTo\"),\n  };\n}\n\n/** The async half: existence, disjointness, and uniqueness checks. */\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  const existingNode = await backend.getNode(ctx.graphId, kind, id);\n  if (existingNode && !existingNode.deleted_at) {\n    throw createNodeAlreadyExistsError(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    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\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: UpdateNodeInput,\n  backend: GraphBackend | TransactionBackend,\n  lock: GraphWriteLock,\n  options?: Readonly<{ clearDeleted?: boolean }>,\n): Promise<Node> {\n  const { kind, id } = input;\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\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  };\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    const row = await applyNodeUpdate(\n      writeContext,\n      { ...shared, existing, clearDeleted: true },\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    { ...shared, existing },\n    backend,\n  );\n  return rowToNode(row);\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 = kindToCheck + CACHE_KEY_SEPARATOR + 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<{\n  preparedCreates: NodeCreatePrepared[];\n  batchInsertParams: InsertNodeParams[];\n}> {\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  const batchInsertParams = preparedCreates.map(\n    (prepared) => prepared.insertParams,\n  );\n\n  return { preparedCreates, batchInsertParams };\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 prepared = await validateAndPrepareNodeCreate(\n        ctx,\n        input,\n        id,\n        target,\n        options,\n      );\n\n      let row: BackendNodeRow | undefined;\n      if (shouldReturnRow) {\n        row = await target.insertNode(prepared.insertParams);\n      } else {\n        await runInsertNoReturn(\n          nodeInsertDispatch(target),\n          prepared.insertParams,\n        );\n      }\n\n      await finalizeNodeCreate(ctx, prepared, target, lock);\n\n      if (row === undefined) return;\n      return rowToNode(row);\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(ctx, backend, async (target, lock) => {\n    const { preparedCreates, batchInsertParams } = await prepareBatchCreates(\n      ctx,\n      inputs,\n      target,\n    );\n\n    await runInsertBatch(nodeInsertDispatch(target), batchInsertParams);\n\n    await finalizeNodeCreateBatch(ctx, preparedCreates, target, lock);\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(ctx, backend, async (target, lock) => {\n    const { preparedCreates, batchInsertParams } = await prepareBatchCreates(\n      ctx,\n      inputs,\n      target,\n      options,\n    );\n\n    const rows = await runInsertBatchReturning(\n      nodeInsertDispatch(target),\n      batchInsertParams,\n    );\n\n    await finalizeNodeCreateBatch(ctx, preparedCreates, target, lock);\n\n    return rows.map((row) => rowToNode(row));\n  });\n}\n\n// ============================================================\n// Node Update Operations\n// ============================================================\n\nexport async function executeNodeUpdate<G extends GraphDef>(\n  ctx: NodeOperationContext<G>,\n  input: UpdateNodeInput,\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(ctx, opContext, backend, (target, lock) =>\n    performNodeUpdate(ctx, input, target, lock, options),\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: UpdateNodeInput,\n  backend: GraphBackend | TransactionBackend,\n  options?: Readonly<{ clearDeleted?: boolean }>,\n): Promise<Node> {\n  return runInWriteTransaction(ctx, backend, (target, lock) =>\n    performNodeUpdate(ctx, input, target, lock, options),\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 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    },\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 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    },\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  // 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    isSoftDeleted: boolean;\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        isSoftDeleted: existing.deleted_at !== undefined,\n      });\n    }\n  }\n\n  type Result = Readonly<{ node: Node; action: GetOrCreateAction }>;\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, isSoftDeleted, nodeId } =\n      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    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"]}