@nicia-ai/typegraph 0.44.0 → 0.46.0

package/dist/chunk-ONU3HIED.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/interchange/types.ts","../src/interchange/stream-source.ts","../src/interchange/import.ts","../src/interchange/export.ts"],"names":["z","isCanonicalIsoDate","acquireSerializedStreamLease","storeBackend","storeRuntime","runInWriteTransaction","snapshotExportContention","ConfigurationError","ValidationError","NodeNotFoundError","IdentityContradictionError","IDENTITY_IMPORT_FAILED_ASSERTION","IDENTITY_IMPORT_PROGRESS","getNodeKinds","getEdgeKinds","createNodeBatchValidationBackend","primeBatchValidationCaches","isLiveNodeRow","rowPropsToObject","checkUniquenessConstraints","applyNodeInsertSideEffectsBatch","UniquenessError","applyNodeUpdate","DatabaseOperationError","INVERTED_VALIDITY_WINDOW_CODE","IMMUTABLE_VALIDITY_LOWER_BOUND_CODE","validateOptionalCanonicalIsoDate","assertOrderedValidityWindow","assertWritableValidityWindow","applyNodeInsertSideEffects","validateEdgeEndpoints","createDataKeyedBag","hasOwnKey","result","encodeTupleKey","ExportStreamCancelledError","nowIso","requireDefined","take","push"],"mappings":"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","file":"chunk-ONU3HIED.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 — the value every export writes.\n *\n * Read-side compatibility policy: the format is versioned separately from what\n * it *accepts*. A 1.0 document is a structurally valid 2.0 document — the only\n * 2.0 addition is the optional `identity` section — so import and\n * {@link GraphDataSchema} accept both `\"1.0\"` and `\"2.0\"` (see\n * {@link AcceptedFormatVersionSchema}), while exports keep writing this\n * constant. Bump this only when exports must emit a new version; add the old\n * value to the accepted set rather than dropping read compatibility.\n */\nexport const FORMAT_VERSION = \"2.0\" as const;\n\n/**\n * Format versions accepted on the read side (import + `GraphDataSchema.parse`).\n * A pre-existing 1.0 export is a valid 2.0 document (the 2.0 change is the\n * additive optional `identity` section), so both validate; exports always write\n * {@link FORMAT_VERSION}.\n */\nconst AcceptedFormatVersionSchema = z.enum([\"1.0\", \"2.0\"]);\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// Operational Identity Interchange\n// ============================================================\n\nexport const IdentityInterchangeModeSchema = z.enum([\"state\", \"archival\"]);\nexport type IdentityInterchangeMode = z.infer<\n  typeof IdentityInterchangeModeSchema\n>;\n\nexport const InterchangeIdentityAssertionSchema = z.object({\n  id: z.string().min(1),\n  relation: z.enum([\"same\", \"different\"]),\n  a: z.object({ kind: z.string().min(1), id: z.string().min(1) }),\n  b: z.object({ kind: z.string().min(1), id: z.string().min(1) }),\n  validFrom: ValidityTimestampSchema,\n  validTo: ValidityTimestampSchema.optional(),\n  /**\n   * The node whose soft-delete cascade ended this assertion — the ledger's\n   * stored cause, carried so an `archival` round-trip preserves WHY each\n   * ending happened and not merely that it did. Absent on open rows and on\n   * explicit retractions; when present it names one of `a` / `b` and requires\n   * `validTo`. Import rejects both violations with an attributed error.\n   */\n  endedBy: z\n    .object({ kind: z.string().min(1), id: z.string().min(1) })\n    .optional(),\n});\nexport type InterchangeIdentityAssertion = z.infer<\n  typeof InterchangeIdentityAssertionSchema\n>;\n\nexport const InterchangeIdentitySchema = z.object({\n  profile: z.literal(\"typegraph-identity-v1\"),\n  mode: IdentityInterchangeModeSchema,\n  assertions: z.array(InterchangeIdentityAssertionSchema),\n});\nexport type InterchangeIdentity = z.infer<typeof InterchangeIdentitySchema>;\n\nconst InterchangeIdentityHeaderSchema = InterchangeIdentitySchema.omit({\n  assertions: true,\n});\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: AcceptedFormatVersionSchema,\n  exportedAt: z.iso.datetime(),\n  source: GraphDataSourceSchema,\n  nodes: z.array(InterchangeNodeSchema),\n  edges: z.array(InterchangeEdgeSchema),\n  identity: InterchangeIdentitySchema.optional(),\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  identity: true,\n}).extend({\n  identity: InterchangeIdentityHeaderSchema.optional(),\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  z.object({\n    type: z.literal(\"identity\"),\n    assertions: z.array(InterchangeIdentityAssertionSchema),\n  }),\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\", \"identity\"]),\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  identity: z.object({\n    created: 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  /** Operational Identity export mode. Defaults to current state only. */\n  identityMode: IdentityInterchangeModeSchema.default(\"state\"),\n  /**\n   * Cancels the export: whatever it had opened is settled — on a backend with\n   * `capabilities.transactions` that means its repeatable-read snapshot is\n   * rolled back and the serialized connection's stream lease released; on one\n   * without, there is no transaction and no lease, and the remaining reads are\n   * simply abandoned. Either way the consumer is rejected with an\n   * `ExportStreamCancelledError` (`code:\n   * \"INTERCHANGE_EXPORT_STREAM_ABORTED\"`), whose message states which of the\n   * two happened, carrying the signal's own `reason` as `cause`. Aborting\n   * before the first read refuses the export outright: nothing is opened and\n   * nothing claimed.\n   *\n   * On `exportGraph` this is a convenience — the call rejects instead of\n   * running to completion. On {@link exportGraphStream} it is the ONLY\n   * contract-grade way to stop a stream a consumer will not finish pulling:\n   * an async generator's `finally` does not run on garbage collection, so a\n   * consumer that pulls `next()` and then drops the iterator — the\n   * `Promise.race([iterator.next(), timeout])` pattern — otherwise holds the\n   * snapshot transaction, and with it the connection's exclusive stream lease,\n   * until the process exits. `break` / `throw` out of a `for await` and an\n   * explicit `iterator.return()` settle the stream cooperatively and need no\n   * signal; a race that abandons the iterator needs one.\n   */\n  signal: z.instanceof(AbortSignal).optional(),\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","import { type GraphBackend } from \"../backend/types\";\nimport { type GraphInterchangeChunk } from \"./types\";\n\nconst EXPORT_STREAM_BACKENDS = new WeakMap<\n  AsyncIterable<GraphInterchangeChunk>,\n  GraphBackend\n>();\n\nexport function markExportStreamBackend(\n  stream: AsyncIterable<GraphInterchangeChunk>,\n  backend: GraphBackend,\n): AsyncIterable<GraphInterchangeChunk> {\n  EXPORT_STREAM_BACKENDS.set(stream, backend);\n  return stream;\n}\n\nexport function exportStreamBackend(\n  stream: AsyncIterable<GraphInterchangeChunk>,\n): GraphBackend | undefined {\n  return EXPORT_STREAM_BACKENDS.get(stream);\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 *\n * ## A write asserts EVERY component its verdict read\n *\n * `onConflict: \"update\"` is a read-then-write pair: this module PROBES the\n * stored row, decides from what it finds, and then writes. Under PostgreSQL\n * READ COMMITTED a concurrent `hardDelete` + recreate re-resolves the probed key\n * between those two statements, so any part of the verdict that is not restated\n * in the UPDATE's own `WHERE` is a decision that can land on a row it was never\n * computed for — and the import reports success, because the write did affect a\n * row. The failure is invisible and only appears under a race, which is why it\n * has taken three rounds to enumerate:\n *\n *  - the edge's KIND — the probe is keyed on `(graph_id, id)` alone, so the row\n *    under an id may be a different edge entirely;\n *  - the edge's ENDPOINTS — kind is not an identity, and an upsert that resolved\n *    an edge BY its endpoints must say so;\n *  - the effective `valid_from` of BOTH entities — {@link\n *    validateUpdateValidityWindow} decides from the stored lower bound, so a\n *    recreate carrying a different one turns that verdict into a write that\n *    ignores the document's `validFrom` or persists `valid_to < valid_from`.\n *\n * The rest of what these legs read, and where each is asserted:\n *\n *  - the row EXISTS (the `getNode` / `getEdge` probe): restated as the\n *    `(graph_id, kind, id)` / `(graph_id, id)` predicate every UPDATE carries.\n *  - the row is LIVE (`isLiveNodeRow` / `deleted_at === undefined`, which is what\n *    routes a tombstone to `skipped` instead of to the update): restated as the\n *    `deleted_at IS NULL` conjunction on the non-resurrecting UPDATE leg. Import\n *    never resurrects, so it never builds the `IS NOT NULL` leg.\n *  - `onConflict: \"skip\"` / `\"error\"`: verdict-independent by construction —\n *    they write nothing.\n *  - the row's PROPS, read as the `oldProps` side of the uniqueness diff: the\n *    ONE input with no portable SQL predicate behind it (a props blob is TEXT on\n *    SQLite and `jsonb` on PostgreSQL, and neither comparison is stable under\n *    key reordering). It is bounded rather than asserted: the sidecar writes now\n *    run AFTER the primary update returns a row (see `applyNodeUpdate`), so a\n *    verdict-invalidating recreate that changes the lower bound takes the\n *    sidecars with it. The residual window is a recreate that reproduces the\n *    probed `valid_from` exactly while changing props — noted here so the next\n *    round starts from the list rather than from the symptom.\n */\nimport type { z } from \"zod\";\n\nimport {\n  acquireSerializedStreamLease,\n  type SerializedStreamKind,\n  type SnapshotExportContention,\n  snapshotExportContention,\n} from \"../backend/transaction-resource\";\nimport {\n  type GraphBackend,\n  isLiveNodeRow,\n  type LiveNodeRow,\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 {\n  type EdgeRegistration,\n  type NodeRegistration,\n  type UniqueConstraint,\n} from \"../core/types\";\nimport {\n  ConfigurationError,\n  DatabaseOperationError,\n  IdentityContradictionError,\n  IMMUTABLE_VALIDITY_LOWER_BOUND_CODE,\n  INVERTED_VALIDITY_WINDOW_CODE,\n  NodeNotFoundError,\n  UniquenessError,\n  ValidationError,\n} from \"../errors\";\nimport {\n  IDENTITY_IMPORT_FAILED_ASSERTION,\n  IDENTITY_IMPORT_PROGRESS,\n} from \"../identity/service\";\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  type NodeWriteContext,\n} from \"../store/operations/node-write-pipeline\";\nimport { runInWriteTransaction } from \"../store/operations/write-transaction\";\nimport { type GraphWriteLock } from \"../store/recorded-capture/clock\";\nimport { storeBackend, storeRuntime } from \"../store/runtime-port\";\nimport { type Store } from \"../store/store\";\nimport { checkUniquenessConstraints } from \"../store/uniqueness\";\nimport {\n  assertOrderedValidityWindow,\n  assertWritableValidityWindow,\n  validateOptionalCanonicalIsoDate,\n  type ValidityLowerBoundFence,\n} from \"../utils/date\";\nimport { createDataKeyedBag, hasOwnKey } from \"../utils/object\";\nimport { encodeTupleKey } from \"../utils/tuple-key\";\nimport { exportStreamBackend } from \"./stream-source\";\nimport {\n  type GraphData,\n  type GraphDataHeader,\n  GraphDataHeaderSchema,\n  type GraphInterchangeChunk,\n  type ImportError,\n  type ImportOptions,\n  ImportOptionsSchema,\n  type ImportResult,\n  type InterchangeEdge,\n  type InterchangeIdentityAssertion,\n  InterchangeIdentitySchema,\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 * Refused with a typed {@link ConfigurationError} when the target writes through\n * a serialized database connection another long-lived interchange operation\n * holds — the same refusal, codes and `details.heldBy` / `details.requested` as\n * {@link importGraphStream}. Hand-rolling a stream as `for await (const chunk of\n * exportGraphStream(source)) await importGraph(target, ...)` on one such\n * connection is therefore refused on the first chunk instead of nesting a write\n * transaction inside the export's open snapshot.\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  return withImportStreamLease(store, () =>\n    importGraphData(store, data, options),\n  );\n}\n\n/**\n * Claims the target connection's exclusive stream lease for the whole of `run`,\n * or refuses with the holder named.\n *\n * GRANULARITY: an in-memory import is not one long-lived transaction — it is a\n * write transaction followed by a best-effort statistics refresh — but it IS one\n * long-lived operation on the connection, and it faces exactly the hazard the\n * streaming guard exists for: an export snapshot holding the single connection\n * this import must write on, or opening midway through it. A lease for the whole\n * call is the simplest claim that covers every write the call makes, so that is\n * what it takes.\n *\n * Claimed at each PUBLIC boundary that writes a whole import — this function's\n * own {@link importGraph} and `trustedImportGraphStream` — and nowhere else.\n * {@link importGraphStream} already holds the lease for its chunk loop and calls\n * {@link importGraphData} directly, so a per-chunk import is never refused by\n * the stream that issued it.\n */\nexport async function withImportStreamLease<G extends GraphDef, T>(\n  store: Store<G>,\n  run: () => Promise<T>,\n): Promise<T> {\n  const lease = acquireSerializedStreamLease(\n    storeBackend(store),\n    \"import-stream\",\n  );\n  if (!lease.acquired) {\n    throw serializedStreamRefusal({\n      graphId: store.graphId,\n      requested: \"import-stream\",\n      heldBy: lease.heldBy,\n    });\n  }\n  try {\n    return await run();\n  } finally {\n    lease.release();\n  }\n}\n\nasync function importGraphData<G extends GraphDef>(\n  store: Store<G>,\n  data: GraphData,\n  options: ResolvedImportOptions,\n): Promise<ImportResult> {\n  // Reject an identity payload aimed at an identity-disabled graph, and\n  // runtime-validate the (bounded) identity section, BEFORE any entity write —\n  // see assertIdentityImportSupported / validateIdentitySection.\n  assertIdentityImportSupported(store, data.identity !== undefined);\n  validateIdentitySection(data.identity);\n\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 runtime = storeRuntime(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(\n    {\n      graphId,\n      schemaVersion: store.introspect().schemaVersion,\n      historyEnabled: store.historyEnabled,\n      revisionTrackingEnabled: store.revisionTrackingEnabled,\n      revisionSchema: store.revisionSchema,\n    },\n    backend,\n    async (target, lock) => {\n      await runtime.lockIdentityImportTarget(target);\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 runtime.foldImportedIdentityNodes(\n        target,\n        data.nodes\n          .filter((node) =>\n            importedNodeIds.has(makeNodeKey(node.kind, node.id)),\n          )\n          .map((node) => ({ kind: node.kind, id: node.id })),\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      if (data.identity !== undefined) {\n        await importIdentitySection(\n          runtime,\n          target,\n          graphId,\n          data.identity,\n          result,\n          errors,\n        );\n      }\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 implementation as an in-memory\n * {@link importGraph}, so validation and conflict semantics stay identical; the\n * chunk calls skip only that function's own lease claim, which this loop already\n * holds on their behalf.\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 *\n * Refused with a typed {@link ConfigurationError} when the target writes through\n * a serialized database connection that another long-lived interchange stream\n * already holds — either because this stream came from a snapshot export on that\n * connection, or because ANY export snapshot or streaming import holds it when\n * the first chunk arrives (which covers a stream the caller has wrapped). The\n * error's `details.heldBy` names the holder's kind and `details.code` the\n * condition: `INTERCHANGE_SHARED_SERIALIZED_BACKEND_SNAPSHOT` (or\n * `INTERCHANGE_SAME_SQLITE_BACKEND_SNAPSHOT`) behind an export snapshot,\n * `INTERCHANGE_SERIALIZED_IMPORT_IN_PROGRESS` behind another import.\n *\n * Once accepted, the import holds that connection's one stream lease for the\n * whole call — every chunk AND the trailing statistics refresh, which is a\n * write like any other — so any export snapshot or second import that tries to\n * start while a write of this import is still to come is the side refused, and\n * this import keeps running instead of stalling against a transaction it can\n * never write past.\n *\n * Connections we cannot observe are not detected: two clients dialed at one\n * server, or two SQLite handles on one file, are independent and are not\n * refused. Neither is a connection whose driver we cannot positively identify as\n * single-connection — see the residual gap documented in\n * `backend/transaction-resource.ts`.\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 sourceBackend = exportStreamBackend(chunks);\n  const targetBackend = storeBackend(store);\n  // Whether this export would hold the connection the import writes through is\n  // decided by the single owner of that predicate — including the\n  // `transactions: false` abstention, where nothing is held open and refusing\n  // would refuse work that succeeds.\n  const contention =\n    sourceBackend === undefined ? undefined : (\n      snapshotExportContention(sourceBackend, targetBackend)\n    );\n  if (contention !== undefined) {\n    throw serializedStreamRefusal({\n      graphId: store.graphId,\n      requested: \"import-stream\",\n      heldBy: \"export-snapshot\",\n      detector: contention,\n    });\n  }\n  const result = emptyImportResult();\n  let header: GraphDataHeader | undefined;\n  let receivedEdges = false;\n  let receivedIdentity = false;\n  let releaseImportLease: (() => void) | undefined;\n\n  try {\n    for await (const chunk of chunks) {\n      // The pre-flight check above needs the stream to still identify its source\n      // backend, which any user wrapper (a delegating generator, `Readable.from`,\n      // a tee) erases. By the time the FIRST chunk arrives the export's snapshot\n      // transaction is already open and the registry says so itself, so a wrapped\n      // stream fails the same way an unwrapped one does instead of stalling\n      // behind a transaction that cannot end until this loop does.\n      //\n      // The claim is EXCLUSIVE and its check-and-register is one synchronous\n      // section inside `acquireSerializedStreamLease`, so the two long-lived\n      // streams can never both conclude the connection was free — and the\n      // holder it reports may be an export snapshot OR another streaming\n      // import, which nests its chunk transactions inside this one's just as\n      // fatally. Whoever gets here second is refused; an export starting\n      // mid-import is refused by `exportGraphStream` claiming the same lease, so\n      // an import whose earlier chunks are already committed is never aborted\n      // for someone else's stream. Nothing between the claim and the assignment\n      // can throw, so the `finally` below owns every release path.\n      if (releaseImportLease === undefined) {\n        const lease = acquireSerializedStreamLease(\n          targetBackend,\n          \"import-stream\",\n        );\n        if (!lease.acquired) {\n          throw serializedStreamRefusal({\n            graphId: store.graphId,\n            requested: \"import-stream\",\n            heldBy: lease.heldBy,\n          });\n        }\n        releaseImportLease = lease.release;\n      }\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          // The header is bounded, so validate it at the runtime stream\n          // boundary. In particular, an invalid identity profile/mode must not\n          // slip through merely because the stream's identity assertion chunk is\n          // empty.\n          validateStreamHeader(chunk.header);\n          // Reject an identity-bearing header aimed at an identity-disabled\n          // graph before any chunk is processed, matching importGraph's guard.\n          assertIdentityImportSupported(\n            store,\n            chunk.header.identity !== undefined,\n          );\n          header = chunk.header;\n          break;\n        }\n        case \"nodes\": {\n          if (header === undefined) {\n            throw new Error(\n              \"Graph interchange stream must start with a header.\",\n            );\n          }\n          if (receivedEdges || receivedIdentity) {\n            throw new Error(\n              `Graph interchange stream cannot emit nodes after ${\n                receivedEdges ? \"edges\" : \"identity assertions\"\n              }.`,\n            );\n          }\n          if (chunk.nodes.length === 0) break;\n          mergeImportResult(\n            result,\n            await importGraphData(\n              store,\n              graphDataForChunk(header, chunk.nodes, [], []),\n              {\n                ...options,\n                refreshStatistics: false,\n              },\n            ),\n          );\n          throwIfStreamChunkFailed(result, options);\n          break;\n        }\n        case \"edges\": {\n          if (header === undefined) {\n            throw new Error(\n              \"Graph interchange stream must start with a header.\",\n            );\n          }\n          if (receivedIdentity) {\n            throw new Error(\n              \"Graph interchange stream cannot emit edges after identity assertions.\",\n            );\n          }\n          receivedEdges = true;\n          if (chunk.edges.length === 0) break;\n          mergeImportResult(\n            result,\n            await importGraphData(\n              store,\n              graphDataForChunk(header, [], chunk.edges, []),\n              {\n                ...options,\n                refreshStatistics: false,\n              },\n            ),\n          );\n          throwIfStreamChunkFailed(result, options);\n          break;\n        }\n        case \"identity\": {\n          if (header === undefined) {\n            throw new Error(\n              \"Graph interchange stream must start with a header.\",\n            );\n          }\n          if (header.identity === undefined) {\n            throw new Error(\n              \"Graph interchange stream emitted identity rows without an identity header.\",\n            );\n          }\n          receivedIdentity = true;\n          if (chunk.assertions.length === 0) break;\n          mergeImportResult(\n            result,\n            await importGraphData(\n              store,\n              graphDataForChunk(header, [], [], chunk.assertions),\n              { ...options, refreshStatistics: false },\n            ),\n          );\n          throwIfStreamChunkFailed(result, options);\n          break;\n        }\n      }\n    }\n    if (header === undefined) {\n      throw new Error(\n        \"Graph interchange stream ended before emitting a header.\",\n      );\n    }\n    // The trailing ANALYZE is a WRITE on the target connection, exactly like\n    // the chunks were, so it belongs inside the lease rather than after it.\n    // Releasing at the end of the chunk loop instead left this write outside\n    // every guard: on a serialized connection an export snapshot opening in\n    // that window takes the one connection ANALYZE has to run on and does not\n    // give it back until the export ends, and the refresh's best-effort\n    // handling swallowed the result as a warning. The lease now spans every\n    // write this call makes — the same span `withImportStreamLease` gives\n    // `importGraph`, whose refresh has always been inside it.\n    await refreshStatisticsAfterImport(\n      store,\n      options,\n      result,\n      \"importGraphStream\",\n    );\n  } finally {\n    // One release for every exit — the loop's, the missing-header throw, and\n    // the refresh's — so \"the lease lives exactly as long as the writes\" holds\n    // on the error paths too.\n    releaseImportLease?.();\n  }\n  return { ...result, success: result.errors.length === 0 };\n}\n\n/**\n * The single owner of the refusal raised when two long-lived interchange streams\n * would run on one serialized database connection — from the import's pre-flight\n * check on the stream's own backend, from its mid-stream claim, and from\n * `exportGraphStream`'s claim alike, so every path states the same detected\n * condition in the same vocabulary.\n *\n * The CODE names the condition — which kind of stream holds the connection —\n * rather than which side was refused. `INTERCHANGE_SAME_SQLITE_BACKEND_SNAPSHOT`\n * is not a second condition: it reports that the object-identity DETECTOR\n * answered (one SQLite backend exporting into itself), which is worth telling\n * apart because the fix differs — pass a second backend, rather than await\n * whatever else is running. `details.heldBy`\n * and `details.requested` then say which pairing was actually refused, so a\n * same-kind refusal (import behind import, export behind export) is never\n * reported as something it is not:\n *\n * | holder          | code                                          |\n * | --------------- | --------------------------------------------- |\n * | export snapshot | `INTERCHANGE_SHARED_SERIALIZED_BACKEND_SNAPSHOT` (or `INTERCHANGE_SAME_SQLITE_BACKEND_SNAPSHOT` when the object-identity detector answered) |\n * | import stream   | `INTERCHANGE_SERIALIZED_IMPORT_IN_PROGRESS`   |\n *\n * Every message describes exactly what is detected. None claims anything about\n * connections we cannot observe (two clients dialed at the same server, two\n * SQLite handles on one file), which are independent and are not refused.\n */\nexport function serializedStreamRefusal(\n  input: Readonly<{\n    graphId: string;\n    requested: SerializedStreamKind;\n    heldBy: SerializedStreamKind;\n    /**\n     * Which detector found the holding export snapshot, when the import's\n     * pre-flight — not the lease — is what answered. Only\n     * `\"same-sqlite-backend\"` changes the code, because only that detector\n     * identifies a distinguishable situation for the caller: the source and the\n     * target are the same SQLite backend object, which no ordering can fix.\n     */\n    detector?: SnapshotExportContention;\n  }>,\n): ConfigurationError {\n  const { graphId, requested, heldBy, detector } = input;\n  const code =\n    heldBy === \"import-stream\" ? SERIALIZED_IMPORT_IN_PROGRESS_CODE\n    : detector === \"same-sqlite-backend\" ?\n      \"INTERCHANGE_SAME_SQLITE_BACKEND_SNAPSHOT\"\n    : \"INTERCHANGE_SHARED_SERIALIZED_BACKEND_SNAPSHOT\";\n  const { message, suggestion } = serializedStreamRefusalText(\n    requested,\n    heldBy,\n  );\n  return new ConfigurationError(\n    message,\n    { code, graphId, requested, heldBy },\n    { suggestion },\n  );\n}\n\n/**\n * The refusal code for \"a streaming import holds the connection this stream\n * needs\", in either of the two orders it can be discovered.\n */\nconst SERIALIZED_IMPORT_IN_PROGRESS_CODE =\n  \"INTERCHANGE_SERIALIZED_IMPORT_IN_PROGRESS\";\n\n/**\n * What each of the four pairings actually does to the one connection. Each\n * message names both streams, because \"a stream already holds this connection\"\n * is not actionable without knowing which one.\n */\nfunction serializedStreamRefusalText(\n  requested: SerializedStreamKind,\n  heldBy: SerializedStreamKind,\n): Readonly<{ message: string; suggestion: string }> {\n  if (heldBy === \"export-snapshot\") {\n    return requested === \"import-stream\" ?\n        {\n          message:\n            \"A snapshot export cannot be streamed into a target that writes through the same serialized database connection: the export's read transaction holds that connection open for the whole stream, so this import can never take the writer slot it needs.\",\n          suggestion:\n            \"Export to a file first, or import the stream into an independent backend.\",\n        }\n      : {\n          message:\n            \"A snapshot export cannot open on a serialized database connection while another snapshot export is streaming from it: the second export's read transaction would have to nest inside the first one on the single connection they share.\",\n          suggestion:\n            \"Await the export already in flight before starting the next one, or export from an independent backend.\",\n        };\n  }\n  return requested === \"export-snapshot\" ?\n      {\n        message:\n          \"A snapshot export cannot open on a serialized database connection while a streaming import is writing through it: the export's read transaction would hold the one connection the import's next chunk has to write on.\",\n        suggestion:\n          \"Await the import before exporting, or export from an independent backend.\",\n      }\n    : {\n        message:\n          \"A streaming import cannot open on a serialized database connection while another streaming import is writing through it: the two imports commit their chunks on the single connection they share, so the second one's chunk transaction would have to nest inside the first one's.\",\n        suggestion:\n          \"Await the import already in flight before starting the next one, or import into an independent backend.\",\n      };\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\n/**\n * Rejects an identity payload aimed at an identity-disabled graph BEFORE any\n * entity write. The internal identity import coordinator raises the same\n * typed `ConfigurationError` (code `IDENTITY_IMPORT_REQUIRES_PROFILE`), but only\n * after `processNodes`/`processEdges` have run — a partial write on a\n * non-transactional backend — and only for a NON-empty assertions array (an\n * empty envelope short-circuits and silently succeeds there). This guard fires\n * first and regardless of assertion count.\n */\nfunction assertIdentityImportSupported<G extends GraphDef>(\n  store: Store<G>,\n  hasIdentitySection: boolean,\n): void {\n  if (hasIdentitySection && store.graph.identity === undefined) {\n    throw new ConfigurationError(\n      \"Cannot import identity assertions into an identity-disabled graph.\",\n      { code: \"IDENTITY_IMPORT_REQUIRES_PROFILE\", graphId: store.graphId },\n    );\n  }\n}\n\n/**\n * Runtime-validates just the identity section of an otherwise pre-typed\n * `GraphData`. {@link importGraph} deliberately trusts the type for the\n * (potentially graph-sized) node and edge arrays to preserve its per-row\n * performance, but a JS caller can still smuggle an out-of-domain `relation` or\n * a non-canonical timestamp straight into SQL — which SQLite accepts and\n * PostgreSQL rejects, a backend-parity divergence. The identity section is\n * bounded, so parsing only it closes that gap without the whole-envelope cost.\n */\nfunction validateIdentitySection(identity: GraphData[\"identity\"]): void {\n  if (identity === undefined) return;\n  const parsed = InterchangeIdentitySchema.safeParse(identity);\n  if (parsed.success) return;\n  throw new ValidationError(\n    `Invalid identity interchange section: ${parsed.error.message}`,\n    {\n      issues: parsed.error.issues.map((issue) => ({\n        path: issue.path.join(\".\"),\n        message: issue.message,\n        code: issue.code,\n      })),\n    },\n    { cause: parsed.error },\n  );\n}\n\n/**\n * An identity assertion is neither a node nor an edge, so it carries its own\n * `entityType`. The identity analogue of a node or edge kind is the relation\n * asserted, and the entity id is the assertion id. A failure that cannot be\n * attributed to a document assertion — which the coordinator's own error\n * details should always allow — falls back to naming the target graph, so the\n * entry still reaches the caller rather than being dropped or rethrown.\n */\nconst IDENTITY_IMPORT_ERROR_ENTITY_TYPE = \"identity\";\nconst IDENTITY_IMPORT_ERROR_PATH = \"identity.assertions\";\nconst UNATTRIBUTED_IDENTITY_ERROR_KIND = \"assertion\";\nconst IDENTITY_IMPORT_ID_CONFLICT_CODE = \"IDENTITY_IMPORT_ID_CONFLICT\";\n\nfunction identityImportError(\n  assertion: InterchangeIdentityAssertion | undefined,\n  graphId: string,\n  message: string,\n): ImportError {\n  const path =\n    assertion === undefined ?\n      IDENTITY_IMPORT_ERROR_PATH\n    : `${IDENTITY_IMPORT_ERROR_PATH}[${assertion.id}]`;\n  return {\n    entityType: IDENTITY_IMPORT_ERROR_ENTITY_TYPE,\n    kind: assertion?.relation ?? UNATTRIBUTED_IDENTITY_ERROR_KIND,\n    id: assertion?.id ?? graphId,\n    error: `${path}: ${message}`,\n  };\n}\n\nfunction isIdConflictError(error: unknown): error is ConfigurationError {\n  return (\n    error instanceof ConfigurationError &&\n    error.details[\"code\"] === IDENTITY_IMPORT_ID_CONFLICT_CODE\n  );\n}\n\nfunction touchesRef(\n  assertion: InterchangeIdentityAssertion,\n  ref: Readonly<{ kind: string; id: string }>,\n): boolean {\n  return (\n    (assertion.a.kind === ref.kind && assertion.a.id === ref.id) ||\n    (assertion.b.kind === ref.kind && assertion.b.id === ref.id)\n  );\n}\n\n/**\n * Converts a per-document identity failure into an {@link ImportError}, or\n * returns `undefined` for anything that is not one — a configuration or\n * programming fault must still propagate.\n */\nfunction asIdentityImportError(\n  assertions: readonly InterchangeIdentityAssertion[],\n  graphId: string,\n  error: unknown,\n): ImportError | undefined {\n  // The coordinator tags the error with the id of the assertion it was\n  // APPLYING — exact attribution. The endpoint heuristics below are only the\n  // fallback for an untagged error: they pick the first assertion touching\n  // the endpoints, which is wrong whenever an earlier assertion over the same\n  // pair succeeded.\n  const tagged = taggedAssertion(assertions, error);\n  if (error instanceof NodeNotFoundError) {\n    const ref = error.details;\n    const assertion =\n      tagged ?? assertions.find((candidate) => touchesRef(candidate, ref));\n    return identityImportError(assertion, graphId, error.message);\n  }\n  if (error instanceof IdentityContradictionError) {\n    const { a, b } = error.details;\n    const assertion =\n      tagged ??\n      assertions.find(\n        (candidate) => touchesRef(candidate, a) && touchesRef(candidate, b),\n      );\n    return identityImportError(assertion, graphId, error.message);\n  }\n  if (isIdConflictError(error)) {\n    const assertion = assertions.find(\n      (candidate) => candidate.id === error.details[\"assertionId\"],\n    );\n    return identityImportError(assertion, graphId, error.message);\n  }\n  if (isIdentityAssertionValidationError(error)) {\n    const issue = error.details.issues[0];\n    const message =\n      issue === undefined ?\n        error.message\n      : `${error.message} (${issue.message})`;\n    return identityImportError(\n      assertions.find((candidate) => candidate.id === issue?.assertionId),\n      graphId,\n      message,\n    );\n  }\n  return undefined;\n}\n\n/**\n * The assertion the coordinator tagged onto the error via\n * `IDENTITY_IMPORT_FAILED_ASSERTION` — exact, structural attribution for any\n * error shape.\n */\nfunction taggedAssertion(\n  assertions: readonly InterchangeIdentityAssertion[],\n  error: unknown,\n): InterchangeIdentityAssertion | undefined {\n  if (typeof error !== \"object\" || error === null) return undefined;\n  const id = (error as Record<PropertyKey, unknown>)[\n    IDENTITY_IMPORT_FAILED_ASSERTION\n  ];\n  if (typeof id !== \"string\") return undefined;\n  return assertions.find((candidate) => candidate.id === id);\n}\n\n/**\n * A `ValidationError` the identity import coordinator raised about assertion\n * CONTENT (ended rows in state mode, out-of-bounds validity windows, unknown\n * kinds, unnormalized pairs, self-assertions). Every issue it emits is pathed\n * at `identity.assertions` and carries the offending assertion's id\n * structurally in `assertionId` — attribution never parses the\n * human-readable message. A validation error shaped any other way is a\n * document-shape or programming fault and must still propagate.\n */\nfunction isIdentityAssertionValidationError(\n  error: unknown,\n): error is ValidationError {\n  return (\n    error instanceof ValidationError &&\n    error.details.issues.length > 0 &&\n    error.details.issues.every(\n      (issue) =>\n        issue.path === \"identity.assertions\" && issue.assertionId !== undefined,\n    )\n  );\n}\n\n/**\n * Applies the identity section, recording a per-document failure in\n * `result.errors` instead of aborting the whole import.\n *\n * {@link importGraph} promises `{ success: false, errors }` for content the\n * target rejects, and the node and edge paths honor that by recording the\n * offending row and moving on. The identity coordinator instead throws, so a\n * missing endpoint, a contradiction against the target graph, or a reused\n * assertion id escaped the transaction and turned a rejected assertion into a\n * thrown import — discarding the valid node and edge work alongside it.\n *\n * Assertions the coordinator applied before the failing one stay committed,\n * exactly as rows accepted before a failing node do. The tagged error carries\n * the coordinator's completed counts so the returned result describes those\n * durable partial effects accurately.\n */\nasync function importIdentitySection<G extends GraphDef>(\n  runtime: ReturnType<typeof storeRuntime<G>>,\n  target: GraphBackend | TransactionBackend,\n  graphId: string,\n  identity: NonNullable<GraphData[\"identity\"]>,\n  result: ImportResult,\n  errors: ImportError[],\n): Promise<void> {\n  try {\n    const summary = await runtime.importIdentityAssertionsAtTarget(\n      target,\n      identity.assertions,\n      identity.mode,\n    );\n    result.identity.created += summary.created;\n    result.identity.skipped += summary.skipped;\n  } catch (error) {\n    const entry = asIdentityImportError(identity.assertions, graphId, error);\n    if (entry === undefined) throw error;\n    const progress = identityImportProgress(error);\n    result.identity.created += progress.created;\n    result.identity.skipped += progress.skipped;\n    errors.push(entry);\n  }\n}\n\nfunction identityImportProgress(\n  error: unknown,\n): Readonly<{ created: number; skipped: number }> {\n  if (typeof error !== \"object\" || error === null) {\n    return { created: 0, skipped: 0 };\n  }\n  const progress = (error as Record<PropertyKey, unknown>)[\n    IDENTITY_IMPORT_PROGRESS\n  ];\n  if (\n    typeof progress !== \"object\" ||\n    progress === null ||\n    !(\"created\" in progress) ||\n    typeof progress.created !== \"number\" ||\n    !(\"skipped\" in progress) ||\n    typeof progress.skipped !== \"number\"\n  ) {\n    return { created: 0, skipped: 0 };\n  }\n  return { created: progress.created, skipped: progress.skipped };\n}\n\nfunction validateStreamHeader(header: GraphDataHeader): void {\n  const parsed = GraphDataHeaderSchema.safeParse(header);\n  if (parsed.success) return;\n  throw new ValidationError(\n    `Invalid graph interchange stream header: ${parsed.error.message}`,\n    {\n      issues: parsed.error.issues.map((issue) => ({\n        path: issue.path.join(\".\"),\n        message: issue.message,\n        code: issue.code,\n      })),\n    },\n    { cause: parsed.error },\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    identity: { created: 0, skipped: 0 },\n    errors: [],\n  };\n}\n\nfunction graphDataForChunk(\n  header: GraphDataHeader,\n  nodes: GraphData[\"nodes\"],\n  edges: GraphData[\"edges\"],\n  assertions: readonly InterchangeIdentityAssertion[],\n): GraphData {\n  const { identity, ...headerWithoutIdentity } = header;\n  return {\n    ...headerWithoutIdentity,\n    nodes,\n    edges,\n    ...(identity === undefined ?\n      {}\n    : {\n        identity: { ...identity, assertions: [...assertions] },\n      }),\n  };\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.identity.created += source.identity.created;\n  target.identity.skipped += source.identity.skipped;\n  target.errors.push(...source.errors);\n}\n\n/**\n * Refreshes planner statistics after a mutating import.\n *\n * CALLED UNDER THE TARGET CONNECTION'S STREAM LEASE by every surface: ANALYZE\n * is a write, and a write that runs outside the lease can be stranded by an\n * export snapshot that takes the one connection it needs. `importGraph` holds\n * the lease through {@link withImportStreamLease} for its whole call;\n * `importGraphStream` holds its chunk-loop lease across this call too.\n *\n * Best-effort: by this point the import is committed, so a failed statistics\n * refresh must not convert the completed (non-atomic on some backends,\n * non-retryable) import into a thrown failure — it degrades to a warning, and\n * the caller can run `store.refreshStatistics()`.\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    result.identity.created;\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        // Interchange rows always carry an explicit id.\n        idProvided: true,\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 updateWindow = validateUpdateValidityWindow(\n            node,\n            existing.valid_from,\n          );\n          if (!updateWindow.ok) {\n            record(node, { status: \"error\", error: updateWindow.error });\n            break;\n          }\n          const updateError = await updateImportedNode(\n            writeContext,\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            node,\n            {\n              existing,\n              schema: schemaEntry.registration.type.schema,\n              validatedProps: props,\n              uniqueConstraints,\n              windowFence: updateWindow.value,\n            },\n          );\n          if (updateError === undefined) {\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            updateError === undefined ?\n              { status: \"updated\" }\n            : { status: \"error\", error: updateError },\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\n/**\n * What a guard hands back when its refusal is a PER-ROW fact: either the value\n * the guard produced, or the message recorded against that row while the import\n * keeps going. Shared by the uniqueness guard and the window guard so the two\n * per-row recoveries have one shape.\n */\ntype PerRowGuardResult<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<PerRowGuardResult<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 * The stable prefix on every per-row refusal caused by an import UPDATE whose\n * target stopped matching the row this import made its decision from.\n *\n * The node counterpart of {@link EDGE_IDENTITY_CONFLICT_CODE}. Nodes need no\n * identity code — their probe is kind-scoped and they have no endpoints — but\n * they do share the temporal half of the class: the update verdict is computed\n * from the PROBED row's `valid_from`, and a concurrent hard delete + recreate\n * can replace it between the probe and the write.\n */\nconst NODE_UPDATE_TARGET_CHANGED_CODE =\n  \"INTERCHANGE_NODE_UPDATE_TARGET_CHANGED\";\n\n/**\n * Updates an existing node under the effective validity lower bound this import\n * checked it carries, and reports a write that landed on nothing as a per-row\n * error.\n *\n * THE SINGLE OWNER of the node update leg, called by both the batched slice and\n * the sequential fallback, so the assertion cannot be threaded through one and\n * forgotten on the other.\n *\n * The `windowFence` is what makes the import's own window check\n * ({@link validateUpdateValidityWindow}) binding rather than advisory. When that\n * check reads the STORED `valid_from` — because the document stated a lower\n * bound to compare against it, or a lone `validTo` to invert against it — it\n * hands back an `expectedValidFrom` predicate, and a read-then-write pair keyed\n * on `(graph_id, kind, id)` alone would otherwise re-resolve that key between the\n * two under PostgreSQL READ COMMITTED: a concurrent hard delete + recreate could\n * leave the write applying a verdict computed for a row that no longer exists —\n * the document's `validFrom` silently ignored, or a `valid_to` persisted below\n * the new row's `valid_from`. The fence puts the bound in the UPDATE's own\n * `WHERE`.\n *\n * A document naming NEITHER bound gets an empty fence, and that is the point: its\n * verdict never looked at the row's lower bound, so a recreate that moved the\n * bound changed nothing this write decided, and refusing the props update would\n * refuse a write the equivalent `store.nodes.*.update` performs. The\n * `deleted_at IS NULL` fence of the live-row update still applies.\n */\nasync function updateImportedNode(\n  writeContext: NodeWriteContext,\n  backend: GraphBackend | TransactionBackend,\n  node: InterchangeNode,\n  args: Readonly<{\n    existing: LiveNodeRow;\n    schema: z.ZodType;\n    validatedProps: Record<string, unknown>;\n    uniqueConstraints: readonly UniqueConstraint[];\n    windowFence: ValidityLowerBoundFence;\n  }>,\n): Promise<string | undefined> {\n  try {\n    const result = await catchUniquenessError(() =>\n      applyNodeUpdate(\n        writeContext,\n        {\n          existing: args.existing,\n          schema: args.schema,\n          validatedProps: args.validatedProps,\n          uniqueConstraints: args.uniqueConstraints,\n          ...args.windowFence,\n          ...(node.validTo !== undefined && { validTo: node.validTo }),\n        },\n        backend,\n      ),\n    );\n    return result.ok ? undefined : result.error;\n  } catch (error) {\n    if (\n      !(error instanceof DatabaseOperationError) ||\n      error.details.reason !== \"no_row_returned\"\n    ) {\n      throw error;\n    }\n    return (\n      `${NODE_UPDATE_TARGET_CHANGED_CODE}: Node \"${node.kind}:${node.id}\" was ` +\n      \"not updated: no live node matching the id and the validity bound this \" +\n      \"import checked remained when the write ran, so the row changed or was \" +\n      \"removed after it was checked. Re-export the source and retry.\"\n    );\n  }\n}\n\n/**\n * The stable prefix on every per-row refusal caused by an incoming edge naming\n * an id that a DIFFERENT edge already occupies, so a caller can recognize the\n * condition without parsing prose — the same `CODE: message` idiom the validity\n * window refusals use.\n *\n * ONE code for the whole immutable-identity class — kind AND endpoints — rather\n * than a second code for endpoint mismatches. The condition is a single fact\n * (\"the row under this id is not the edge this document describes\"), the\n * recovery is a single action (\"give it a distinct id, or import it under the\n * identity the stored row carries\"), and a caller that had to match two prefixes\n * to catch one condition would eventually match only one. The message names\n * which components differ; the prefix says what class of thing went wrong.\n *\n * The token still reads `…_KIND_CONFLICT` because it is a PUBLISHED, branchable\n * prefix (documented in `interchange.md`) and renaming it would silently break\n * every caller filtering on it; the constant is named for what it now covers.\n */\nconst EDGE_IDENTITY_CONFLICT_CODE = \"INTERCHANGE_EDGE_KIND_CONFLICT\";\n\n/** The immutable identity of a stored edge, as the probe reports it. */\ntype StoredEdgeIdentity = Readonly<{\n  kind: string;\n  from_kind: string;\n  from_id: string;\n  to_kind: string;\n  to_id: string;\n}>;\n\n/**\n * Whether an existing row is actually the edge this document is describing.\n *\n * THE SINGLE OWNER of that decision, consulted by both edge-import paths (the\n * batched slice and the per-row fallback) before ANY conflict strategy runs.\n *\n * Edge ids are graph-global while every interchange edge states a kind AND both\n * endpoints, and the existence probe (`getEdge` / `getEdges`) is keyed on\n * `(graph_id, id)` alone — so an incoming edge whose id is already taken by a\n * DIFFERENT edge finds that row and, without this check, was treated as the same\n * edge by all three strategies: `update` wrote the incoming props onto the other\n * row with nothing in `result.errors`, and `skip` counted the document's edge as\n * already present when nothing matching was ever there. Both are silent, and the\n * id is unique per graph, so the incoming edge cannot be created under it\n * either. Reporting is the only honest outcome.\n *\n * Compares the FULL immutable identity — kind and all four endpoint components —\n * not kind alone. Kind is not an identity: an id already held by an edge of the\n * same kind pointing somewhere else is just as much \"not this edge\", and a\n * kind-only comparison reported `updated: 1` while overwriting that row's props\n * and silently retaining its old endpoints (endpoints are immutable, so the\n * document's stated `from`/`to` were simply discarded). Every component is\n * checked because every component is immutable for a given row.\n *\n * Deliberately checked ABOVE the `onConflict` switch rather than inside each\n * arm: the question \"is this the same edge?\" is prior to \"what do we do about\n * the same edge?\", and answering it per-arm is how two of the three arms came\n * to answer it differently.\n *\n * Nodes need no equivalent: their probe is `getNode(graphId, kind, id)`, which\n * is kind-scoped, and a node has no endpoints — so a cross-kind id collision\n * simply reads as absent there.\n */\nfunction edgeIdentityConflict(\n  edge: InterchangeEdge,\n  existing: StoredEdgeIdentity,\n): string | undefined {\n  const differences = [\n    ...(existing.kind === edge.kind ?\n      []\n    : [`kind \"${existing.kind}\" (document states \"${edge.kind}\")`]),\n    ...((\n      existing.from_kind === edge.from.kind && existing.from_id === edge.from.id\n    ) ?\n      []\n    : [\n        `from \"${existing.from_kind}:${existing.from_id}\" (document states ` +\n          `\"${edge.from.kind}:${edge.from.id}\")`,\n      ]),\n    ...(existing.to_kind === edge.to.kind && existing.to_id === edge.to.id ?\n      []\n    : [\n        `to \"${existing.to_kind}:${existing.to_id}\" (document states ` +\n          `\"${edge.to.kind}:${edge.to.id}\")`,\n      ]),\n  ];\n  if (differences.length === 0) return undefined;\n  return (\n    `${EDGE_IDENTITY_CONFLICT_CODE}: Edge \"${edge.id}\" already exists with a ` +\n    `different immutable identity — ${differences.join(\"; \")}. Edge ids are ` +\n    \"unique per graph, so the incoming edge can neither update nor be created \" +\n    \"under that id. Give it a distinct id, or import it under the identity the \" +\n    \"stored row already carries.\"\n  );\n}\n\n/**\n * Updates an existing edge under the full immutable identity the caller checked\n * it carries, and reports a write that landed on nothing as a per-row error.\n *\n * All five identity components are stated so the predicate lives in the UPDATE's\n * own `WHERE` — the contract on {@link UpdateEdgeParams}, and the only placement\n * a concurrent hard-delete-and-recreate cannot slip past, because a\n * read-then-write pair keyed on `(graph_id, id)` alone re-resolves that id\n * between the probe and the write under PostgreSQL READ COMMITTED. Omitting them\n * made the import's own identity check advisory: correct until raced.\n *\n * The endpoints move together with `kind` rather than being left out because\n * they are \"less likely\" to be raced: the window is the same window, and this\n * import HAS checked all five against a row it read, which is exactly the\n * precondition {@link UpdateEdgeParams} states for asserting them.\n *\n * The effective `valid_from` joins them for a DIFFERENT reason, and the doc on\n * {@link UpdateEdgeParams.expectedValidFrom} spells it out: the five identity\n * components are asserted because they are immutable, the bound because it is\n * NOT. {@link validateUpdateValidityWindow} decides from the row's stored\n * `valid_from` — whether the document may state a lower bound this update will\n * not apply, and whether its `validTo` sits above the bound the row keeps — so a\n * recreate that satisfies all five identity components while carrying a\n * different bound would still land a verdict computed for a row that is gone.\n *\n * Which is why the bound arrives as the guard's own `windowFence` rather than as\n * a value this function re-derives: it is present exactly when the verdict read\n * it. A document naming neither `validFrom` nor `validTo` read nothing, so it is\n * fenced on identity alone and a recreate that only moved the bound no longer\n * refuses its props update.\n *\n * When the predicate does match nothing, the backend reports it as a\n * `no_row_returned` {@link DatabaseOperationError}. By then this import has\n * already checked the identity against a row it read, so reaching here means the\n * target changed underneath us — a per-row fact about one edge, not a reason to\n * abort an import whose earlier rows are already written.\n */\nasync function updateImportedEdge(\n  backend: GraphBackend | TransactionBackend,\n  graphId: string,\n  edge: InterchangeEdge,\n  props: Readonly<Record<string, unknown>>,\n  windowFence: ValidityLowerBoundFence,\n): Promise<string | undefined> {\n  try {\n    await backend.updateEdge({\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      ...windowFence,\n      ...(edge.validTo !== undefined && { validTo: edge.validTo }),\n    });\n    return undefined;\n  } catch (error) {\n    if (\n      !(error instanceof DatabaseOperationError) ||\n      error.details.reason !== \"no_row_returned\"\n    ) {\n      throw error;\n    }\n    return (\n      `${EDGE_IDENTITY_CONFLICT_CODE}: Edge \"${edge.id}\" of kind \"${edge.kind}\" ` +\n      `from \"${edge.from.kind}:${edge.from.id}\" to \"${edge.to.kind}:${edge.to.id}\" ` +\n      \"was not updated: no live edge matching the identity and the validity \" +\n      \"bound this import checked remained when the write ran, so the row \" +\n      \"changed or was removed after it was checked. Re-export the source and \" +\n      \"retry.\"\n    );\n  }\n}\n\n/**\n * Runs a window guard and reports its refusal as a per-row error message\n * (recorded in the import result) instead of throwing, so one malformed row does\n * not abort the whole import. On success the guard's own verdict comes back, so\n * a write leg fences on what the guard decided rather than on a second spelling\n * of it. A window refusal that carries a stable issue code —\n * {@link INVERTED_VALIDITY_WINDOW_CODE} or\n * {@link IMMUTABLE_VALIDITY_LOWER_BOUND_CODE} — is prefixed with it, so the\n * refusal is recognizable without parsing prose.\n */\nfunction windowResultOf<T>(assert: () => T): PerRowGuardResult<T> {\n  try {\n    return { ok: true, value: assert() };\n  } catch (error) {\n    if (error instanceof ValidationError) {\n      const coded = error.details.issues.find(\n        (issue) =>\n          issue.code === INVERTED_VALIDITY_WINDOW_CODE ||\n          issue.code === IMMUTABLE_VALIDITY_LOWER_BOUND_CODE,\n      );\n      if (coded !== undefined) {\n        return { ok: false, error: `${coded.code}: ${error.message}` };\n      }\n    }\n    return {\n      ok: false,\n      error: error instanceof Error ? error.message : String(error),\n    };\n  }\n}\n\n/** {@link windowResultOf} for a guard whose only output is its refusal. */\nfunction windowErrorOf(assert: () => void): string | undefined {\n  const result = windowResultOf(assert);\n  return result.ok ? undefined : result.error;\n}\n\n/**\n * Validates an entity's validity window against the two contracts `create` /\n * `update` enforce: canonical fixed-width UTC ISO-8601 timestamps, so no import\n * write path can persist a `valid_from` / `valid_to` that later mis-sorts as\n * text against an `asOf` read coordinate, and non-negative window WIDTH, so no\n * import document can persist a row that stopped being true before it started.\n * Import writes straight to the backend rather than through the store\n * operations layer, so it carries its own copy of both — this is the only place\n * the guarantee exists for an imported row.\n *\n * The interchange schema enforces the timestamp contract at the parse boundary,\n * but `importGraph` accepts a pre-typed `GraphData` and does not re-parse it, so\n * this is also the guarantee for callers that bypass the schema.\n *\n * This is the INSERT-shaped half, judged before the existence probe so a\n * malformed document is refused whether or not the row already exists. The\n * update legs additionally call {@link validateUpdateValidityWindow}, which\n * needs the row.\n */\nfunction validateValidityWindow(\n  entity: Readonly<{\n    kind: string;\n    id: string;\n    validFrom?: string | null | undefined;\n    validTo?: string | undefined;\n  }>,\n): string | undefined {\n  return windowErrorOf(() => {\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    // On an INSERT only a stated pair is judged — a lone historical validTo\n    // means \"born already ended\", exactly as it does on `create` (see\n    // assertWritableValidityWindow). `null` is a confirmed open-left window and\n    // is not a lower bound at all.\n    assertOrderedValidityWindow(\n      `${entity.kind} \"${entity.id}\"`,\n      entity.validFrom ?? undefined,\n      entity.validTo,\n    );\n  });\n}\n\n/**\n * The UPDATE-shaped half, for `onConflict: \"update\"` against a row that already\n * exists. All four update legs — batched and sequential, nodes and edges — send\n * the document's `validTo` to an in-place update of a LIVE row while its stored\n * `valid_from` stays put, so the document's end is held to that bound exactly as\n * `store.nodes.*.update` holds a caller's. Without this an import could still\n * write the inverted row the direct update path refuses, and the insert-shaped\n * check above cannot see it: such a document may state no `validFrom` at all.\n *\n * The document's `validFrom` is judged here for the same reason: import never\n * sends it on an update, so a document stating a bound that differs from the\n * row's is stating one the write will not apply. That is refused per row —\n * `onConflict: \"update\"` re-importing a document whose rows were created at a\n * different instant now reports those rows instead of silently updating their\n * props under a bound it ignored. `null` is a confirmed open-left window rather\n * than a stated bound (see `InterchangeNodeSchema`'s `validFrom`) and asserts\n * nothing.\n *\n * Returns the guard's own {@link ValidityLowerBoundFence}, which all four update\n * legs carry verbatim into their write. Import used to assert the probed\n * `valid_from` unconditionally instead — a second spelling of a decision the\n * verdict owns — which refused a props-only document (one naming neither bound)\n * whenever a concurrent recreate moved a bound this verdict never looked at.\n */\nfunction validateUpdateValidityWindow(\n  entity: Readonly<{\n    kind: string;\n    id: string;\n    validFrom?: string | null | undefined;\n    validTo?: string | undefined;\n  }>,\n  storedValidFrom: string | undefined,\n): PerRowGuardResult<ValidityLowerBoundFence> {\n  const verdict = windowResultOf(() =>\n    assertWritableValidityWindow(\n      `${entity.kind} \"${entity.id}\"`,\n      entity.validFrom ?? undefined,\n      {\n        effectiveValidFrom: storedValidFrom,\n        appliesStatedValidFrom: false,\n        // Import updates a LIVE row in place, so the effective bound is always\n        // the one the row already stores.\n        effectiveBoundIsStored: true,\n      },\n      entity.validTo,\n    ),\n  );\n  return verdict.ok ?\n      { ok: true, value: verdict.value.storedLowerBoundFence }\n    : verdict;\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        const updateWindow = validateUpdateValidityWindow(\n          node,\n          existing.valid_from,\n        );\n        if (!updateWindow.ok) {\n          return { status: \"error\", error: updateWindow.error };\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. Both per-row\n        // recoveries below are safe to catch and commit past because every\n        // `UniquenessError` `applyNodeUpdate` can raise comes from its plan or\n        // its claim, both of which precede the row write (and the claim\n        // compensates itself), and a write that landed on nothing wrote nothing\n        // by definition.\n        const updateError = await updateImportedNode(\n          writeContext,\n          backend,\n          node,\n          {\n            existing,\n            schema: registration.type.schema,\n            validatedProps: propsResult.data,\n            uniqueConstraints,\n            windowFence: updateWindow.value,\n          },\n        );\n        if (updateError !== undefined) {\n          return { status: \"error\", error: updateError };\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      // Prior to every strategy: a row occupying this id under a different\n      // immutable identity is not this edge, and none of the three arms may\n      // treat it as one.\n      const identityConflict = edgeIdentityConflict(edge, existing);\n      if (identityConflict !== undefined) {\n        record(edge, { status: \"error\", error: identityConflict });\n        continue;\n      }\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          const updateWindow = validateUpdateValidityWindow(\n            edge,\n            existing.valid_from,\n          );\n          if (!updateWindow.ok) {\n            record(edge, { status: \"error\", error: updateWindow.error });\n            break;\n          }\n          const updateError = await updateImportedEdge(\n            backend,\n            graphId,\n            edge,\n            props,\n            updateWindow.value,\n          );\n          if (updateError !== undefined) {\n            record(edge, { status: \"error\", error: updateError });\n            break;\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    // Same prior question as the batched path, answered by the same owner.\n    const identityConflict = edgeIdentityConflict(edge, existing);\n    if (identityConflict !== undefined) {\n      return { status: \"error\", error: identityConflict };\n    }\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        const updateWindow = validateUpdateValidityWindow(\n          edge,\n          existing.valid_from,\n        );\n        if (!updateWindow.ok) {\n          return { status: \"error\", error: updateWindow.error };\n        }\n        const updateError = await updateImportedEdge(\n          backend,\n          graphId,\n          edge,\n          propsResult.data,\n          updateWindow.value,\n        );\n        if (updateError !== undefined) {\n          return { status: \"error\", error: updateError };\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          // Data-keyed: `knownKeys` are schema-declared property names.\n          const stripped = createDataKeyedBag<unknown>();\n          for (const key of knownKeys) {\n            if (hasOwnKey(properties, key)) {\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 encodeTupleKey([kind, id]);\n}\n","/**\n * Graph data export functionality.\n *\n * Exports nodes and edges from a store to the interchange format.\n */\nimport { acquireSerializedStreamLease } from \"../backend/transaction-resource\";\nimport {\n  type GraphBackend,\n  rowPropsToObject,\n  type TransactionBackend,\n} from \"../backend/types\";\nimport {\n  getEdgeKinds,\n  getNodeKinds,\n  type GraphDef,\n} from \"../core/define-graph\";\nimport { ExportStreamCancelledError } from \"../errors\";\nimport { storeBackend, storeRuntime } from \"../store/runtime-port\";\nimport { type Store } from \"../store/store\";\nimport { nowIso } from \"../utils/date\";\nimport { requireDefined } from \"../utils/presence\";\nimport { serializedStreamRefusal } from \"./import\";\nimport { markExportStreamBackend } from \"./stream-source\";\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 InterchangeIdentityAssertion,\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  const identityAssertions: InterchangeIdentityAssertion[] = [];\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      case \"identity\": {\n        identityAssertions.push(...chunk.assertions);\n        break;\n      }\n    }\n  }\n  if (header === undefined) {\n    throw new Error(\"Graph export stream ended before emitting its header.\");\n  }\n  const { identity, ...headerWithoutIdentity } = header;\n  return {\n    ...headerWithoutIdentity,\n    nodes,\n    edges,\n    ...(identity === undefined ?\n      {}\n    : {\n        identity: { ...identity, assertions: identityAssertions },\n      }),\n  };\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 *\n * ## One snapshot, WHERE THE BACKEND HAS TRANSACTIONS\n *\n * On a backend reporting `capabilities.transactions`, the whole export —\n * header, every node page, every edge page, every identity page — is read\n * inside ONE `repeatable_read` / `read_only` transaction, so a slow consumer\n * still gets one point in time rather than a mixture of the graph as it was at\n * the first chunk and as it is at the last.\n *\n * A backend WITHOUT transactions (SQLite `transactionMode: \"none\"`, the\n * session-less HTTP Postgres drivers) opens no such transaction: its export\n * paginates statement by statement, and a write committed mid-stream can appear\n * in the pages that follow. There is no way to offer the guarantee on an engine\n * that cannot frame the reads, so it is a declared capability gap rather than\n * something the stream pretends to. Callers needing a coherent export from such\n * a backend must quiesce writes for its duration.\n *\n * ## Stopping a stream you will not finish\n *\n * While a transactional stream is open it holds that snapshot transaction, and\n * on a serialized connection it holds the connection's one EXCLUSIVE stream\n * lease with it. Every cooperative exit settles both, because each runs the\n * generator's `finally`: `break` or `throw` out of a `for await`, and an\n * explicit `iterator.return()`. (A non-transactional stream holds neither, so\n * it has nothing to strand — but it still owes its consumer an answer, which\n * the same cancellation path gives it.)\n *\n * A consumer that pulls `next()` and then simply DROPS the iterator has no\n * cooperative exit — async-generator `finally` blocks do not run on garbage\n * collection — so it must pass {@link ExportOptions.signal} and abort it.\n * Without that, the snapshot transaction stays open for the life of the\n * process and every later interchange stream on that connection is refused on\n * behalf of a stream nobody is reading.\n *\n * ### Why there is no garbage-collection safety net (#429)\n *\n * A `FinalizationRegistry` on the iterable cannot close this: it is not merely\n * unreliable here, it can never fire. The producer is interruptible in exactly\n * one place — it is parked in {@link RendezvousChannel.push} waiting for the\n * consumer, not in the database — so any cleanup state capable of settling an\n * abandoned stream has to reach that channel. A registry holds its held value\n * STRONGLY, and holding anything that reaches the channel's scope keeps the\n * abandoned generator permanently reachable: measured on Node 24, publishing\n * just `channel.abort` is enough to stop the stream being collected, while\n * publishing an unrelated object is not. The net's own bookkeeping would\n * therefore be what kept the entry from ever firing — a safety promise that\n * reads as protection and is not there. The signal is the mechanism, and it is\n * a contract rather than a hint.\n */\nexport function exportGraphStream<G extends GraphDef>(\n  store: Store<G>,\n  options?: ExportStreamOptionsInput,\n): AsyncIterable<GraphInterchangeChunk> {\n  const backend = storeBackend(store);\n  return markExportStreamBackend(\n    exportGraphStreamFromBackend(store, backend, options),\n    backend,\n  );\n}\n\nasync function* exportGraphStreamFromBackend<G extends GraphDef>(\n  store: Store<G>,\n  backend: GraphBackend,\n  options?: ExportStreamOptionsInput,\n): AsyncIterable<GraphInterchangeChunk> {\n  const resolved = ExportStreamOptionsSchema.parse(options ?? {});\n  const signal = resolved.signal;\n  const channel = createRendezvousChannel<GraphInterchangeChunk>();\n  const abortStream = (): void => {\n    channel.abort(\n      exportStreamCancelled(\n        \"mid-stream\",\n        store.graphId,\n        signal,\n        backend.capabilities.transactions,\n      ),\n    );\n  };\n  const unsubscribeFromSignal = (): void => {\n    signal?.removeEventListener(\"abort\", abortStream);\n  };\n  // REGISTER, THEN RE-CHECK — and in that order, because the two halves cover\n  // different instants and neither covers both:\n  //\n  // - The listener covers every abort from now on, including one raised\n  //   SYNCHRONOUSLY by the driver inside `backend.transaction(...)` below. That\n  //   is the window this ordering exists for: subscribing after that call\n  //   returned meant such an abort was delivered to nobody — an `AbortSignal`\n  //   does not replay `abort` to a listener that arrives late — and the export\n  //   went on holding its snapshot and its lease with `signal.aborted === true`.\n  // - The re-check covers an abort that already happened, which the event will\n  //   never deliver at all. It is not ceremonial: `parse` above reads the\n  //   caller's options object, and a getter on it can abort the controller\n  //   before this line is reached.\n  //\n  // Nothing between them can yield, so there is no instant at which an abort is\n  // neither seen by the re-check nor delivered to the listener.\n  signal?.addEventListener(\"abort\", abortStream, { once: true });\n  if (signal?.aborted === true) {\n    // Nothing has been claimed or opened yet, so this stream is over before it\n    // started rather than cancelled in flight — and it must leave no listener\n    // on a signal the caller may hold for the rest of the process.\n    unsubscribeFromSignal();\n    throw exportStreamCancelled(\n      \"before-open\",\n      store.graphId,\n      signal,\n      backend.capabilities.transactions,\n    );\n  }\n  const produce = async (\n    target: GraphBackend | TransactionBackend,\n  ): Promise<void> => {\n    await produceExportChunks(store, target, resolved, (chunk) =>\n      channel.push(chunk),\n    );\n  };\n  /**\n   * Opens the snapshot and wires the producer, or gives back EVERYTHING this\n   * stream has taken and rethrows.\n   *\n   * On a serialized backend the snapshot transaction holds the single\n   * connection for the whole stream. Claiming that connection's one stream\n   * lease for the duration makes a concurrent import — or a SECOND export,\n   * whose snapshot transaction would nest inside this one just as fatally —\n   * be refused rather than left to wait for a slot that cannot free up. This is\n   * what the stream's consumer identity cannot answer once a caller wraps the\n   * iterable. And if another stream already holds that connection, THIS side is\n   * the one refused: it is the stream that started second. The claim is\n   * deliberately inside the generator body: it must begin when the transaction\n   * opens (first pull), not when the iterable is constructed.\n   *\n   * Two things can stop the stream before it starts, and both give back what\n   * they took. The lease refusal takes nothing but the signal subscription made\n   * above. `backend.transaction(...)` is a driver call, and a driver can reject\n   * SYNCHRONOUSLY — a closed handle, a pool that refuses the checkout — before\n   * any promise exists; the release is installed on the promise it returns, so\n   * a synchronous throw would otherwise skip it and strand the lease for the\n   * life of the process, refusing every later stream on that connection on\n   * behalf of one that never ran a statement.\n   */\n  const beginProducer = (): Promise<void> => {\n    try {\n      const releaseSnapshotExport =\n        backend.capabilities.transactions ?\n          claimSnapshotExportLeaseOrRefuse(store.graphId, backend)\n        : () => {\n            // No snapshot transaction is opened here, so nothing was claimed:\n            // a non-transactional export holds nothing against a concurrent\n            // stream.\n          };\n      try {\n        const started =\n          backend.capabilities.transactions ?\n            backend.transaction((target) => produce(target), {\n              isolationLevel: \"repeatable_read\",\n              accessMode: \"read_only\",\n            })\n          : produce(backend);\n        return started.then(\n          () => {\n            releaseSnapshotExport();\n            channel.finish();\n          },\n          (error: unknown) => {\n            releaseSnapshotExport();\n            channel.fail(error);\n          },\n        );\n      } catch (error) {\n        releaseSnapshotExport();\n        throw error;\n      }\n    } catch (error) {\n      unsubscribeFromSignal();\n      throw error;\n    }\n  };\n  const producer = beginProducer();\n\n  try {\n    for (;;) {\n      const delivery = await channel.take();\n      if (delivery === undefined) return;\n      yield delivery.value;\n      delivery.acknowledge();\n    }\n  } finally {\n    // Unsubscribe FIRST: this stream is settling through a cooperative path, so\n    // an abort arriving during the teardown below must not publish a terminal\n    // error in place of the clean end the consumer is owed — and a signal the\n    // caller reuses for its next export must not still reach this one, nor keep\n    // this generator's scope alive for as long as the caller holds it.\n    unsubscribeFromSignal();\n    channel.cancel();\n    await producer;\n  }\n}\n\n/**\n * How far the stream had got when the abort landed. Every phase ends the same\n * way for the caller — nothing is held, start a new export — so they share one\n * error class and ONE `code`; only the message differs, because a refusal that\n * claimed nothing must not claim to have rolled anything back.\n *\n * - `before-open` — the abort was already visible when the stream was asked for\n *   its first chunk. No transaction was opened and no lease claimed, whatever\n *   the backend can do.\n * - `mid-stream` — the abort arrived from the moment the stream began opening\n *   onward, INCLUDING synchronously inside `backend.transaction(...)`. What was\n *   given back depends on what was taken, which is why this phase needs the\n *   backend's capability to describe itself honestly.\n */\ntype ExportAbortPhase = \"before-open\" | \"mid-stream\";\n\n/**\n * The single owner of the error an aborted export stream reports, so the\n * pre-flight refusal and the mid-stream abort state the same condition in the\n * same vocabulary — one code, the signal's own reason as `cause`, and a message\n * that is true of the phase AND of the backend it describes.\n *\n * `framed` is `backend.capabilities.transactions`. A non-transactional export\n * opened no snapshot and claimed no lease, so telling its consumer that a\n * snapshot was rolled back and a connection released would describe work that\n * never happened — and would hide the thing that consumer actually needs to\n * know, which is that the chunks it did receive were never one point in time.\n */\nfunction exportStreamCancelled(\n  phase: ExportAbortPhase,\n  graphId: string,\n  signal: AbortSignal | undefined,\n  framed: boolean,\n): ExportStreamCancelledError {\n  const message =\n    phase === \"before-open\" ?\n      \"The graph export stream was aborted through its AbortSignal before it opened: no snapshot transaction was started and no database connection claimed.\"\n    : framed ?\n      \"The graph export stream was aborted through its AbortSignal: its repeatable-read snapshot has been rolled back and the connection it held released.\"\n    : \"The graph export stream was aborted through its AbortSignal: its remaining reads were abandoned. This backend does not support transactions, so the export held no snapshot and no connection — and the chunks already delivered were never guaranteed to agree with one another.\";\n  const cause: unknown = signal?.reason;\n  // The suggestion must be capability-aware for the same reason the message is:\n  // the class default claims a snapshot rollback, which is false on the\n  // non-transactional arm and for a stream that never opened.\n  const suggestion =\n    phase === \"before-open\" ?\n      \"Start a new export; the aborted one claimed nothing.\"\n    : framed ?\n      \"Start a new export; the aborted one released its snapshot transaction and the connection it held.\"\n    : \"Start a new export; nothing was held, but discard the chunks already delivered unless partial, mutually-inconsistent data is acceptable.\";\n  return new ExportStreamCancelledError(\n    message,\n    { graphId },\n    {\n      suggestion,\n      ...(cause === undefined ? {} : { cause }),\n    },\n  );\n}\n\n/**\n * Claims the serialized connection for this export's snapshot transaction, or\n * refuses because another long-lived stream — a streaming import, or another\n * snapshot export — is already using it.\n *\n * The check and the claim are one synchronous section inside\n * {@link acquireSerializedStreamLease}, which offers no way to ask without\n * claiming. On a single-threaded event loop that makes \"no other stream held\n * this connection when the snapshot opened\" true for the whole stream: nobody\n * can slip a claim in between, and two streams cannot both conclude the\n * connection was free.\n *\n * Only called when the backend is transactional: a `transactionMode: \"none\"`\n * export holds nothing open, interleaves harmlessly, and must not be refused —\n * nor refuse anyone.\n */\nfunction claimSnapshotExportLeaseOrRefuse(\n  graphId: string,\n  backend: GraphBackend,\n): () => void {\n  const lease = acquireSerializedStreamLease(backend, \"export-snapshot\");\n  if (!lease.acquired) {\n    throw serializedStreamRefusal({\n      graphId,\n      requested: \"export-snapshot\",\n      heldBy: lease.heldBy,\n    });\n  }\n  return lease.release;\n}\n\nasync function produceExportChunks<G extends GraphDef>(\n  store: Store<G>,\n  backend: GraphBackend | TransactionBackend,\n  options: ExportOptions_ & Readonly<{ batchSize: number }>,\n  emit: (chunk: GraphInterchangeChunk) => Promise<void>,\n): Promise<void> {\n  const graphId = store.graphId;\n  const nodeKinds = options.nodeKinds ?? getNodeKinds(store.graph);\n  const edgeKinds = options.edgeKinds ?? getEdgeKinds(store.graph);\n  const schemaVersion = await backend.getActiveSchema(graphId);\n\n  await emit({\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      ...(store.graph.identity === undefined ?\n        {}\n      : {\n          identity: {\n            profile: \"typegraph-identity-v1\" as const,\n            mode: options.identityMode,\n          },\n        }),\n    },\n  });\n\n  for (const kind of nodeKinds) {\n    for await (const chunk of exportNodeChunks(\n      backend,\n      graphId,\n      kind,\n      options,\n    )) {\n      await emit(chunk);\n    }\n  }\n  for (const kind of edgeKinds) {\n    for await (const chunk of exportEdgeChunks(\n      backend,\n      graphId,\n      kind,\n      options,\n    )) {\n      await emit(chunk);\n    }\n  }\n  if (store.graph.identity === undefined) return;\n\n  let after: string | undefined;\n  for (;;) {\n    const page = await storeRuntime(store).readIdentityAssertionPageAtTarget(\n      backend,\n      options.identityMode,\n      {\n        ...(options.nodeKinds === undefined ? {} : { nodeKinds }),\n        includeDeleted: options.includeDeleted,\n        ...(after === undefined ? {} : { after }),\n        limit: options.batchSize,\n      },\n    );\n    if (page.assertions.length > 0) {\n      await emit({ type: \"identity\", assertions: [...page.assertions] });\n    }\n    if (page.done) return;\n    after = requireDefined(page.nextAfter);\n  }\n}\n\ntype ExportOptions_ = Readonly<{\n  includeTemporal: boolean;\n  includeMeta: boolean;\n  includeDeleted: boolean;\n  identityMode: \"state\" | \"archival\";\n  nodeKinds?: readonly string[] | undefined;\n  edgeKinds?: readonly string[] | undefined;\n}>;\n\ntype RendezvousDelivery<T> = Readonly<{\n  value: T;\n  acknowledge: () => void;\n}>;\n\ntype RendezvousChannel<T> = Readonly<{\n  push: (value: T) => Promise<void>;\n  take: () => Promise<RendezvousDelivery<T> | undefined>;\n  finish: () => void;\n  fail: (error: unknown) => void;\n  /** The consumer left through a cooperative path; the stream simply ends. */\n  cancel: () => void;\n  /**\n   * Nobody is coming back for this stream. Unwinds the producer — which rolls\n   * the snapshot transaction back and releases the connection's lease on its\n   * way out — AND makes `error` the channel's terminal state, so a consumer\n   * that is waiting on `next()`, or that asks again later, is told why rather\n   * than handed a silent end of stream it would read as a complete export.\n   */\n  abort: (error: Error) => void;\n}>;\n\nfunction createRendezvousChannel<T>(): RendezvousChannel<T> {\n  type PendingPush = Readonly<{\n    delivery: RendezvousDelivery<T>;\n    reject: (error: unknown) => void;\n  }>;\n  type PendingTake = Readonly<{\n    resolve: (delivery: RendezvousDelivery<T> | undefined) => void;\n    reject: (error: unknown) => void;\n  }>;\n\n  const consumerCancelledError = new Error(\"Export stream consumer cancelled.\");\n  let pendingPush: PendingPush | undefined;\n  let pendingTake: PendingTake | undefined;\n  let inFlightReject: ((error: unknown) => void) | undefined;\n  let terminal: Readonly<{ error?: Error }> | undefined;\n  /**\n   * Why the producer is being torn down, once something decided to tear it\n   * down — a cooperative consumer exit ({@link cancel}) or a cancellation\n   * ({@link abort}).\n   *\n   * The single owner of \"this stream is unwinding\": it is what every pending\n   * and future push rejects with, so the producer always unwinds through one\n   * rejection whichever side started it, and it is how {@link fail} recognizes\n   * the failure this channel caused itself.\n   */\n  let producerUnwindError: Error | undefined;\n\n  function push(value: T): Promise<void> {\n    if (producerUnwindError !== undefined) {\n      return Promise.reject(producerUnwindError);\n    }\n    if (terminal !== undefined || pendingPush !== undefined) {\n      return Promise.reject(\n        new Error(\"Cannot push to a completed or occupied export channel.\"),\n      );\n    }\n    return new Promise<void>((resolve, reject) => {\n      const delivery = {\n        value,\n        acknowledge: () => {\n          inFlightReject = undefined;\n          resolve();\n        },\n      };\n      if (pendingTake !== undefined) {\n        const take = pendingTake;\n        pendingTake = undefined;\n        inFlightReject = reject;\n        take.resolve(delivery);\n        return;\n      }\n      pendingPush = { delivery, reject };\n    });\n  }\n\n  function take(): Promise<RendezvousDelivery<T> | undefined> {\n    if (pendingPush !== undefined) {\n      const push = pendingPush;\n      pendingPush = undefined;\n      inFlightReject = push.reject;\n      return Promise.resolve(push.delivery);\n    }\n    if (terminal !== undefined) {\n      return terminal.error === undefined ?\n          Promise.resolve(undefined)\n        : Promise.reject(terminal.error);\n    }\n    if (pendingTake !== undefined) {\n      return Promise.reject(\n        new Error(\"Export channel already has a consumer.\"),\n      );\n    }\n    return new Promise<RendezvousDelivery<T> | undefined>((resolve, reject) => {\n      pendingTake = { resolve, reject };\n    });\n  }\n\n  function finish(): void {\n    if (producerUnwindError !== undefined) return;\n    terminal = {};\n    if (pendingTake !== undefined) {\n      const take = pendingTake;\n      pendingTake = undefined;\n      take.resolve(undefined);\n    }\n  }\n\n  function fail(error: unknown): void {\n    // The producer failed with the very rejection this channel handed it in\n    // order to unwind: that is this channel's own doing, not a new outcome to\n    // report. Compared against a DEFINED unwind error only — a producer that\n    // rejects with `undefined` is a real failure and must still reach the\n    // consumer.\n    if (producerUnwindError !== undefined && error === producerUnwindError) {\n      return;\n    }\n    // An abort already published the terminal state the consumer must see; the\n    // producer's own unwinding failure must not overwrite it.\n    if (terminal !== undefined) return;\n    const exportError =\n      error instanceof Error ? error : (\n        new Error(\"Graph export failed.\", { cause: error })\n      );\n    terminal = { error: exportError };\n    if (pendingTake !== undefined) {\n      const take = pendingTake;\n      pendingTake = undefined;\n      take.reject(exportError);\n    }\n  }\n\n  function cancel(): void {\n    if (producerUnwindError !== undefined) return;\n    producerUnwindError = consumerCancelledError;\n    if (pendingPush !== undefined) {\n      const push = pendingPush;\n      pendingPush = undefined;\n      push.reject(consumerCancelledError);\n    }\n    if (inFlightReject !== undefined) {\n      const reject = inFlightReject;\n      inFlightReject = undefined;\n      reject(consumerCancelledError);\n    }\n    if (pendingTake !== undefined) {\n      const take = pendingTake;\n      pendingTake = undefined;\n      take.resolve(undefined);\n    }\n  }\n\n  function abort(error: Error): void {\n    // Nothing is held any more, so this abort has nothing to take back and must\n    // not restate the outcome. The two arms are NOT alike in how they are\n    // reached:\n    //\n    // - `terminal !== undefined` IS reachable. The producer settles\n    //   (`finish`/`fail`) and resolves the consumer's pending take, but the\n    //   generator only resumes to run its `finally` — and unsubscribe — in a\n    //   later microtask. An abort landing in that window finds the outcome\n    //   already published and must leave it alone: the export really did end\n    //   the way `terminal` says, and the consumer has already been handed that\n    //   answer.\n    // - `producerUnwindError !== undefined` is defensive. `cancel()` sets it\n    //   from the generator's `finally`, which unsubscribes BEFORE calling it,\n    //   and the listener is `{ once: true }`, so there is no path today that\n    //   calls `abort` twice or calls it after `cancel`.\n    if (terminal !== undefined || producerUnwindError !== undefined) return;\n    producerUnwindError = error;\n    terminal = { error };\n    if (pendingPush !== undefined) {\n      const push = pendingPush;\n      pendingPush = undefined;\n      push.reject(error);\n    }\n    if (inFlightReject !== undefined) {\n      const reject = inFlightReject;\n      inFlightReject = undefined;\n      reject(error);\n    }\n    if (pendingTake !== undefined) {\n      const take = pendingTake;\n      pendingTake = undefined;\n      take.reject(error);\n    }\n  }\n\n  return { push, take, finish, fail, cancel, abort };\n}\n\n// ============================================================\n// Node Export\n// ============================================================\n\nasync function* exportNodeChunks(\n  backend: GraphBackend | TransactionBackend,\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 | TransactionBackend,\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"]}