@nicia-ai/typegraph 0.34.0 → 0.35.0

package/dist/chunk-XOX22WHL.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/temporal.ts","../src/query/compiler/schema.ts","../src/utils/id.ts","../src/store/recorded-capture/guards.ts","../src/store/recorded-capture/clock.ts","../src/store/insert-dispatch.ts","../src/store/row-fetch.ts","../src/store/edge-fetch.ts","../src/store/node-fetch.ts","../src/store/recorded-capture/relations.ts","../src/store/recorded-capture/flush.ts","../src/store/recorded-capture.ts","../src/store/embedding-sync.ts","../src/store/fulltext-sync.ts","../src/constraints/index.ts","../src/store/uniqueness.ts","../src/store/operations/node-write-pipeline.ts"],"names":["validateCanonicalIsoDate","ValidationError","ConfigurationError","MAX_PG_IDENTIFIER_LENGTH","sql","nanoid","asCompiledStatementSql","asCompiledRowsSql","nowIso","rows","rowPropsToJsonText","sqlNull","sqlValueList","isPresent","chunk","groupBy","createBackendOverlay","withRecordedRelationsPrecondition","resolveEmbeddingFields","DEFAULT_SEARCHABLE_LANGUAGE","getSearchableFields","CardinalityError","EndpointError","DisjointError","UniquenessError","RestrictedDeleteError","rowPropsToObject"],"mappings":"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","file":"chunk-XOX22WHL.cjs","sourcesContent":["/**\n * Shared temporal coordinate + validation.\n */\nimport { ValidationError } from \"../errors\";\nimport { validateCanonicalIsoDate } from \"../utils/date\";\nimport { type TemporalMode } from \"./types\";\n\n/**\n * Open-ended recorded-time sentinel. Chosen so SQLite text ordering and\n * PostgreSQL `timestamptz` ordering both put every real commit instant before\n * the open interval end.\n */\nexport const RECORDED_MAX = \"9999-12-31T23:59:59.999Z\";\n\ndeclare const RECORDED_INSTANT_BRAND: unique symbol;\n\n/**\n * A canonical UTC ISO-8601 recorded-time instant (`YYYY-MM-DDTHH:mm:ss.sssZ`),\n * nominally branded so it can only originate from a recorded-time source —\n * {@link Store.recordedNow} or an explicit {@link asRecordedInstant} — never an\n * ad-hoc wall-clock string.\n *\n * The recorded commit clock is a logical, monotonic per-graph instant that can\n * run briefly ahead of wall time under bursty same-millisecond writes, so a raw\n * `new Date().toISOString()` may sort *before* the most recent commits and\n * silently omit them. The brand turns that footgun into a compile error:\n * `store.asOfRecorded` accepts only a `RecordedInstant`, so a bare wall-clock\n * string no longer type-checks — callers reach for `await store.recordedNow()`\n * (the monotonic high-water mark) or {@link asRecordedInstant} instead.\n */\nexport type RecordedInstant = string & {\n  readonly [RECORDED_INSTANT_BRAND]: \"RecordedInstant\";\n};\n\nexport function assertValidRecordedInstant(value: string, path: string): void {\n  validateCanonicalIsoDate(value, path);\n  if (value >= RECORDED_MAX) {\n    throw new ValidationError(\n      `${path} must be before the recorded-time open sentinel ${RECORDED_MAX}.`,\n      {\n        issues: [\n          {\n            path,\n            message: `Expected a timestamp before ${RECORDED_MAX}, got \"${value}\"`,\n          },\n        ],\n      },\n      {\n        suggestion:\n          \"Use a real recorded-time commit instant, not the open-interval sentinel.\",\n      },\n    );\n  }\n}\n\n/**\n * Brands a canonical UTC ISO-8601 string as a {@link RecordedInstant}.\n *\n * The escape hatch for an instant that round-trips through untyped storage:\n * captured from {@link Store.recordedNow}, persisted as a plain string, read\n * back, and replayed into `asOfRecorded`. Validates the canonical form eagerly —\n * the same check `asOfRecorded` applies — so a malformed value fails here, at the\n * brand site, rather than deeper in a read. Does *not* assert the instant is a\n * real captured commit; it only guarantees the value is well-formed enough to\n * compare correctly against the recorded relations.\n *\n * @throws {ValidationError} when `value` is not a canonical UTC ISO-8601 string.\n */\nexport function asRecordedInstant(value: string): RecordedInstant {\n  assertValidRecordedInstant(value, \"asRecordedInstant\");\n  return value as RecordedInstant;\n}\n\n/**\n * The single opaque temporal coordinate every pinned read is resolved\n * against. It carries the valid-time axis plus an optional recorded/system-time\n * axis, so every surface can inject one coordinate object instead of threading\n * each temporal dimension separately.\n */\nexport type ReadCoordinate = Readonly<{\n  /**\n   * The valid-time axis: a resolved temporal mode and (only for `\"asOf\"`) the\n   * instant it is pinned to.\n   */\n  valid: Readonly<{\n    mode: TemporalMode;\n    /** Defined only when `mode` is `\"asOf\"`. */\n    asOf?: string;\n  }>;\n  /** The recorded/system-time axis. Defined only for recorded-pinned views. */\n  recorded?: Readonly<{ asOf: RecordedInstant }>;\n}>;\n\n/**\n * Resolves and validates a `(mode, asOf)` pair into a {@link ReadCoordinate}.\n * Rejects an `asOf` paired with any non-`\"asOf\"` mode rather than silently\n * dropping it — pinning an instant is only meaningful in `\"asOf\"` mode, so a\n * `view({ mode: \"current\", asOf })` is a caller mistake, not a coordinate to\n * quietly discard. Then validates via {@link assertValidAsOf}.\n *\n * @param mode - The temporal mode to pin.\n * @param asOf - The supplied timestamp. Required for `\"asOf\"`; rejected for\n *   every other mode.\n * @param suggestion - Caller-specific remediation hint for the\n *   missing/invalid-timestamp case.\n */\nexport function resolveReadCoordinate(\n  mode: TemporalMode,\n  asOf: string | undefined,\n  suggestion?: string,\n): ReadCoordinate {\n  if (mode !== \"asOf\" && asOf !== undefined) {\n    throw new ValidationError(\n      `Temporal mode \"${mode}\" does not take an asOf timestamp.`,\n      {\n        issues: [\n          {\n            path: \"asOf\",\n            message: `asOf is only valid with mode \"asOf\", not \"${mode}\"`,\n          },\n        ],\n      },\n      {\n        suggestion:\n          'Pin an instant with store.asOf(timestamp) or store.view({ mode: \"asOf\", asOf }); drop asOf for other modes.',\n      },\n    );\n  }\n  assertValidAsOf(\n    mode,\n    asOf,\n    suggestion === undefined ? undefined : { suggestion },\n  );\n  return { valid: asOf === undefined ? { mode } : { mode, asOf } };\n}\n\n/**\n * Adds a recorded/system-time pin to an existing valid-time coordinate.\n * Direct `store.asOfRecorded(T)` passes the diagonal valid-time coordinate\n * (`mode: \"asOf\", asOf: T`); `store.asOf(vt).asOfRecorded(rt)` passes the\n * already-resolved valid coordinate and adds the recorded sibling.\n */\nexport function withRecordedCoordinate(\n  coordinate: ReadCoordinate,\n  recordedAsOf: RecordedInstant,\n): ReadCoordinate {\n  assertValidRecordedInstant(recordedAsOf, \"asOfRecorded\");\n  return {\n    ...coordinate,\n    recorded: { asOf: recordedAsOf },\n  };\n}\n\n/**\n * Validates the `asOf` coordinate of a temporal read: `\"asOf\"` mode\n * requires a timestamp, and any supplied timestamp must be a canonical\n * fixed-width UTC ISO-8601 string (`YYYY-MM-DDTHH:mm:ss.sssZ`). The latter\n * is load-bearing — temporal filters compare `asOf` against `valid_from` /\n * `valid_to` as text on SQLite, so a non-canonical value (date-only, an\n * offset, natural language, or variable-width / missing milliseconds like\n * `.1Z`) would sort and compare wrong rather than error. Reached only through\n * {@link resolveReadCoordinate}, which every temporal read entry point routes\n * through (direct reads, queries, subgraphs, algorithms, and StoreView), so\n * they all fail identically.\n *\n * @param mode - The resolved temporal mode.\n * @param asOf - The supplied timestamp (may be `undefined`).\n * @param options.suggestion - A caller-specific remediation hint for the\n *   missing-timestamp case.\n *\n * @throws {ValidationError} when `mode` is `\"asOf\"` and `asOf` is missing, or\n *   when any supplied `asOf` is not a canonical UTC ISO-8601 timestamp. The\n *   canonical check runs for *every* mode that consumes `asOf`, so a\n *   non-canonical value can never reach a text comparison.\n */\nfunction assertValidAsOf(\n  mode: TemporalMode,\n  asOf: string | undefined,\n  options?: Readonly<{ suggestion?: string }>,\n): void {\n  if (mode === \"asOf\" && asOf === undefined) {\n    throw new ValidationError(\n      'Temporal mode \"asOf\" requires a timestamp',\n      {\n        issues: [\n          { path: \"asOf\", message: \"Timestamp is required for asOf mode\" },\n        ],\n      },\n      {\n        suggestion:\n          options?.suggestion ??\n          'Provide an ISO-8601 timestamp for asOf mode, e.g. \"2026-01-01T00:00:00.000Z\".',\n      },\n    );\n  }\n  if (asOf !== undefined) {\n    validateCanonicalIsoDate(asOf, \"asOf\");\n  }\n}\n\n/**\n * A human-readable description of a coordinate for error messages, e.g.\n * `mode \"current\"` or `mode \"asOf\" asOf 2026-01-01T00:00:00.000Z`. Shared by\n * every refusal path (the `StoreView` read-only / current-only / search facades\n * and the sealed-query builder) so they describe a coordinate identically — and\n * a future axis (recorded time) is reflected everywhere from one place.\n */\nexport function describeCoordinate(coordinate: ReadCoordinate): string {\n  const { mode, asOf } = coordinate.valid;\n  const valid =\n    asOf === undefined ? `mode \"${mode}\"` : `mode \"${mode}\" asOf ${asOf}`;\n  return coordinate.recorded === undefined ?\n      valid\n    : `${valid}, recorded asOf ${coordinate.recorded.asOf}`;\n}\n\n/**\n * The structured error-context fields describing a coordinate, shared by the\n * same refusal paths as {@link describeCoordinate}.\n */\nexport function coordinateContext(\n  coordinate: ReadCoordinate,\n): Record<string, unknown> {\n  const { mode, asOf } = coordinate.valid;\n  return {\n    temporalMode: mode,\n    ...(asOf !== undefined && { asOf }),\n    ...(coordinate.recorded === undefined ?\n      {}\n    : { recordedAsOf: coordinate.recorded.asOf }),\n  };\n}\n","/**\n * SQL Schema Configuration for Query Compilation\n *\n * Provides table and column identifiers that the query compiler uses.\n * This allows the compiler to work with custom table names instead of\n * hard-coded defaults.\n */\nimport { type SQL, sql } from \"drizzle-orm\";\n\nimport { type VectorIndexType, type VectorMetric } from \"../../backend/types\";\nimport { MAX_PG_IDENTIFIER_LENGTH } from \"../../constants\";\nimport { ConfigurationError } from \"../../errors\";\n\n/**\n * Table names for TypeGraph SQL schema.\n *\n * Carries every customizable physical-table name the backend exposes,\n * including the secondary tables (`uniques`) that the query compiler\n * itself doesn't reference but `materializeRemovals` and other\n * cleanup paths need to address by name. Backends without a\n * `uniques` table (custom embeddings-only stores) leave it as the\n * default — the cleanup path is a no-op for kinds with no unique\n * rows.\n */\nexport type SqlTableNames = Readonly<{\n  /** Nodes table name (default: \"typegraph_nodes\") */\n  nodes: string;\n  /** Edges table name (default: \"typegraph_edges\") */\n  edges: string;\n  /** Recorded node relation table name (default: \"typegraph_recorded_nodes\") */\n  recordedNodes?: string | undefined;\n  /** Recorded edge relation table name (default: \"typegraph_recorded_edges\") */\n  recordedEdges?: string | undefined;\n  /** Recorded-time commit clock table name (default: \"typegraph_recorded_clock\") */\n  recordedClock?: string | undefined;\n  /** Durable per-graph revision-origin table name (default: \"typegraph_revision_origins\") */\n  revisionOrigins?: string | undefined;\n  /** Node fulltext table name (default: \"typegraph_node_fulltext\") */\n  fulltext: string;\n  /** Node uniques table name (default: \"typegraph_node_uniques\") */\n  uniques: string;\n}>;\n\nexport type ResolvedSqlTableNames = Readonly<{\n  /** Nodes table name */\n  nodes: string;\n  /** Edges table name */\n  edges: string;\n  /** Recorded node relation table name */\n  recordedNodes: string;\n  /** Recorded edge relation table name */\n  recordedEdges: string;\n  /** Recorded-time commit clock table name */\n  recordedClock: string;\n  /** Durable per-graph revision-origin table name */\n  revisionOrigins: string;\n  /** Node fulltext table name */\n  fulltext: string;\n  /** Node uniques table name */\n  uniques: string;\n}>;\n\ntype SqlSchemaFields = Readonly<{\n  /** Table names */\n  tables: ResolvedSqlTableNames;\n  /** Get a SQL reference to the nodes table */\n  nodesTable: SQL;\n  /** Get a SQL reference to the edges table */\n  edgesTable: SQL;\n  /** Get a SQL reference to the recorded node relation */\n  recordedNodesTable: SQL;\n  /** Get a SQL reference to the recorded edge relation */\n  recordedEdgesTable: SQL;\n  /** Get a SQL reference to the recorded-time commit clock */\n  recordedClockTable: SQL;\n  /** Get a SQL reference to the durable per-graph revision origins */\n  revisionOriginsTable: SQL;\n  /** Get a SQL reference to the fulltext table */\n  fulltextTable: SQL;\n}>;\n\n/**\n * SQL schema configuration for query compilation.\n * Contains table identifiers and utility methods for generating SQL references.\n *\n * Branded and frozen by {@link createSqlSchema}; callers should not construct\n * schema-shaped objects by hand.\n */\nexport type SqlSchema = SqlSchemaDescriptor;\n\nclass SqlSchemaDescriptor implements SqlSchemaFields {\n  // Private field gives SqlSchema nominal identity; runtime checks use instanceof.\n  readonly #brand = true;\n  readonly tables: ResolvedSqlTableNames;\n  readonly nodesTable: SQL;\n  readonly edgesTable: SQL;\n  readonly recordedNodesTable: SQL;\n  readonly recordedEdgesTable: SQL;\n  readonly recordedClockTable: SQL;\n  readonly revisionOriginsTable: SQL;\n  readonly fulltextTable: SQL;\n\n  constructor(fields: SqlSchemaFields) {\n    this.tables = fields.tables;\n    this.nodesTable = fields.nodesTable;\n    this.edgesTable = fields.edgesTable;\n    this.recordedNodesTable = fields.recordedNodesTable;\n    this.recordedEdgesTable = fields.recordedEdgesTable;\n    this.recordedClockTable = fields.recordedClockTable;\n    this.revisionOriginsTable = fields.revisionOriginsTable;\n    this.fulltextTable = fields.fulltextTable;\n    void this.#brand;\n    Object.freeze(this);\n  }\n}\n\n/**\n * Default table names matching the standard TypeGraph schema.\n */\nconst DEFAULT_TABLE_NAMES: ResolvedSqlTableNames = {\n  nodes: \"typegraph_nodes\",\n  edges: \"typegraph_edges\",\n  recordedNodes: \"typegraph_recorded_nodes\",\n  recordedEdges: \"typegraph_recorded_edges\",\n  recordedClock: \"typegraph_recorded_clock\",\n  revisionOrigins: \"typegraph_revision_origins\",\n  fulltext: \"typegraph_node_fulltext\",\n  uniques: \"typegraph_node_uniques\",\n};\n\nfunction resolveTableNames(\n  names: Partial<SqlTableNames>,\n): ResolvedSqlTableNames {\n  return {\n    nodes: names.nodes ?? DEFAULT_TABLE_NAMES.nodes,\n    edges: names.edges ?? DEFAULT_TABLE_NAMES.edges,\n    recordedNodes: names.recordedNodes ?? DEFAULT_TABLE_NAMES.recordedNodes,\n    recordedEdges: names.recordedEdges ?? DEFAULT_TABLE_NAMES.recordedEdges,\n    recordedClock: names.recordedClock ?? DEFAULT_TABLE_NAMES.recordedClock,\n    revisionOrigins:\n      names.revisionOrigins ?? DEFAULT_TABLE_NAMES.revisionOrigins,\n    fulltext: names.fulltext ?? DEFAULT_TABLE_NAMES.fulltext,\n    uniques: names.uniques ?? DEFAULT_TABLE_NAMES.uniques,\n  };\n}\n\n/**\n * Regex for valid SQL identifiers.\n * Must start with a letter or underscore.\n * Can contain letters, digits, underscores, and dollar signs.\n * Dollar signs are a PostgreSQL extension but commonly supported.\n */\nconst VALID_IDENTIFIER_PATTERN = /^[a-z_][a-z0-9_$]*$/i;\n\n/**\n * Validates that a table name is a valid SQL identifier.\n *\n * @throws Error if the table name is invalid\n */\nfunction validateTableName(name: string, label: string): void {\n  if (!name || name.length === 0) {\n    throw new ConfigurationError(`${label} table name cannot be empty`);\n  }\n  if (name.length > MAX_PG_IDENTIFIER_LENGTH) {\n    throw new ConfigurationError(\n      `${label} table name exceeds maximum length of ${MAX_PG_IDENTIFIER_LENGTH} characters`,\n    );\n  }\n  if (!VALID_IDENTIFIER_PATTERN.test(name)) {\n    throw new ConfigurationError(\n      `${label} table name \"${name}\" is not a valid SQL identifier. ` +\n        `Table names must start with a letter or underscore and contain only letters, digits, underscores, or dollar signs.`,\n    );\n  }\n}\n\n/**\n * Quotes a SQL identifier using ANSI SQL standard double quotes.\n * Escapes any embedded double quotes by doubling them.\n *\n * This works for both SQLite and PostgreSQL.\n */\nfunction quoteIdentifier(name: string): string {\n  return `\"${name.replaceAll('\"', '\"\"')}\"`;\n}\n\nfunction freezeSqlSchema(fields: SqlSchemaFields): SqlSchema {\n  return new SqlSchemaDescriptor(fields);\n}\n\nfunction isSqlSchema(schema: unknown): schema is SqlSchema {\n  return schema instanceof SqlSchemaDescriptor && Object.isFrozen(schema);\n}\n\nexport function requireSqlSchema(\n  schema: unknown,\n  surface = \"SqlSchema\",\n): SqlSchema {\n  if (isSqlSchema(schema)) return schema;\n  throw new ConfigurationError(\n    `${surface} must be created with createSqlSchema(...).`,\n    { code: \"INVALID_SQL_SCHEMA\", surface },\n    {\n      suggestion:\n        \"Pass the result of createSqlSchema(...) instead of a plain schema-shaped object.\",\n    },\n  );\n}\n\n/**\n * Creates a SqlSchema configuration from table names.\n *\n * Table names are validated to ensure they are valid SQL identifiers.\n * This prevents SQL injection and ensures compatibility across databases.\n *\n * @param names - Optional custom table names (defaults to standard names)\n * @returns SqlSchema configuration for query compilation\n * @throws Error if any table name is invalid\n *\n * @example\n * ```typescript\n * // Use default table names\n * const schema = createSqlSchema();\n *\n * // Use custom table names\n * const schema = createSqlSchema({\n *   nodes: \"myapp_nodes\",\n *   edges: \"myapp_edges\",\n *   fulltext: \"myapp_fulltext\",\n * });\n * ```\n */\nexport function createSqlSchema(names: Partial<SqlTableNames> = {}): SqlSchema {\n  const tables = resolveTableNames(names);\n\n  // Validate all table names\n  validateTableName(tables.nodes, \"nodes\");\n  validateTableName(tables.edges, \"edges\");\n  validateTableName(tables.recordedNodes, \"recordedNodes\");\n  validateTableName(tables.recordedEdges, \"recordedEdges\");\n  validateTableName(tables.recordedClock, \"recordedClock\");\n  validateTableName(tables.revisionOrigins, \"revisionOrigins\");\n  validateTableName(tables.fulltext, \"fulltext\");\n  validateTableName(tables.uniques, \"uniques\");\n\n  return freezeSqlSchema({\n    tables: Object.freeze(tables),\n    nodesTable: sql.raw(quoteIdentifier(tables.nodes)),\n    edgesTable: sql.raw(quoteIdentifier(tables.edges)),\n    recordedNodesTable: sql.raw(quoteIdentifier(tables.recordedNodes)),\n    recordedEdgesTable: sql.raw(quoteIdentifier(tables.recordedEdges)),\n    recordedClockTable: sql.raw(quoteIdentifier(tables.recordedClock)),\n    revisionOriginsTable: sql.raw(quoteIdentifier(tables.revisionOrigins)),\n    fulltextTable: sql.raw(quoteIdentifier(tables.fulltext)),\n  });\n}\n\n/**\n * The recorded/system-time relation a read coordinate may reconstruct from.\n *\n * TypeGraph's built-in capture relation is bound by `createStore(..., {\n * history: true })`. Hosts can also bind externally populated row-compatible\n * recorded relations through `recordedRelation({ schema })`. Keeping both as\n * explicit values separates the read contract from the write-capture mechanism\n * so future external/TMS-owned recorded relations can feed the same query\n * machinery without changing StoreView or ReadCoordinate.\n */\nconst EXTERNAL_RECORDED_READ_SOURCE: unique symbol = Symbol(\n  \"ExternalRecordedReadSource\",\n);\n\nexport type ExternalRecordedReadSource = Readonly<{\n  source: \"external\";\n  schema: SqlSchema;\n  [EXTERNAL_RECORDED_READ_SOURCE]: true;\n}>;\n\ntype ExternalRecordedReadSourceCandidate = Readonly<{\n  source?: unknown;\n  schema?: unknown;\n  [EXTERNAL_RECORDED_READ_SOURCE]?: unknown;\n}>;\n\nconst TYPEGRAPH_RECORDED_READ_SOURCE: unique symbol = Symbol(\n  \"TypeGraphRecordedReadSource\",\n);\n\nexport type TypeGraphRecordedReadSource = Readonly<{\n  source: \"typegraph-capture\";\n  schema: SqlSchema;\n  [TYPEGRAPH_RECORDED_READ_SOURCE]: true;\n}>;\n\ntype RecordedReadSource =\n  ExternalRecordedReadSource | TypeGraphRecordedReadSource;\n\nexport type RecordedReadBinding = RecordedReadSource;\n\nexport type RecordedRelationOptions = Readonly<{\n  schema: SqlSchema;\n}>;\n\nexport function recordedRelation(\n  options: RecordedRelationOptions,\n): ExternalRecordedReadSource {\n  const schema = requireSqlSchema(options.schema, \"recordedRelation schema\");\n  return Object.freeze({\n    source: \"external\",\n    schema,\n    [EXTERNAL_RECORDED_READ_SOURCE]: true as const,\n  });\n}\n\nexport function requireExternalRecordedReadSource(\n  source: unknown,\n): ExternalRecordedReadSource | undefined {\n  if (source === undefined) return undefined;\n  if (isExternalRecordedReadSource(source)) return source;\n  throw new ConfigurationError(\n    \"recordedRead must be created with recordedRelation({ schema }).\",\n    { code: \"INVALID_RECORDED_READ_SOURCE\" },\n    {\n      suggestion:\n        \"Pass { recordedRead: recordedRelation({ schema }) } for an externally populated recorded relation. Use { history: true } when TypeGraph should capture writes.\",\n    },\n  );\n}\n\nfunction isExternalRecordedReadSource(\n  source: unknown,\n): source is ExternalRecordedReadSource {\n  if (typeof source !== \"object\" || source === null) return false;\n  const candidate = source as ExternalRecordedReadSourceCandidate;\n  return (\n    candidate.source === \"external\" &&\n    candidate[EXTERNAL_RECORDED_READ_SOURCE] === true &&\n    isSqlSchema(candidate.schema) &&\n    Object.isFrozen(candidate)\n  );\n}\n\nexport function createRecordedReadBinding(\n  schema: SqlSchema,\n): TypeGraphRecordedReadSource {\n  const readSchema = requireSqlSchema(schema, \"recorded read binding schema\");\n  return Object.freeze({\n    source: \"typegraph-capture\",\n    schema: readSchema,\n    [TYPEGRAPH_RECORDED_READ_SOURCE]: true as const,\n  });\n}\n\nexport function requireRecordedReadBinding(\n  binding: unknown,\n  surface: string,\n): RecordedReadBinding {\n  if (isRecordedReadBinding(binding)) return binding;\n  if (binding !== undefined) {\n    throw new ConfigurationError(\n      \"Recorded-time reads require a recorded read relation created by TypeGraph.\",\n      { code: \"INVALID_RECORDED_READ_BINDING\", surface },\n      {\n        suggestion:\n          \"Use createStore(graph, backend, { history: true }) or { recordedRead: recordedRelation({ schema }) } instead of passing a plain object.\",\n      },\n    );\n  }\n  throw new ConfigurationError(\n    \"Recorded-time reads require a recorded read relation.\",\n    { code: \"RECORDED_READ_REQUIRES_BINDING\", surface },\n    {\n      suggestion:\n        \"Create the store with createStore(graph, backend, { history: true }) to bind TypeGraph's built-in captured relation, or pass { recordedRead: recordedRelation({ schema }) } for an externally populated recorded relation.\",\n    },\n  );\n}\n\ntype TypeGraphRecordedReadSourceCandidate = Readonly<{\n  source?: unknown;\n  schema?: unknown;\n  [TYPEGRAPH_RECORDED_READ_SOURCE]?: unknown;\n}>;\n\nfunction isTypeGraphRecordedReadSource(\n  source: unknown,\n): source is TypeGraphRecordedReadSource {\n  if (typeof source !== \"object\" || source === null) return false;\n  const candidate = source as TypeGraphRecordedReadSourceCandidate;\n  return (\n    candidate.source === \"typegraph-capture\" &&\n    candidate[TYPEGRAPH_RECORDED_READ_SOURCE] === true &&\n    isSqlSchema(candidate.schema) &&\n    Object.isFrozen(candidate)\n  );\n}\n\nfunction isRecordedReadBinding(\n  binding: unknown,\n): binding is RecordedReadBinding {\n  return (\n    isExternalRecordedReadSource(binding) ||\n    isTypeGraphRecordedReadSource(binding)\n  );\n}\n\n/**\n * Returns a schema view whose primary node/edge sources are the recorded-time\n * relations. The recorded relations are row-compatible with the live tables\n * for every column the query compiler, subgraph extractor, and algorithms\n * already read; the temporal filter adds the `recorded_from/to` predicate.\n */\nexport function recordedReadSqlSchema(binding: RecordedReadBinding): SqlSchema {\n  const { schema } = requireRecordedReadBinding(\n    binding,\n    \"recorded-read-schema\",\n  );\n  return freezeSqlSchema({\n    tables: schema.tables,\n    nodesTable: schema.recordedNodesTable,\n    edgesTable: schema.recordedEdgesTable,\n    recordedNodesTable: schema.recordedNodesTable,\n    recordedEdgesTable: schema.recordedEdgesTable,\n    recordedClockTable: schema.recordedClockTable,\n    revisionOriginsTable: schema.revisionOriginsTable,\n    fulltextTable: schema.fulltextTable,\n  });\n}\n\n/**\n * Resolves the read schema for a coordinate: the live schema when no recorded\n * pin is set, or the recorded-relation view when `recordedAsOf` is present. The\n * single place every read path decides whether to source the recorded tables.\n */\nexport function recordedReadSchemaFor(\n  schema: SqlSchema,\n  recordedAsOf: string | undefined,\n  binding: RecordedReadBinding | undefined,\n  surface: string,\n): SqlSchema {\n  const baseSchema = requireSqlSchema(schema, `${surface} schema`);\n  if (recordedAsOf === undefined) return baseSchema;\n  return recordedReadSqlSchema(requireRecordedReadBinding(binding, surface));\n}\n\n/**\n * Default SqlSchema using standard TypeGraph table names.\n */\nexport const DEFAULT_SQL_SCHEMA: SqlSchema = createSqlSchema();\n\n/**\n * The compiler's resolved view of one declared embedding field — the\n * `(dimensions, metric, indexType)` a {@link VectorStrategy} needs to\n * name and scan the field's typed per-`(kind, field)` storage. Sourced\n * from the registered node schema's `embedding()` declaration when the\n * store builds its compile options.\n */\nexport type VectorSlotDescriptor = Readonly<{\n  dimensions: number;\n  metric: VectorMetric;\n  indexType: VectorIndexType;\n}>;\n\n/**\n * Map of declared embedding slots keyed by {@link vectorSlotKey} -\n * `\"<nodeKind>\\0<fieldPath>\"` (NUL-separated). Carries every `(concrete kind,\n * fieldPath)` that declares an embedding field, so the compiler's\n * `field.similarTo(...)` CTE can UNION ALL the per-field tables for the\n * kinds in an alias that actually declare the field (only\n * `includeSubClasses` yields more than one).\n */\nexport type VectorSlotMap = ReadonlyMap<string, VectorSlotDescriptor>;\n\n/** NUL-delimited composite key for {@link VectorSlotMap}. */\nexport function vectorSlotKey(nodeKind: string, fieldPath: string): string {\n  return `${nodeKind}\\u0000${fieldPath}`;\n}\n\n/**\n * CTE aliases used by the standard query emitter. Joining on these names\n * across multiple builder files is fragile when typed as raw strings —\n * import these constants instead.\n */\nexport const ALIAS_CTE_PREFIX = \"cte_\" as const;\nexport const EMBEDDINGS_CTE_ALIAS = \"cte_embeddings\" as const;\nexport const FULLTEXT_CTE_ALIAS = \"cte_fulltext\" as const;\nexport const HYBRID_CANDIDATES_CTE_ALIAS = \"cte_relevance_candidates\" as const;\n","import { nanoid } from \"nanoid\";\n\n/**\n * ID generation utilities.\n *\n * Default implementation uses nanoid.\n * Benefits:\n * - URL-safe\n * - Compact (21 characters by default)\n * - Secure random generation\n */\n\n/**\n * Generates a new unique ID.\n */\nexport function generateId(): string {\n  return nanoid();\n}\n\n/**\n * ID generator function type.\n */\nexport type IdGenerator = () => string;\n\n/**\n * Default ID generator configuration.\n */\nexport type IdConfig = Readonly<{\n  /** Generator for node IDs */\n  nodeIdGenerator: IdGenerator;\n  /** Generator for edge IDs */\n  edgeIdGenerator: IdGenerator;\n}>;\n","import { type SQL, sql } from \"drizzle-orm\";\n\nimport {\n  type AdoptedTransaction,\n  type GraphBackend,\n  type TransactionBackend,\n  type TransactionOptions,\n} from \"../../backend/types\";\nimport { ConfigurationError } from \"../../errors\";\nimport { createSqlSchema, type SqlSchema } from \"../../query/compiler/schema\";\nimport {\n  asCompiledRowsSql,\n  asCompiledStatementSql,\n  type CompiledStatementSql,\n} from \"../../query/sql-intent\";\nexport { withRecordedRelationsPrecondition } from \"../../utils/sql-errors\";\n\ntype IsolationRow = Readonly<{ transaction_isolation: unknown }>;\n\n/**\n * Resolves the recorded-relation schema for a capture target, failing loud when\n * the backend does not expose `tableNames`. Without this guard a custom backend\n * that omits `tableNames` would silently fall back to {@link createSqlSchema}'s\n * defaults and write/close recorded rows against the wrong tables.\n */\nexport function requireRecordedSchema(\n  target: Pick<GraphBackend, \"tableNames\" | \"dialect\">,\n): SqlSchema {\n  if (target.tableNames === undefined) {\n    throw new ConfigurationError(\n      \"Recorded-time capture requires the backend to expose tableNames.\",\n      { dialect: target.dialect },\n      {\n        suggestion:\n          \"Use a built-in SQLite/PostgreSQL backend, or set tableNames on the custom backend so recorded-time capture targets the configured relations.\",\n      },\n    );\n  }\n  return createSqlSchema(target.tableNames);\n}\n\n/**\n * Asserts the transaction target can run capture's non-row-returning\n * statements. Checked once when a capture scope opens so the failure surfaces\n * before any write, not mid-flush after the live row is already written —\n * `assertCapturableBackend` only validates the outer backend, and a custom\n * backend's transaction target can differ from it.\n */\nexport function requireCaptureStatements(\n  target: Pick<GraphBackend, \"dialect\" | \"executeStatement\">,\n): asserts target is Pick<GraphBackend, \"dialect\" | \"executeStatement\"> &\n  Readonly<{\n    executeStatement: NonNullable<GraphBackend[\"executeStatement\"]>;\n  }> {\n  if (target.executeStatement === undefined) {\n    throw new ConfigurationError(\n      \"Recorded-time capture requires backend.executeStatement support on the transaction backend.\",\n      { dialect: target.dialect },\n      {\n        suggestion:\n          \"Use the built-in SQLite/PostgreSQL backends or provide executeStatement on the custom backend's transaction target.\",\n      },\n    );\n  }\n}\n\nexport async function executeStatement(\n  target: Pick<GraphBackend, \"dialect\" | \"executeStatement\">,\n  query: SQL,\n): Promise<void> {\n  requireCaptureStatements(target);\n  await target.executeStatement(asCompiledStatementSql(query));\n}\n\nfunction unsupportedPostgresIsolationError(\n  isolationLevel: string | undefined,\n): ConfigurationError {\n  return new ConfigurationError(\n    \"Recorded-time capture on PostgreSQL requires read_committed isolation.\",\n    { isolationLevel: isolationLevel ?? \"unknown\" },\n    {\n      suggestion:\n        \"Omit the transaction isolation option or use read_committed. PostgreSQL repeatable_read/serializable snapshots cannot safely allocate the per-graph recorded clock inside the captured transaction.\",\n    },\n  );\n}\n\nfunction isSupportedRecordedIsolationLevel(\n  isolationLevel: string | undefined,\n): boolean {\n  return (\n    isolationLevel === undefined ||\n    isolationLevel === \"read_committed\" ||\n    isolationLevel === \"read_uncommitted\"\n  );\n}\n\nexport function assertRequestedRecordedIsolation(\n  backend: Pick<GraphBackend, \"dialect\">,\n  options: TransactionOptions | undefined,\n): void {\n  if (backend.dialect !== \"postgres\") return;\n  const isolationLevel = options?.isolationLevel;\n  if (isSupportedRecordedIsolationLevel(isolationLevel)) return;\n\n  throw unsupportedPostgresIsolationError(isolationLevel);\n}\n\nfunction normalizeIsolationLevel(value: unknown): string | undefined {\n  if (typeof value !== \"string\") return undefined;\n  return value.replaceAll(\" \", \"_\").toLowerCase();\n}\n\nexport async function assertRecordedCaptureTransactionIsolation(\n  target: Pick<TransactionBackend, \"dialect\" | \"execute\">,\n): Promise<void> {\n  if (target.dialect !== \"postgres\") return;\n\n  const rows = await target.execute<IsolationRow>(\n    asCompiledRowsSql(sql`\n      SELECT current_setting('transaction_isolation') AS transaction_isolation\n    `),\n  );\n  const isolationLevel = normalizeIsolationLevel(\n    rows[0]?.transaction_isolation,\n  );\n  if (isSupportedRecordedIsolationLevel(isolationLevel)) return;\n\n  throw unsupportedPostgresIsolationError(isolationLevel);\n}\n\n/**\n * The single error raised when a caller tries to adopt a context-returning\n * external transaction while history capture is on — there is no flush point\n * before the caller commits. `details` carries the call-site-specific context.\n */\nexport function recordedCaptureRequiresCallbackTransactionError(\n  details: Record<string, unknown>,\n): ConfigurationError {\n  return new ConfigurationError(\n    \"withTransaction() has no recorded-time capture flush point when history is enabled.\",\n    details,\n    {\n      suggestion:\n        \"Use store.withRecordedTransaction(externalTx, async (tx) => ...) so TypeGraph can flush capture before the caller commits.\",\n    },\n  );\n}\n\n/**\n * Raw SQL surfaces (`tx.sql`, `backend.executeStatement`) write relational rows\n * without advancing recorded-time capture, so they are disabled on a\n * history-enabled store. `surface` names the escape the caller reached for.\n */\nfunction historyUnsafeRawWriteError(surface: string): ConfigurationError {\n  return new ConfigurationError(\n    `${surface} is not available when history capture is enabled because raw SQL writes bypass recorded-time capture.`,\n    { code: \"RECORDED_CAPTURE_RAW_SQL_DISABLED\" },\n    {\n      suggestion:\n        \"Run graph writes through store.nodes/store.edges (or tx.nodes/tx.edges inside a transaction), or perform raw relational writes outside a history-enabled TypeGraph store.\",\n    },\n  );\n}\n\nfunction revisionTrackingUnsafeRawWriteError(\n  surface: string,\n): ConfigurationError {\n  return new ConfigurationError(\n    `${surface} is not available when revision tracking is enabled because raw SQL writes bypass the revision anchor.`,\n    { code: \"REVISION_TRACKING_RAW_SQL_DISABLED\" },\n    {\n      suggestion:\n        \"Run graph writes through store.nodes/store.edges (or tx.nodes/tx.edges inside a transaction), so TypeGraph can advance the revision anchor.\",\n    },\n  );\n}\n\nfunction failHistoryUnsafeSqlRef(): never {\n  throw historyUnsafeRawWriteError(\"tx.sql\");\n}\n\nfunction failRevisionTrackingUnsafeSqlRef(): never {\n  throw revisionTrackingUnsafeRawWriteError(\"tx.sql\");\n}\n\n/**\n * A stand-in for the raw transaction SQL handle that throws on any access —\n * including `then`, so `await tx.sql` fail-louds rather than silently resolving\n * to the proxy. The history-enabled store hands this to transaction callbacks\n * in place of the real handle so raw writes can't slip past recorded-time\n * capture.\n */\nexport function createHistoryUnsafeSqlRef(): AdoptedTransaction {\n  return createUnsafeSqlRef(failHistoryUnsafeSqlRef);\n}\n\n/**\n * A fail-loud replacement for `tx.sql` on a revision-tracked live store. It\n * deliberately names revision tracking rather than history capture so callers\n * see the invariant their store actually enabled.\n */\nexport function createRevisionTrackingUnsafeSqlRef(): AdoptedTransaction {\n  return createUnsafeSqlRef(failRevisionTrackingUnsafeSqlRef);\n}\n\nfunction createUnsafeSqlRef(fail: () => never): AdoptedTransaction {\n  return new Proxy(\n    function unsafeSqlRef(): never {\n      return fail();\n    },\n    {\n      get(): never {\n        return fail();\n      },\n      apply(): never {\n        return fail();\n      },\n      set(): never {\n        return fail();\n      },\n      defineProperty(): never {\n        return fail();\n      },\n      deleteProperty(): never {\n        return fail();\n      },\n      // Enumeration / inspection traps too, so spreading (`{...tx.sql}`),\n      // `Object.keys`, `in`, and prototype reads also fail loudly rather than\n      // silently yielding an empty object that reads as \"no raw handle\".\n      has(): never {\n        return fail();\n      },\n      ownKeys(): never {\n        return fail();\n      },\n      getOwnPropertyDescriptor(): never {\n        return fail();\n      },\n      getPrototypeOf(): never {\n        return fail();\n      },\n    },\n  ) as unknown as AdoptedTransaction;\n}\n\n/**\n * Disables the raw, non-row-returning write escapes on a history-enabled\n * backend: `executeStatement` and `executeDdl` both return `Promise<void>` and\n * exist solely to run relational writes/DDL that would bypass recorded-time\n * capture. The row-returning raw read path (`executeRaw`, the prepared-query\n * fast path) and `execute` are left intact — they are read contracts, treated\n * identically, and must not be used to route writes (e.g. `DELETE ...\n * RETURNING`); that invariant is documented, not policed by inspecting SQL text.\n */\nexport function rawWriteGuards(\n  target: Pick<GraphBackend, \"executeStatement\" | \"executeDdl\">,\n  prefix: string,\n): Pick<Partial<GraphBackend>, \"executeStatement\" | \"executeDdl\"> {\n  return {\n    ...(target.executeStatement === undefined ?\n      {}\n    : {\n        executeStatement(_query: CompiledStatementSql): Promise<void> {\n          return Promise.reject(\n            historyUnsafeRawWriteError(`${prefix}.executeStatement`),\n          );\n        },\n      }),\n    ...(target.executeDdl === undefined ?\n      {}\n    : {\n        executeDdl(_ddl: string): Promise<void> {\n          return Promise.reject(\n            historyUnsafeRawWriteError(`${prefix}.executeDdl`),\n          );\n        },\n      }),\n  };\n}\n\nexport function assertCapturableBackend(backend: GraphBackend): void {\n  if (!backend.capabilities.transactions) {\n    throw new ConfigurationError(\n      \"history: true requires a backend with transaction support.\",\n      { dialect: backend.dialect },\n      {\n        suggestion:\n          \"Use a transactional SQLite/PostgreSQL backend or disable recorded-time capture for this store.\",\n      },\n    );\n  }\n  if (backend.executeStatement === undefined) {\n    throw new ConfigurationError(\n      \"history: true requires a backend that supports executeStatement.\",\n      { dialect: backend.dialect },\n      {\n        suggestion:\n          \"Use a built-in SQLite/PostgreSQL backend, or implement executeStatement on the custom backend so recorded-time capture can write history rows.\",\n      },\n    );\n  }\n  if (backend.capabilities.returning === false) {\n    throw new ConfigurationError(\n      \"history: true requires a backend that supports UPDATE … RETURNING.\",\n      { dialect: backend.dialect },\n      {\n        suggestion:\n          \"Use a built-in SQLite/PostgreSQL backend, or run recorded-time capture on a backend whose engine supports UPDATE … RETURNING — capture closes recorded intervals with a RETURNING statement on its hot path.\",\n      },\n    );\n  }\n  if (backend.tableNames === undefined) {\n    throw new ConfigurationError(\n      \"history: true requires a backend that exposes tableNames.\",\n      { dialect: backend.dialect },\n      {\n        suggestion:\n          \"Use a built-in SQLite/PostgreSQL backend, or set tableNames on the custom backend so recorded-time capture can resolve the recorded relations instead of silently falling back to defaults.\",\n      },\n    );\n  }\n}\n\n/**\n * Verifies the narrower backend contract for live-store revision tracking.\n * Unlike recorded-time history, a revision anchor does not capture after-images\n * and therefore does not require `UPDATE … RETURNING`.\n */\nexport function assertRevisionTrackableBackend(backend: GraphBackend): void {\n  if (!backend.capabilities.transactions) {\n    throw new ConfigurationError(\n      \"revisionTracking: true requires a backend with transaction support.\",\n      { dialect: backend.dialect },\n      {\n        suggestion:\n          \"Use a transactional SQLite/PostgreSQL backend or leave revision tracking disabled.\",\n      },\n    );\n  }\n  if (backend.executeStatement === undefined) {\n    throw new ConfigurationError(\n      \"revisionTracking: true requires a backend that supports executeStatement.\",\n      { dialect: backend.dialect },\n      {\n        suggestion:\n          \"Use a built-in SQLite/PostgreSQL backend, or implement executeStatement so TypeGraph can advance the revision clock.\",\n      },\n    );\n  }\n  if (backend.tableNames === undefined) {\n    throw new ConfigurationError(\n      \"revisionTracking: true requires a backend that exposes tableNames.\",\n      { dialect: backend.dialect },\n      {\n        suggestion:\n          \"Use a built-in SQLite/PostgreSQL backend, or set tableNames so TypeGraph can address the revision clock relation.\",\n      },\n    );\n  }\n  if (backend.ensureRevisionOriginsTable === undefined) {\n    throw new ConfigurationError(\n      \"revisionTracking: true requires a backend that can bootstrap revision origins.\",\n      { dialect: backend.dialect },\n      {\n        suggestion:\n          \"Use a built-in SQLite/PostgreSQL backend, or implement ensureRevisionOriginsTable so TypeGraph can durably namespace revision anchors.\",\n      },\n    );\n  }\n}\n","import { type SQL, sql } from \"drizzle-orm\";\n\nimport { type GraphBackend } from \"../../backend/types\";\nimport { RECORDED_MAX } from \"../../core/temporal\";\nimport { ConfigurationError } from \"../../errors\";\nimport { type SqlSchema } from \"../../query/compiler/schema\";\nimport { asCompiledRowsSql } from \"../../query/sql-intent\";\nimport { nowIso } from \"../../utils/date\";\nimport { generateId } from \"../../utils/id\";\nimport { executeStatement } from \"./guards\";\n\ntype ClockRow = Readonly<{ recorded_at: unknown }>;\ntype RevisionOriginRow = Readonly<{ origin: unknown }>;\n\ntype RecordedClockBackend = Pick<\n  GraphBackend,\n  \"dialect\" | \"execute\" | \"executeStatement\"\n>;\n\ntype RevisionOriginBackend = Pick<\n  GraphBackend,\n  \"dialect\" | \"ensureRevisionOriginsTable\" | \"execute\" | \"executeStatement\"\n>;\n\n/**\n * Floor sentinel used only to seed-and-lock a graph's clock row before the\n * read/advance/write sequence on SQLite-family backends. Always overwritten by\n * the real commit within the same transaction; chosen so every real wall-clock\n * instant sorts after it on both text and timestamp ordering.\n */\nconst RECORDED_MIN = \"1970-01-01T00:00:00.000Z\";\nconst RECORDED_MAX_TIME = new Date(RECORDED_MAX).getTime();\nconst RECORDED_CLOCK_ADVISORY_LOCK_NAMESPACE = \"typegraph:recorded-clock\";\nconst RECORDED_GRAPH_WRITE_ADVISORY_LOCK_NAMESPACE =\n  \"typegraph:recorded-graph-write\";\n\n/**\n * Builds a `pg_advisory_xact_lock` call scoped to a `(namespace, graphId)` pair.\n * Keep lock namespaces tied to acquire order, not to feature names:\n *\n * - recorded graph writes take `typegraph:recorded-graph-write` before any row\n *   reads/writes that can affect graph state;\n * - recorded-clock allocation takes `typegraph:recorded-clock` late, at flush,\n *   after the live writes have already happened.\n *\n * Sharing one key across those two acquire-order positions creates a circular\n * wait under ordinary concurrent load.\n */\nfunction graphAdvisoryLockSql(namespace: string, graphId: string): SQL {\n  return sql`\n    SELECT pg_advisory_xact_lock(\n      hashtext(${namespace}),\n      hashtext(${graphId})\n    )\n  `;\n}\n\nexport function recordedClockAdvisoryLockSql(graphId: string): SQL {\n  return graphAdvisoryLockSql(RECORDED_CLOCK_ADVISORY_LOCK_NAMESPACE, graphId);\n}\n\nexport function recordedGraphWriteAdvisoryLockSql(graphId: string): SQL {\n  return graphAdvisoryLockSql(\n    RECORDED_GRAPH_WRITE_ADVISORY_LOCK_NAMESPACE,\n    graphId,\n  );\n}\n\ndeclare const GRAPH_WRITE_LOCK_BRAND: unique symbol;\n\n/**\n * Compile-time evidence that the per-graph write-lock discipline was\n * satisfied BEFORE any row work in the current transaction — either the\n * advisory lock was actually acquired ({@link lockRecordedGraphWrite}, on a\n * capture-enabled Postgres store) or the store provably needs no lock\n * ({@link uncapturedGraphWriteLock}). Functions that perform captured row\n * writes (the node write pipeline) require this token as a parameter, so\n * \"sidecar write before lock\" is a compile error rather than a lock-order\n * inversion found in review.\n */\nexport type GraphWriteLock = Readonly<{\n  [GRAPH_WRITE_LOCK_BRAND]: true;\n}>;\n\n// The brand is compile-time only (a `unique symbol` with no runtime value —\n// see the `declare const` above), so the token carries no actual per-call\n// data and every acquisition can share this one frozen empty instance.\nconst GRAPH_WRITE_LOCK_EVIDENCE = Object.freeze({}) as GraphWriteLock;\n\nfunction graphWriteLockEvidence(): GraphWriteLock {\n  return GRAPH_WRITE_LOCK_EVIDENCE;\n}\n\n/**\n * Evidence constructor for stores WITHOUT history capture, where no\n * advisory lock exists to acquire. Calling this is an explicit claim that\n * the target store is not capture-enabled — do not use it to skip the lock\n * on a history store.\n */\nexport function uncapturedGraphWriteLock(): GraphWriteLock {\n  return graphWriteLockEvidence();\n}\n\n/**\n * Per-transaction memo of graphs whose advisory lock is already held.\n *\n * `pg_advisory_xact_lock` is reentrant and held until the top-level\n * transaction ends, so re-acquiring it on every captured write inside one\n * transaction is pure round-trip churn — a multi-write transaction paid one\n * lock round trip per write. The capture layer registers its per-transaction\n * backend here; every lock path that receives that backend (the capture\n * delegate's own writes, `runInWriteTransaction`, provenance) then skips the\n * SQL once the graph's lock is held.\n *\n * Keyed weakly by the backend object: the delegate is created per\n * transaction, so memo lifetime equals lock lifetime. NOT savepoint-aware —\n * a manual `SAVEPOINT` rolled back across the first acquisition releases the\n * lock but not the memo entry. That matches the capture session's touch\n * state (also not savepoint-scoped); manual savepoints inside a recorded\n * transaction are outside the capture contract.\n */\n/**\n * Single-flight per graph: the memo stores the IN-FLIGHT acquisition\n * promise, not just completed acquisitions, so concurrent same-transaction\n * writers (`Promise.all` over captured writes) coalesce onto one advisory\n * round trip instead of racing past an empty resolved-set. A rejected\n * acquisition evicts its entry so a retry is not poisoned (in practice a\n * failed statement has aborted the Postgres transaction anyway).\n */\nexport type RecordedGraphLockMemo = Map<string, Promise<void>>;\n\nexport function createRecordedGraphLockMemo(): RecordedGraphLockMemo {\n  return new Map();\n}\n\nconst recordedGraphLockMemos = new WeakMap<object, RecordedGraphLockMemo>();\n\nexport function registerRecordedGraphLockMemo(\n  backend: object,\n  memo: RecordedGraphLockMemo,\n): void {\n  recordedGraphLockMemos.set(backend, memo);\n}\n\nasync function acquireRecordedGraphWriteLock(\n  target: Pick<GraphBackend, \"execute\">,\n  graphId: string,\n): Promise<void> {\n  await target.execute(\n    asCompiledRowsSql(recordedGraphWriteAdvisoryLockSql(graphId)),\n  );\n}\n\nexport async function lockRecordedGraphWrite(\n  target: Pick<GraphBackend, \"dialect\" | \"execute\">,\n  graphId: string,\n  memo?: RecordedGraphLockMemo,\n): Promise<GraphWriteLock> {\n  if (target.dialect !== \"postgres\") return graphWriteLockEvidence();\n  const effectiveMemo = memo ?? recordedGraphLockMemos.get(target);\n  if (effectiveMemo === undefined) {\n    await acquireRecordedGraphWriteLock(target, graphId);\n    return graphWriteLockEvidence();\n  }\n  let pending = effectiveMemo.get(graphId);\n  if (pending === undefined) {\n    pending = acquireRecordedGraphWriteLock(target, graphId).catch(\n      (error: unknown) => {\n        effectiveMemo.delete(graphId);\n        throw error;\n      },\n    );\n    effectiveMemo.set(graphId, pending);\n  }\n  await pending;\n  return graphWriteLockEvidence();\n}\n\nfunction failInvalidClockTimestamp(value: unknown): never {\n  throw new ConfigurationError(\n    \"Recorded clock row contained an invalid timestamp\",\n    { value },\n  );\n}\n\n/**\n * A `YYYY-MM-DD[ T]HH:MM:SS[.fff]` timestamp carrying no timezone designator\n * (no trailing `Z` and no `±HH:MM` offset). `new Date()` would parse such a\n * value in the host's *local* zone, so it must be pinned to UTC explicitly.\n */\nconst ZONELESS_DATETIME_PATTERN =\n  /^\\d{4}-\\d{2}-\\d{2}[ T]\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d+)?)?$/;\nconst OFFSET_DATETIME_PATTERN =\n  /^(\\d{4}-\\d{2}-\\d{2})[ T](\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d+)?)?)(Z|[+-]\\d{2}(?::?\\d{2})?)$/i;\n\nfunction normalizeOffsetDesignator(offset: string): string {\n  if (offset.toUpperCase() === \"Z\") return \"Z\";\n  if (/^[+-]\\d{2}$/.test(offset)) return `${offset}:00`;\n  if (/^[+-]\\d{4}$/.test(offset)) {\n    return `${offset.slice(0, 3)}:${offset.slice(3)}`;\n  }\n  return offset;\n}\n\n/**\n * Milliseconds since the epoch for a recorded-clock timestamp string. A\n * zoneless timestamp is interpreted as UTC — not the host's local zone — so\n * `recordedNow()` never drifts by the server's offset (or by a DST transition)\n * on a backend whose driver yields a naive timestamp for the recorded columns.\n * Timezone-aware and date-only strings are parsed as-is (already unambiguous).\n */\nfunction clockTimestampMs(value: string): number {\n  if (ZONELESS_DATETIME_PATTERN.test(value)) {\n    return Date.parse(`${value.replace(\" \", \"T\")}Z`);\n  }\n  const offsetMatch = OFFSET_DATETIME_PATTERN.exec(value);\n  if (offsetMatch) {\n    const [, date, time, offset] = offsetMatch;\n    return Date.parse(`${date}T${time}${normalizeOffsetDesignator(offset!)}`);\n  }\n  return Date.parse(value);\n}\n\n/**\n * Canonicalizes a recorded-clock value (a driver `Date` or an ISO string) to a\n * canonical UTC ISO string. Both branches guard against an unrepresentable\n * instant: a `Date` whose `getTime()` is `NaN` would otherwise make\n * `toISOString()` throw a bare `RangeError`, masking the typed\n * {@link ConfigurationError} the string branch already raises for an\n * unparseable value. Exported for focused unit coverage of that guard.\n */\nexport function toCanonicalIso(value: unknown): string {\n  if (value instanceof Date) {\n    if (Number.isNaN(value.getTime())) return failInvalidClockTimestamp(value);\n    return value.toISOString();\n  }\n  if (typeof value === \"string\") {\n    const timestamp = clockTimestampMs(value);\n    if (Number.isNaN(timestamp)) return failInvalidClockTimestamp(value);\n    return new Date(timestamp).toISOString();\n  }\n  return failInvalidClockTimestamp(value);\n}\n\n/**\n * The next monotonic recorded-commit instant (ms since epoch) for a graph: the\n * wall clock, or one millisecond past the previous commit when the wall clock\n * has not advanced. Returned as a number so the caller range-checks it against\n * the open sentinel before formatting — one parse in, one format out.\n */\nfunction nextRecordedCommitTime(previous: string | undefined): number {\n  // `nowIso()` (not `Date.now()`) so a mocked wall clock still drives capture;\n  // `Date.parse` of its canonical-Z string avoids the extra Date allocation +\n  // re-parse of `new Date(nowIso()).getTime()` on this per-commit hot path.\n  const wallTime = Date.parse(nowIso());\n  return previous === undefined ? wallTime : (\n      Math.max(wallTime, Date.parse(previous) + 1)\n    );\n}\n\n/**\n * Reads the recorded-time high-water mark for a graph — the latest committed\n * recorded instant. Exported so {@link Store.recordedNow} can hand callers a\n * deterministic `asOfRecorded` anchor. Accepts any read-capable backend or\n * transaction.\n */\nexport async function readRecordedClock(\n  target: Pick<GraphBackend, \"execute\">,\n  schema: SqlSchema,\n  graphId: string,\n): Promise<string | undefined> {\n  const rows = await target.execute<ClockRow>(\n    asCompiledRowsSql(sql`\n      SELECT recorded_at\n      FROM ${schema.recordedClockTable}\n      WHERE graph_id = ${graphId}\n    `),\n  );\n  const first = rows[0];\n  return first === undefined ? undefined : toCanonicalIso(first.recorded_at);\n}\n\n/**\n * Reads the durable, random origin assigned to one graph's revision clock.\n * The origin namespaces an otherwise timestamp-only revision anchor, so a\n * branch cannot mistake another store's coincident clock value for its base.\n */\nexport async function readRevisionOrigin(\n  target: Pick<GraphBackend, \"execute\">,\n  schema: SqlSchema,\n  graphId: string,\n): Promise<string | undefined> {\n  const rows = await target.execute<RevisionOriginRow>(\n    asCompiledRowsSql(sql`\n      SELECT origin\n      FROM ${schema.revisionOriginsTable}\n      WHERE graph_id = ${graphId}\n    `),\n  );\n  const first = rows[0];\n  if (first === undefined) return undefined;\n  if (typeof first.origin !== \"string\" || first.origin.length === 0) {\n    throw new ConfigurationError(\n      \"Revision origin row contained an invalid origin\",\n      { graphId, origin: first.origin },\n    );\n  }\n  return first.origin;\n}\n\n/**\n * Returns a graph's durable revision-origin nonce, creating it exactly once.\n * The unique graph-id row makes concurrent first readers converge on the\n * winner's origin rather than manufacturing incompatible anchors.\n */\nexport async function ensureRevisionOrigin(\n  target: RevisionOriginBackend,\n  schema: SqlSchema,\n  graphId: string,\n): Promise<string> {\n  const ensureTable = target.ensureRevisionOriginsTable;\n  if (ensureTable === undefined) {\n    throw new ConfigurationError(\n      \"Revision tracking requires a backend that can bootstrap revision origins.\",\n      { dialect: target.dialect },\n      {\n        suggestion:\n          \"Use a built-in SQLite/PostgreSQL backend, or implement ensureRevisionOriginsTable on the custom backend.\",\n      },\n    );\n  }\n  await ensureTable();\n  const existing = await readRevisionOrigin(target, schema, graphId);\n  if (existing !== undefined) return existing;\n\n  await executeStatement(\n    target,\n    sql`\n      INSERT INTO ${schema.revisionOriginsTable} (graph_id, origin)\n      VALUES (${graphId}, ${generateId()})\n      ON CONFLICT (graph_id) DO NOTHING\n    `,\n  );\n  const origin = await readRevisionOrigin(target, schema, graphId);\n  if (origin !== undefined) return origin;\n  throw new ConfigurationError(\n    \"Revision origin was not persisted after initialization.\",\n    { graphId, dialect: target.dialect },\n  );\n}\n\nasync function writeRecordedClock(\n  target: RecordedClockBackend,\n  schema: SqlSchema,\n  graphId: string,\n  recordedAt: string,\n): Promise<void> {\n  await executeStatement(\n    target,\n    sql`\n      INSERT INTO ${schema.recordedClockTable} (graph_id, recorded_at)\n      VALUES (${graphId}, ${recordedAt})\n      ON CONFLICT (graph_id) DO UPDATE SET recorded_at = ${recordedAt}\n    `,\n  );\n}\n\nasync function lockRecordedClock(\n  target: RecordedClockBackend,\n  schema: SqlSchema,\n  graphId: string,\n  ownsWriteLock: boolean,\n): Promise<void> {\n  // Serialize the read/advance/write sequence per graph. Without this,\n  // concurrent transactions can read the same previous clock value and\n  // allocate the same recorded instant.\n  if (target.dialect === \"postgres\") {\n    await target.execute(\n      asCompiledRowsSql(recordedClockAdvisoryLockSql(graphId)),\n    );\n    return;\n  }\n\n  // SQLite family: the seed-UPSERT exists only to take the clock row's write\n  // lock before reading when the enclosing transaction did NOT already hold one\n  // — an adopted external transaction (withRecordedTransaction) may have begun\n  // in deferred mode, where two concurrent commits could otherwise both read\n  // the same previous value. The bundled transaction paths open BEGIN IMMEDIATE\n  // (ownsWriteLock), so the lock is already held and the seed is a redundant\n  // write; skip it there. The seeded floor is overwritten by writeRecordedClock\n  // in the same transaction when it does run.\n  if (ownsWriteLock) return;\n  await executeStatement(\n    target,\n    sql`\n      INSERT INTO ${schema.recordedClockTable} (graph_id, recorded_at)\n      VALUES (${graphId}, ${RECORDED_MIN})\n      ON CONFLICT (graph_id) DO UPDATE SET recorded_at = recorded_at\n    `,\n  );\n}\n\nexport async function allocateRecordedCommit(\n  target: RecordedClockBackend,\n  schema: SqlSchema,\n  graphId: string,\n  ownsWriteLock: boolean,\n  previousRevision?: string,\n): Promise<string> {\n  await lockRecordedClock(target, schema, graphId, ownsWriteLock);\n  const previous =\n    previousRevision ?? (await readRecordedClock(target, schema, graphId));\n  const recordedCommitTime = nextRecordedCommitTime(previous);\n  if (\n    !Number.isFinite(recordedCommitTime) ||\n    recordedCommitTime >= RECORDED_MAX_TIME\n  ) {\n    throw new ConfigurationError(\n      `Recorded commit clock reached the open sentinel ${RECORDED_MAX}`,\n      { graphId, recordedCommitTime },\n      {\n        suggestion:\n          \"Use a graph with a normal recorded-time clock; the open sentinel is reserved for relation intervals.\",\n      },\n    );\n  }\n  const recordedCommit = new Date(recordedCommitTime).toISOString();\n  await writeRecordedClock(target, schema, graphId, recordedCommit);\n  return recordedCommit;\n}\n\n/**\n * Advances the durable graph revision after a successful live-store write.\n *\n * Revision tracking deliberately reuses the monotonic per-graph clock already\n * owned by recorded-time capture. The write path holds the graph write lock\n * before this runs. Callers additionally state whether their SQLite\n * transaction owns the write lock so `allocateRecordedCommit` can skip its\n * redundant seed-UPSERT only on bundled `BEGIN IMMEDIATE` paths. It preserves\n * monotonicity even when wall-clock milliseconds repeat. History capture calls\n * `allocateRecordedCommit` during its own flush instead, so a captured write\n * remains one revision rather than being advanced twice.\n */\nexport async function advanceRevisionClock(\n  target: RecordedClockBackend,\n  schema: SqlSchema,\n  graphId: string,\n  ownsWriteLock: boolean,\n  previousRevision?: string,\n): Promise<string> {\n  return allocateRecordedCommit(\n    target,\n    schema,\n    graphId,\n    ownsWriteLock,\n    previousRevision,\n  );\n}\n","import {\n  type EdgeRow,\n  type GraphBackend,\n  type InsertEdgeParams,\n  type InsertNodeParams,\n  type NodeRow,\n  type TransactionBackend,\n} from \"../backend/types\";\n\nexport type InsertDispatch<Params, Row> = Readonly<{\n  one: (params: Params) => Promise<Row>;\n  oneNoReturn?: ((params: Params) => Promise<void>) | undefined;\n  batch?: ((params: readonly Params[]) => Promise<void>) | undefined;\n  batchReturning?:\n    ((params: readonly Params[]) => Promise<readonly Row[]>) | undefined;\n}>;\n\ntype InsertBackend = GraphBackend | TransactionBackend;\n\nexport function nodeInsertDispatch(\n  backend: InsertBackend,\n): InsertDispatch<InsertNodeParams, NodeRow> {\n  return {\n    one: (params) => backend.insertNode(params),\n    oneNoReturn:\n      backend.insertNodeNoReturn === undefined ?\n        undefined\n      : (params) => backend.insertNodeNoReturn!(params),\n    batch:\n      backend.insertNodesBatch === undefined ?\n        undefined\n      : (params) => backend.insertNodesBatch!(params),\n    batchReturning:\n      backend.insertNodesBatchReturning === undefined ?\n        undefined\n      : (params) => backend.insertNodesBatchReturning!(params),\n  };\n}\n\nexport function edgeInsertDispatch(\n  backend: InsertBackend,\n): InsertDispatch<InsertEdgeParams, EdgeRow> {\n  return {\n    one: (params) => backend.insertEdge(params),\n    oneNoReturn:\n      backend.insertEdgeNoReturn === undefined ?\n        undefined\n      : (params) => backend.insertEdgeNoReturn!(params),\n    batch:\n      backend.insertEdgesBatch === undefined ?\n        undefined\n      : (params) => backend.insertEdgesBatch!(params),\n    batchReturning:\n      backend.insertEdgesBatchReturning === undefined ?\n        undefined\n      : (params) => backend.insertEdgesBatchReturning!(params),\n  };\n}\n\nexport async function runInsertNoReturn<Params, Row>(\n  dispatch: InsertDispatch<Params, Row>,\n  params: Params,\n): Promise<void> {\n  if (dispatch.oneNoReturn !== undefined) {\n    await dispatch.oneNoReturn(params);\n    return;\n  }\n  await dispatch.one(params);\n}\n\nexport async function runInsertBatch<Params, Row>(\n  dispatch: InsertDispatch<Params, Row>,\n  params: readonly Params[],\n): Promise<void> {\n  if (params.length === 0) return;\n  if (dispatch.batch !== undefined) {\n    await dispatch.batch(params);\n    return;\n  }\n  for (const insertParams of params) {\n    await runInsertNoReturn(dispatch, insertParams);\n  }\n}\n\nexport async function runInsertBatchReturning<Params, Row>(\n  dispatch: InsertDispatch<Params, Row>,\n  params: readonly Params[],\n): Promise<readonly Row[]> {\n  if (dispatch.batchReturning !== undefined) {\n    return dispatch.batchReturning(params);\n  }\n  const rows: Row[] = [];\n  for (const insertParams of params) {\n    rows.push(await dispatch.one(insertParams));\n  }\n  return rows;\n}\n","type RowWithId = Readonly<{ id: string }>;\n\nexport type RowFetchPolicy<Row extends RowWithId> = Readonly<{\n  batch?: ((ids: readonly string[]) => Promise<readonly Row[]>) | undefined;\n  one: (id: string) => Promise<Row | undefined>;\n}>;\n\n/**\n * Shared \"batch if available, otherwise deduped single reads\" policy for\n * store row hydration. Node and edge callers supply only the backend-specific\n * read functions, so future bind-limit/chunking changes land in one place.\n */\nexport async function getRowsByIds<Row extends RowWithId>(\n  ids: readonly string[],\n  policy: RowFetchPolicy<Row>,\n): Promise<Map<string, Row>> {\n  const rowsById = new Map<string, Row>();\n  if (ids.length === 0) return rowsById;\n\n  if (policy.batch !== undefined) {\n    const rows = await policy.batch(ids);\n    for (const row of rows) {\n      rowsById.set(row.id, row);\n    }\n    return rowsById;\n  }\n\n  const uniqueIds = [...new Set(ids)];\n  const rows = await Promise.all(uniqueIds.map((id) => policy.one(id)));\n  for (const row of rows) {\n    if (row !== undefined) rowsById.set(row.id, row);\n  }\n  return rowsById;\n}\n","/**\n * Shared edge-row fetching.\n *\n * The edge twin of {@link ./node-fetch}: collection reads (`getByIds`), bulk\n * upsert existence probes, and recorded-time after-image capture all need to\n * fetch many edge rows by id, preferring the backend's batch `getEdges` and\n * falling back to parallel `getEdge` calls. Centralizing the fetch mechanics\n * keeps the copies from drifting; each caller layers its own filtering\n * (temporal mode, kind narrowing) on top.\n */\nimport {\n  type EdgeRow,\n  type GraphBackend,\n  type TransactionBackend,\n} from \"../backend/types\";\nimport { getRowsByIds } from \"./row-fetch\";\n\n/**\n * Fetches edge rows by id into a Map keyed by id. Uses `backend.getEdges`\n * when available, otherwise issues parallel `getEdge` calls for the distinct\n * ids. Missing ids are simply absent from the returned Map.\n */\nexport async function getEdgeRowsByIds(\n  backend: GraphBackend | TransactionBackend,\n  graphId: string,\n  ids: readonly string[],\n): Promise<Map<string, EdgeRow>> {\n  return getRowsByIds(ids, {\n    batch:\n      backend.getEdges === undefined ?\n        undefined\n      : (batchIds) => backend.getEdges!(graphId, batchIds),\n    one: (id) => backend.getEdge(graphId, id),\n  });\n}\n","/**\n * Shared node-row fetching.\n *\n * Both collection reads (`getByIds`) and declared-index lookup hydration need\n * to fetch many node rows by id, preferring the backend's batch `getNodes`\n * and falling back to parallel `getNode` calls. Centralizing the fetch\n * mechanics keeps the two paths from drifting; each caller layers its own\n * filtering (temporal mode vs. live-only) on top.\n */\nimport {\n  type GraphBackend,\n  type NodeRow as BackendNodeRow,\n  type TransactionBackend,\n} from \"../backend/types\";\nimport { getRowsByIds } from \"./row-fetch\";\n\n/**\n * Fetches node rows by id into a Map keyed by id. Uses `backend.getNodes`\n * when available, otherwise issues parallel `getNode` calls for the distinct\n * ids. Missing ids are simply absent from the returned Map.\n */\nexport async function getNodeRowsByIds(\n  backend: GraphBackend | TransactionBackend,\n  graphId: string,\n  kind: string,\n  ids: readonly string[],\n): Promise<Map<string, BackendNodeRow>> {\n  return getRowsByIds(ids, {\n    batch:\n      backend.getNodes === undefined ?\n        undefined\n      : (batchIds) => backend.getNodes!(graphId, kind, batchIds),\n    one: (id) => backend.getNode(graphId, kind, id),\n  });\n}\n","import { type SQL, sql } from \"drizzle-orm\";\n\nimport { sqlNull } from \"../../backend/drizzle/operations/shared\";\nimport {\n  type EdgeRow,\n  type NodeRow,\n  rowPropsToJsonText,\n  type TransactionBackend,\n} from \"../../backend/types\";\nimport { RECORDED_MAX } from \"../../core/temporal\";\nimport { ConfigurationError } from \"../../errors\";\nimport { generateId } from \"../../utils/id\";\nimport { executeStatement } from \"./guards\";\n\nexport type RecordedOperation = \"create\" | \"update\" | \"delete\";\n\nexport type RecordedInsert<Row> = Readonly<{\n  row: Row;\n  operation: RecordedOperation;\n}>;\n\n/**\n * `meta`, `schema_version`, and `tx_id` are reserved SQL:2011 audit columns of\n * the recorded relations. They are not yet populated by a writer, so every\n * captured row stamps `meta` with this empty object and leaves `schema_version`\n * / `tx_id` NULL; they are carried now so the relation shape is stable when a\n * populator lands.\n */\nconst RECORDED_HISTORY_META = \"{}\";\n\n/**\n * Recorded-relation column order. The same list builds each INSERT's column\n * clause and derives the per-statement chunk size, so adding a column updates\n * both in lockstep instead of relying on a hand-counted bind-parameter count.\n */\nexport const RECORDED_NODE_COLUMNS = [\n  \"history_id\",\n  \"graph_id\",\n  \"kind\",\n  \"id\",\n  \"props\",\n  \"version\",\n  \"valid_from\",\n  \"valid_to\",\n  \"created_at\",\n  \"updated_at\",\n  \"deleted_at\",\n  \"recorded_from\",\n  \"recorded_to\",\n  \"op\",\n  \"schema_version\",\n  \"tx_id\",\n  \"meta\",\n] as const;\n\nexport const RECORDED_EDGE_COLUMNS = [\n  \"history_id\",\n  \"graph_id\",\n  \"id\",\n  \"kind\",\n  \"from_kind\",\n  \"from_id\",\n  \"to_kind\",\n  \"to_id\",\n  \"props\",\n  \"valid_from\",\n  \"valid_to\",\n  \"created_at\",\n  \"updated_at\",\n  \"deleted_at\",\n  \"recorded_from\",\n  \"recorded_to\",\n  \"op\",\n  \"schema_version\",\n  \"tx_id\",\n  \"meta\",\n] as const;\n\nconst RECORDED_NODE_COLUMN_LIST = sql.raw(RECORDED_NODE_COLUMNS.join(\", \"));\nconst RECORDED_EDGE_COLUMN_LIST = sql.raw(RECORDED_EDGE_COLUMNS.join(\", \"));\n\n/**\n * Conservative per-statement bound-parameter budget, used only as the fallback\n * when a backend does not advertise `capabilities.maxBindParameters`.\n */\nconst RECORDED_BIND_PARAM_BUDGET = 900;\n\nexport function recordedBindParamBudget(\n  target: Pick<TransactionBackend, \"capabilities\">,\n): number {\n  const budget =\n    target.capabilities.maxBindParameters ?? RECORDED_BIND_PARAM_BUDGET;\n  if (!Number.isSafeInteger(budget) || budget < 1) {\n    throw new ConfigurationError(\n      `backend capabilities.maxBindParameters must be a positive integer, got: ${String(budget)}`,\n      {\n        code: \"INVALID_BACKEND_CAPABILITY\",\n        capability: \"maxBindParameters\",\n        value: budget,\n      },\n    );\n  }\n  return budget;\n}\n\n/**\n * Rows per recorded INSERT statement: the backend's real bound-parameter ceiling\n * divided by the per-row column count.\n */\nfunction recordedChunkSize(\n  target: Pick<TransactionBackend, \"capabilities\">,\n  columnCount: number,\n): number {\n  const budget = recordedBindParamBudget(target);\n  return Math.max(1, Math.floor(budget / columnCount));\n}\n\n/**\n * Builds one recorded column's value from an after-image row, the commit\n * instant, and the operation. Each recorded relation maps every column name to\n * one of these, so VALUES tuples are derived from the column list.\n */\ntype RecordedCellBuilder<Row> = (\n  row: Row,\n  recordedCommit: string,\n  operation: RecordedOperation,\n) => SQL;\n\ntype RecordedCommonColumn =\n  | \"history_id\"\n  | \"graph_id\"\n  | \"id\"\n  | \"kind\"\n  | \"props\"\n  | \"valid_from\"\n  | \"valid_to\"\n  | \"created_at\"\n  | \"updated_at\"\n  | \"deleted_at\"\n  | \"recorded_from\"\n  | \"recorded_to\"\n  | \"op\"\n  | \"schema_version\"\n  | \"tx_id\"\n  | \"meta\";\n\nfunction recordedCommonCells<Row extends NodeRow | EdgeRow>(): Record<\n  RecordedCommonColumn,\n  RecordedCellBuilder<Row>\n> {\n  return {\n    history_id: () => sql`${generateId()}`,\n    graph_id: (row) => sql`${row.graph_id}`,\n    id: (row) => sql`${row.id}`,\n    kind: (row) => sql`${row.kind}`,\n    props: (row) => sql`${rowPropsToJsonText(row.props)}`,\n    valid_from: (row) => sql`${sqlNull(row.valid_from)}`,\n    valid_to: (row) => sql`${sqlNull(row.valid_to)}`,\n    created_at: (row) => sql`${row.created_at}`,\n    updated_at: (row) => sql`${row.updated_at}`,\n    deleted_at: (row) => sql`${sqlNull(row.deleted_at)}`,\n    recorded_from: (_row, recordedCommit) => sql`${recordedCommit}`,\n    recorded_to: () => sql`${RECORDED_MAX}`,\n    op: (_row, _recordedCommit, operation) => sql`${operation}`,\n    schema_version: () => sql`NULL`,\n    tx_id: () => sql`NULL`,\n    meta: () => sql`${RECORDED_HISTORY_META}`,\n  };\n}\n\nconst recordedNodeCells: Record<\n  (typeof RECORDED_NODE_COLUMNS)[number],\n  RecordedCellBuilder<NodeRow>\n> = {\n  ...recordedCommonCells<NodeRow>(),\n  version: (row) => sql`${row.version}`,\n};\n\nconst recordedEdgeCells: Record<\n  (typeof RECORDED_EDGE_COLUMNS)[number],\n  RecordedCellBuilder<EdgeRow>\n> = {\n  ...recordedCommonCells<EdgeRow>(),\n  from_kind: (row) => sql`${row.from_kind}`,\n  from_id: (row) => sql`${row.from_id}`,\n  to_kind: (row) => sql`${row.to_kind}`,\n  to_id: (row) => sql`${row.to_id}`,\n};\n\nfunction recordedValuesTuple<Row, Column extends string>(\n  columns: readonly Column[],\n  cells: Record<Column, RecordedCellBuilder<Row>>,\n  row: Row,\n  recordedCommit: string,\n  operation: RecordedOperation,\n): SQL {\n  const tuple = columns.map((column) =>\n    cells[column](row, recordedCommit, operation),\n  );\n  return sql`(${sql.join(tuple, sql`, `)})`;\n}\n\nasync function insertRecordedRows<Row, Column extends string>(\n  target: TransactionBackend,\n  table: SQL,\n  columnList: SQL,\n  columns: readonly Column[],\n  cells: Record<Column, RecordedCellBuilder<Row>>,\n  inserts: readonly RecordedInsert<Row>[],\n  recordedCommit: string,\n): Promise<void> {\n  if (inserts.length === 0) return;\n  const values = inserts.map((insert) =>\n    recordedValuesTuple(\n      columns,\n      cells,\n      insert.row,\n      recordedCommit,\n      insert.operation,\n    ),\n  );\n  await executeStatement(\n    target,\n    sql`\n      INSERT INTO ${table} (${columnList})\n      VALUES ${sql.join(values, sql`, `)}\n    `,\n  );\n}\n\nexport function recordedNodeChunkSize(target: TransactionBackend): number {\n  return recordedChunkSize(target, RECORDED_NODE_COLUMNS.length);\n}\n\nexport function recordedEdgeChunkSize(target: TransactionBackend): number {\n  return recordedChunkSize(target, RECORDED_EDGE_COLUMNS.length);\n}\n\nexport function insertRecordedNodeRows(\n  target: TransactionBackend,\n  table: SQL,\n  inserts: readonly RecordedInsert<NodeRow>[],\n  recordedCommit: string,\n): Promise<void> {\n  return insertRecordedRows(\n    target,\n    table,\n    RECORDED_NODE_COLUMN_LIST,\n    RECORDED_NODE_COLUMNS,\n    recordedNodeCells,\n    inserts,\n    recordedCommit,\n  );\n}\n\nexport function insertRecordedEdgeRows(\n  target: TransactionBackend,\n  table: SQL,\n  inserts: readonly RecordedInsert<EdgeRow>[],\n  recordedCommit: string,\n): Promise<void> {\n  return insertRecordedRows(\n    target,\n    table,\n    RECORDED_EDGE_COLUMN_LIST,\n    RECORDED_EDGE_COLUMNS,\n    recordedEdgeCells,\n    inserts,\n    recordedCommit,\n  );\n}\n","import { type SQL, sql } from \"drizzle-orm\";\n\nimport {\n  type EdgeRow,\n  type HardDeleteNodeParams,\n  type NodeRow,\n  type TransactionBackend,\n} from \"../../backend/types\";\nimport { RECORDED_MAX } from \"../../core/temporal\";\nimport { sqlValueList } from \"../../query/compiler/predicate-utils\";\nimport { type SqlSchema } from \"../../query/compiler/schema\";\nimport { asCompiledRowsSql } from \"../../query/sql-intent\";\nimport { chunk } from \"../../utils/array\";\nimport { isPresent } from \"../../utils/presence\";\nimport { getEdgeRowsByIds } from \"../edge-fetch\";\nimport { getNodeRowsByIds } from \"../node-fetch\";\nimport { allocateRecordedCommit } from \"./clock\";\nimport { executeStatement } from \"./guards\";\nimport {\n  insertRecordedEdgeRows,\n  insertRecordedNodeRows,\n  recordedEdgeChunkSize,\n  type RecordedInsert,\n  recordedNodeChunkSize,\n  type RecordedOperation,\n} from \"./relations\";\n\nexport type TouchedNode = Readonly<{\n  entity: \"node\";\n  graphId: string;\n  kind: string;\n  id: string;\n  // The after-image returned by the live write, when it returned one. Carried so\n  // flush can build the recorded row without re-reading a row the write already\n  // handed back. Absent for writes that return no row.\n  afterImage?: NodeRow | undefined;\n}>;\n\nexport type TouchedEdge = Readonly<{\n  entity: \"edge\";\n  graphId: string;\n  id: string;\n  afterImage?: EdgeRow | undefined;\n}>;\n\nexport type TouchedEntity = TouchedNode | TouchedEdge;\n\ntype IdRow = Readonly<{ id: string }>;\ntype ClosedRow = Readonly<{ id: string; deleted_at: unknown }>;\n\nexport function entityKey(entity: TouchedEntity): string {\n  switch (entity.entity) {\n    case \"node\": {\n      return `node\\u0000${entity.graphId}\\u0000${entity.kind}\\u0000${entity.id}`;\n    }\n    case \"edge\": {\n      return `edge\\u0000${entity.graphId}\\u0000${entity.id}`;\n    }\n  }\n}\n\n/**\n * Closes every open recorded interval for the given ids in one statement and\n * returns, per id, whether the row it just closed was a soft-delete tombstone.\n */\nasync function closeOpenReturning(\n  target: TransactionBackend,\n  table: SQL,\n  graphId: string,\n  ids: readonly string[],\n  recordedCommit: string,\n  kind?: string,\n): Promise<ReadonlyMap<string, boolean>> {\n  const kindFilter = kind === undefined ? sql`` : sql`AND kind = ${kind}`;\n  const rows = await target.execute<ClosedRow>(\n    asCompiledRowsSql(sql`\n      UPDATE ${table}\n      SET recorded_to = ${recordedCommit}\n      WHERE graph_id = ${graphId}\n        ${kindFilter}\n        AND recorded_to = ${RECORDED_MAX}\n        AND id IN (${sqlValueList(ids)})\n      RETURNING id, deleted_at\n    `),\n  );\n  return new Map(rows.map((row) => [row.id, isPresent(row.deleted_at)]));\n}\n\nfunction recordedOp(\n  hadOpenRow: boolean,\n  priorRowWasTombstone: boolean,\n  after: Readonly<{ deleted_at: string | undefined }>,\n): RecordedOperation {\n  if (isPresent(after.deleted_at)) return \"delete\";\n  if (!hadOpenRow || priorRowWasTombstone) return \"create\";\n  return \"update\";\n}\n\nfunction groupNodesByKind(\n  entities: readonly TouchedNode[],\n): ReadonlyMap<string, TouchedNode[]> {\n  const byKind = new Map<string, TouchedNode[]>();\n  for (const entity of entities) {\n    const group = byKind.get(entity.kind) ?? [];\n    group.push(entity);\n    byKind.set(entity.kind, group);\n  }\n  return byKind;\n}\n\nasync function resolveAfterImages<Row>(\n  entities: readonly Readonly<{ id: string; afterImage?: Row | undefined }>[],\n  readMissing: (ids: readonly string[]) => Promise<ReadonlyMap<string, Row>>,\n): Promise<ReadonlyMap<string, Row>> {\n  const afterById = new Map<string, Row>();\n  const needRead: string[] = [];\n  for (const entity of entities) {\n    if (entity.afterImage === undefined) {\n      needRead.push(entity.id);\n    } else {\n      afterById.set(entity.id, entity.afterImage);\n    }\n  }\n  if (needRead.length > 0) {\n    for (const [id, row] of await readMissing(needRead)) afterById.set(id, row);\n  }\n  return afterById;\n}\n\nfunction recordedInsertsFor<\n  Row extends Readonly<{ id: string; deleted_at: string | undefined }>,\n>(\n  afterById: ReadonlyMap<string, Row>,\n  closed: ReadonlyMap<string, boolean>,\n): readonly RecordedInsert<Row>[] {\n  return [...afterById.values()].map((row) => ({\n    row,\n    operation: recordedOp(closed.has(row.id), closed.get(row.id) ?? false, row),\n  }));\n}\n\nexport async function flushNodes(\n  target: TransactionBackend,\n  schema: SqlSchema,\n  graphId: string,\n  entities: readonly TouchedNode[],\n  recordedCommit: string,\n): Promise<void> {\n  const chunkSize = recordedNodeChunkSize(target);\n  for (const [kind, group] of groupNodesByKind(entities)) {\n    for (const entityChunk of chunk(group, chunkSize)) {\n      const ids = entityChunk.map((entity) => entity.id);\n      const closed = await closeOpenReturning(\n        target,\n        schema.recordedNodesTable,\n        graphId,\n        ids,\n        recordedCommit,\n        kind,\n      );\n      const afterById = await resolveAfterImages(entityChunk, (missing) =>\n        getNodeRowsByIds(target, graphId, kind, missing),\n      );\n      await insertRecordedNodeRows(\n        target,\n        schema.recordedNodesTable,\n        recordedInsertsFor(afterById, closed),\n        recordedCommit,\n      );\n    }\n  }\n}\n\nexport async function flushEdges(\n  target: TransactionBackend,\n  schema: SqlSchema,\n  graphId: string,\n  entities: readonly TouchedEdge[],\n  recordedCommit: string,\n): Promise<void> {\n  const chunkSize = recordedEdgeChunkSize(target);\n  for (const entityChunk of chunk(entities, chunkSize)) {\n    const ids = entityChunk.map((entity) => entity.id);\n    const closed = await closeOpenReturning(\n      target,\n      schema.recordedEdgesTable,\n      graphId,\n      ids,\n      recordedCommit,\n    );\n    const afterById = await resolveAfterImages(entityChunk, (missing) =>\n      getEdgeRowsByIds(target, graphId, missing),\n    );\n    await insertRecordedEdgeRows(\n      target,\n      schema.recordedEdgesTable,\n      recordedInsertsFor(afterById, closed),\n      recordedCommit,\n    );\n  }\n}\n\nasync function closeOpenByKind(\n  target: TransactionBackend,\n  table: SQL,\n  graphId: string,\n  kind: string,\n  recordedCommit: string,\n): Promise<void> {\n  await executeStatement(\n    target,\n    sql`\n      UPDATE ${table}\n      SET recorded_to = ${recordedCommit}\n      WHERE graph_id = ${graphId}\n        AND kind = ${kind}\n        AND recorded_to = ${RECORDED_MAX}\n    `,\n  );\n}\n\nasync function closeOpenEdgesByNodeKind(\n  target: TransactionBackend,\n  schema: SqlSchema,\n  graphId: string,\n  nodeKind: string,\n  recordedCommit: string,\n): Promise<void> {\n  await executeStatement(\n    target,\n    sql`\n      UPDATE ${schema.recordedEdgesTable}\n      SET recorded_to = ${recordedCommit}\n      WHERE graph_id = ${graphId}\n        AND (from_kind = ${nodeKind} OR to_kind = ${nodeKind})\n        AND recorded_to = ${RECORDED_MAX}\n    `,\n  );\n}\n\nexport async function closeRecordedHardDeletedKind(\n  target: TransactionBackend,\n  schema: SqlSchema,\n  graphId: string,\n  removal: Readonly<{ entity: \"node\" | \"edge\"; kind: string }>,\n  ownsWriteLock: boolean,\n): Promise<void> {\n  const recordedCommit = await allocateRecordedCommit(\n    target,\n    schema,\n    graphId,\n    ownsWriteLock,\n  );\n  if (removal.entity === \"node\") {\n    await closeOpenByKind(\n      target,\n      schema.recordedNodesTable,\n      graphId,\n      removal.kind,\n      recordedCommit,\n    );\n    await closeOpenEdgesByNodeKind(\n      target,\n      schema,\n      graphId,\n      removal.kind,\n      recordedCommit,\n    );\n    return;\n  }\n  await closeOpenByKind(\n    target,\n    schema.recordedEdgesTable,\n    graphId,\n    removal.kind,\n    recordedCommit,\n  );\n}\n\nexport async function queryConnectedEdgeIds(\n  target: TransactionBackend,\n  schema: SqlSchema,\n  params: HardDeleteNodeParams,\n): Promise<readonly string[]> {\n  const rows = await target.execute<IdRow>(\n    asCompiledRowsSql(sql`\n      SELECT id\n      FROM ${schema.edgesTable}\n      WHERE graph_id = ${params.graphId}\n        AND (\n          (from_kind = ${params.kind} AND from_id = ${params.id})\n          OR (to_kind = ${params.kind} AND to_id = ${params.id})\n        )\n    `),\n  );\n  return rows.map((row) => row.id);\n}\n","import {\n  createBackendOverlay,\n  type DeleteEdgesBatchParams,\n  type EdgeRow,\n  type GraphBackend,\n  type InsertEdgeParams,\n  type InsertNodeParams,\n  type NodeRow,\n  type TransactionBackend,\n  type TransactionOptions,\n} from \"../backend/types\";\nimport { ConfigurationError } from \"../errors\";\nimport { type SqlSchema } from \"../query/compiler/schema\";\nimport { groupBy } from \"../utils/array\";\nimport {\n  edgeInsertDispatch,\n  nodeInsertDispatch,\n  runInsertBatch,\n  runInsertBatchReturning,\n  runInsertNoReturn,\n} from \"./insert-dispatch\";\nimport {\n  allocateRecordedCommit,\n  createRecordedGraphLockMemo,\n  lockRecordedGraphWrite,\n  registerRecordedGraphLockMemo,\n} from \"./recorded-capture/clock\";\nimport {\n  entityKey,\n  flushEdges,\n  flushNodes,\n  queryConnectedEdgeIds,\n  type TouchedEdge,\n  type TouchedEntity,\n  type TouchedNode,\n} from \"./recorded-capture/flush\";\nimport {\n  assertCapturableBackend,\n  assertRecordedCaptureTransactionIsolation,\n  assertRequestedRecordedIsolation,\n  createHistoryUnsafeSqlRef,\n  rawWriteGuards,\n  recordedCaptureRequiresCallbackTransactionError,\n  requireCaptureStatements,\n  requireRecordedSchema,\n  withRecordedRelationsPrecondition,\n} from \"./recorded-capture/guards\";\n\nexport {\n  advanceRevisionClock,\n  ensureRevisionOrigin,\n  lockRecordedGraphWrite,\n  readRecordedClock,\n  readRevisionOrigin,\n  recordedClockAdvisoryLockSql,\n  recordedGraphWriteAdvisoryLockSql,\n  toCanonicalIso,\n} from \"./recorded-capture/clock\";\nexport { closeRecordedHardDeletedKind } from \"./recorded-capture/flush\";\nexport {\n  assertRecordedCaptureTransactionIsolation,\n  assertRevisionTrackableBackend,\n  createHistoryUnsafeSqlRef,\n  createRevisionTrackingUnsafeSqlRef,\n  recordedCaptureRequiresCallbackTransactionError,\n  withRecordedRelationsPrecondition,\n} from \"./recorded-capture/guards\";\nexport {\n  RECORDED_EDGE_COLUMNS,\n  RECORDED_NODE_COLUMNS,\n} from \"./recorded-capture/relations\";\nexport {\n  RECORDED_OPTIONAL_WRITE_METHODS,\n  RECORDED_REQUIRED_WRITE_METHODS,\n} from \"./recorded-capture/write-surface\";\n\ntype RecordedCaptureSession = Readonly<{\n  touchNode: (\n    graphId: string,\n    kind: string,\n    id: string,\n    afterImage?: NodeRow,\n  ) => void;\n  touchEdge: (graphId: string, id: string, afterImage?: EdgeRow) => void;\n  flush: (\n    target: TransactionBackend,\n    schema: SqlSchema,\n    ownsWriteLock: boolean,\n  ) => Promise<RecordedFlushInstants>;\n}>;\n\nexport type RecordedFlushInstants = ReadonlyMap<string, string>;\n\ntype RecordedFlushObserver = (instants: RecordedFlushInstants) => void;\n\nconst RECORDED_FLUSH_OBSERVER = Symbol(\"typegraph.recordedFlushObserver\");\n\ntype RecordedFlushObserverOptions = TransactionOptions &\n  Readonly<{\n    [RECORDED_FLUSH_OBSERVER]?: RecordedFlushObserver;\n  }>;\n\nfunction readRecordedFlushObserver(\n  options: TransactionOptions | undefined,\n): RecordedFlushObserver | undefined {\n  return (options as RecordedFlushObserverOptions | undefined)?.[\n    RECORDED_FLUSH_OBSERVER\n  ];\n}\n\nfunction stripRecordedFlushObserver(\n  options: TransactionOptions | undefined,\n): TransactionOptions | undefined {\n  if (options === undefined) return undefined;\n  // Omit only the observer symbol; every other (current or future)\n  // TransactionOptions field passes through to the wrapped backend untouched.\n  const { [RECORDED_FLUSH_OBSERVER]: _observer, ...backendOptions } =\n    options as RecordedFlushObserverOptions;\n  return backendOptions;\n}\n\nexport function withRecordedFlushObserver(\n  options: TransactionOptions | undefined,\n  observer: RecordedFlushObserver,\n): TransactionOptions {\n  return {\n    ...stripRecordedFlushObserver(options),\n    [RECORDED_FLUSH_OBSERVER]: observer,\n  } as RecordedFlushObserverOptions;\n}\n\ntype RecordedTransactionScope = Readonly<{\n  backend: TransactionBackend;\n  flush: () => Promise<RecordedFlushInstants>;\n}>;\n\ndeclare const NODE_IDENTITY_KEY_BRAND: unique symbol;\ndeclare const EDGE_IDENTITY_KEY_BRAND: unique symbol;\n\ntype NodeIdentityKey = string &\n  Readonly<{ [NODE_IDENTITY_KEY_BRAND]: \"node-identity-key\" }>;\ntype EdgeIdentityKey = string &\n  Readonly<{ [EDGE_IDENTITY_KEY_BRAND]: \"edge-identity-key\" }>;\n\ntype NodeIdentityParams = Pick<InsertNodeParams, \"graphId\" | \"kind\" | \"id\">;\ntype NodeIdentityRow = Pick<NodeRow, \"graph_id\" | \"kind\" | \"id\">;\ntype EdgeIdentityParams = Pick<InsertEdgeParams, \"graphId\" | \"id\">;\ntype EdgeIdentityRow = Pick<EdgeRow, \"graph_id\" | \"id\">;\n\nfunction nodeIdentityKey(\n  graphId: string,\n  kind: string,\n  id: string,\n): NodeIdentityKey {\n  return `${graphId}\\u0000${kind}\\u0000${id}` as NodeIdentityKey;\n}\n\nfunction nodeParamsIdentityKey(params: NodeIdentityParams): NodeIdentityKey {\n  return nodeIdentityKey(params.graphId, params.kind, params.id);\n}\n\nfunction nodeRowIdentityKey(row: NodeIdentityRow): NodeIdentityKey {\n  return nodeIdentityKey(row.graph_id, row.kind, row.id);\n}\n\nfunction edgeIdentityKey(graphId: string, id: string): EdgeIdentityKey {\n  return `${graphId}\\u0000${id}` as EdgeIdentityKey;\n}\n\nfunction edgeParamsIdentityKey(params: EdgeIdentityParams): EdgeIdentityKey {\n  return edgeIdentityKey(params.graphId, params.id);\n}\n\nfunction edgeRowIdentityKey(row: EdgeIdentityRow): EdgeIdentityKey {\n  return edgeIdentityKey(row.graph_id, row.id);\n}\n\nfunction createRecordedCaptureSession(): RecordedCaptureSession {\n  const touched = new Map<string, TouchedEntity>();\n  // Sealed by flush(): a scope flushes exactly once, at its terminal point, so\n  // any touch afterward means a graph write happened after capture lost its\n  // flush window (e.g. a caller reused the withRecordedTransaction context after\n  // it returned). Fail loud rather than let that write commit uncaptured and\n  // silently diverge history from live state.\n  let sealed = false;\n\n  function touch(entity: TouchedEntity): void {\n    if (sealed) {\n      throw new ConfigurationError(\n        \"Recorded-time capture session is sealed: a graph write happened after the transaction's capture was flushed.\",\n        { entity: entity.entity, graphId: entity.graphId, id: entity.id },\n        {\n          suggestion:\n            \"Perform all writes inside the withRecordedTransaction callback; do not reuse the transaction context after it returns.\",\n        },\n      );\n    }\n    touched.set(entityKey(entity), entity);\n  }\n\n  return {\n    touchNode(\n      graphId: string,\n      kind: string,\n      id: string,\n      afterImage?: NodeRow,\n    ): void {\n      touch({ entity: \"node\", graphId, kind, id, afterImage });\n    },\n\n    touchEdge(graphId: string, id: string, afterImage?: EdgeRow): void {\n      touch({ entity: \"edge\", graphId, id, afterImage });\n    },\n\n    async flush(\n      target: TransactionBackend,\n      schema: SqlSchema,\n      ownsWriteLock: boolean,\n    ): Promise<RecordedFlushInstants> {\n      if (sealed) {\n        throw new ConfigurationError(\n          \"Recorded-time capture session was already flushed.\",\n          {},\n          {\n            suggestion:\n              \"A capture scope flushes once at its terminal point; do not flush it twice.\",\n          },\n        );\n      }\n      // Seal before the early-return so a no-write scope is sealed too, and\n      // before any awaits so a re-entrant touch during flush also fails loud.\n      // flush() writes recorded rows directly (never via touch), so sealing here\n      // does not block its own work.\n      sealed = true;\n      if (touched.size === 0) return new Map();\n      const recordedByGraph = new Map<string, string>();\n      const byGraph = groupBy(touched.values(), (entity) => entity.graphId);\n      for (const [graphId, entities] of byGraph) {\n        const recordedCommit = await allocateRecordedCommit(\n          target,\n          schema,\n          graphId,\n          ownsWriteLock,\n        );\n        recordedByGraph.set(graphId, recordedCommit);\n        const nodes = entities.filter(\n          (entity): entity is TouchedNode => entity.entity === \"node\",\n        );\n        const edges = entities.filter(\n          (entity): entity is TouchedEdge => entity.entity === \"edge\",\n        );\n        await flushNodes(target, schema, graphId, nodes, recordedCommit);\n        await flushEdges(target, schema, graphId, edges, recordedCommit);\n      }\n      touched.clear();\n      return recordedByGraph;\n    },\n  };\n}\n\nfunction createRecordedTransactionBackend(\n  target: TransactionBackend,\n  session: RecordedCaptureSession,\n  schema: SqlSchema,\n): TransactionBackend {\n  const nodeDispatch = nodeInsertDispatch(target);\n  const edgeDispatch = edgeInsertDispatch(target);\n\n  // One advisory-lock round trip per graph per transaction: the memo is\n  // shared with the returned overlay (see registerRecordedGraphLockMemo),\n  // so external lock paths handed this backend dedupe against the same\n  // single-flight promises — including concurrent same-transaction writers.\n  const graphLocks = createRecordedGraphLockMemo();\n\n  async function lockGraph(graphId: string): Promise<void> {\n    await lockRecordedGraphWrite(target, graphId, graphLocks);\n  }\n\n  async function lockGraphs(\n    params: readonly Readonly<{ graphId: string }>[],\n  ): Promise<void> {\n    // Codepoint sort, NOT localeCompare: every process must acquire\n    // multi-graph locks in the same order, and locale-sensitive collation\n    // varies with the host's ICU configuration — two processes sorting the\n    // same ids differently would take the same lock pair in opposite\n    // orders and deadlock.\n    const graphIds = [\n      ...new Set(params.map((parameter) => parameter.graphId)),\n    ].toSorted();\n    for (const graphId of graphIds) {\n      await lockRecordedGraphWrite(target, graphId, graphLocks);\n    }\n  }\n\n  const overlay = createBackendOverlay(target, {\n    ...rawWriteGuards(target, \"tx.backend\"),\n\n    async insertNode(params) {\n      await lockGraph(params.graphId);\n      const row = await target.insertNode(params);\n      session.touchNode(params.graphId, params.kind, params.id, row);\n      return row;\n    },\n\n    ...(target.insertNodeNoReturn === undefined ?\n      {}\n    : {\n        async insertNodeNoReturn(params: InsertNodeParams): Promise<void> {\n          await lockGraph(params.graphId);\n          await runInsertNoReturn(nodeDispatch, params);\n          session.touchNode(params.graphId, params.kind, params.id);\n        },\n      }),\n\n    ...(target.insertNodesBatch === undefined ?\n      {}\n    : {\n        async insertNodesBatch(\n          params: readonly InsertNodeParams[],\n        ): Promise<void> {\n          await lockGraphs(params);\n          await runInsertBatch(nodeDispatch, params);\n          for (const node of params) {\n            session.touchNode(node.graphId, node.kind, node.id);\n          }\n        },\n      }),\n\n    ...(target.insertNodesBatchReturning === undefined ?\n      {}\n    : {\n        async insertNodesBatchReturning(\n          params: readonly InsertNodeParams[],\n        ): Promise<readonly NodeRow[]> {\n          await lockGraphs(params);\n          const rows = await runInsertBatchReturning(nodeDispatch, params);\n          const rowsByIdentity = new Map(\n            rows.map((row) => [nodeRowIdentityKey(row), row] as const),\n          );\n          for (const node of params) {\n            session.touchNode(\n              node.graphId,\n              node.kind,\n              node.id,\n              rowsByIdentity.get(nodeParamsIdentityKey(node)),\n            );\n          }\n          return rows;\n        },\n      }),\n\n    async updateNode(params) {\n      await lockGraph(params.graphId);\n      const row = await target.updateNode(params);\n      session.touchNode(params.graphId, params.kind, params.id, row);\n      return row;\n    },\n\n    async deleteNode(params) {\n      await lockGraph(params.graphId);\n      await target.deleteNode(params);\n      session.touchNode(params.graphId, params.kind, params.id);\n    },\n\n    async hardDeleteNode(params) {\n      await lockGraph(params.graphId);\n      const connectedEdgeIds = await queryConnectedEdgeIds(\n        target,\n        schema,\n        params,\n      );\n      await target.hardDeleteNode(params);\n      session.touchNode(params.graphId, params.kind, params.id);\n      for (const edgeId of connectedEdgeIds) {\n        session.touchEdge(params.graphId, edgeId);\n      }\n    },\n\n    async insertEdge(params) {\n      await lockGraph(params.graphId);\n      const row = await target.insertEdge(params);\n      session.touchEdge(params.graphId, params.id, row);\n      return row;\n    },\n\n    ...(target.insertEdgeNoReturn === undefined ?\n      {}\n    : {\n        async insertEdgeNoReturn(params: InsertEdgeParams): Promise<void> {\n          await lockGraph(params.graphId);\n          await runInsertNoReturn(edgeDispatch, params);\n          session.touchEdge(params.graphId, params.id);\n        },\n      }),\n\n    ...(target.insertEdgesBatch === undefined ?\n      {}\n    : {\n        async insertEdgesBatch(\n          params: readonly InsertEdgeParams[],\n        ): Promise<void> {\n          await lockGraphs(params);\n          await runInsertBatch(edgeDispatch, params);\n          for (const edge of params) {\n            session.touchEdge(edge.graphId, edge.id);\n          }\n        },\n      }),\n\n    ...(target.insertEdgesBatchReturning === undefined ?\n      {}\n    : {\n        async insertEdgesBatchReturning(\n          params: readonly InsertEdgeParams[],\n        ): Promise<readonly EdgeRow[]> {\n          await lockGraphs(params);\n          const rows = await runInsertBatchReturning(edgeDispatch, params);\n          const rowsByIdentity = new Map(\n            rows.map((row) => [edgeRowIdentityKey(row), row] as const),\n          );\n          for (const edge of params) {\n            session.touchEdge(\n              edge.graphId,\n              edge.id,\n              rowsByIdentity.get(edgeParamsIdentityKey(edge)),\n            );\n          }\n          return rows;\n        },\n      }),\n\n    async updateEdge(params) {\n      await lockGraph(params.graphId);\n      const row = await target.updateEdge(params);\n      session.touchEdge(params.graphId, params.id, row);\n      return row;\n    },\n\n    async deleteEdge(params) {\n      await lockGraph(params.graphId);\n      await target.deleteEdge(params);\n      session.touchEdge(params.graphId, params.id);\n    },\n\n    async hardDeleteEdge(params) {\n      await lockGraph(params.graphId);\n      await target.hardDeleteEdge(params);\n      session.touchEdge(params.graphId, params.id);\n    },\n\n    ...(target.deleteEdgesBatch === undefined ?\n      {}\n    : {\n        async deleteEdgesBatch(params: DeleteEdgesBatchParams): Promise<void> {\n          await lockGraph(params.graphId);\n          await target.deleteEdgesBatch!(params);\n          for (const id of params.ids) {\n            session.touchEdge(params.graphId, id);\n          }\n        },\n      }),\n\n    ...(target.hardDeleteEdgesBatch === undefined ?\n      {}\n    : {\n        async hardDeleteEdgesBatch(\n          params: DeleteEdgesBatchParams,\n        ): Promise<void> {\n          await lockGraph(params.graphId);\n          await target.hardDeleteEdgesBatch!(params);\n          for (const id of params.ids) {\n            session.touchEdge(params.graphId, id);\n          }\n        },\n      }),\n  });\n  registerRecordedGraphLockMemo(overlay, graphLocks);\n  return overlay;\n}\n\nexport function createRecordedTransactionScope(\n  target: TransactionBackend,\n  schema?: SqlSchema,\n  // True only when the enclosing transaction already holds a SQLite write lock\n  // (the bundled BEGIN IMMEDIATE paths), letting clock allocation skip the\n  // redundant seed-UPSERT. Defaults to false so an adopted (possibly deferred)\n  // external transaction still seeds the lock — the safe choice.\n  ownsWriteLock = false,\n): RecordedTransactionScope {\n  // Fail fast — before any write runs in the adopted/opened transaction — if\n  // the transaction target cannot execute the statements capture flush needs,\n  // rather than throwing mid-flush after the live write has already happened.\n  requireCaptureStatements(target);\n  const session = createRecordedCaptureSession();\n  // Table names are fixed for the transaction's lifetime, so resolve the schema\n  // once and thread it through capture instead of rebuilding it per flush. The\n  // store passes its resolved schema so capture targets the same recorded\n  // relations recorded reads do; the fallback covers standalone capture.\n  const resolvedSchema = schema ?? requireRecordedSchema(target);\n  return {\n    backend: createRecordedTransactionBackend(target, session, resolvedSchema),\n    async flush(): Promise<RecordedFlushInstants> {\n      // By flush time the live write has committed within this transaction, so a\n      // missing-table error can only be a recorded relation — surface it as the\n      // typed precondition the constructor gate could not check.\n      return withRecordedRelationsPrecondition(\n        session.flush(target, resolvedSchema, ownsWriteLock),\n        { dialect: target.dialect, surface: \"capture-flush\" },\n      );\n    },\n  };\n}\n\nasync function runCapturedAutocommit<T>(\n  backend: GraphBackend,\n  schema: SqlSchema | undefined,\n  fn: (target: TransactionBackend) => Promise<T>,\n  options?: TransactionOptions,\n): Promise<T> {\n  assertRequestedRecordedIsolation(backend, options);\n  return backend.transaction(async (target) => {\n    await assertRecordedCaptureTransactionIsolation(target);\n    // The bundled transaction opened BEGIN IMMEDIATE, so the write lock is held.\n    const scope = createRecordedTransactionScope(target, schema, true);\n    const result = await fn(scope.backend);\n    await scope.flush();\n    return result;\n  }, options);\n}\n\nexport function createRecordedBackend(\n  backend: GraphBackend,\n  schema?: SqlSchema,\n): GraphBackend {\n  assertCapturableBackend(backend);\n  const capture = <T>(\n    fn: (target: TransactionBackend) => Promise<T>,\n  ): Promise<T> => runCapturedAutocommit(backend, schema, fn);\n\n  return createBackendOverlay(backend, {\n    ...rawWriteGuards(backend, \"backend\"),\n\n    async insertNode(params) {\n      return capture((target) => target.insertNode(params));\n    },\n\n    ...(backend.insertNodeNoReturn === undefined ?\n      {}\n    : {\n        async insertNodeNoReturn(params: InsertNodeParams): Promise<void> {\n          await capture((target) =>\n            runInsertNoReturn(nodeInsertDispatch(target), params),\n          );\n        },\n      }),\n\n    ...(backend.insertNodesBatch === undefined ?\n      {}\n    : {\n        async insertNodesBatch(\n          params: readonly InsertNodeParams[],\n        ): Promise<void> {\n          await capture((target) =>\n            runInsertBatch(nodeInsertDispatch(target), params),\n          );\n        },\n      }),\n\n    ...(backend.insertNodesBatchReturning === undefined ?\n      {}\n    : {\n        async insertNodesBatchReturning(\n          params: readonly InsertNodeParams[],\n        ): Promise<readonly NodeRow[]> {\n          return capture((target) =>\n            runInsertBatchReturning(nodeInsertDispatch(target), params),\n          );\n        },\n      }),\n\n    async updateNode(params) {\n      return capture((target) => target.updateNode(params));\n    },\n\n    async deleteNode(params) {\n      await capture((target) => target.deleteNode(params));\n    },\n\n    async hardDeleteNode(params) {\n      await capture((target) => target.hardDeleteNode(params));\n    },\n\n    async insertEdge(params) {\n      return capture((target) => target.insertEdge(params));\n    },\n\n    ...(backend.insertEdgeNoReturn === undefined ?\n      {}\n    : {\n        async insertEdgeNoReturn(params: InsertEdgeParams): Promise<void> {\n          await capture((target) =>\n            runInsertNoReturn(edgeInsertDispatch(target), params),\n          );\n        },\n      }),\n\n    ...(backend.insertEdgesBatch === undefined ?\n      {}\n    : {\n        async insertEdgesBatch(\n          params: readonly InsertEdgeParams[],\n        ): Promise<void> {\n          await capture((target) =>\n            runInsertBatch(edgeInsertDispatch(target), params),\n          );\n        },\n      }),\n\n    ...(backend.insertEdgesBatchReturning === undefined ?\n      {}\n    : {\n        async insertEdgesBatchReturning(\n          params: readonly InsertEdgeParams[],\n        ): Promise<readonly EdgeRow[]> {\n          return capture((target) =>\n            runInsertBatchReturning(edgeInsertDispatch(target), params),\n          );\n        },\n      }),\n\n    async updateEdge(params) {\n      return capture((target) => target.updateEdge(params));\n    },\n\n    async deleteEdge(params) {\n      await capture((target) => target.deleteEdge(params));\n    },\n\n    async hardDeleteEdge(params) {\n      await capture((target) => target.hardDeleteEdge(params));\n    },\n\n    ...(backend.deleteEdgesBatch === undefined ?\n      {}\n    : {\n        async deleteEdgesBatch(params: DeleteEdgesBatchParams): Promise<void> {\n          await capture((target) => target.deleteEdgesBatch!(params));\n        },\n      }),\n\n    ...(backend.hardDeleteEdgesBatch === undefined ?\n      {}\n    : {\n        async hardDeleteEdgesBatch(\n          params: DeleteEdgesBatchParams,\n        ): Promise<void> {\n          await capture((target) => target.hardDeleteEdgesBatch!(params));\n        },\n      }),\n\n    async transaction(fn, options) {\n      const observer = readRecordedFlushObserver(options);\n      const backendOptions = stripRecordedFlushObserver(options);\n      assertRequestedRecordedIsolation(backend, backendOptions);\n      return backend.transaction(async (target) => {\n        await assertRecordedCaptureTransactionIsolation(target);\n        // Bundled BEGIN IMMEDIATE transaction — the write lock is already held.\n        const scope = createRecordedTransactionScope(target, schema, true);\n        const result = await fn(scope.backend, createHistoryUnsafeSqlRef());\n        const instants = await scope.flush();\n        observer?.(instants);\n        return result;\n      }, backendOptions);\n    },\n\n    ...(backend.adoptTransaction === undefined ?\n      {}\n    : {\n        adoptTransaction(externalTx): TransactionBackend {\n          throw recordedCaptureRequiresCallbackTransactionError({\n            externalTxType: typeof externalTx,\n          });\n        },\n      }),\n  });\n}\n","/**\n * Embedding Sync Utilities\n *\n * Handles automatic synchronization of embedding fields with the embeddings table.\n * When nodes with embedding properties are created, updated, or deleted,\n * these utilities ensure the embeddings table stays in sync.\n */\nimport { type z } from \"zod\";\n\nimport { type GraphBackend, type TransactionBackend } from \"../backend/types\";\nimport {\n  type ResolvedEmbeddingField,\n  resolveEmbeddingFields,\n} from \"../core/embedding\";\n\n// ============================================================\n// Types\n// ============================================================\n\n/**\n * Information about an embedding field in a node schema.\n *\n * Re-exports the canonical {@link ResolvedEmbeddingField} so the backend\n * gets `dimensions` plus the resolved index `(metric, indexType)` — all\n * three needed to address the field's typed per-`(kind, field)` storage\n * slot when upserting.\n */\ntype EmbeddingFieldInfo = ResolvedEmbeddingField;\n\n/**\n * Context for embedding sync operations.\n */\nexport type EmbeddingSyncContext = Readonly<{\n  graphId: string;\n  nodeKind: string;\n  nodeId: string;\n  backend: GraphBackend | TransactionBackend;\n}>;\n\n// ============================================================\n// Schema Introspection\n// ============================================================\n\n/**\n * Cache keyed by the Zod schema instance. Schemas are immutable at\n * runtime; the same reference recurs across every CRUD call.\n */\nconst embeddingFieldsCache = new WeakMap<\n  z.ZodType,\n  readonly EmbeddingFieldInfo[]\n>();\n\n/**\n * Extracts embedding field information from a Zod schema.\n * Returns all embedding fields found at the top level of an object schema.\n *\n * Thin per-schema-instance memoization over the canonical\n * {@link resolveEmbeddingFields}; the same schema reference recurs across\n * every CRUD call, so caching avoids re-walking the shape each time.\n */\nexport function getEmbeddingFields(\n  schema: z.ZodType,\n): readonly EmbeddingFieldInfo[] {\n  const cached = embeddingFieldsCache.get(schema);\n  if (cached) return cached;\n  const fields = resolveEmbeddingFields(schema);\n  embeddingFieldsCache.set(schema, fields);\n  return fields;\n}\n\n// ============================================================\n// Embedding Sync Operations\n// ============================================================\n\n/**\n * Syncs embeddings after a node create or update operation.\n *\n * For each embedding field in the schema:\n * - If the props contain an embedding value, upsert it to the embeddings table\n * - If the props don't contain an embedding value (undefined), delete any existing embedding\n */\nexport async function syncEmbeddings(\n  ctx: EmbeddingSyncContext,\n  schema: z.ZodType,\n  props: Record<string, unknown>,\n): Promise<void> {\n  const { backend } = ctx;\n\n  // Check if backend supports embedding operations\n  if (!backend.upsertEmbedding || !backend.deleteEmbedding) {\n    return;\n  }\n\n  const embeddingFields = getEmbeddingFields(schema);\n  if (embeddingFields.length === 0) {\n    return;\n  }\n\n  for (const field of embeddingFields) {\n    const value = props[field.fieldPath];\n\n    if (isValidEmbeddingValue(value)) {\n      // Upsert the embedding\n      await backend.upsertEmbedding({\n        graphId: ctx.graphId,\n        nodeKind: ctx.nodeKind,\n        nodeId: ctx.nodeId,\n        fieldPath: field.fieldPath,\n        embedding: value,\n        dimensions: field.dimensions,\n        metric: field.metric,\n        indexType: field.indexType,\n      });\n    } else if (value === undefined) {\n      // Delete any existing embedding for this field\n      await backend.deleteEmbedding({\n        graphId: ctx.graphId,\n        nodeKind: ctx.nodeKind,\n        nodeId: ctx.nodeId,\n        fieldPath: field.fieldPath,\n        dimensions: field.dimensions,\n        metric: field.metric,\n        indexType: field.indexType,\n      });\n    }\n    // If value is null or invalid, skip (validation should have caught this)\n  }\n}\n\n/**\n * Syncs embeddings for a batch of same-kind node creates through one\n * `upsertEmbeddingBatch` per field (falling back to per-row\n * `upsertEmbedding` when the backend lacks the batch primitive). Mirrors\n * `syncEmbeddings` per row: present values upsert, `undefined` values\n * delete any existing embedding for the field.\n */\nexport async function syncEmbeddingsBatchForKind(\n  args: Readonly<{\n    graphId: string;\n    nodeKind: string;\n    backend: GraphBackend | TransactionBackend;\n  }>,\n  schema: z.ZodType,\n  items: readonly Readonly<{\n    nodeId: string;\n    props: Record<string, unknown>;\n  }>[],\n): Promise<void> {\n  const { graphId, nodeKind, backend } = args;\n  if (!backend.upsertEmbedding || !backend.deleteEmbedding) {\n    return;\n  }\n\n  const embeddingFields = getEmbeddingFields(schema);\n  if (embeddingFields.length === 0) {\n    return;\n  }\n\n  for (const field of embeddingFields) {\n    const rows: { nodeId: string; embedding: readonly number[] }[] = [];\n    const deletionIds: string[] = [];\n    for (const item of items) {\n      const value = item.props[field.fieldPath];\n      if (isValidEmbeddingValue(value)) {\n        rows.push({ nodeId: item.nodeId, embedding: value });\n      } else if (value === undefined) {\n        deletionIds.push(item.nodeId);\n      }\n    }\n\n    if (rows.length > 0) {\n      if (backend.upsertEmbeddingBatch === undefined) {\n        for (const row of rows) {\n          await backend.upsertEmbedding({\n            graphId,\n            nodeKind,\n            nodeId: row.nodeId,\n            fieldPath: field.fieldPath,\n            embedding: row.embedding,\n            dimensions: field.dimensions,\n            metric: field.metric,\n            indexType: field.indexType,\n          });\n        }\n      } else {\n        await backend.upsertEmbeddingBatch({\n          graphId,\n          nodeKind,\n          fieldPath: field.fieldPath,\n          dimensions: field.dimensions,\n          metric: field.metric,\n          indexType: field.indexType,\n          rows,\n        });\n      }\n    }\n\n    for (const nodeId of deletionIds) {\n      await backend.deleteEmbedding({\n        graphId,\n        nodeKind,\n        nodeId,\n        fieldPath: field.fieldPath,\n        dimensions: field.dimensions,\n        metric: field.metric,\n        indexType: field.indexType,\n      });\n    }\n  }\n}\n\n/**\n * Deletes a node's embeddings for the embedding fields its kind CURRENTLY\n * declares. A field dropped from the schema after the node was written is\n * intentionally NOT swept here — its entire per-field table is reclaimed\n * wholesale by `store.materializeRemovals()` (the deferred-cleanup verb), which\n * also covers live (never-deleted) nodes' rows. So a hard/soft delete can leave\n * a transient orphan row in a removed field's table until the next reclaim pass;\n * that is the deferred-cleanup design, not a leak.\n */\nexport async function deleteNodeEmbeddings(\n  ctx: EmbeddingSyncContext,\n  schema: z.ZodType,\n): Promise<void> {\n  const { backend } = ctx;\n\n  // Check if backend supports embedding operations\n  if (!backend.deleteEmbedding) {\n    return;\n  }\n\n  const embeddingFields = getEmbeddingFields(schema);\n  if (embeddingFields.length === 0) {\n    return;\n  }\n\n  for (const field of embeddingFields) {\n    await backend.deleteEmbedding({\n      graphId: ctx.graphId,\n      nodeKind: ctx.nodeKind,\n      nodeId: ctx.nodeId,\n      fieldPath: field.fieldPath,\n      dimensions: field.dimensions,\n      metric: field.metric,\n      indexType: field.indexType,\n    });\n  }\n}\n\n// ============================================================\n// Validation Helpers\n// ============================================================\n\n/**\n * Checks if a value is a valid embedding (array of numbers).\n */\nfunction isValidEmbeddingValue(value: unknown): value is readonly number[] {\n  if (!Array.isArray(value)) {\n    return false;\n  }\n  return value.every((n) => typeof n === \"number\" && Number.isFinite(n));\n}\n","/**\n * Keeps the fulltext index in sync with node data. One row per node:\n * the values of every `searchable()` field are concatenated (joined by\n * `\\n`) and stored as the indexed `content`, so a single FTS query can\n * match terms spanning multiple source fields — which a per-field\n * layout cannot, since FTS5 / Postgres MATCH require all terms in one\n * indexed document.\n *\n * Sync runs inline in the node-operation call path, so it inherits the\n * caller's transaction context.\n */\nimport { type z } from \"zod\";\n\nimport { type GraphBackend, type TransactionBackend } from \"../backend/types\";\nimport {\n  DEFAULT_SEARCHABLE_LANGUAGE,\n  getSearchableFields,\n  type SearchableFieldInfo,\n} from \"../core/searchable\";\n\nexport { getSearchableFields } from \"../core/searchable\";\n\nexport type FulltextSyncContext = Readonly<{\n  graphId: string;\n  nodeKind: string;\n  nodeId: string;\n  backend: GraphBackend | TransactionBackend;\n}>;\n\nconst FIELD_SEPARATOR = \"\\n\";\n\n/**\n * Picks a representative language when a node has searchable fields with\n * different language settings. Users who need true per-field\n * multilingual indexing should split the data across node kinds.\n */\nfunction resolveCombinedLanguage(\n  fields: readonly SearchableFieldInfo[],\n): string {\n  return fields[0]?.metadata.language ?? DEFAULT_SEARCHABLE_LANGUAGE;\n}\n\n/**\n * Computes the combined fulltext content for a node, or `undefined`\n * if the node has no non-empty searchable fields.\n *\n * Shared between `syncFulltext` (per-write) and `rebuildFulltextIndex`\n * (bulk) so the two never drift.\n */\nexport function computeFulltextContent(\n  schema: z.ZodType,\n  props: Record<string, unknown>,\n): { content: string; language: string } | undefined {\n  const searchableFields = getSearchableFields(schema);\n  if (searchableFields.length === 0) return undefined;\n\n  const parts: string[] = [];\n  for (const field of searchableFields) {\n    const value = props[field.fieldPath];\n    if (typeof value === \"string\" && value.length > 0) {\n      parts.push(value);\n    }\n  }\n  if (parts.length === 0) return undefined;\n\n  return {\n    content: parts.join(FIELD_SEPARATOR),\n    language: resolveCombinedLanguage(searchableFields),\n  };\n}\n\n/**\n * Syncs the fulltext index row after a node create or update.\n *\n * Concatenates the values of all searchable fields into a single content\n * string and upserts it. If every field is empty / undefined, deletes\n * any existing row for the node.\n */\nexport async function syncFulltext(\n  ctx: FulltextSyncContext,\n  schema: z.ZodType,\n  props: Record<string, unknown>,\n): Promise<void> {\n  const { backend } = ctx;\n\n  if (!backend.upsertFulltext || !backend.deleteFulltext) {\n    return;\n  }\n\n  // `computeFulltextContent` returns `undefined` both when the schema has\n  // no `searchable()` fields and when every value is empty — either case\n  // means the row should not exist. Delete any stale row only when the\n  // schema declares searchable fields (nothing to clean up otherwise).\n  const computed = computeFulltextContent(schema, props);\n  if (computed !== undefined) {\n    await backend.upsertFulltext({\n      graphId: ctx.graphId,\n      nodeKind: ctx.nodeKind,\n      nodeId: ctx.nodeId,\n      content: computed.content,\n      language: computed.language,\n    });\n    return;\n  }\n  if (getSearchableFields(schema).length === 0) return;\n  await backend.deleteFulltext({\n    graphId: ctx.graphId,\n    nodeKind: ctx.nodeKind,\n    nodeId: ctx.nodeId,\n  });\n}\n\n/**\n * Syncs the fulltext rows for a batch of same-kind node creates through\n * one `upsertFulltextBatch` call (falling back to per-row `upsertFulltext`\n * when the backend lacks the batch primitive). Mirrors `syncFulltext`\n * per row: computed content upserts, empty content deletes any stale row\n * when the schema declares searchable fields.\n */\nexport async function syncFulltextBatchForKind(\n  args: Readonly<{\n    graphId: string;\n    nodeKind: string;\n    backend: GraphBackend | TransactionBackend;\n  }>,\n  schema: z.ZodType,\n  items: readonly Readonly<{\n    nodeId: string;\n    props: Record<string, unknown>;\n  }>[],\n): Promise<void> {\n  const { graphId, nodeKind, backend } = args;\n  if (!backend.upsertFulltext || !backend.deleteFulltext) {\n    return;\n  }\n\n  const rows: { nodeId: string; content: string; language: string }[] = [];\n  const emptyContentIds: string[] = [];\n  const hasSearchableFields = getSearchableFields(schema).length > 0;\n  for (const item of items) {\n    const computed = computeFulltextContent(schema, item.props);\n    if (computed !== undefined) {\n      rows.push({\n        nodeId: item.nodeId,\n        content: computed.content,\n        language: computed.language,\n      });\n    } else if (hasSearchableFields) {\n      emptyContentIds.push(item.nodeId);\n    }\n  }\n\n  if (rows.length > 0) {\n    if (backend.upsertFulltextBatch === undefined) {\n      for (const row of rows) {\n        await backend.upsertFulltext({\n          graphId,\n          nodeKind,\n          nodeId: row.nodeId,\n          content: row.content,\n          language: row.language,\n        });\n      }\n    } else {\n      await backend.upsertFulltextBatch({ graphId, nodeKind, rows });\n    }\n  }\n\n  if (emptyContentIds.length > 0) {\n    if (backend.deleteFulltextBatch === undefined) {\n      for (const nodeId of emptyContentIds) {\n        await backend.deleteFulltext({ graphId, nodeKind, nodeId });\n      }\n    } else {\n      await backend.deleteFulltextBatch({\n        graphId,\n        nodeKind,\n        nodeIds: emptyContentIds,\n      });\n    }\n  }\n}\n\n/**\n * Deletes the fulltext row for a node.\n * Called on soft-delete; hard-delete is handled by the backend cascade.\n */\nexport async function deleteNodeFulltext(\n  ctx: FulltextSyncContext,\n  schema: z.ZodType,\n): Promise<void> {\n  const { backend } = ctx;\n\n  if (!backend.deleteFulltext) {\n    return;\n  }\n\n  if (getSearchableFields(schema).length === 0) {\n    return;\n  }\n\n  await backend.deleteFulltext({\n    graphId: ctx.graphId,\n    nodeKind: ctx.nodeKind,\n    nodeId: ctx.nodeId,\n  });\n}\n","/**\n * Constraint validation module.\n *\n * Provides validation functions for enforcing graph constraints:\n * - Uniqueness constraints on node properties\n * - Cardinality constraints on edges\n * - Endpoint type constraints on edges\n * - Disjointness constraints between node kinds\n */\n\n/**\n * Separator used between field values in composite unique keys.\n * Uses ASCII Record Separator (0x1E) — valid UTF-8 and safe for PostgreSQL\n * TEXT columns (unlike \\0 which PostgreSQL rejects).\n */\nconst UNIQUE_KEY_SEPARATOR = \"\\u001E\";\n\n/** Marker for undefined/null field values in unique keys. */\nconst UNIQUE_KEY_NULL_MARKER = \"\\u001F\"; // ASCII Unit Separator\nimport {\n  type Cardinality,\n  type Collation,\n  type EdgeRegistration,\n  type NullCheckOp,\n  type UniqueConstraint,\n  type UniquenessScope,\n} from \"../core/types\";\nimport {\n  CardinalityError,\n  DisjointError,\n  EndpointError,\n  UniquenessError,\n} from \"../errors\";\nimport { type KindRegistry } from \"../registry/kind-registry\";\nimport { isPresent } from \"../utils/presence\";\n\n// ============================================================\n// Uniqueness Validation\n// ============================================================\n\n/**\n * Computes the unique key for a node's uniqueness constraint.\n *\n * The key is built by concatenating the specified field values,\n * optionally normalized for case-insensitive comparison.\n */\nexport function computeUniqueKey(\n  props: Record<string, unknown>,\n  fields: readonly string[],\n  collation: Collation,\n): string {\n  const values = fields.map((field) => {\n    const value = props[field];\n    if (value === undefined || value === null) {\n      return UNIQUE_KEY_NULL_MARKER;\n    }\n    // Convert to string, handling primitives safely\n    const stringValue =\n      typeof value === \"string\" ? value\n      : typeof value === \"number\" || typeof value === \"boolean\" ?\n        value.toString()\n      : JSON.stringify(value);\n    return collation === \"caseInsensitive\" ?\n        stringValue.toLowerCase()\n      : stringValue;\n  });\n  return values.join(UNIQUE_KEY_SEPARATOR);\n}\n\n/**\n * Checks if a uniqueness constraint's where predicate passes.\n */\nexport function checkWherePredicate(\n  constraint: UniqueConstraint,\n  props: Record<string, unknown>,\n): boolean {\n  if (!constraint.where) {\n    return true; // No where clause, always applies\n  }\n\n  // Build predicate context\n  const predicateBuilder = buildPredicateContext(props);\n  const predicate = constraint.where(predicateBuilder);\n\n  // Evaluate predicate\n  return evaluatePredicate(predicate, props);\n}\n\ntype UniquePredicate = Readonly<{\n  __type: \"unique_predicate\";\n  field: string;\n  op: NullCheckOp;\n}>;\n\ntype PredicateContext = Readonly<\n  Record<\n    string,\n    Readonly<{\n      isNull: () => UniquePredicate;\n      isNotNull: () => UniquePredicate;\n    }>\n  >\n>;\n\n/**\n * Builds a predicate context for where clause evaluation.\n */\nfunction buildPredicateContext(\n  props: Record<string, unknown>,\n): PredicateContext {\n  const context: Record<\n    string,\n    { isNull: () => UniquePredicate; isNotNull: () => UniquePredicate }\n  > = {};\n\n  for (const key of Object.keys(props)) {\n    context[key] = {\n      isNull: () => ({\n        __type: \"unique_predicate\" as const,\n        field: key,\n        op: \"isNull\" as const,\n      }),\n      isNotNull: () => ({\n        __type: \"unique_predicate\" as const,\n        field: key,\n        op: \"isNotNull\" as const,\n      }),\n    };\n  }\n\n  return context;\n}\n\n/**\n * Evaluates a uniqueness predicate.\n */\nfunction evaluatePredicate(\n  predicate: unknown,\n  props: Record<string, unknown>,\n): boolean {\n  if (\n    typeof predicate !== \"object\" ||\n    predicate === null ||\n    !(\"__type\" in predicate)\n  ) {\n    return true;\n  }\n\n  const pred = predicate as {\n    __type: string;\n    field: string;\n    op: NullCheckOp;\n  };\n\n  if (pred.__type !== \"unique_predicate\") {\n    return true;\n  }\n\n  const value = props[pred.field];\n  if (pred.op === \"isNull\") {\n    return value === null || value === undefined;\n  }\n  return isPresent(value);\n}\n\n/**\n * Gets all kinds that should be checked for a uniqueness constraint.\n *\n * For \"kindWithSubClasses\" scope, includes the entire subclass hierarchy:\n * - The kind itself\n * - All ancestors (parent classes)\n * - All descendants of those ancestors (sibling classes)\n *\n * For \"kind\" scope, only the specific kind.\n */\nexport function getKindsForUniquenessCheck(\n  baseKind: string,\n  scope: UniquenessScope,\n  registry: KindRegistry,\n): readonly string[] {\n  if (scope === \"kind\") {\n    return [baseKind];\n  }\n\n  // Get the entire connected subclass hierarchy by finding the root ancestor\n  const root = findRootAncestor(baseKind, registry);\n\n  // Return the root and all its descendants (which includes baseKind and siblings)\n  return registry.expandSubClasses(root);\n}\n\n/**\n * Finds the topmost ancestor of a kind, or the kind itself if it has no ancestors.\n */\nfunction findRootAncestor(kind: string, registry: KindRegistry): string {\n  const ancestors = registry.getAncestors(kind);\n\n  if (ancestors.size === 0) {\n    return kind;\n  }\n\n  // Find an ancestor with no ancestors (the root)\n  for (const ancestor of ancestors) {\n    if (registry.getAncestors(ancestor).size === 0) {\n      return ancestor;\n    }\n  }\n\n  // If all ancestors have ancestors, recurse up\n  const firstAncestor = [...ancestors][0];\n  return firstAncestor ? findRootAncestor(firstAncestor, registry) : kind;\n}\n\n/**\n * Creates a uniqueness error.\n */\nexport function createUniquenessError(\n  constraintName: string,\n  kind: string,\n  existingId: string,\n  newId: string,\n  fields: readonly string[],\n): UniquenessError {\n  return new UniquenessError({\n    constraintName,\n    kind,\n    existingId,\n    newId,\n    fields: [...fields],\n  });\n}\n\n// ============================================================\n// Cardinality Validation\n// ============================================================\n\n/**\n * Checks if adding an edge would violate cardinality constraints.\n *\n * @param edgeKind - The edge kind being added\n * @param fromKind - The source node kind\n * @param fromId - The source node ID\n * @param cardinality - The cardinality constraint\n * @param existingEdgeCount - Number of existing edges of this kind from this source\n * @param hasActiveEdge - Whether there's an active (valid_to IS NULL) edge\n * @returns Error if violation, undefined if valid\n */\nexport function checkCardinality(\n  edgeKind: string,\n  fromKind: string,\n  fromId: string,\n  cardinality: Cardinality,\n  existingEdgeCount: number,\n  hasActiveEdge: boolean,\n): CardinalityError | undefined {\n  switch (cardinality) {\n    case \"many\": {\n      // No constraint\n      return undefined;\n    }\n    case \"one\": {\n      // At most one edge of this kind from any source node\n      if (existingEdgeCount > 0) {\n        return new CardinalityError({\n          edgeKind,\n          fromKind,\n          fromId,\n          cardinality: \"one\",\n          existingCount: existingEdgeCount,\n        });\n      }\n      return undefined;\n    }\n    case \"unique\": {\n      // unique is checked separately per (source, target) pair\n      return undefined;\n    }\n    case \"oneActive\": {\n      // At most one edge with valid_to IS NULL from any source\n      if (hasActiveEdge) {\n        return new CardinalityError({\n          edgeKind,\n          fromKind,\n          fromId,\n          cardinality: \"oneActive\",\n          existingCount: 1,\n        });\n      }\n      return undefined;\n    }\n  }\n}\n\n/**\n * Checks unique edge constraint (at most one edge between any source-target pair).\n */\nexport function checkUniqueEdge(\n  edgeKind: string,\n  fromKind: string,\n  fromId: string,\n  _toKind: string,\n  _toId: string,\n  existingCount: number,\n): CardinalityError | undefined {\n  if (existingCount > 0) {\n    return new CardinalityError({\n      edgeKind,\n      fromKind,\n      fromId,\n      cardinality: \"unique\",\n      existingCount,\n    });\n  }\n  return undefined;\n}\n\n// ============================================================\n// Endpoint Validation\n// ============================================================\n\n/**\n * Validates that an edge's endpoints are valid node kinds.\n */\nexport function validateEdgeEndpoints(\n  edgeKind: string,\n  fromKind: string,\n  toKind: string,\n  registration: EdgeRegistration,\n  registry: KindRegistry,\n): EndpointError | undefined {\n  // Check from kinds\n  const validFromKinds = registration.from.map((node) => node.kind);\n  if (!registry.isAssignableToAny(fromKind, validFromKinds)) {\n    return new EndpointError({\n      edgeKind,\n      endpoint: \"from\",\n      actualKind: fromKind,\n      expectedKinds: validFromKinds,\n    });\n  }\n\n  // Check to kinds\n  const validToKinds = registration.to.map((node) => node.kind);\n  if (!registry.isAssignableToAny(toKind, validToKinds)) {\n    return new EndpointError({\n      edgeKind,\n      endpoint: \"to\",\n      actualKind: toKind,\n      expectedKinds: validToKinds,\n    });\n  }\n\n  return undefined;\n}\n\n// ============================================================\n// Disjointness Validation\n// ============================================================\n\n/**\n * Checks if creating a node would violate disjointness constraints.\n *\n * @param nodeId - The node ID being created\n * @param nodeKind - The kind of the new node\n * @param existingKinds - Kinds of existing nodes with the same ID\n * @param registry - The kind registry for disjointness checks\n * @returns Error if disjoint violation, undefined if valid\n */\nexport function checkDisjointness(\n  nodeId: string,\n  nodeKind: string,\n  existingKinds: readonly string[],\n  registry: KindRegistry,\n): DisjointError | undefined {\n  for (const existingKind of existingKinds) {\n    if (registry.areDisjoint(nodeKind, existingKind)) {\n      return new DisjointError({\n        nodeId,\n        attemptedKind: nodeKind,\n        conflictingKind: existingKind,\n      });\n    }\n  }\n  return undefined;\n}\n\n/**\n * Gets all disjoint kinds for a given kind.\n */\nexport function getDisjointKinds(\n  kind: string,\n  registry: KindRegistry,\n): readonly string[] {\n  return registry.getDisjointKinds(kind);\n}\n","/**\n * Uniqueness Constraint Management\n *\n * Handles checking, inserting, updating, and deleting uniqueness constraint entries.\n */\nimport {\n  type GraphBackend,\n  type InsertUniqueParams,\n  type TransactionBackend,\n} from \"../backend/types\";\nimport {\n  checkWherePredicate,\n  computeUniqueKey,\n  getKindsForUniquenessCheck,\n} from \"../constraints\";\nimport { type UniqueConstraint } from \"../core/types\";\nimport { UniquenessError } from \"../errors\";\nimport { type KindRegistry } from \"../registry/kind-registry\";\n\n/**\n * Context for uniqueness operations.\n */\nexport type UniquenessContext = Readonly<{\n  graphId: string;\n  registry: KindRegistry;\n  backend: GraphBackend | TransactionBackend;\n}>;\n\n/** Builds a {@link UniquenessContext} — the one constructor every call site shares. */\nexport function createUniquenessContext(\n  graphId: string,\n  registry: KindRegistry,\n  backend: GraphBackend | TransactionBackend,\n): UniquenessContext {\n  return { graphId, registry, backend };\n}\n\n/**\n * Checks uniqueness constraints for a new or existing node.\n *\n * @throws ValidationError if any constraint is violated\n */\nexport async function checkUniquenessConstraints(\n  ctx: UniquenessContext,\n  kind: string,\n  id: string,\n  props: Record<string, unknown>,\n  constraints: readonly UniqueConstraint[],\n): Promise<void> {\n  for (const constraint of constraints) {\n    if (!checkWherePredicate(constraint, props)) {\n      continue;\n    }\n\n    const key = computeUniqueKey(\n      props,\n      constraint.fields,\n      constraint.collation,\n    );\n\n    const kindsToCheck = getKindsForUniquenessCheck(\n      kind,\n      constraint.scope,\n      ctx.registry,\n    );\n\n    for (const kindToCheck of kindsToCheck) {\n      const existing = await ctx.backend.checkUnique({\n        graphId: ctx.graphId,\n        nodeKind: kindToCheck,\n        constraintName: constraint.name,\n        key,\n      });\n\n      if (existing && existing.node_id !== id) {\n        throw new UniquenessError({\n          constraintName: constraint.name,\n          kind: kindToCheck,\n          existingId: existing.node_id,\n          newId: id,\n          fields: constraint.fields,\n        });\n      }\n    }\n  }\n}\n\n/**\n * Inserts uniqueness entries for a newly created node.\n */\nexport async function insertUniquenessEntries(\n  ctx: UniquenessContext,\n  kind: string,\n  id: string,\n  props: Record<string, unknown>,\n  constraints: readonly UniqueConstraint[],\n): Promise<void> {\n  for (const constraint of constraints) {\n    if (!checkWherePredicate(constraint, props)) {\n      continue;\n    }\n\n    const key = computeUniqueKey(\n      props,\n      constraint.fields,\n      constraint.collation,\n    );\n\n    await ctx.backend.insertUnique({\n      graphId: ctx.graphId,\n      nodeKind: kind,\n      constraintName: constraint.name,\n      key,\n      nodeId: id,\n      concreteKind: kind,\n    });\n  }\n}\n\n/**\n * Inserts uniqueness entries for a batch of newly created nodes through one\n * `insertUniqueBatch` call (falling back to per-entry `insertUnique` when\n * the backend lacks the batch primitive). Same conflict semantics as the\n * per-node path: the first entry whose key a different live node holds\n * throws `UniquenessError`.\n */\nexport async function insertUniquenessEntriesBatch(\n  ctx: UniquenessContext,\n  items: readonly Readonly<{\n    kind: string;\n    id: string;\n    props: Record<string, unknown>;\n    constraints: readonly UniqueConstraint[];\n  }>[],\n): Promise<void> {\n  const entries: InsertUniqueParams[] = [];\n  for (const item of items) {\n    for (const constraint of item.constraints) {\n      if (!checkWherePredicate(constraint, item.props)) {\n        continue;\n      }\n      entries.push({\n        graphId: ctx.graphId,\n        nodeKind: item.kind,\n        constraintName: constraint.name,\n        key: computeUniqueKey(\n          item.props,\n          constraint.fields,\n          constraint.collation,\n        ),\n        nodeId: item.id,\n        concreteKind: item.kind,\n      });\n    }\n  }\n  if (entries.length === 0) return;\n\n  if (ctx.backend.insertUniqueBatch !== undefined) {\n    await ctx.backend.insertUniqueBatch(entries);\n    return;\n  }\n  for (const entry of entries) {\n    await ctx.backend.insertUnique(entry);\n  }\n}\n\n/**\n * Deletes uniqueness entries for a node being deleted.\n */\nexport async function deleteUniquenessEntries(\n  ctx: UniquenessContext,\n  kind: string,\n  props: Record<string, unknown>,\n  constraints: readonly UniqueConstraint[],\n): Promise<void> {\n  for (const constraint of constraints) {\n    if (!checkWherePredicate(constraint, props)) {\n      continue;\n    }\n\n    const key = computeUniqueKey(\n      props,\n      constraint.fields,\n      constraint.collation,\n    );\n\n    await ctx.backend.deleteUnique({\n      graphId: ctx.graphId,\n      nodeKind: kind,\n      constraintName: constraint.name,\n      key,\n    });\n  }\n}\n\n/**\n * Updates uniqueness entries when a node's props change.\n * Handles cases where:\n * - Constraint now applies (wasn't before)\n * - Constraint no longer applies (was before)\n * - Key value changed\n *\n * @throws ValidationError if updated value violates a constraint\n */\nexport async function updateUniquenessEntries(\n  ctx: UniquenessContext,\n  kind: string,\n  id: string,\n  oldProps: Record<string, unknown>,\n  newProps: Record<string, unknown>,\n  constraints: readonly UniqueConstraint[],\n): Promise<void> {\n  // A single constraint's sidecar change, computed once every changed key has\n  // been proven free (pass 1) and applied only afterwards (pass 2). `oldKey`\n  // (undefined = nothing to release) is deleted; `newKey` (undefined = nothing\n  // to reserve) is inserted.\n  type PendingUniqueMutation = Readonly<{\n    constraintName: string;\n    oldKey: string | undefined;\n    newKey: string | undefined;\n  }>;\n\n  // Pass 1 — preflight EVERY changed constraint before mutating any sidecar. A\n  // node can carry several unique constraints; mutating them one at a time would\n  // let a later constraint's conflict throw AFTER earlier sidecars were already\n  // changed, and a caller that catches UniquenessError and still commits the\n  // transaction (e.g. importGraph's onConflict: \"update\", which reports the\n  // conflict per-row) would leave those earlier sidecars mutated while the row\n  // stays unchanged. Checking every new key first means the throw happens with\n  // zero writes. Checks are independent per `constraintName`, so a constraint's\n  // preflight is unaffected by the still-unapplied mutations of the others.\n  const pending: PendingUniqueMutation[] = [];\n  for (const constraint of constraints) {\n    const oldApplies = checkWherePredicate(constraint, oldProps);\n    const newApplies = checkWherePredicate(constraint, newProps);\n\n    const oldKey =\n      oldApplies ?\n        computeUniqueKey(oldProps, constraint.fields, constraint.collation)\n      : undefined;\n    const newKey =\n      newApplies ?\n        computeUniqueKey(newProps, constraint.fields, constraint.collation)\n      : undefined;\n\n    // No change - constraint didn't apply and still doesn't\n    if (!oldApplies && !newApplies) {\n      continue;\n    }\n\n    // Keys are the same and constraint still applies - nothing to do\n    if (oldApplies && newApplies && oldKey === newKey) {\n      continue;\n    }\n\n    // Check the new key for conflicts with OTHER nodes.\n    if (newApplies && newKey !== undefined) {\n      const kindsToCheck = getKindsForUniquenessCheck(\n        kind,\n        constraint.scope,\n        ctx.registry,\n      );\n\n      for (const kindToCheck of kindsToCheck) {\n        const existing = await ctx.backend.checkUnique({\n          graphId: ctx.graphId,\n          nodeKind: kindToCheck,\n          constraintName: constraint.name,\n          key: newKey,\n        });\n\n        if (existing && existing.node_id !== id) {\n          throw new UniquenessError({\n            constraintName: constraint.name,\n            kind: kindToCheck,\n            existingId: existing.node_id,\n            newId: id,\n            fields: constraint.fields,\n          });\n        }\n      }\n    }\n\n    pending.push({ constraintName: constraint.name, oldKey, newKey });\n  }\n\n  // Pass 2 — every changed key is proven free, so releasing the old entries and\n  // reserving the new ones can no longer fail on a duplicate mid-way. Release\n  // all before reserving all, so a value moving between this node's constraints\n  // is never transiently double-held.\n  for (const mutation of pending) {\n    if (mutation.oldKey !== undefined) {\n      await ctx.backend.deleteUnique({\n        graphId: ctx.graphId,\n        nodeKind: kind,\n        constraintName: mutation.constraintName,\n        key: mutation.oldKey,\n      });\n    }\n  }\n  for (const mutation of pending) {\n    if (mutation.newKey !== undefined) {\n      await ctx.backend.insertUnique({\n        graphId: ctx.graphId,\n        nodeKind: kind,\n        constraintName: mutation.constraintName,\n        key: mutation.newKey,\n        nodeId: id,\n        concreteKind: kind,\n      });\n    }\n  }\n}\n","/**\n * Composable node write steps — the integrity side effects that every node\n * mutation must apply, extracted so there is a single implementation instead of\n * one hand-stitched copy per write path.\n *\n * A node mutation is the core row write plus a fixed set of side effects:\n * uniqueness entries, embedding sync, fulltext sync, and — for deletes —\n * delete-behavior enforcement over connected edges. These steps are shared by\n * the canonical collection operations (create / update / delete) and by\n * provenance retraction, which drives the same close/reopen of a fact node's\n * currency but skips delete-behavior enforcement so every connected edge\n * survives for a later reopen.\n *\n * The steps assume they run inside a write transaction (see\n * {@link runInWriteTransaction}); they perform no transaction management of\n * their own.\n */\nimport { type z } from \"zod\";\n\nimport {\n  type GraphBackend,\n  type LiveNodeRow,\n  type NodeRow,\n  rowPropsToObject,\n  type TombstonedNodeRow,\n  type TransactionBackend,\n} from \"../../backend/types\";\nimport { type DeleteBehavior, type UniqueConstraint } from \"../../core/types\";\nimport { RestrictedDeleteError } from \"../../errors\";\nimport { type KindRegistry } from \"../../registry/kind-registry\";\nimport {\n  deleteNodeEmbeddings,\n  syncEmbeddings,\n  syncEmbeddingsBatchForKind,\n} from \"../embedding-sync\";\nimport {\n  deleteNodeFulltext,\n  syncFulltext,\n  syncFulltextBatchForKind,\n} from \"../fulltext-sync\";\nimport { type GraphWriteLock } from \"../recorded-capture/clock\";\nimport {\n  checkUniquenessConstraints,\n  createUniquenessContext,\n  deleteUniquenessEntries,\n  insertUniquenessEntries,\n  insertUniquenessEntriesBatch,\n  updateUniquenessEntries,\n} from \"../uniqueness\";\n\ntype Backend = GraphBackend | TransactionBackend;\n\n/**\n * The graph-scoped state the node write steps need. `lock` is compile-time\n * evidence that the per-graph write-lock discipline was satisfied BEFORE any\n * row work (see {@link GraphWriteLock}): the pipeline performs no locking of\n * its own, so requiring the token here makes \"sidecar write before lock\" a\n * type error at the call site instead of a lock-order inversion in review.\n */\nexport type NodeWriteContext = Readonly<{\n  graphId: string;\n  registry: KindRegistry;\n  lock: GraphWriteLock;\n}>;\n\n/** Builds a {@link NodeWriteContext} — the one constructor every call site shares. */\nexport function createNodeWriteContext(\n  graphId: string,\n  registry: KindRegistry,\n  lock: GraphWriteLock,\n): NodeWriteContext {\n  return { graphId, registry, lock };\n}\n\n/** Whether a delete removes the node (`hard`) or tombstones it (`soft`). */\ntype NodeDeleteMode = \"soft\" | \"hard\";\n\n/**\n * Tunes how a delete treats the node's connected edges.\n *\n * By default delete behavior is enforced: connected edges block a `restrict`\n * node and are removed under `cascade` / `disconnect`. Provenance retraction\n * passes `enforceDeleteBehavior: false` — closing a fact's currency is a\n * belief-status change, not a domain delete, so its edges neither block the\n * close nor get removed; they survive untouched so a later reopen is an exact\n * inverse.\n */\nexport type NodeDeletePolicy = Readonly<{\n  enforceDeleteBehavior: boolean;\n}>;\n\nfunction uniquenessContext(ctx: NodeWriteContext, backend: Backend) {\n  return createUniquenessContext(ctx.graphId, ctx.registry, backend);\n}\n\n/**\n * The `(graphId, nodeKind, nodeId, backend)` context shared by the embedding and\n * fulltext sync helpers — `EmbeddingSyncContext` and `FulltextSyncContext` are\n * structurally identical, so one builder serves both.\n */\nfunction nodeSyncContext(\n  ctx: NodeWriteContext,\n  kind: string,\n  id: string,\n  backend: Backend,\n) {\n  return { graphId: ctx.graphId, nodeKind: kind, nodeId: id, backend };\n}\n\n/**\n * Enforces a node's delete behavior against its connected edges: they block\n * the delete (`restrict`) or are removed alongside the node (`cascade` /\n * `disconnect`). Skipped entirely when the caller's {@link NodeDeletePolicy}\n * disables enforcement.\n */\nasync function enforceNodeDeleteBehavior(\n  ctx: NodeWriteContext,\n  args: Readonly<{\n    kind: string;\n    id: string;\n    mode: NodeDeleteMode;\n    onDelete: DeleteBehavior | undefined;\n  }>,\n  backend: Backend,\n  policy?: NodeDeletePolicy,\n): Promise<void> {\n  if (policy?.enforceDeleteBehavior === false) return;\n  const behavior = args.onDelete ?? \"restrict\";\n  const connectedEdges = await backend.findEdgesConnectedTo({\n    graphId: ctx.graphId,\n    nodeKind: args.kind,\n    nodeId: args.id,\n  });\n\n  if (connectedEdges.length === 0) return;\n\n  switch (behavior) {\n    case \"restrict\": {\n      throw new RestrictedDeleteError({\n        nodeKind: args.kind,\n        nodeId: args.id,\n        edgeCount: connectedEdges.length,\n        edgeKinds: [...new Set(connectedEdges.map((edge) => edge.kind))],\n      });\n    }\n\n    case \"cascade\":\n    case \"disconnect\": {\n      // Both behaviors remove connected edges. \"cascade\" signals intent to\n      // remove dependent data; \"disconnect\" signals intent to sever the\n      // relationship. The effect is identical because edges cannot exist\n      // without both endpoints. One batched statement per bind-budget\n      // chunk instead of one statement per edge; the per-edge loop remains\n      // for backends without the batch members.\n      const batchDelete =\n        args.mode === \"hard\" ?\n          backend.hardDeleteEdgesBatch\n        : backend.deleteEdgesBatch;\n      if (batchDelete !== undefined) {\n        await batchDelete.call(backend, {\n          graphId: ctx.graphId,\n          ids: connectedEdges.map((edge) => edge.id),\n        });\n        break;\n      }\n      for (const edge of connectedEdges) {\n        await (args.mode === \"hard\" ?\n          backend.hardDeleteEdge({ graphId: ctx.graphId, id: edge.id })\n        : backend.deleteEdge({ graphId: ctx.graphId, id: edge.id }));\n      }\n      break;\n    }\n  }\n}\n\n/**\n * Applies the side effects that follow a node insert: uniqueness entries, then\n * embedding and fulltext sync. Uniqueness has already been *checked* during\n * create preparation; this writes the entries.\n */\nexport async function applyNodeInsertSideEffects(\n  ctx: NodeWriteContext,\n  args: Readonly<{\n    kind: string;\n    id: string;\n    schema: z.ZodType;\n    props: Record<string, unknown>;\n    uniqueConstraints: readonly UniqueConstraint[];\n  }>,\n  backend: Backend,\n): Promise<void> {\n  await insertUniquenessEntries(\n    uniquenessContext(ctx, backend),\n    args.kind,\n    args.id,\n    args.props,\n    args.uniqueConstraints,\n  );\n  await Promise.all([\n    syncEmbeddings(\n      nodeSyncContext(ctx, args.kind, args.id, backend),\n      args.schema,\n      args.props,\n    ),\n    syncFulltext(\n      nodeSyncContext(ctx, args.kind, args.id, backend),\n      args.schema,\n      args.props,\n    ),\n  ]);\n}\n\n/**\n * Batched {@link applyNodeInsertSideEffects}: one uniqueness batch across\n * every item, then one embedding batch per (kind, field) and one fulltext\n * batch per kind — instead of the per-row statement fan the single-op path\n * issues. Ordering matches the single-op path (uniqueness first, then the\n * sync fans).\n */\nexport async function applyNodeInsertSideEffectsBatch(\n  ctx: NodeWriteContext,\n  items: readonly Readonly<{\n    kind: string;\n    id: string;\n    schema: z.ZodType;\n    props: Record<string, unknown>;\n    uniqueConstraints: readonly UniqueConstraint[];\n  }>[],\n  backend: Backend,\n): Promise<void> {\n  if (items.length === 0) return;\n\n  await insertUniquenessEntriesBatch(\n    uniquenessContext(ctx, backend),\n    items.map((item) => ({\n      kind: item.kind,\n      id: item.id,\n      props: item.props,\n      constraints: item.uniqueConstraints,\n    })),\n  );\n\n  interface KindGroup {\n    schema: z.ZodType;\n    rows: { nodeId: string; props: Record<string, unknown> }[];\n  }\n  const byKind = new Map<string, KindGroup>();\n  for (const item of items) {\n    const group = byKind.get(item.kind) ?? { schema: item.schema, rows: [] };\n    group.rows.push({ nodeId: item.id, props: item.props });\n    byKind.set(item.kind, group);\n  }\n\n  await Promise.all(\n    [...byKind.entries()].flatMap(([kind, group]) => {\n      const syncArguments = { graphId: ctx.graphId, nodeKind: kind, backend };\n      return [\n        syncEmbeddingsBatchForKind(syncArguments, group.schema, group.rows),\n        syncFulltextBatchForKind(syncArguments, group.schema, group.rows),\n      ];\n    }),\n  );\n}\n\nfunction parseRowProps(row: NodeRow): Record<string, unknown> {\n  return rowPropsToObject(row.props);\n}\n\n/**\n * The row a node update targets. A plain update runs live-row side effects\n * (uniqueness diff, embedding/fulltext sync), so it must be handed a\n * {@link LiveNodeRow}; only an explicit `clearDeleted: true` resurrecting\n * upsert may target a possibly-tombstoned row. Encoding the pairing as a\n * union makes \"live-row update pipeline on a tombstoned row\" a type error.\n */\nexport type NodeUpdateTarget =\n  | Readonly<{ existing: LiveNodeRow; clearDeleted?: false }>\n  | Readonly<{ existing: NodeRow; clearDeleted: true }>;\n\n/**\n * Applies a node update: uniqueness maintenance (diff-based for a live row;\n * check-and-reinsert for a resurrecting update, whose entries the soft delete\n * removed), the core row update, then embedding and fulltext sync. Returns\n * the updated row.\n */\nexport async function applyNodeUpdate(\n  ctx: NodeWriteContext,\n  args: Readonly<{\n    schema: z.ZodType;\n    validatedProps: Record<string, unknown>;\n    uniqueConstraints: readonly UniqueConstraint[];\n    validTo?: string;\n  }> &\n    NodeUpdateTarget,\n  backend: Backend,\n): Promise<NodeRow> {\n  const { kind, id } = args.existing;\n  if (args.existing.deleted_at === undefined) {\n    await updateUniquenessEntries(\n      uniquenessContext(ctx, backend),\n      kind,\n      id,\n      parseRowProps(args.existing),\n      args.validatedProps,\n      args.uniqueConstraints,\n    );\n  } else {\n    // Resurrecting update (clearDeleted on a tombstoned row): the soft delete\n    // already removed this node's uniqueness entries, so the diff-based path\n    // would skip an unchanged key entirely and the resurrected node would\n    // hold NO reservation — a later create could then silently duplicate the\n    // value. Re-check and re-insert for the new props instead, exactly as\n    // applyNodeResurrect does.\n    await checkUniquenessConstraints(\n      uniquenessContext(ctx, backend),\n      kind,\n      id,\n      args.validatedProps,\n      args.uniqueConstraints,\n    );\n    await insertUniquenessEntries(\n      uniquenessContext(ctx, backend),\n      kind,\n      id,\n      args.validatedProps,\n      args.uniqueConstraints,\n    );\n  }\n\n  const updateParams: {\n    graphId: string;\n    kind: string;\n    id: string;\n    props: Record<string, unknown>;\n    validTo?: string;\n    incrementVersion?: boolean;\n    clearDeleted?: boolean;\n  } = {\n    graphId: ctx.graphId,\n    kind,\n    id,\n    props: args.validatedProps,\n    incrementVersion: true,\n  };\n  if (args.validTo !== undefined) updateParams.validTo = args.validTo;\n  if (args.clearDeleted) updateParams.clearDeleted = true;\n\n  const row = await backend.updateNode(updateParams);\n\n  await Promise.all([\n    syncEmbeddings(\n      nodeSyncContext(ctx, kind, id, backend),\n      args.schema,\n      args.validatedProps,\n    ),\n    syncFulltext(\n      nodeSyncContext(ctx, kind, id, backend),\n      args.schema,\n      args.validatedProps,\n    ),\n  ]);\n\n  return row;\n}\n\n/**\n * Applies a node soft delete: delete-behavior enforcement, the tombstone\n * write, then removal of uniqueness entries, embeddings, and fulltext.\n * Requires a {@link LiveNodeRow}: deleting an already-tombstoned row would\n * re-run sidecar cleanup against entries the first delete already removed.\n */\nexport async function applyNodeSoftDelete(\n  ctx: NodeWriteContext,\n  args: Readonly<{\n    existing: LiveNodeRow;\n    schema: z.ZodType;\n    uniqueConstraints: readonly UniqueConstraint[];\n    onDelete: DeleteBehavior | undefined;\n  }>,\n  backend: Backend,\n  policy?: NodeDeletePolicy,\n): Promise<void> {\n  const { kind, id } = args.existing;\n  await enforceNodeDeleteBehavior(\n    ctx,\n    { kind, id, mode: \"soft\", onDelete: args.onDelete },\n    backend,\n    policy,\n  );\n  await backend.deleteNode({\n    graphId: ctx.graphId,\n    kind,\n    id,\n  });\n  await deleteUniquenessEntries(\n    uniquenessContext(ctx, backend),\n    kind,\n    parseRowProps(args.existing),\n    args.uniqueConstraints,\n  );\n  await deleteNodeEmbeddings(\n    nodeSyncContext(ctx, kind, id, backend),\n    args.schema,\n  );\n  await deleteNodeFulltext(\n    nodeSyncContext(ctx, kind, id, backend),\n    args.schema,\n  );\n}\n\n/**\n * Applies a node hard delete: delete-behavior enforcement, permanent removal,\n * then embedding cleanup. Uniqueness and fulltext rows are removed by the\n * backend's `hardDeleteNode` cascade; embeddings live in strategy-owned\n * per-`(kind, field)` tables the graph-agnostic cascade cannot reach, so they\n * are cleaned here.\n */\nexport async function applyNodeHardDelete(\n  ctx: NodeWriteContext,\n  args: Readonly<{\n    kind: string;\n    id: string;\n    schema: z.ZodType;\n    onDelete: DeleteBehavior | undefined;\n  }>,\n  backend: Backend,\n): Promise<void> {\n  await enforceNodeDeleteBehavior(\n    ctx,\n    { kind: args.kind, id: args.id, mode: \"hard\", onDelete: args.onDelete },\n    backend,\n  );\n  await backend.hardDeleteNode({\n    graphId: ctx.graphId,\n    kind: args.kind,\n    id: args.id,\n  });\n  await deleteNodeEmbeddings(\n    nodeSyncContext(ctx, args.kind, args.id, backend),\n    args.schema,\n  );\n}\n\n/**\n * Reopens a soft-deleted node with its stored props (no merge, no\n * re-validation): re-checks and re-inserts uniqueness entries (the delete\n * removed them), clears the tombstone, then re-syncs embeddings and fulltext.\n * Used by provenance to reinstate a fact whose currency is restored. Returns\n * the reopened row.\n *\n * @throws {UniquenessError} when a unique key the node held was taken by\n *   another node while it was tombstoned.\n */\nexport async function applyNodeResurrect(\n  ctx: NodeWriteContext,\n  args: Readonly<{\n    existing: TombstonedNodeRow;\n    schema: z.ZodType;\n    uniqueConstraints: readonly UniqueConstraint[];\n  }>,\n  backend: Backend,\n): Promise<NodeRow> {\n  const { kind, id } = args.existing;\n  const props = parseRowProps(args.existing);\n  await checkUniquenessConstraints(\n    uniquenessContext(ctx, backend),\n    kind,\n    id,\n    props,\n    args.uniqueConstraints,\n  );\n  await insertUniquenessEntries(\n    uniquenessContext(ctx, backend),\n    kind,\n    id,\n    props,\n    args.uniqueConstraints,\n  );\n  const row = await backend.updateNode({\n    graphId: ctx.graphId,\n    kind,\n    id,\n    props,\n    incrementVersion: true,\n    clearDeleted: true,\n  });\n  await Promise.all([\n    syncEmbeddings(nodeSyncContext(ctx, kind, id, backend), args.schema, props),\n    syncFulltext(nodeSyncContext(ctx, kind, id, backend), args.schema, props),\n  ]);\n  return row;\n}\n"]}

package/dist/{ddl-BrmPg61z.d.ts → ddl-C2rZ-Aen.d.ts}

@@ -1,6 +1,6 @@
-import { F as FulltextStrategy } from './types-D1Sqeyxy.js';
-import { P as PostgresTables } from './postgres-CWHLwNl1.js';
-import { S as SqliteTables } from './sqlite-CGu5SLsw.js';
+import { F as FulltextStrategy } from './fulltext-strategy-B57yvC5Q.js';
+import { P as PostgresTables } from './postgres-DQ5R6rzV.js';
+import { S as SqliteTables } from './sqlite-DvQndLky.js';
 
 /**
  * Generates all DDL statements for the given SQLite tables.
@@ -35,4 +35,4 @@ declare function generatePostgresDDL(tables?: PostgresTables, fulltextStrategy?:
  */
 declare function generatePostgresMigrationSQL(tables?: PostgresTables, fulltextStrategy?: FulltextStrategy): string;
 
-export { generateSqliteMigrationSQL as a, generatePostgresDDL as b, generatePostgresMigrationSQL as c, generateSqliteDDL as g };
+export { generatePostgresMigrationSQL as a, generateSqliteDDL as b, generateSqliteMigrationSQL as c, generatePostgresDDL as g };

package/dist/{ddl-j1-sH6lE.d.cts → ddl-CZz7a0E8.d.cts}

@@ -1,6 +1,6 @@
-import { F as FulltextStrategy } from './types-DkNnF-7K.cjs';
-import { P as PostgresTables } from './postgres-BhpxGMC5.cjs';
-import { S as SqliteTables } from './sqlite-XrDxNaa7.cjs';
+import { F as FulltextStrategy } from './fulltext-strategy-CDkSSYhq.cjs';
+import { P as PostgresTables } from './postgres-CfEqsRMp.cjs';
+import { S as SqliteTables } from './sqlite-D7zBinNR.cjs';
 
 /**
  * Generates all DDL statements for the given SQLite tables.
@@ -35,4 +35,4 @@ declare function generatePostgresDDL(tables?: PostgresTables, fulltextStrategy?:
  */
 declare function generatePostgresMigrationSQL(tables?: PostgresTables, fulltextStrategy?: FulltextStrategy): string;
 
-export { generateSqliteMigrationSQL as a, generatePostgresDDL as b, generatePostgresMigrationSQL as c, generateSqliteDDL as g };
+export { generatePostgresMigrationSQL as a, generateSqliteDDL as b, generateSqliteMigrationSQL as c, generatePostgresDDL as g };