@nicia-ai/typegraph 0.42.0 → 0.43.0

package/dist/chunk-EVFL2ZY5.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/store/types.ts","../src/store/runtime-port.ts","../src/query/compiler/temporal.ts","../src/query/subquery-utils.ts","../src/query/predicates.ts","../src/utils/id.ts","../src/store/recorded-capture/guards.ts","../src/store/recorded-capture/clock.ts","../src/backend/graph-backend-projection.ts","../src/store/insert-dispatch.ts","../src/query/compiler/predicates.ts","../src/query/compiler/predicate-utils.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/schema-version.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":["expr","qualifier","normalizeValueType","literal","pattern","left","opSql","arrayField","predicate","rows"],"mappings":"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","file":"chunk-EVFL2ZY5.js","sourcesContent":["/**\n * Store types for TypeGraph operations.\n */\nimport { type z } from \"zod\";\n\nimport {\n  type EdgeRow,\n  type NodeRow,\n  type TransactionBackend,\n  type TransactionReadBackend,\n} from \"../backend/types\";\nimport { type GraphDef } from \"../core/define-graph\";\nimport { type RecordedInstant } from \"../core/temporal\";\nimport {\n  type AnyEdgeType,\n  type EdgeId,\n  type EdgeRegistration,\n  type EdgeType,\n  type KindEntity,\n  type NodeId,\n  type NodeRegistration,\n  type NodeType,\n  type TemporalMode,\n} from \"../core/types\";\nimport type { TraversalExpansion } from \"../query/ast\";\nimport type { BatchableQuery, NodeAccessor } from \"../query/builder/types\";\nimport {\n  type ExternalRecordedReadSource,\n  type SqlSchema,\n} from \"../query/compiler/schema\";\nimport type { Predicate } from \"../query/predicates\";\nimport { typeGraphGlobalSymbol } from \"../utils/global-symbol\";\nimport type {\n  CURRENT_ONLY_READ_NAMES,\n  EDGE_BATCH_READ_NAMES,\n  EDGE_TEMPORAL_READ_NAMES,\n  EDGE_WRITE_NAMES,\n  NODE_TEMPORAL_READ_NAMES,\n  NODE_WRITE_NAMES,\n  RECORDED_POINT_READ_NAMES,\n} from \"./collection-surface\";\n\n// ============================================================\n// Row-to-Meta Field Mapping\n// ============================================================\n\n/**\n * Canonical mapping from snake_case row fields to camelCase meta fields.\n *\n * This is the single source of truth for which row columns become metadata.\n * Both the Meta types and the row-to-meta functions in row-mappers.ts must\n * stay in sync with this mapping. If you add a temporal/audit column to a\n * row type, add the mapping here — the compiler will then force you to\n * update the row mapper functions as well (since their return type is\n * NodeMeta/EdgeMeta, which is derived from this mapping).\n */\ntype TemporalMetaFieldMap = Readonly<{\n  valid_from: \"validFrom\";\n  valid_to: \"validTo\";\n  created_at: \"createdAt\";\n  updated_at: \"updatedAt\";\n  deleted_at: \"deletedAt\";\n}>;\n\n/**\n * Maps row fields to their camelCase meta counterparts, preserving types.\n */\ntype MapRowToMeta<\n  R extends Readonly<Record<string, unknown>>,\n  M extends Readonly<Record<string, string>>,\n> = Readonly<{\n  [SnakeKey in keyof M as M[SnakeKey] & string]: SnakeKey extends keyof R ?\n    R[SnakeKey]\n  : never;\n}>;\n\n// ============================================================\n// Node Instance Types\n// ============================================================\n\n/**\n * Metadata for a node instance.\n * Derived from NodeRow via TemporalMetaFieldMap + version.\n *\n * Adding a new metadata column requires:\n * 1. Add the column to NodeRow in backend/types.ts\n * 2. Add the mapping to TemporalMetaFieldMap above\n * 3. The compiler will error in rowToNodeMeta() until you add the field there\n */\nexport type NodeMeta = MapRowToMeta<NodeRow, TemporalMetaFieldMap> &\n  Readonly<{ version: NodeRow[\"version\"] }>;\n\n/**\n * A node instance in the graph.\n *\n * Properties from the schema are spread at the top level for ergonomic access:\n * - `node.name` instead of `node.props.name`\n * - System metadata is under `node.meta.*`\n */\nexport type Node<N extends NodeType = NodeType> = Readonly<{\n  kind: N[\"kind\"];\n  id: NodeId<N>;\n  meta: NodeMeta;\n}> &\n  Readonly<z.infer<N[\"schema\"]>>;\n\n/**\n * Input for creating a node.\n */\nexport type CreateNodeInput<N extends NodeType = NodeType> = Readonly<{\n  kind: N[\"kind\"];\n  id?: string; // Optional - will generate ULID if not provided\n  props: z.infer<N[\"schema\"]>;\n  validFrom?: string;\n  validTo?: string;\n}>;\n\n/**\n * Input for updating a node.\n */\nexport type UpdateNodeInput<N extends NodeType = NodeType> = Readonly<{\n  kind: N[\"kind\"];\n  id: NodeId<N>;\n  props: Partial<z.infer<N[\"schema\"]>>;\n  validTo?: string;\n}>;\n\n// ============================================================\n// Edge Instance Types\n// ============================================================\n\n/**\n * Metadata for an edge instance.\n * Derived from EdgeRow via TemporalMetaFieldMap (edges have no version).\n */\nexport type EdgeMeta = MapRowToMeta<EdgeRow, TemporalMetaFieldMap>;\n\n/**\n * An edge instance in the graph.\n *\n * Properties from the schema are spread at the top level for ergonomic access:\n * - `edge.role` instead of `edge.props.role`\n * - System metadata is under `edge.meta.*`\n */\nexport type Edge<\n  E extends AnyEdgeType = EdgeType,\n  From extends NodeType = NodeType,\n  To extends NodeType = NodeType,\n> = Readonly<{\n  id: EdgeId<E>;\n  kind: E[\"kind\"];\n  fromKind: From[\"kind\"];\n  fromId: NodeId<From>;\n  toKind: To[\"kind\"];\n  toId: NodeId<To>;\n  meta: EdgeMeta;\n}> &\n  Readonly<z.infer<E[\"schema\"]>>;\n\n/**\n * Input for creating an edge.\n */\nexport type CreateEdgeInput<E extends AnyEdgeType = EdgeType> = Readonly<{\n  kind: E[\"kind\"];\n  id?: string; // Optional - will generate ULID if not provided\n  fromKind: string;\n  fromId: string;\n  toKind: string;\n  toId: string;\n  props: z.infer<E[\"schema\"]>;\n  validFrom?: string;\n  validTo?: string;\n}>;\n\n/**\n * Input for updating an edge.\n */\nexport type UpdateEdgeInput<E extends AnyEdgeType = EdgeType> = Readonly<{\n  id: EdgeId<E>;\n  props: Partial<z.infer<E[\"schema\"]>>;\n  validTo?: string;\n}>;\n\n// ============================================================\n// Query Options\n// ============================================================\n\n/**\n * Options for node and edge queries.\n */\nexport type NoRecordedCoordinate = Readonly<{\n  /**\n   * Recorded/system-time coordinates are internal-only and supplied by\n   * RecordedStoreView. A public options object carrying this key is a type\n   * error even when the object is pre-bound before the call site.\n   */\n  recordedAsOf?: never;\n}>;\n\nexport type QueryOptions = NoRecordedCoordinate &\n  Readonly<{\n    /** Temporal mode for the query */\n    temporalMode?: TemporalMode;\n    /** Specific timestamp for asOf queries */\n    asOf?: string;\n  }>;\n\n// ============================================================\n// Observability Hooks\n// ============================================================\n\n/**\n * Context passed to observability hooks.\n */\nexport type HookContext = Readonly<{\n  /** Unique ID for this operation */\n  operationId: string;\n  /** Graph ID */\n  graphId: string;\n  /** Timestamp when operation started */\n  startedAt: Date;\n}>;\n\n/**\n * Query hook context with SQL information.\n */\nexport type QueryHookContext = HookContext &\n  Readonly<{\n    /** The SQL query being executed */\n    sql: string;\n    /** Query parameters */\n    params: readonly unknown[];\n  }>;\n\n/**\n * Operation hook context for CRUD operations.\n */\nexport type OperationHookContext = HookContext &\n  Readonly<{\n    /** Operation type */\n    operation: \"create\" | \"update\" | \"delete\";\n    /** Entity type */\n    entity: KindEntity;\n    /** Kind of node or edge */\n    kind: string;\n    /** Entity ID */\n    id: string;\n  }>;\n\n/**\n * Observability hooks for monitoring store operations.\n *\n * Note: Batch operations (`bulkCreate`, `bulkInsert`, `bulkUpsertById`) skip\n * per-item operation hooks for throughput. Query hooks still fire normally.\n *\n * @example\n * ```typescript\n * const hooks: StoreHooks = {\n *   onQueryStart: (ctx) => {\n *     console.log(`[${ctx.operationId}] Query: ${ctx.sql}`);\n *   },\n *   onQueryEnd: (ctx, result) => {\n *     const duration = Date.now() - ctx.startedAt.getTime();\n *     console.log(`[${ctx.operationId}] Completed in ${duration}ms`);\n *   },\n *   onError: (ctx, error) => {\n *     console.error(`[${ctx.operationId}] Error:`, error);\n *   },\n * };\n *\n * const store = createStore(graph, backend, { hooks });\n * ```\n */\nexport type StoreHooks = Readonly<{\n  /** Called before a query is executed */\n  onQueryStart?: (ctx: QueryHookContext) => void;\n  /** Called after a query completes successfully */\n  onQueryEnd?: (\n    ctx: QueryHookContext,\n    result: Readonly<{ rowCount: number; durationMs: number }>,\n  ) => void;\n  /** Called before a CRUD operation starts */\n  onOperationStart?: (ctx: OperationHookContext) => void;\n  /**\n   * Called after a CRUD operation completes AND is durably committed. For a\n   * top-level operation that is when its own transaction commits; for an\n   * operation inside `store.transaction`, emission is deferred until the\n   * enclosing transaction commits — if that commit fails, the operation is\n   * reported through `onError` instead. (Inside an adopted transaction —\n   * `withTransaction` / `withRecordedTransaction` — the commit belongs to\n   * the caller and cannot be observed, so this fires when the operation\n   * completes within the still-open transaction.)\n   */\n  onOperationEnd?: (\n    ctx: OperationHookContext,\n    result: Readonly<{ durationMs: number }>,\n  ) => void;\n  /**\n   * Called when an operation fails — including an operation that completed\n   * inside a `store.transaction` whose commit then failed and rolled it\n   * back.\n   */\n  onError?: (ctx: HookContext, error: Error) => void;\n}>;\n\n// ============================================================\n// Store Configuration\n// ============================================================\n\n/**\n * Default row count at which an autocommit bulk write triggers an\n * automatic planner-statistics refresh. Below this, the refresh cost is\n * not worth paying per call and autovacuum/PRAGMA optimize cover it.\n */\nexport const AUTO_REFRESH_STATISTICS_ROW_THRESHOLD = 1000;\n\nexport type BaseStoreOptions = Readonly<{\n  /** Observability hooks for monitoring */\n  hooks?: StoreHooks;\n  /**\n   * Maintain a durable, graph-wide revision anchor for TypeGraph writes:\n   * a random per-graph origin plus a monotonic revision clock. `branch()` uses\n   * this anchor to validate that its base has not moved without\n   * re-fingerprinting every live row, and cannot confuse a coincident clock in\n   * a separately created store for its original base. `history: true` enables\n   * the same tracking automatically through its recorded-time commit clock.\n   *\n   * This is intentionally opt-in for live stores: each successful graph write\n   * advances the anchor inside its write transaction. On PostgreSQL, those\n   * transactions take a graph-scoped advisory lock until commit; writes to the\n   * same graph therefore serialize. Enable it for branchable graphs, but size\n   * high-throughput multi-writer workloads for that trade-off.\n   *\n   * Writes performed directly through a backend — including raw graph-table\n   * writes through `tx.sql` — bypass the anchor and are outside the\n   * revision-tracking contract.\n   */\n  revisionTracking?: boolean;\n  /**\n   * Automatic planner-statistics refresh after large autocommit bulk\n   * writes (bulkCreate and bulkInsert on nodes and edges). Stale statistics after a\n   * bulk load are a whole class of planner cliffs: the planner keeps\n   * pre-load row estimates until ANALYZE runs. When a single\n   * autocommit bulk write reaches the threshold\n   * ({@link AUTO_REFRESH_STATISTICS_ROW_THRESHOLD} rows by default),\n   * the store runs `refreshStatistics()` after the write commits.\n   * Pass a number to change the threshold, or `false` to disable.\n   * Bulk writes inside a caller-provided transaction never\n   * auto-refresh (statistics cannot see uncommitted rows); refresh\n   * manually after commit. `importGraph` handles its own refresh.\n   */\n  autoRefreshStatistics?: false | number;\n  /**\n   * Skip the write for an `upsertById` (or `bulkUpsertById` item) whose\n   * validated props are value-identical to the existing live row. Default\n   * off.\n   *\n   * Enable this for at-least-once / replay materializers. An event log that\n   * re-delivers a byte-identical change would otherwise rewrite the row anyway:\n   * today an `upsertById` on an existing id calls `updateNode`\n   * unconditionally, allocating a fresh recorded instant and a new history row\n   * per re-delivery.\n   *\n   * The win is scoped to re-delivery of the **current** value. A full\n   * replay-from-zero over the current state still writes wherever the stream\n   * superseded a value in place: re-applying an older value over the live row\n   * is a genuine change (and restoring the current value afterwards is\n   * another), so only streams whose rows never supersede each other replay\n   * without churn. A rebuild that should avoid that re-walk belongs in a fresh\n   * store — replay into it and publish it, rather than re-applying the log\n   * over current state.\n   *\n   * When enabled, an upsert that would not change the stored value performs\n   * **no write at all**: no `updateNode`, no recorded-time capture, no history\n   * row, no revision-anchor advance, and no `update` operation hooks (nothing\n   * happened, so nothing is reported). It resolves with the **existing** node,\n   * preserving its original `validFrom` / `updatedAt` / `version`.\n   *\n   * Receipt shape is unchanged and needs no new signal: a coalesced upsert\n   * still counts as one write intent (`writes.total` includes it), but\n   * captures nothing (`receipt.recorded` stays `undefined` when it is the only\n   * write) — the same shape a no-op delete already produces, so a consumer\n   * that carries the prior anchor forward on `recorded === undefined` handles\n   * it unchanged.\n   *\n   * A write is coalesced only when **all** of the following hold; otherwise the\n   * normal write happens:\n   *   1. An existing row is found for the id (else it is a create).\n   *   2. That row is not soft-deleted (a deleted row resurrects — a real\n   *      change — and is never coalesced).\n   *   3. The caller passed no explicit `validFrom` / `validTo` (an explicit\n   *      temporal override is a deliberate request and is never coalesced;\n   *      applied per item in the bulk path).\n   *   4. The new props, merged over the stored props and run through the\n   *      kind's Zod schema (defaults applied, values normalized), are deeply\n   *      value-identical to the stored props (key order aside).\n   *\n   * Default-off because some consumers *want* an audit row per re-delivery as\n   * proof the event was reprocessed; coalescing removes that signal.\n   */\n  coalesceUnchangedUpserts?: boolean;\n  /** SQL schema configuration from createSqlSchema(...) for custom table names */\n  schema?: SqlSchema;\n  /** Query default behaviors. */\n  queryDefaults?: Readonly<{\n    /** Default traversal ontology expansion mode (default: \"inverse\"). */\n    traversalExpansion?: TraversalExpansion;\n  }>;\n}>;\n\n/**\n * Store options without built-in recorded-time capture. A recorded read relation\n * can still be bound explicitly for hosts that populate history externally.\n */\nexport type LiveStoreOptions = BaseStoreOptions &\n  Readonly<{\n    history?: false | undefined;\n    recordedRead?: ExternalRecordedReadSource | undefined;\n  }>;\n\n/** Live-store options that do not bind a recorded-read relation. */\nexport type UnboundLiveStoreOptions = LiveStoreOptions &\n  Readonly<{ recordedRead?: undefined }>;\n\n/** Live-store options with an explicitly bound recorded-read relation. */\nexport type RecordedReadStoreOptions = LiveStoreOptions &\n  Readonly<{\n    recordedRead: NonNullable<LiveStoreOptions[\"recordedRead\"]>;\n  }>;\n\n/**\n * Store options with TypeGraph-managed recorded-time capture. `history: true`\n * captures TypeGraph writes and binds TypeGraph's built-in recorded relation\n * internally. Externally populated recorded read sources are read-only bindings\n * and are intentionally accepted only by {@link LiveStoreOptions}.\n */\nexport type HistoryStoreOptions = BaseStoreOptions &\n  Readonly<{\n    history: true;\n    recordedRead?: never;\n  }>;\n\n/**\n * Options for creating a store.\n */\nexport type StoreOptions = LiveStoreOptions | HistoryStoreOptions;\n\n/**\n * A mutable handle to the current `Store`, used by `store.evolve(...)`\n * so long-lived consumers can dereference through the ref and pick up\n * the new store after each evolve call. `current` is overwritten by\n * `evolve()` atomically with the schema commit when the ref is passed\n * via `evolve(extension, { ref })`.\n *\n * **Mid-request semantics.** `ref.current` flips on the *next* call\n * after evolve, not mid-handler. Dereference once at request entry and\n * reuse the captured `Store` for the duration:\n *\n * ```ts\n * async function handleRequest(): Promise<void> {\n *   const store = ref.current; // capture once\n *   const tag = await store.nodes.Tag?.create({ label: \"...\" });\n *   // ...further work on the same `store`...\n * }\n * ```\n *\n * Pure dereferenceable handle — no event/subscription machinery. If\n * consumers need eventing, they wrap the ref themselves.\n *\n * Generic over the held value (typically `Store<G>`) so the store\n * module can refer to it without importing the `Store` class into\n * `types.ts`. The type parameter is deliberately invariant: evolution writes\n * a replacement into `current`, so a ref for an adapter-only or history-only\n * Store must never be accepted by a Store that cannot preserve that surface.\n */\nexport interface StoreRef<in out T> {\n  current: T;\n}\n\n// ============================================================\n// Transaction Receipt Types\n// ============================================================\n\n/**\n * Result plus write summary. Returned by `store.transactionWithReceipt(fn)`,\n * `store.withRecordedTransaction(externalTx, fn)` (the adopted-commit path), and\n * `tx.measure(fn)` (a scoped sub-receipt). See {@link TransactionReceipt}.\n */\nexport type TransactionOutcome<T> = Readonly<{\n  result: T;\n  receipt: TransactionReceipt;\n}>;\n\n/**\n * Transaction write summary.\n *\n * Receipt counts are completed write intents at the collection surface, not\n * rows affected:\n *\n * 1. Every successful completion of a write method on `tx.nodes.*` /\n *    `tx.edges.*` counts. The authoritative method list is\n *    {@link NodeWrites} / {@link EdgeWrites}.\n * 2. Bulk methods count by input length; an empty bulk call (`bulkCreate([])`)\n *    counts 0.\n * 3. Single-row methods count 1 on resolve — including `delete` of an absent\n *    id and `getOrCreate*` that found an existing row. Consumers that need\n *    \"did anything actually change\" semantics apply their own per-operation\n *    policy.\n * 4. A method that rejects counts 0 — even when the backend applied part of a\n *    bulk input before failing. On SQLite a failed statement does not abort\n *    the surrounding transaction, so a caller that catches the rejection and\n *    commits can persist rows the receipt never counted. Do not read the\n *    receipt as rows-affected in that scenario.\n * 5. A node `delete` under `cascade` / `disconnect` removes connected edges\n *    through the backend, not the edge-collection surface; those removals do\n *    not appear in `edges`.\n * 6. Rows-affected fidelity is intentionally out of scope for this first\n *    version; a future extension could ask backends to return row counts.\n */\nexport type TransactionReceipt = Readonly<{\n  writes: Readonly<{\n    /** Completed node write intents by node kind. */\n    nodes: Readonly<Record<string, number>>;\n    /** Completed edge write intents by edge kind. */\n    edges: Readonly<Record<string, number>>;\n    /** Sum of all node and edge write intents. */\n    total: number;\n  }>;\n  /**\n   * The recorded commit instant allocated for this store's graph by this\n   * transaction. Undefined when history capture is off, the transaction is\n   * read-only, or no captured writes were flushed. **Always undefined on a\n   * scoped receipt from {@link ScopedMeasure}** (`tx.measure`) — the recorded\n   * instant is a per-transaction flush concern allocated once when the whole\n   * transaction's capture flushes, unknowable mid-transaction.\n   */\n  recorded?: RecordedInstant;\n}>;\n\n// ============================================================\n// Get-Or-Create Types\n// ============================================================\n\n/**\n * Behavior when a get-or-create operation matches an existing record.\n */\nexport type IfExistsMode = \"return\" | \"update\";\n\n/**\n * Action taken by a get-or-create operation.\n */\nexport type GetOrCreateAction = \"created\" | \"found\" | \"updated\" | \"resurrected\";\n\n/**\n * Result of a node getOrCreateByConstraint operation.\n */\nexport type NodeGetOrCreateByConstraintResult<N extends NodeType> = Readonly<{\n  node: Node<N>;\n  action: GetOrCreateAction;\n}>;\n\n/**\n * Options for node getOrCreateByConstraint operations.\n */\nexport type NodeGetOrCreateByConstraintOptions = Readonly<{\n  /** Existing record behavior. Default: \"return\" */\n  ifExists?: IfExistsMode;\n}>;\n\n/**\n * Options for node bulkFindByIndex operations.\n */\nexport type NodeBulkFindByIndexOptions = Readonly<{\n  /**\n   * Maximum number of candidate nodes returned per input item. When omitted,\n   * each input's candidate set is unbounded. Must be a positive integer.\n   *\n   * Candidates are ordered deterministically by node id, so the cap is stable\n   * across calls. Use this to bound fan-out on low-selectivity index keys.\n   */\n  limitPerInput?: number;\n}>;\n\n/**\n * Result of an edge getOrCreateByEndpoints operation.\n */\nexport type EdgeGetOrCreateByEndpointsResult<\n  E extends AnyEdgeType,\n  From extends NodeType = NodeType,\n  To extends NodeType = NodeType,\n> = Readonly<{\n  edge: Edge<E, From, To>;\n  action: GetOrCreateAction;\n}>;\n\n/**\n * Options for edge findByEndpoints operations.\n */\nexport type EdgeFindByEndpointsOptions<E extends AnyEdgeType> = Readonly<{\n  /**\n   * Edge property fields to include in the match alongside the (from, to) endpoints.\n   * When omitted, matches on endpoints only (returns the first edge at the read coordinate).\n   */\n  matchOn?: readonly (keyof z.input<E[\"schema\"]>)[];\n  /** Property values to match against when matchOn is specified. */\n  props?: Partial<z.input<E[\"schema\"]>>;\n}>;\n\n/**\n * Options for edge getOrCreateByEndpoints operations.\n */\nexport type EdgeGetOrCreateByEndpointsOptions<E extends AnyEdgeType> =\n  Readonly<{\n    /**\n     * Edge property fields to include in the match key alongside the (from, to) endpoints.\n     * Default: `[]` — match on endpoints only.\n     */\n    matchOn?: readonly (keyof z.input<E[\"schema\"]>)[];\n    /** Existing record behavior. Default: \"return\" */\n    ifExists?: IfExistsMode;\n  }>;\n\n// ============================================================\n// Collection Interfaces\n// ============================================================\n\n/**\n * A collection of nodes of a specific type.\n *\n * Provides ergonomic CRUD operations for a single node type.\n */\nexport type NodeCollection<\n  N extends NodeType,\n  CN extends string = string,\n> = Readonly<{\n  /**\n   * Create a new node.\n   *\n   * `validFrom` defaults to the operation's creation timestamp when omitted.\n   */\n  create: (\n    props: z.input<N[\"schema\"]>,\n    options?: Readonly<{ id?: string; validFrom?: string; validTo?: string }>,\n  ) => Promise<Node<N>>;\n\n  /** Get a node by ID */\n  getById: (\n    id: NodeId<N>,\n    options?: QueryOptions,\n  ) => Promise<Node<N> | undefined>;\n\n  /** Get multiple nodes by ID, preserving input order (undefined for missing) */\n  getByIds: (\n    ids: readonly NodeId<N>[],\n    options?: QueryOptions,\n  ) => Promise<readonly (Node<N> | undefined)[]>;\n\n  /** Update a node */\n  update: (\n    id: NodeId<N>,\n    props: Partial<z.input<N[\"schema\"]>>,\n    options?: Readonly<{ validTo?: string }>,\n  ) => Promise<Node<N>>;\n\n  /** Delete a node (soft delete - sets deletedAt timestamp) */\n  delete: (id: NodeId<N>) => Promise<void>;\n\n  /**\n   * Permanently delete a node from the database.\n   *\n   * Unlike `delete()` which performs a soft delete, this permanently\n   * removes the node and its associated data (uniqueness entries, embeddings).\n   *\n   * **Warning:** This operation is irreversible and should be used carefully.\n   * Consider using soft delete (`delete()`) for most use cases.\n   *\n   * @throws Error if edges are still connected to this node (delete edges first)\n   */\n  hardDelete: (id: NodeId<N>) => Promise<void>;\n\n  /**\n   * Find nodes matching criteria.\n   *\n   * Supports predicate filtering via the `where` option for SQL-level filtering.\n   * For simple queries. Use store.query() for complex traversals.\n   */\n  find: (\n    filter?: Readonly<{\n      where?: (accessor: NodeAccessor<N>) => Predicate;\n      limit?: number;\n      offset?: number;\n    }>,\n    temporal?: QueryOptions,\n  ) => Promise<Node<N>[]>;\n\n  /** Count nodes matching criteria */\n  count: (temporal?: QueryOptions) => Promise<number>;\n\n  /**\n   * Create a node from untyped data, relying on runtime Zod validation.\n   *\n   * Use this for dynamic dispatch (changesets, migrations, imports) where\n   * the data shape is determined at runtime, not compile time.\n   * The return type is fully typed — only the input gate is relaxed.\n   *\n   * `validFrom` defaults to the operation's creation timestamp when omitted.\n   */\n  createFromRecord: (\n    data: Record<string, unknown>,\n    options?: Readonly<{ id?: string; validFrom?: string; validTo?: string }>,\n  ) => Promise<Node<N>>;\n\n  /**\n   * Create or update a node.\n   *\n   * If a node with the given ID exists, updates it with the provided props.\n   * Otherwise, creates a new node with that ID.\n   *\n   * `validFrom` only applies on the create branch, defaulting to the\n   * operation's creation timestamp when omitted; it has no effect on update.\n   */\n  upsertById: (\n    id: string,\n    props: z.input<N[\"schema\"]>,\n    options?: Readonly<{ validFrom?: string; validTo?: string }>,\n  ) => Promise<Node<N>>;\n\n  /**\n   * Upsert a node from untyped data, relying on runtime Zod validation.\n   *\n   * Use this for dynamic dispatch (changesets, migrations, imports) where\n   * the data shape is determined at runtime, not compile time.\n   * The return type is fully typed — only the input gate is relaxed.\n   *\n   * `validFrom` only applies on the create branch, defaulting to the\n   * operation's creation timestamp when omitted; it has no effect on update.\n   */\n  upsertByIdFromRecord: (\n    id: string,\n    data: Record<string, unknown>,\n    options?: Readonly<{ validFrom?: string; validTo?: string }>,\n  ) => Promise<Node<N>>;\n\n  /**\n   * Create multiple nodes in a batch.\n   *\n   * More efficient than calling create() multiple times.\n   * Use `bulkInsert` for the dedicated fast path that skips returning results.\n   *\n   * `validFrom` defaults to the operation's creation timestamp when omitted.\n   */\n  bulkCreate: (\n    items: readonly Readonly<{\n      props: z.input<N[\"schema\"]>;\n      id?: string;\n      validFrom?: string;\n      validTo?: string;\n    }>[],\n  ) => Promise<Node<N>[]>;\n\n  /**\n   * Create or update multiple nodes in a batch.\n   *\n   * For each item, if a node with the given ID exists, updates it.\n   * Otherwise, creates a new node with that ID.\n   *\n   * `validFrom` only applies on the create branch, defaulting to the\n   * operation's creation timestamp when omitted; it has no effect on update.\n   */\n  bulkUpsertById: (\n    items: readonly Readonly<{\n      id: string;\n      props: z.input<N[\"schema\"]>;\n      validFrom?: string;\n      validTo?: string;\n    }>[],\n  ) => Promise<Node<N>[]>;\n\n  /**\n   * Insert multiple nodes without returning results.\n   *\n   * This is the dedicated fast path for bulk inserts. Unlike `bulkCreate`\n   * with `returnResults: false`, the intent is unambiguous: no results\n   * are returned and the operation is wrapped in a transaction.\n   *\n   * `validFrom` defaults to the operation's creation timestamp when omitted.\n   */\n  bulkInsert: (\n    items: readonly Readonly<{\n      props: z.input<N[\"schema\"]>;\n      id?: string;\n      validFrom?: string;\n      validTo?: string;\n    }>[],\n  ) => Promise<void>;\n\n  /**\n   * Delete multiple nodes by ID.\n   *\n   * Atomic when the backend supports transactions. Silently ignores IDs\n   * that don't exist.\n   */\n  bulkDelete: (ids: readonly NodeId<N>[]) => Promise<void>;\n\n  /**\n   * Find a node by uniqueness constraint.\n   *\n   * Looks up a live node by the named constraint key computed from `props`.\n   * Returns the node if found, or undefined. Soft-deleted nodes are excluded.\n   *\n   * @param constraintName - Name of the uniqueness constraint to match on\n   * @param props - Properties to compute the constraint key from\n   */\n  findByConstraint: (\n    constraintName: CN,\n    props: z.input<N[\"schema\"]>,\n  ) => Promise<Node<N> | undefined>;\n\n  /**\n   * Batch version of findByConstraint.\n   *\n   * Results are returned in the same order as the input items.\n   * Returns undefined for entries that don't match.\n   */\n  bulkFindByConstraint: (\n    constraintName: CN,\n    items: readonly Readonly<{\n      props: z.input<N[\"schema\"]>;\n    }>[],\n  ) => Promise<(Node<N> | undefined)[]>;\n\n  /**\n   * Batched candidate retrieval against a declared node index.\n   *\n   * For each input item, TypeGraph computes the index lookup key from\n   * `index.fields` (JSON-pointer extraction, partial-`where` applied to\n   * stored rows, null-safe matching) and returns the live, non-soft-deleted\n   * nodes that share that key. Unlike {@link bulkFindByConstraint}, the index\n   * may be non-unique, so each input yields a (possibly empty) array.\n   *\n   * Results preserve input order; each inner array is ordered by node id.\n   * Empty input returns `[]`. An unknown index name throws\n   * `NodeIndexNotFoundError`; a type-incompatible indexed field throws\n   * `ValidationError`. This is candidate retrieval, not a uniqueness or\n   * identity guarantee.\n   *\n   * @param indexName - Name of the declared node index to match on\n   * @param items - Records whose `props` supply the indexed-field values\n   * @param options - Optional `limitPerInput` to bound per-input fan-out\n   */\n  bulkFindByIndex: (\n    indexName: string,\n    items: readonly Readonly<{\n      props: Partial<z.input<N[\"schema\"]>>;\n    }>[],\n    options?: NodeBulkFindByIndexOptions,\n  ) => Promise<readonly Node<N>[][]>;\n\n  /**\n   * Get an existing node by uniqueness constraint, or create a new one.\n   *\n   * Looks up a node by the named constraint key computed from `props`.\n   * If found, returns it (optionally updating with `ifExists: \"update\"`).\n   * If not found, creates a new node. Soft-deleted matches are always resurrected.\n   *\n   * @param constraintName - Name of the uniqueness constraint to match on\n   * @param props - Full properties for create, or merge source for update\n   * @param options - Existing record behavior (default: \"return\")\n   */\n  getOrCreateByConstraint: (\n    constraintName: CN,\n    props: z.input<N[\"schema\"]>,\n    options?: NodeGetOrCreateByConstraintOptions,\n  ) => Promise<NodeGetOrCreateByConstraintResult<N>>;\n\n  /**\n   * Batch version of getOrCreateByConstraint.\n   *\n   * Results are returned in the same order as the input items.\n   * Atomic when the backend supports transactions.\n   */\n  bulkGetOrCreateByConstraint: (\n    constraintName: CN,\n    items: readonly Readonly<{\n      props: z.input<N[\"schema\"]>;\n    }>[],\n    options?: NodeGetOrCreateByConstraintOptions,\n  ) => Promise<NodeGetOrCreateByConstraintResult<N>[]>;\n}>;\n\n/**\n * Reference to a node of a specific kind.\n *\n * Accepts either:\n * - A Node instance of the correct kind\n * - An explicit { kind, id } object with the correct kind name\n *\n * This provides compile-time checking that edge endpoints match the\n * allowed node kinds defined in the edge registration.\n */\nexport type NodeRef<N extends NodeType = NodeType> =\n  Node<N> | Readonly<{ kind: N[\"kind\"]; id: string }>;\n\n/**\n * Options for creating an edge.\n */\ntype EdgeCreateOptions = Readonly<{\n  id?: string;\n  validFrom?: string;\n  validTo?: string;\n}>;\n\n/**\n * Arguments for edge creation, with props optional when schema allows empty object.\n *\n * Uses `{}` to check if an empty object literal satisfies the schema input type.\n */\n/* eslint-disable @typescript-eslint/no-empty-object-type -- {} is intentional: checking if empty object satisfies schema */\ntype EdgeCreateArguments<E extends AnyEdgeType> =\n  {} extends z.input<E[\"schema\"]> ?\n    [props?: z.input<E[\"schema\"]>, options?: EdgeCreateOptions]\n  : [props: z.input<E[\"schema\"]>, options?: EdgeCreateOptions];\n/* eslint-enable @typescript-eslint/no-empty-object-type */\n\n/**\n * A collection of edges of a specific type.\n *\n * Provides ergonomic CRUD operations for a single edge type.\n * The From and To type parameters enforce that edge endpoints\n * match the allowed node types at compile time.\n *\n * @example\n * ```typescript\n * // Create an edge - pass Node objects directly\n * const edge = await store.edges.worksAt.create(alice, acme, { role: \"Engineer\" });\n *\n * // TypeScript error: Company is not a valid 'from' type for worksAt\n * // store.edges.worksAt.create(acme, alice, { role: \"Engineer\" });\n *\n * // For edges with empty schemas, props is optional\n * await store.edges.wrote.create(author, book);\n *\n * // Find edges from a node\n * const edges = await store.edges.worksAt.findFrom(alice);\n * ```\n */\nexport type EdgeCollection<\n  E extends AnyEdgeType,\n  From extends NodeType = NodeType,\n  To extends NodeType = NodeType,\n> = Readonly<{\n  /**\n   * Create a new edge.\n   *\n   * `validFrom` defaults to the operation's creation timestamp when omitted.\n   *\n   * @param from - Source node (must be one of the allowed 'from' types)\n   * @param to - Target node (must be one of the allowed 'to' types)\n   * @param args - Edge properties (optional if schema is empty) and creation options\n   */\n  create: (\n    from: NodeRef<From>,\n    to: NodeRef<To>,\n    ...args: EdgeCreateArguments<E>\n  ) => Promise<Edge<E, From, To>>;\n\n  /** Get an edge by ID */\n  getById: (\n    id: EdgeId<E>,\n    options?: QueryOptions,\n  ) => Promise<Edge<E, From, To> | undefined>;\n\n  /** Get multiple edges by ID, preserving input order (undefined for missing) */\n  getByIds: (\n    ids: readonly EdgeId<E>[],\n    options?: QueryOptions,\n  ) => Promise<readonly (Edge<E, From, To> | undefined)[]>;\n\n  /** Update an edge's properties */\n  update: (\n    id: EdgeId<E>,\n    props: Partial<z.input<E[\"schema\"]>>,\n    options?: Readonly<{ validTo?: string }>,\n  ) => Promise<Edge<E, From, To>>;\n\n  /**\n   * Find edges from a specific node.\n   *\n   * Honors the same temporal model as `getById` / `find`: with no\n   * `options`, the graph's default `temporalMode` applies (excluding\n   * soft-deleted edges and, in `current` / `asOf` modes, edges outside\n   * their validity window). Pass `temporalMode` / `asOf` to read the\n   * endpoint's edges at another temporal coordinate.\n   */\n  findFrom: (\n    from: NodeRef<From>,\n    options?: QueryOptions,\n  ) => Promise<Edge<E, From, To>[]>;\n\n  /**\n   * Find edges to a specific node.\n   *\n   * Temporal semantics mirror {@link EdgeCollection.findFrom}.\n   */\n  findTo: (\n    to: NodeRef<To>,\n    options?: QueryOptions,\n  ) => Promise<Edge<E, From, To>[]>;\n\n  /**\n   * Deferred variant of `findFrom` for use with `store.batch()`.\n   *\n   * Returns a `BatchableQuery` instead of executing immediately. Accepts\n   * the same temporal `options` as {@link EdgeCollection.findFrom}.\n   */\n  batchFindFrom: (\n    from: NodeRef<From>,\n    options?: QueryOptions,\n  ) => BatchableQuery<Edge<E, From, To>>;\n\n  /**\n   * Deferred variant of `findTo` for use with `store.batch()`.\n   *\n   * Returns a `BatchableQuery` instead of executing immediately. Accepts\n   * the same temporal `options` as {@link EdgeCollection.findTo}.\n   */\n  batchFindTo: (\n    to: NodeRef<To>,\n    options?: QueryOptions,\n  ) => BatchableQuery<Edge<E, From, To>>;\n\n  /**\n   * Deferred variant of `findByEndpoints` for use with `store.batch()`.\n   *\n   * Returns a `BatchableQuery` that yields a 0-or-1 element array\n   * (matching `findByEndpoints`' at-most-one semantics).\n   */\n  batchFindByEndpoints: (\n    from: NodeRef<From>,\n    to: NodeRef<To>,\n    options?: EdgeFindByEndpointsOptions<E>,\n    temporal?: QueryOptions,\n  ) => BatchableQuery<Edge<E, From, To>>;\n\n  /** Delete an edge (soft delete - sets deletedAt timestamp) */\n  delete: (id: EdgeId<E>) => Promise<void>;\n\n  /**\n   * Permanently delete an edge from the database.\n   *\n   * Unlike `delete()` which performs a soft delete, this permanently\n   * removes the edge record.\n   *\n   * **Warning:** This operation is irreversible and should be used carefully.\n   * Consider using soft delete (`delete()`) for most use cases.\n   */\n  hardDelete: (id: EdgeId<E>) => Promise<void>;\n\n  /** Find edges matching endpoint and pagination criteria */\n  find: (\n    filter?: Readonly<{\n      from?: NodeRef<From>;\n      to?: NodeRef<To>;\n      limit?: number;\n      offset?: number;\n    }>,\n    temporal?: QueryOptions,\n  ) => Promise<Edge<E, From, To>[]>;\n\n  /** Count edges matching criteria */\n  count: (\n    filter?: Readonly<{\n      from?: NodeRef<From>;\n      to?: NodeRef<To>;\n    }>,\n    temporal?: QueryOptions,\n  ) => Promise<number>;\n\n  /**\n   * Create multiple edges in a batch.\n   *\n   * More efficient than calling create() multiple times.\n   * Use `bulkInsert` for the dedicated fast path that skips returning results.\n   *\n   * `validFrom` defaults to the operation's creation timestamp when omitted.\n   */\n  bulkCreate: (\n    items: readonly Readonly<{\n      from: NodeRef<From>;\n      to: NodeRef<To>;\n      props?: z.input<E[\"schema\"]>;\n      id?: string;\n      validFrom?: string;\n      validTo?: string;\n    }>[],\n  ) => Promise<Edge<E, From, To>[]>;\n\n  /**\n   * Create or update multiple edges in a batch.\n   *\n   * For each item, if an edge with the given ID exists, updates it.\n   * Otherwise, creates a new edge with that ID.\n   *\n   * `validFrom` only applies on the create branch, defaulting to the\n   * operation's creation timestamp when omitted; it has no effect on update.\n   */\n  bulkUpsertById: (\n    items: readonly Readonly<{\n      id: EdgeId<E>;\n      from: NodeRef<From>;\n      to: NodeRef<To>;\n      props?: z.input<E[\"schema\"]>;\n      validFrom?: string;\n      validTo?: string;\n    }>[],\n  ) => Promise<Edge<E, From, To>[]>;\n\n  /**\n   * Insert multiple edges without returning results.\n   *\n   * This is the dedicated fast path for bulk inserts. Unlike `bulkCreate`\n   * with `returnResults: false`, the intent is unambiguous: no results\n   * are returned and the operation is wrapped in a transaction.\n   *\n   * `validFrom` defaults to the operation's creation timestamp when omitted.\n   */\n  bulkInsert: (\n    items: readonly Readonly<{\n      from: NodeRef<From>;\n      to: NodeRef<To>;\n      props?: z.input<E[\"schema\"]>;\n      id?: string;\n      validFrom?: string;\n      validTo?: string;\n    }>[],\n  ) => Promise<void>;\n\n  /**\n   * Delete multiple edges by ID.\n   *\n   * Atomic when the backend supports transactions. Silently ignores IDs\n   * that don't exist.\n   */\n  bulkDelete: (ids: readonly EdgeId<E>[]) => Promise<void>;\n\n  /**\n   * Find an edge by endpoints and optional property fields.\n   *\n   * Returns the first matching edge at the read coordinate, or undefined.\n   * Honors the temporal model like `findFrom` / `findTo`: by default\n   * (`current` mode) soft-deleted and out-of-window edges are excluded; under\n   * `includeTombstones` a soft-deleted edge can be returned.\n   *\n   * @param from - Source node\n   * @param to - Target node\n   * @param options - Match criteria (matchOn fields and property values)\n   * @param temporal - Temporal coordinate. With no `temporal`, the graph's\n   *   default `temporalMode` applies (so under the default `\"current\"` mode,\n   *   edges outside their validity window are excluded). Pass\n   *   `temporalMode` / `asOf` to read the edge as of another coordinate.\n   */\n  findByEndpoints: (\n    from: NodeRef<From>,\n    to: NodeRef<To>,\n    options?: EdgeFindByEndpointsOptions<E>,\n    temporal?: QueryOptions,\n  ) => Promise<Edge<E, From, To> | undefined>;\n\n  /**\n   * Get an existing edge by endpoints and optional property fields, or create a new one.\n   *\n   * Matches edges of this kind between `(from, to)`. When `matchOn` specifies\n   * property fields, only edges whose properties match on those fields are considered.\n   * Soft-deleted matches are resurrected when cardinality allows.\n   *\n   * @param from - Source node\n   * @param to - Target node\n   * @param props - Full properties for create, or merge source for update\n   * @param options - Match criteria and conflict resolution\n   */\n  getOrCreateByEndpoints: (\n    from: NodeRef<From>,\n    to: NodeRef<To>,\n    props: z.input<E[\"schema\"]>,\n    options?: EdgeGetOrCreateByEndpointsOptions<E>,\n  ) => Promise<EdgeGetOrCreateByEndpointsResult<E, From, To>>;\n\n  /**\n   * Batch version of getOrCreateByEndpoints.\n   *\n   * Results are returned in the same order as the input items.\n   * Atomic when the backend supports transactions.\n   */\n  bulkGetOrCreateByEndpoints: (\n    items: readonly Readonly<{\n      from: NodeRef<From>;\n      to: NodeRef<To>;\n      props: z.input<E[\"schema\"]>;\n    }>[],\n    options?: EdgeGetOrCreateByEndpointsOptions<E>,\n  ) => Promise<EdgeGetOrCreateByEndpointsResult<E, From, To>[]>;\n}>;\n\n// ============================================================\n// Type Helpers\n// ============================================================\n\n/**\n * Extract uniqueness constraint names from a NodeRegistration.\n *\n * - Returns `never` when no uniqueness constraints are configured.\n * - Returns a literal union when names are inferred via `defineGraph` const params.\n * - Falls back to `string` when names are widened/dynamic.\n */\nexport type ConstraintNames<R extends NodeRegistration> =\n  \"unique\" extends keyof R ?\n    R[\"unique\"] extends readonly { readonly name: infer N }[] ?\n      N & string\n    : string\n  : never;\n\n/**\n * Extract the union of 'from' node types from an EdgeRegistration.\n */\ntype EdgeFromTypes<R extends EdgeRegistration> =\n  R[\"from\"] extends readonly (infer N)[] ? N : never;\n\n/**\n * Extract the union of 'to' node types from an EdgeRegistration.\n */\ntype EdgeToTypes<R extends EdgeRegistration> =\n  R[\"to\"] extends readonly (infer N)[] ? N : never;\n\n/**\n * Create a type-safe EdgeCollection from an EdgeRegistration.\n * Extracts the edge type and from/to node types automatically.\n */\nexport type TypedEdgeCollection<R extends EdgeRegistration> = EdgeCollection<\n  R[\"type\"],\n  EdgeFromTypes<R> extends NodeType ? EdgeFromTypes<R> : NodeType,\n  EdgeToTypes<R> extends NodeType ? EdgeToTypes<R> : NodeType\n>;\n\n// ============================================================\n// Transaction Types\n// ============================================================\n\n// ============================================================\n// Graph Collection Maps\n// ============================================================\n\n/** Mapped type of all node collections for a graph. */\nexport type GraphNodeCollections<G extends GraphDef> = {\n  [K in keyof G[\"nodes\"] & string]-?: NodeCollection<\n    G[\"nodes\"][K][\"type\"],\n    ConstraintNames<G[\"nodes\"][K]>\n  >;\n};\n\n/** Mapped type of all edge collections for a graph. */\nexport type GraphEdgeCollections<G extends GraphDef> = {\n  [K in keyof G[\"edges\"] & string]-?: TypedEdgeCollection<G[\"edges\"][K]>;\n};\n\n// ============================================================\n// StoreView read-only collection surfaces\n// ============================================================\n\n/** Temporal-aware node reads — a {@link StoreView} pins these. */\nexport type NodeTemporalReads<\n  N extends NodeType,\n  CN extends string = string,\n> = Pick<NodeCollection<N, CN>, (typeof NODE_TEMPORAL_READ_NAMES)[number]>;\n\n/**\n * Current-state-only node reads (constraint / index lookups). No temporal\n * axis, so a {@link StoreView} delegates them on a `current` pin and refuses\n * them on a temporal pin.\n */\nexport type NodeCurrentReads<\n  N extends NodeType,\n  CN extends string = string,\n> = Pick<NodeCollection<N, CN>, (typeof CURRENT_ONLY_READ_NAMES)[number]>;\n\n/** Node writes — never available on a read-only {@link StoreView}. */\nexport type NodeWrites<N extends NodeType, CN extends string = string> = Pick<\n  NodeCollection<N, CN>,\n  (typeof NODE_WRITE_NAMES)[number]\n>;\n\n/** Temporal-aware edge reads — a {@link StoreView} pins these. */\nexport type EdgeTemporalReads<\n  E extends AnyEdgeType,\n  From extends NodeType = NodeType,\n  To extends NodeType = NodeType,\n> = Pick<\n  EdgeCollection<E, From, To>,\n  (typeof EDGE_TEMPORAL_READ_NAMES)[number]\n>;\n\n/**\n * Deferred edge reads for `store.batch()` — absent from a {@link StoreView},\n * which has no batch context.\n */\nexport type EdgeBatchReads<\n  E extends AnyEdgeType,\n  From extends NodeType = NodeType,\n  To extends NodeType = NodeType,\n> = Pick<EdgeCollection<E, From, To>, (typeof EDGE_BATCH_READ_NAMES)[number]>;\n\n/** Edge writes — never available on a read-only {@link StoreView}. */\nexport type EdgeWrites<\n  E extends AnyEdgeType,\n  From extends NodeType = NodeType,\n  To extends NodeType = NodeType,\n> = Pick<EdgeCollection<E, From, To>, (typeof EDGE_WRITE_NAMES)[number]>;\n\n/**\n * The read-only node surface a {@link StoreView} exposes for one node kind.\n * The temporal reads drop the per-call temporal argument — the pin owns the\n * axis; the current reads ({@link NodeCurrentReads}) are exposed as-is\n * (delegated on a `current` view, refused on a temporal pin). Writes live on\n * the live `Store`. The conformance test asserts the temporal part equals the\n * pinned form of {@link NodeTemporalReads}.\n */\nexport type StoreViewNodeCollection<\n  N extends NodeType,\n  CN extends string = string,\n> = Readonly<{\n  /** Get a node by ID at the view's pinned coordinate. */\n  getById: (id: NodeId<N>) => Promise<Node<N> | undefined>;\n\n  /** Get multiple nodes by ID, preserving input order (undefined for missing). */\n  getByIds: (\n    ids: readonly NodeId<N>[],\n  ) => Promise<readonly (Node<N> | undefined)[]>;\n\n  /** Find nodes matching criteria at the view's pinned coordinate. */\n  find: (\n    filter?: Readonly<{\n      where?: (accessor: NodeAccessor<N>) => Predicate;\n      limit?: number;\n      offset?: number;\n    }>,\n  ) => Promise<Node<N>[]>;\n\n  /** Count nodes at the view's pinned coordinate. */\n  count: () => Promise<number>;\n}> &\n  NodeCurrentReads<N, CN>;\n\n/**\n * The read-only edge surface a {@link StoreView} exposes for one edge\n * kind, mirroring {@link StoreViewNodeCollection}. Every edge read —\n * including `findByEndpoints` — honors the pin via the same temporal model,\n * so (unlike nodes) there are no current-state-only edge reads.\n */\nexport type StoreViewEdgeCollection<\n  E extends AnyEdgeType,\n  From extends NodeType = NodeType,\n  To extends NodeType = NodeType,\n> = Readonly<{\n  /** Get an edge by ID at the view's pinned coordinate. */\n  getById: (id: EdgeId<E>) => Promise<Edge<E, From, To> | undefined>;\n\n  /** Get multiple edges by ID, preserving input order (undefined for missing). */\n  getByIds: (\n    ids: readonly EdgeId<E>[],\n  ) => Promise<readonly (Edge<E, From, To> | undefined)[]>;\n\n  /** Find edges matching endpoint and pagination criteria. */\n  find: (\n    filter?: Readonly<{\n      from?: NodeRef<From>;\n      to?: NodeRef<To>;\n      limit?: number;\n      offset?: number;\n    }>,\n  ) => Promise<Edge<E, From, To>[]>;\n\n  /** Count edges matching criteria at the view's pinned coordinate. */\n  count: (\n    filter?: Readonly<{ from?: NodeRef<From>; to?: NodeRef<To> }>,\n  ) => Promise<number>;\n\n  /** Find edges from a specific node at the view's pinned coordinate. */\n  findFrom: (from: NodeRef<From>) => Promise<Edge<E, From, To>[]>;\n\n  /** Find edges to a specific node at the view's pinned coordinate. */\n  findTo: (to: NodeRef<To>) => Promise<Edge<E, From, To>[]>;\n\n  /** Find the edge between two endpoints at the view's pinned coordinate. */\n  findByEndpoints: (\n    from: NodeRef<From>,\n    to: NodeRef<To>,\n    options?: EdgeFindByEndpointsOptions<E>,\n  ) => Promise<Edge<E, From, To> | undefined>;\n}>;\n\n/**\n * Read-only view edge collection derived from an `EdgeRegistration`,\n * extracting the edge type and from/to node types — the read-only\n * counterpart of {@link TypedEdgeCollection}.\n */\nexport type TypedStoreViewEdgeCollection<R extends EdgeRegistration> =\n  StoreViewEdgeCollection<\n    R[\"type\"],\n    EdgeFromTypes<R> extends NodeType ? EdgeFromTypes<R> : NodeType,\n    EdgeToTypes<R> extends NodeType ? EdgeToTypes<R> : NodeType\n  >;\n\n/** Mapped type of all read-only view node collections for a graph. */\nexport type StoreViewNodeCollections<G extends GraphDef> = {\n  [K in keyof G[\"nodes\"] & string]-?: StoreViewNodeCollection<\n    G[\"nodes\"][K][\"type\"]\n  >;\n};\n\n/** Mapped type of all read-only view edge collections for a graph. */\nexport type StoreViewEdgeCollections<G extends GraphDef> = {\n  [K in keyof G[\"edges\"] & string]-?: TypedStoreViewEdgeCollection<\n    G[\"edges\"][K]\n  >;\n};\n\n/** Options for one bounded, forward-only recorded-time collection scan. */\nexport type RecordedScanOptions = Readonly<{\n  /** Maximum entities to return. Defaults to 1,000 and cannot exceed 1,000. */\n  limit?: number;\n  /** Opaque cursor returned by the preceding page. */\n  after?: string;\n}>;\n\n/** One page from a deterministic recorded-time collection scan. */\nexport type RecordedScanPage<T> = Readonly<{\n  /** Entities ordered by canonical id ascending. */\n  data: readonly T[];\n  /** Cursor for the next page, or `undefined` when the scan is complete. */\n  nextCursor: string | undefined;\n  /** Whether another page exists after this one. */\n  hasNextPage: boolean;\n}>;\n\n/** Recorded-time reconstructing reads for one node kind. */\nexport type RecordedStoreViewNodeCollection<N extends NodeType> = Pick<\n  StoreViewNodeCollection<N>,\n  (typeof RECORDED_POINT_READ_NAMES)[number]\n> &\n  Readonly<{\n    /** Scan one bounded page at the view's pinned coordinate. */\n    scan: (options?: RecordedScanOptions) => Promise<RecordedScanPage<Node<N>>>;\n  }>;\n\n/** Recorded-time reconstructing reads for one edge kind. */\nexport type RecordedStoreViewEdgeCollection<\n  E extends AnyEdgeType,\n  From extends NodeType = NodeType,\n  To extends NodeType = NodeType,\n> = Pick<\n  StoreViewEdgeCollection<E, From, To>,\n  (typeof RECORDED_POINT_READ_NAMES)[number]\n> &\n  Readonly<{\n    /** Scan one bounded page at the view's pinned coordinate. */\n    scan: (\n      options?: RecordedScanOptions,\n    ) => Promise<RecordedScanPage<Edge<E, From, To>>>;\n  }>;\n\n/** Recorded-time edge collection derived from an `EdgeRegistration`. */\nexport type TypedRecordedStoreViewEdgeCollection<R extends EdgeRegistration> =\n  RecordedStoreViewEdgeCollection<\n    R[\"type\"],\n    EdgeFromTypes<R> extends NodeType ? EdgeFromTypes<R> : NodeType,\n    EdgeToTypes<R> extends NodeType ? EdgeToTypes<R> : NodeType\n  >;\n\n/** Mapped type of all recorded-time node reconstructing-read collections. */\nexport type RecordedStoreViewNodeCollections<G extends GraphDef> = {\n  [K in keyof G[\"nodes\"] & string]-?: RecordedStoreViewNodeCollection<\n    G[\"nodes\"][K][\"type\"]\n  >;\n};\n\n/** Mapped type of all recorded-time edge reconstructing-read collections. */\nexport type RecordedStoreViewEdgeCollections<G extends GraphDef> = {\n  [K in keyof G[\"edges\"] & string]-?: TypedRecordedStoreViewEdgeCollection<\n    G[\"edges\"][K]\n  >;\n};\n\n// ============================================================\n// Transaction Context\n// ============================================================\n\n/**\n * Whether — and why — `tx.sql` can be used on a transaction context. A single\n * required discriminant covering exactly the four states raw-SQL access can be\n * in, so an adapter caller branches on capability instead of truthiness-testing\n * `tx.sql`. The non-available variants omit `sql` entirely, so even reading the\n * handle requires first narrowing `sqlAvailability` to `\"available\"`. The\n * runtime object keeps a fail-loud getter under history / revision tracking for\n * JavaScript and type-suppressed callers. See\n * {@link AdapterTransactionContext} for the per-value semantics.\n */\nexport type SqlAvailability =\n  \"available\" | \"history\" | \"revisionTracking\" | \"unavailable\";\n\ntype AdapterTransactionSqlAccess<TNativeTransaction> =\n  | Readonly<{\n      sql: TNativeTransaction;\n      sqlAvailability: \"available\";\n    }>\n  | Readonly<{\n      sqlAvailability: \"history\" | \"revisionTracking\";\n    }>\n  | Readonly<{\n      sqlAvailability: \"unavailable\";\n    }>;\n\nexport const TRANSACTION_RUNTIME: unique symbol = typeGraphGlobalSymbol(\n  \"transaction-runtime-v1\",\n);\n\ntype TransactionRuntime = Readonly<{\n  backend: TransactionBackend;\n  runNodeOperationHooks: <T>(\n    operation: \"create\" | \"update\" | \"delete\",\n    kind: string,\n    id: string,\n    fn: () => Promise<T>,\n  ) => Promise<T>;\n}>;\n\n/**\n * The portable transaction context mirrors the Store's typed graph operations\n * while exposing only a read-only backend projection bound to the transaction.\n * Adapter-native handles are available only through\n * {@link AdapterTransactionContext}; arbitrary backend writes are absent from\n * every public transaction context. TypeGraph's non-enumerable symbol port is\n * an unsupported implementation detail, not a JavaScript security boundary:\n * reflective code can still discover symbol properties.\n *\n * @example\n * ```typescript\n * await store.transaction(async (tx) => {\n *   const person = await tx.nodes.Person.create({ name: \"Alice\" });\n *   const company = await tx.nodes.Company.create({ name: \"Acme\" });\n *   await tx.edges.worksAt.create(person, company, { role: \"Engineer\" });\n * });\n * ```\n */\ntype TransactionCollections<G extends GraphDef> = Readonly<{\n  [TRANSACTION_RUNTIME]: TransactionRuntime;\n  nodes: GraphNodeCollections<G>;\n  edges: GraphEdgeCollections<G>;\n  /** Read-only backend projection bound to the same graph transaction. */\n  backend: TransactionReadBackend;\n  /**\n   * Runtime string-keyed node collection access, mirroring\n   * `Store.getNodeCollection`. Returns `undefined` when `kind` is not\n   * registered in this graph.\n   */\n  getNodeCollection: (kind: string) => DynamicNodeCollection | undefined;\n}>;\n\n/**\n * A portable transaction context containing only TypeGraph-owned graph\n * operations. Managed Stores use this surface so adapter-native handles never\n * enter their public contract.\n */\nexport type TransactionContext<G extends GraphDef> = TransactionCollections<G>;\n\n/**\n * A transaction context exposed by an {@link AdapterStore}. In addition to the\n * portable graph collections, it carries the adapter-native handle when that\n * capability is available. The TypeGraph backend remains the same runtime\n * read projection as the portable context; adapter-native writes intentionally\n * go through `sql`, making that escape hatch explicit.\n */\nexport type AdapterTransactionContext<\n  G extends GraphDef,\n  TNativeTransaction,\n> = TransactionCollections<G> & AdapterTransactionSqlAccess<TNativeTransaction>;\n\n/**\n * Scoped write measurement, available only on the receipt-enabled transaction\n * contexts (`transactionWithReceipt`, `withRecordedTransaction`). Runs `fn`,\n * passing it a **scoped context** — a second view over the same transaction — and\n * returns a {@link TransactionOutcome} whose receipt counts exactly the writes\n * made *through that scoped context* (`scoped.nodes` / `scoped.edges`).\n *\n * Attribution is by **which context you write through**, not by timing. A write\n * through the scoped context counts in both the scope and the outer receipt (it\n * happened in the transaction); a write through the outer `tx` during the scope\n * counts only in the outer receipt. This makes overlapping and concurrent\n * measures safe by construction — two scopes running under `Promise.all`, each\n * writing through its own scoped context, never cross-count. Nesting composes:\n * `scoped.measure(...)` opens a child scope that counts in itself, every\n * ancestor scope, and the outer receipt.\n *\n * Counts otherwise inherit {@link TransactionReceipt} (bulk by input length, a\n * rejected write counts 0). The returned receipt's `recorded` is **always\n * `undefined`**: the recorded commit instant is a per-transaction flush concern,\n * unknowable mid-transaction.\n */\nexport type ScopedMeasure<Context> = <T>(\n  fn: (scoped: Context) => Promise<T>,\n) => Promise<TransactionOutcome<T>>;\n\n/**\n * A {@link TransactionContext} that also exposes {@link ScopedMeasure}. Only the\n * receipt-enabled entry points (`transactionWithReceipt`,\n * `withRecordedTransaction`) hand a callback this type; plain `transaction()`\n * contexts have no recorder and therefore no `measure`, keeping that path\n * zero-overhead. Assignable to {@link TransactionContext}, so a projector helper\n * typed `(tx: TransactionContext<G>) => ...` accepts a measurable context. The\n * scoped context handed to `measure` is itself measurable, so scopes nest.\n */\nexport type MeasurableTransactionContext<G extends GraphDef> =\n  TransactionContext<G> &\n    Readonly<{\n      measure: ScopedMeasure<MeasurableTransactionContext<G>>;\n    }>;\n\n/** Receipt-enabled transaction context for an {@link AdapterStore}. */\nexport type MeasurableAdapterTransactionContext<\n  G extends GraphDef,\n  TNativeTransaction,\n> = AdapterTransactionContext<G, TNativeTransaction> &\n  Readonly<{\n    measure: ScopedMeasure<\n      MeasurableAdapterTransactionContext<G, TNativeTransaction>\n    >;\n  }>;\n\n// ============================================================\n// Dynamic Collection Types (widened for runtime dispatch)\n// ============================================================\n\n/**\n * Replace branded `NodeId` / `EdgeId` with plain `string` in each\n * method's parameter list. Return types are preserved unchanged.\n *\n * Handles three shapes:\n * 1. Direct branded ID parameter → `string`\n * 2. `readonly NodeId[]` / `readonly EdgeId[]` → `readonly string[]`\n * 3. Branded IDs nested one level inside bulk-item object arrays\n */\ntype WidenBrandedIds<T> = {\n  readonly [K in keyof T]: T[K] extends (...args: infer A) => infer R ?\n    (...args: { [P in keyof A]: UnbrandParam<A[P]> }) => R\n  : T[K];\n};\n\n/** Replace a branded ID with `string`, recursing one level into arrays. */\ntype UnbrandParam<T> =\n  T extends NodeId<NodeType> ? string\n  : T extends EdgeId<AnyEdgeType> ? string\n  : T extends readonly NodeId<NodeType>[] ? readonly string[]\n  : T extends readonly EdgeId<AnyEdgeType>[] ? readonly string[]\n  : T extends readonly (infer Item extends Record<string, unknown>)[] ?\n    readonly UnbrandRecord<Item>[]\n  : T;\n\n/** Replace branded ID values in object properties (does not recurse into nested structures). */\ntype UnbrandRecord<T extends Record<string, unknown>> = {\n  readonly [K in keyof T]: T[K] extends NodeId<NodeType> ? string\n  : T[K] extends EdgeId<AnyEdgeType> ? string\n  : T[K];\n};\n\n/**\n * A node collection with widened generics for runtime string-keyed access.\n *\n * This is the return type of `store.getNodeCollection(kind)`. It exposes\n * the full `NodeCollection` API but with `NodeType` and `string` constraint\n * names instead of the specific generic parameters, since the concrete type\n * is not known at compile time.\n *\n * ID parameters accept plain `string` instead of branded `NodeId<N>`, since\n * the dynamic path typically receives IDs from edge metadata, snapshots,\n * or external input where the brand is not available.\n */\nexport type DynamicNodeCollection = WidenBrandedIds<\n  NodeCollection<NodeType, string>\n>;\n\n/**\n * An edge collection with widened generics for runtime string-keyed access.\n *\n * This is the return type of `store.getEdgeCollection(kind)`. It exposes\n * the full `EdgeCollection` API but with `NodeType` endpoint types, since\n * the concrete from/to types are not known at compile time.\n *\n * ID parameters accept plain `string` instead of branded `EdgeId<E>`, since\n * the dynamic path typically receives IDs from edge metadata, snapshots,\n * or external input where the brand is not available.\n */\nexport type DynamicEdgeCollection = WidenBrandedIds<\n  EdgeCollection<AnyEdgeType, NodeType, NodeType>\n>;\n\n// ============================================================\n// Store Projection\n// ============================================================\n\n/**\n * A type-level projection of a store's surface onto a subset of its\n * node and edge collections.\n *\n * Node collections are projected with constraint names erased (`never`),\n * so constraint-based methods like `findByConstraint` become uncallable.\n * This is intentional: unique constraints are graph-registration-level\n * details that differ between graphs sharing the same node types.\n *\n * @example\n * ```typescript\n * type CoreStore = StoreProjection<\n *   typeof myGraph,\n *   \"Document\" | \"Chunk\",\n *   \"hasChunk\"\n * >;\n *\n * async function ingestChunk(\n *   store: CoreStore,\n *   document: Node<typeof Document>,\n *   text: string,\n * ) {\n *   const chunk = await store.nodes.Chunk.create({ text });\n *   await store.edges.hasChunk.create(document, chunk);\n *   return chunk;\n * }\n * ```\n *\n * Both `Store<G>` and `TransactionContext<G>` are structurally assignable\n * to a `StoreProjection` whose keys are a subset of `G`.\n */\nexport type StoreProjection<\n  G extends GraphDef,\n  N extends keyof G[\"nodes\"] & string = never,\n  E extends keyof G[\"edges\"] & string = never,\n> = Readonly<{\n  nodes: { [K in N]-?: NodeCollection<G[\"nodes\"][K][\"type\"], never> };\n  edges: Pick<GraphEdgeCollections<G>, E>;\n}>;\n","import { type GraphBackend, type TransactionBackend } from \"../backend/types\";\nimport {\n  type AllNodeTypes,\n  type EdgeKinds,\n  type GraphDef,\n  type NodeKinds,\n} from \"../core/define-graph\";\nimport { type ReadCoordinate } from \"../core/temporal\";\nimport {\n  type AnyEdgeType,\n  type EdgeId,\n  type NodeId,\n  type NodeType,\n} from \"../core/types\";\nimport { type InitialQueryBuilder } from \"../query/builder\";\nimport { typeGraphGlobalSymbol } from \"../utils/global-symbol\";\nimport { type InternalGraphAlgorithms } from \"./algorithms\";\nimport {\n  type InternalSubgraphOptions,\n  type SubgraphProject,\n  type SubgraphResult,\n} from \"./subgraph\";\nimport {\n  type Edge,\n  type Node,\n  type RecordedScanOptions,\n  type RecordedScanPage,\n  TRANSACTION_RUNTIME,\n} from \"./types\";\n\nexport const STORE_RUNTIME: unique symbol =\n  typeGraphGlobalSymbol(\"store-runtime-v1\");\n\n/**\n * @internal Operations used by Store-owned views. The port is absent from the\n * public Store contract and non-enumerable at runtime. JavaScript reflection\n * can still discover symbol properties, so this is an unsupported internal\n * surface rather than a security boundary.\n */\nexport type StoreRuntime<G extends GraphDef> = Readonly<{\n  backend: GraphBackend;\n  sealedQuery: (coordinate: ReadCoordinate) => InitialQueryBuilder<G, \"sealed\">;\n  recordedNodeGetById: <N extends NodeType>(\n    kind: string,\n    id: NodeId<N>,\n    coordinate: ReadCoordinate,\n  ) => Promise<Node<N> | undefined>;\n  recordedNodeGetByIds: <N extends NodeType>(\n    kind: string,\n    ids: readonly NodeId<N>[],\n    coordinate: ReadCoordinate,\n  ) => Promise<readonly (Node<N> | undefined)[]>;\n  recordedNodeScan: <N extends NodeType>(\n    kind: string,\n    coordinate: ReadCoordinate,\n    options?: RecordedScanOptions,\n  ) => Promise<RecordedScanPage<Node<N>>>;\n  recordedEdgeGetById: <E extends AnyEdgeType>(\n    kind: string,\n    id: EdgeId<E>,\n    coordinate: ReadCoordinate,\n  ) => Promise<Edge<E> | undefined>;\n  recordedEdgeGetByIds: <E extends AnyEdgeType>(\n    kind: string,\n    ids: readonly EdgeId<E>[],\n    coordinate: ReadCoordinate,\n  ) => Promise<readonly (Edge<E> | undefined)[]>;\n  recordedEdgeScan: <E extends AnyEdgeType>(\n    kind: string,\n    coordinate: ReadCoordinate,\n    options?: RecordedScanOptions,\n  ) => Promise<RecordedScanPage<Edge<E>>>;\n  subgraphAtCoordinate: <\n    const EK extends EdgeKinds<G>,\n    const NK extends NodeKinds<G> = NodeKinds<G>,\n    const P extends SubgraphProject<G, NK, EK> | undefined = undefined,\n  >(\n    rootId: NodeId<AllNodeTypes<G>>,\n    options: InternalSubgraphOptions<G, EK, NK, P>,\n  ) => Promise<SubgraphResult<G, NK, EK, P>>;\n  algorithmsAtCoordinate: (\n    coordinate: ReadCoordinate,\n  ) => InternalGraphAlgorithms<G>;\n}>;\n\nexport function storeRuntime<G extends GraphDef>(\n  store: Readonly<{ [STORE_RUNTIME]?: StoreRuntime<G> }>,\n): StoreRuntime<G> {\n  const runtime = store[STORE_RUNTIME];\n  if (runtime === undefined) {\n    throw new TypeError(\n      \"Cannot access this Store's runtime port. The Store may come from an incompatible TypeGraph version.\",\n    );\n  }\n  return runtime;\n}\n\nexport function storeBackend<G extends GraphDef>(\n  store: Readonly<{ [STORE_RUNTIME]?: StoreRuntime<G> }>,\n): GraphBackend {\n  return storeRuntime(store).backend;\n}\n\ntype TransactionRuntimePort = Readonly<{\n  [TRANSACTION_RUNTIME]?: Readonly<{\n    backend: TransactionBackend;\n    runNodeOperationHooks: TransactionNodeOperationHookRunner;\n  }>;\n}>;\n\ntype TransactionNodeOperationHookRunner = <T>(\n  operation: \"create\" | \"update\" | \"delete\",\n  kind: string,\n  id: string,\n  fn: () => Promise<T>,\n) => Promise<T>;\n\n/** Returns the full backend for privileged transaction-bound internals. */\nexport function transactionBackend(\n  transaction: TransactionRuntimePort,\n): TransactionBackend {\n  const runtime = transaction[TRANSACTION_RUNTIME];\n  if (runtime === undefined) {\n    throw new TypeError(\n      \"Cannot access this transaction's runtime port. The transaction may come from an incompatible TypeGraph version.\",\n    );\n  }\n  return runtime.backend;\n}\n\n/** Returns the hook runner paired with a transaction's internal backend. */\nexport function transactionNodeOperationHookRunner(\n  transaction: TransactionRuntimePort,\n): TransactionNodeOperationHookRunner {\n  const runtime = transaction[TRANSACTION_RUNTIME];\n  if (runtime === undefined) {\n    throw new TypeError(\n      \"Cannot access this transaction's runtime port. The transaction may come from an incompatible TypeGraph version.\",\n    );\n  }\n  return runtime.runNodeOperationHooks;\n}\n","/**\n * Temporal Filter Compilation\n *\n * Generates SQL clauses for temporal filtering based on valid_from/valid_to\n * and deleted_at timestamps. Consolidates the previously duplicated temporal\n * filter functions into a single, parameterized implementation.\n */\nimport { parseRecordedInstant } from \"../../core/temporal\";\nimport { type TemporalMode } from \"../../core/types\";\nimport { nowIso } from \"../../utils/date\";\nimport { sql, type SqlFragment } from \"../sql-fragment\";\n\n/**\n * The instant every `currentReadInstant()` inside {@link withPinnedReadInstant}\n * returns. Compilation is synchronous and single-threaded, so this dynamic\n * scope needs no async-context machinery: nothing can interleave between the\n * assignment and the `finally` that clears it.\n */\nlet pinnedReadInstant: string | undefined;\n\n/**\n * Compiles `emit` with one shared \"current\" instant.\n *\n * A set operation is a single statement whose operands are compiled\n * independently, so each operand would otherwise sample its own `nowIso()`.\n * Two instants microseconds apart mean the two halves of an `INTERSECT` or\n * `EXCEPT` disagree about whether a row created between them is current — the\n * one thing a compound SELECT, evaluated against one snapshot, must never do.\n *\n * Re-entrant: a nested set operation keeps the outer pin rather than resampling.\n */\nexport function withPinnedReadInstant<T>(emit: () => T): T {\n  if (pinnedReadInstant !== undefined) return emit();\n  pinnedReadInstant = nowIso();\n  try {\n    return emit();\n  } finally {\n    pinnedReadInstant = undefined;\n  }\n}\n\n/**\n * The \"current\" valid-time read instant, bound as a parameter — the\n * APPLICATION clock (`nowIso()`), NOT the database clock (`NOW()`).\n *\n * `valid_from` is stamped from the application clock on write, so a \"current\"\n * read must compare against the same clock. Comparing `valid_from` (app clock)\n * against the database `NOW()` would hide a freshly-created row from an\n * immediately-following current read whenever the app server's clock runs\n * ahead of the database server's clock — a read-after-write consistency\n * violation on Postgres (issue #242; SQLite is single-process so it was never\n * exposed). This binds the same clock the facade search-currency filter\n * (`liveNodeIdsSubquery`) and the recorded/logical clock already use, and the\n * same form the `asOf` predicate uses (a bound ISO instant), so it needs no\n * dialect-specific expression.\n *\n * Samples the clock per call unless a {@link withPinnedReadInstant} scope is\n * open, in which case every call in that scope binds the same instant.\n */\nexport function currentReadInstant(): SqlFragment {\n  return sql`${pinnedReadInstant ?? nowIso()}`;\n}\n\n/**\n * How a \"current\" valid-time read instant is emitted into compiled SQL:\n *\n * - `\"literal\"` — bound as a concrete value at compile time\n *   ({@link currentReadInstant}). The instant is frozen into the compiled\n *   statement, so the statement must be recompiled to observe a newer \"now\".\n * - `\"placeholder\"` — bound as a reserved execution-time placeholder\n *   ({@link currentReadInstantPlaceholder}). The statement can be compiled\n *   once and reused across executions, filling a fresh instant each call.\n *\n * Defaults to `\"literal\"` everywhere except the query builder's compiled\n * template cache, which opts into `\"placeholder\"` so a reused/prepared query\n * never freezes \"now\" the way a cached literal would (the #246 regression).\n */\nexport type ReadInstantMode = \"literal\" | \"placeholder\";\n\n/**\n * Reserved Drizzle placeholder name for the \"current\" valid-time read instant.\n * The query builder's template cache fills it with a fresh application-clock\n * value on every execution. The `__typegraph_` prefix keeps it disjoint from\n * every user `param()` name.\n */\nexport const CURRENT_READ_INSTANT_PLACEHOLDER =\n  \"__typegraph_current_read_instant__\";\n\n/**\n * The \"current\" read instant as a reserved execution-time placeholder rather\n * than a frozen value. Compiles to the same SQL text as\n * {@link currentReadInstant} (a bound parameter), but leaves the value unbound\n * so one compiled statement can be reused across executions with a fresh\n * instant filled in per call. See {@link CURRENT_READ_INSTANT_PLACEHOLDER}.\n */\nfunction currentReadInstantPlaceholder(): SqlFragment {\n  return sql`${sql.placeholder(CURRENT_READ_INSTANT_PLACEHOLDER)}`;\n}\n\n/** Emits the \"current\" read instant for the requested {@link ReadInstantMode}. */\nexport function currentReadInstantFor(mode: ReadInstantMode): SqlFragment {\n  return mode === \"placeholder\" ?\n      currentReadInstantPlaceholder()\n    : currentReadInstant();\n}\n\n/**\n * Temporal filter options.\n */\nexport type TemporalFilterOptions = Readonly<{\n  /** The temporal mode to apply */\n  mode: TemporalMode;\n  /** Timestamp for asOf queries (required when mode is \"asOf\") */\n  asOf?: string | undefined;\n  /** Optional table alias prefix for column references */\n  tableAlias?: string | undefined;\n  /** Optional execution-time current timestamp SQL expression */\n  currentTimestamp?: SqlFragment | undefined;\n  /** Recorded/system-time timestamp for recorded-pinned reads. */\n  recordedAsOf?: string | undefined;\n}>;\n\n/**\n * Compiles a temporal filter to SQL.\n *\n * This is the unified temporal filter function that handles all temporal modes\n * and optional table alias prefixes. It replaces the previous three separate\n * functions (compileTemporalFilter, compileEdgeTemporalFilter, compileNodeTemporalFilter).\n *\n * @param options - Temporal filter configuration\n * @returns `SqlFragment` for the temporal filter\n *\n * @example\n * ```typescript\n * // Without table alias (for CTEs)\n * compileTemporalFilter({ mode: \"current\" })\n * // → deleted_at IS NULL AND (valid_from IS NULL OR ...) AND ...\n *\n * // With table alias (for JOINs)\n * compileTemporalFilter({ mode: \"current\", tableAlias: \"e\" })\n * // → e.deleted_at IS NULL AND (e.valid_from IS NULL OR ...) AND ...\n *\n * // AsOf mode\n * compileTemporalFilter({ mode: \"asOf\", asOf: \"2024-01-01T00:00:00.000Z\" })\n * // → deleted_at IS NULL AND (valid_from IS NULL OR valid_from <= '2024-01-01...') AND ...\n * ```\n */\nexport function compileTemporalFilter(\n  options: TemporalFilterOptions,\n): SqlFragment {\n  const { mode, asOf, tableAlias, currentTimestamp, recordedAsOf } = options;\n\n  // Build column references with optional prefix\n  const prefix = tableAlias ? sql.raw(`${tableAlias}.`) : sql.raw(\"\");\n  const deletedAt = sql`${prefix}deleted_at`;\n  const validFrom = sql`${prefix}valid_from`;\n  const validTo = sql`${prefix}valid_to`;\n\n  const validFilter = (() => {\n    switch (mode) {\n      case \"current\": {\n        // When pinned to a recorded instant, \"current\" valid-time means\n        // valid-current *as of that recorded instant* — not the wall clock at\n        // read time. Pinning here collapses\n        // view({mode:'current'}).asOfRecorded(rt) to the diagonal\n        // store.asOfRecorded(rt) and stops silently dropping rows that were\n        // valid-current when recorded but ended before the read.\n        const now =\n          recordedAsOf === undefined ?\n            (currentTimestamp ?? currentReadInstant())\n          : sql`${parseRecordedInstant(recordedAsOf, \"recordedAsOf\").recordedAt}`;\n        return sql`${deletedAt} IS NULL AND (${validFrom} IS NULL OR ${validFrom} <= ${now}) AND (${validTo} IS NULL OR ${validTo} > ${now})`;\n      }\n\n      case \"asOf\": {\n        if (asOf === undefined) {\n          throw new Error(\n            `asOf timestamp is required for temporal mode \"asOf\"`,\n          );\n        }\n        const timestamp = asOf;\n        return sql`${deletedAt} IS NULL AND (${validFrom} IS NULL OR ${validFrom} <= ${timestamp}) AND (${validTo} IS NULL OR ${validTo} > ${timestamp})`;\n      }\n\n      case \"includeEnded\": {\n        // Include records that have ended but not been deleted\n        return sql`${deletedAt} IS NULL`;\n      }\n\n      case \"includeTombstones\": {\n        // Include everything, no filter\n        return sql.raw(\"1=1\");\n      }\n    }\n  })();\n\n  if (recordedAsOf === undefined) return validFilter;\n\n  const recordedFrom = sql`${prefix}recorded_from`;\n  const recordedTo = sql`${prefix}recorded_to`;\n  const recordedRevision = parseRecordedInstant(\n    recordedAsOf,\n    \"recordedAsOf\",\n  ).revision;\n  return sql`(${validFilter}) AND ${recordedFrom} <= ${recordedRevision} AND ${recordedRevision} < ${recordedTo}`;\n}\n\n/**\n * Extracts temporal options from a query AST.\n *\n * @param ast - Query AST with temporalMode\n * @param tableAlias - Optional table alias for column references\n * @returns TemporalFilterOptions for use with compileTemporalFilter\n */\nexport function extractTemporalOptions(\n  ast: {\n    temporalMode: { mode: TemporalMode; asOf?: string };\n    recordedAsOf?: string;\n  },\n  tableAlias?: string,\n): TemporalFilterOptions {\n  return {\n    mode: ast.temporalMode.mode,\n    asOf: ast.temporalMode.asOf,\n    recordedAsOf: ast.recordedAsOf,\n    tableAlias,\n  };\n}\n","/**\n * Shared utilities for subquery projection shape and type handling.\n */\nimport { type AggregateExpr, type QueryAst, type ValueType } from \"./ast\";\n\n/**\n * Normalizes a value type by treating \"unknown\" as undefined.\n */\nfunction normalizeValueType(valueType?: ValueType): ValueType | undefined {\n  if (valueType === undefined || valueType === \"unknown\") {\n    return undefined;\n  }\n  return valueType;\n}\n\n/**\n * Returns true when the type cannot be compared with IN/NOT IN.\n */\nexport function isUnsupportedInSubqueryValueType(\n  valueType?: ValueType,\n): boolean {\n  const normalized = normalizeValueType(valueType);\n  return (\n    normalized === \"array\" ||\n    normalized === \"object\" ||\n    normalized === \"embedding\"\n  );\n}\n\n/**\n * Returns true when two value types are compatible for IN/NOT IN.\n *\n * Unknown types are treated as compatible (deferred to runtime) to preserve\n * flexibility for untyped fields.\n */\nexport function isInSubqueryTypeCompatible(\n  left?: ValueType,\n  right?: ValueType,\n): boolean {\n  const normalizedLeft = normalizeValueType(left);\n  const normalizedRight = normalizeValueType(right);\n\n  if (normalizedLeft === undefined || normalizedRight === undefined) {\n    return true;\n  }\n\n  return normalizedLeft === normalizedRight;\n}\n\n/**\n * Resolves the value type produced by an aggregate projection.\n */\nfunction getAggregateValueType(\n  aggregate: AggregateExpr,\n): ValueType | undefined {\n  switch (aggregate.function) {\n    case \"count\":\n    case \"countDistinct\":\n    case \"sum\":\n    case \"avg\": {\n      return \"number\";\n    }\n    case \"min\":\n    case \"max\": {\n      return normalizeValueType(aggregate.field.valueType);\n    }\n  }\n}\n\n/**\n * Returns effective projected column value types for a subquery.\n *\n * If selective fields are present, they represent the effective projection.\n * Otherwise, falls back to the explicit projection fields.\n */\nfunction getProjectedValueTypes(\n  subquery: QueryAst,\n): readonly (ValueType | undefined)[] {\n  if (subquery.selectiveFields && subquery.selectiveFields.length > 0) {\n    return subquery.selectiveFields.map((field) =>\n      normalizeValueType(field.valueType),\n    );\n  }\n\n  return subquery.projection.fields.map((field) => {\n    if (field.source.__type === \"aggregate\") {\n      return getAggregateValueType(field.source);\n    }\n    return normalizeValueType(field.source.valueType);\n  });\n}\n\n/**\n * Returns the effective number of columns projected by a subquery.\n */\nexport function getSubqueryColumnCount(subquery: QueryAst): number {\n  return getProjectedValueTypes(subquery).length;\n}\n\n/**\n * Returns the value type when a subquery projects exactly one column.\n */\nexport function getSingleSubqueryColumnValueType(\n  subquery: QueryAst,\n): ValueType | undefined {\n  const valueTypes = getProjectedValueTypes(subquery);\n  if (valueTypes.length !== 1) {\n    return undefined;\n  }\n  return valueTypes[0];\n}\n","/**\n * Predicate builders for TypeGraph queries.\n *\n * Provides a fluent API for building type-safe predicates.\n */\nimport { type FulltextQueryMode } from \"../backend/types\";\nimport { type NullCheckOp } from \"../core/types\";\nimport { ConfigurationError, UnsupportedPredicateError } from \"../errors\";\nimport {\n  type ArrayOp,\n  type ArrayPredicate,\n  type BetweenPredicate,\n  type ComparisonOp,\n  type ComparisonPredicate,\n  type ExistsSubquery,\n  type FieldRef,\n  type FulltextMatchPredicate,\n  type InSubquery,\n  type LiteralValue,\n  type NullPredicate,\n  type ObjectOp,\n  type ObjectPredicate,\n  type ParameterRef,\n  type PredicateExpression,\n  type QueryAst,\n  type StringOp,\n  type StringPredicate,\n  type ValueType,\n  type VectorMetricType,\n  type VectorSimilarityPredicate,\n} from \"./ast\";\nimport { CURRENT_READ_INSTANT_PLACEHOLDER } from \"./compiler/temporal\";\nimport { resolveFieldTypeInfoAtJsonPointer } from \"./field-type-info\";\nimport {\n  joinJsonPointers,\n  type JsonPointer,\n  jsonPointer,\n  type JsonPointerInput,\n  type JsonPointerSegment,\n  normalizeJsonPointer,\n  type ResolveJsonPointer,\n  type ResolveJsonPointerSegments,\n} from \"./json-pointer\";\nimport { type FieldTypeInfo } from \"./schema-introspector\";\nimport {\n  getSingleSubqueryColumnValueType,\n  getSubqueryColumnCount,\n  isInSubqueryTypeCompatible,\n  isUnsupportedInSubqueryValueType,\n} from \"./subquery-utils\";\n\n// ============================================================\n// Predicate Builder\n// ============================================================\n\n/**\n * A chainable predicate that can be combined with AND/OR.\n */\nexport type Predicate = Readonly<{\n  __expr: PredicateExpression;\n  and: (other: Predicate) => Predicate;\n  or: (other: Predicate) => Predicate;\n  not: () => Predicate;\n}>;\n\n/**\n * Creates a predicate wrapper with chainable methods.\n */\nfunction predicate(expr: PredicateExpression): Predicate {\n  return {\n    __expr: expr,\n    and: (other: Predicate): Predicate =>\n      predicate({\n        __type: \"and\",\n        predicates: [expr, other.__expr],\n      }),\n    or: (other: Predicate): Predicate =>\n      predicate({\n        __type: \"or\",\n        predicates: [expr, other.__expr],\n      }),\n    not: (): Predicate =>\n      predicate({\n        __type: \"not\",\n        predicate: expr,\n      }),\n  };\n}\n\n// ============================================================\n// Parameter References\n// ============================================================\n\n/**\n * Creates a named parameter reference for prepared queries.\n *\n * Use with `query.prepare()` to create reusable parameterized queries.\n * Only supported in scalar comparison positions (eq, neq, gt, etc.),\n * string operations, and between bounds. Not supported in `in()`/`notIn()`.\n *\n * @example\n * ```typescript\n * const prepared = store.query()\n *   .from(\"Person\", \"p\")\n *   .whereNode(\"p\", (p) => p.name.eq(param(\"name\")))\n *   .select((ctx) => ctx.p)\n *   .prepare();\n *\n * const results = await prepared.execute({ name: \"Alice\" });\n * ```\n */\n// eslint-disable-next-line unicorn/name-replacements -- concise public API\nexport function param(name: string): ParameterRef {\n  // The compiled template fills this reserved placeholder with the current read\n  // instant, so a user param of the same name would be silently overwritten by\n  // the wall clock (see fillTemplateParams). Reject it up front.\n  if (name === CURRENT_READ_INSTANT_PLACEHOLDER) {\n    throw new ConfigurationError(\n      `Parameter name \"${name}\" is reserved for internal use`,\n      { parameterName: name },\n    );\n  }\n  return { __type: \"parameter\", name };\n}\n\n/**\n * Type guard for ParameterRef values.\n */\nexport function isParameterRef(value: unknown): value is ParameterRef {\n  if (typeof value !== \"object\" || value === null) return false;\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- runtime guard for untyped input\n  return (value as ParameterRef).__type === \"parameter\";\n}\n\n// ============================================================\n// Field Builder\n// ============================================================\n\n/**\n * A typed field builder for creating predicates.\n */\ntype FieldBuilder<T> =\n  [T] extends [string] ? StringFieldBuilder\n  : [T] extends [number] ? NumberFieldBuilder\n  : [T] extends [boolean] ? BooleanFieldBuilder\n  : [T] extends [Date] ? DateFieldBuilder\n  : [T] extends [readonly (infer U)[]] ? ArrayFieldBuilder<U>\n  : [T] extends [Record<string, unknown>] ? ObjectFieldBuilder<T>\n  : BaseFieldBuilder;\n\n/**\n * Base field operations available on all types.\n */\ntype BaseFieldBuilder = Readonly<{\n  eq: (value: unknown) => Predicate;\n  neq: (value: unknown) => Predicate;\n  isNull: () => Predicate;\n  isNotNull: () => Predicate;\n  in: (values: readonly unknown[]) => Predicate;\n  notIn: (values: readonly unknown[]) => Predicate;\n}>;\n\n/**\n * Options for the `$fulltext.matches()` predicate.\n *\n * Note the term glossary used throughout TypeGraph search:\n * - **`k`** (the positional argument on `.matches(query, k)`) is the\n *   per-predicate top-k cap applied inside the fulltext CTE.\n * - **`limit`** (on store-level `search.fulltext` / `search.hybrid` and\n *   on the query builder) is the final result count returned to the\n *   caller after any fusion.\n */\ntype MatchesOptions = Readonly<{\n  /**\n   * Parse mode for the query string. Default: \"websearch\".\n   *\n   * - \"websearch\": Google-style syntax (quoted phrases, `-excluded`, `OR`).\n   *   Postgres: `websearch_to_tsquery`. SQLite: translated to FTS5 MATCH.\n   * - \"phrase\": treats the whole query as a phrase.\n   * - \"plain\": splits on whitespace and ANDs terms.\n   * - \"raw\": dialect-native syntax passed through unchanged.\n   */\n  mode?: FulltextQueryMode;\n  /**\n   * Language override for query parsing. Default: the kind's declared\n   * language when every kind in the alias shares one (a plan-time\n   * constant, so PostgreSQL can serve the match from the GIN index);\n   * mixed-language subclass aliases fall back to the per-row language\n   * column.\n   */\n  language?: string;\n  /** Minimum relevance score to include. */\n  minScore?: number;\n}>;\n\n/**\n * String-specific field operations.\n *\n * Fulltext match is exposed on `n.$fulltext.matches(...)` at the node\n * level (gated by `searchable()` declarations in the schema), not on\n * individual string fields.\n */\ntype StringFieldBuilder = BaseFieldBuilder &\n  Readonly<{\n    gt: (value: string | ParameterRef) => Predicate;\n    gte: (value: string | ParameterRef) => Predicate;\n    lt: (value: string | ParameterRef) => Predicate;\n    lte: (value: string | ParameterRef) => Predicate;\n    contains: (pattern: string | ParameterRef) => Predicate;\n    startsWith: (pattern: string | ParameterRef) => Predicate;\n    endsWith: (pattern: string | ParameterRef) => Predicate;\n    like: (pattern: string | ParameterRef) => Predicate;\n    ilike: (pattern: string | ParameterRef) => Predicate;\n  }>;\n\n/**\n * Number-specific field operations.\n */\ntype NumberFieldBuilder = BaseFieldBuilder &\n  Readonly<{\n    gt: (value: number | ParameterRef) => Predicate;\n    gte: (value: number | ParameterRef) => Predicate;\n    lt: (value: number | ParameterRef) => Predicate;\n    lte: (value: number | ParameterRef) => Predicate;\n    between: (\n      lower: number | ParameterRef,\n      upper: number | ParameterRef,\n    ) => Predicate;\n  }>;\n\n/**\n * Boolean-specific field operations.\n */\ntype BooleanFieldBuilder = BaseFieldBuilder;\n\n/**\n * Date-specific field operations.\n */\ntype DateFieldBuilder = BaseFieldBuilder &\n  Readonly<{\n    gt: (value: Date | string | ParameterRef) => Predicate;\n    gte: (value: Date | string | ParameterRef) => Predicate;\n    lt: (value: Date | string | ParameterRef) => Predicate;\n    lte: (value: Date | string | ParameterRef) => Predicate;\n    between: (\n      lower: Date | string | ParameterRef,\n      upper: Date | string | ParameterRef,\n    ) => Predicate;\n  }>;\n\ntype ScalarValue = string | number | boolean | Date;\n\ntype ArrayPredicateOps<T> =\n  [T] extends [ScalarValue] ?\n    Readonly<{\n      /** Check if array contains a specific value */\n      contains: (value: T) => Predicate;\n      /** Check if array contains all specified values */\n      containsAll: (values: readonly T[]) => Predicate;\n      /** Check if array contains any of the specified values (overlaps) */\n      containsAny: (values: readonly T[]) => Predicate;\n    }>\n  : Readonly<Record<string, never>>;\n\n/**\n * Array-specific field operations.\n */\ntype ArrayFieldBuilder<T = unknown> = BaseFieldBuilder &\n  Readonly<{\n    /** Check if array is empty */\n    isEmpty: () => Predicate;\n    /** Check if array is not empty */\n    isNotEmpty: () => Predicate;\n    /** Check if array length equals a value */\n    lengthEq: (length: number) => Predicate;\n    /** Check if array length is greater than a value */\n    lengthGt: (length: number) => Predicate;\n    /** Check if array length is greater than or equal to a value */\n    lengthGte: (length: number) => Predicate;\n    /** Check if array length is less than a value */\n    lengthLt: (length: number) => Predicate;\n    /** Check if array length is less than or equal to a value */\n    lengthLte: (length: number) => Predicate;\n  }> &\n  ArrayPredicateOps<T>;\n\n/**\n * Object/JSON-specific field operations.\n */\ntype ResolvedPointerInput<T, Pointer> =\n  Pointer extends string ? ResolveJsonPointer<T, Pointer>\n  : Pointer extends readonly JsonPointerSegment[] ?\n    ResolveJsonPointerSegments<T, Pointer>\n  : unknown;\n\n/**\n * Resolves the type of a nested key access on an object type.\n * Returns ObjectFieldBuilder for nested objects, FieldBuilder for scalars.\n */\ntype NestedFieldBuilder<T, K extends keyof T> =\n  NonNullable<T[K]> extends Record<string, unknown> ?\n    ObjectFieldBuilder<NonNullable<T[K]>>\n  : FieldBuilder<T[K]>;\n\ntype ObjectFieldBuilder<\n  T extends Record<string, unknown> = Record<string, unknown>,\n> = BaseFieldBuilder &\n  Readonly<{\n    /** Access a nested field by key for fluent chaining */\n    get: <K extends keyof T & string>(key: K) => NestedFieldBuilder<T, K>;\n    /** Check if object has a specific key at root level */\n    hasKey: (key: string) => Predicate;\n    /** Check if object has a nested path (JSON Pointer) */\n    hasPath: <P extends JsonPointerInput<T>>(pointer: P) => Predicate;\n    /** Check if value at path equals a value */\n    pathEquals: <P extends JsonPointerInput<T>>(\n      pointer: P,\n      value: string | number | boolean | Date,\n    ) => Predicate;\n    /** Check if value at path (array) contains a value */\n    pathContains: <P extends JsonPointerInput<T>>(\n      pointer: P,\n      value: string | number | boolean | Date,\n    ) => Predicate;\n    /** Check if value at path is null */\n    pathIsNull: <P extends JsonPointerInput<T>>(pointer: P) => Predicate;\n    /** Check if value at path is not null */\n    pathIsNotNull: <P extends JsonPointerInput<T>>(pointer: P) => Predicate;\n    /** Access a nested field to get a typed field builder */\n    field: <P extends JsonPointerInput<T>>(\n      pointer: P,\n    ) => FieldBuilder<ResolvedPointerInput<T, P>>;\n  }>;\n\n/**\n * Options for the similarTo method.\n */\nexport type SimilarToOptions = Readonly<{\n  /** Similarity metric to use. Default: \"cosine\" */\n  metric?: VectorMetricType;\n  /**\n   * Minimum similarity score to include results.\n   * For cosine: 0-1 where 1 is identical.\n   * For L2: maximum distance to include.\n   * For inner_product: minimum inner product value.\n   */\n  minScore?: number;\n  /**\n   * Opt into approximate retrieval: each declaring kind's candidates come\n   * from the engine's native ANN structure (pgvector HNSW/IVFFlat scans,\n   * vec0 `MATCH … k=`, libSQL `vector_top_k`) instead of an exact\n   * distance scan. This is a SEMANTIC change — results are subject to the\n   * index's recall, and predicates composed alongside constrain the ANN\n   * candidate set (exact on pgvector/vec0; bounded by over-fetch on\n   * libSQL). A slot declared with `indexType: \"none\"` falls back to the\n   * exact scan. Default: exact.\n   */\n  approximate?: boolean;\n}>;\n\n/**\n * Embedding-specific field operations for vector similarity search.\n */\ntype EmbeddingFieldBuilder = BaseFieldBuilder &\n  Readonly<{\n    /**\n     * Find nodes with similar embeddings.\n     * Returns results ordered by similarity (most similar first).\n     *\n     * @param queryEmbedding - The embedding vector to compare against\n     * @param k - Maximum number of results to return (top-k)\n     * @param options - Optional configuration (metric, minScore)\n     *\n     * @example\n     * ```typescript\n     * store.query()\n     *   .from(\"Document\", \"d\")\n     *   .whereNode(\"d\", (d) =>\n     *     d.embedding.similarTo(queryVector, 10, { metric: \"cosine\" })\n     *   )\n     *   .select((ctx) => ({ doc: ctx.d }))\n     *   .execute()\n     * ```\n     */\n    similarTo: (\n      queryEmbedding: readonly number[],\n      k: number,\n      options?: SimilarToOptions,\n    ) => Predicate;\n  }>;\n\n// ============================================================\n// Field Builder Factory\n// ============================================================\n\n/**\n * Creates a field reference.\n */\ntype FieldRefOptions = Readonly<{\n  jsonPointer?: JsonPointer | undefined;\n  valueType?: ValueType | undefined;\n  elementType?: ValueType | undefined;\n}>;\n\nexport function fieldRef(\n  alias: string,\n  path: readonly string[],\n  options?: FieldRefOptions,\n): FieldRef {\n  return {\n    __type: \"field_ref\",\n    alias,\n    path,\n    ...(options?.jsonPointer !== undefined && {\n      jsonPointer: options.jsonPointer,\n    }),\n    ...(options?.valueType !== undefined && { valueType: options.valueType }),\n    ...(options?.elementType !== undefined && {\n      elementType: options.elementType,\n    }),\n  };\n}\n\nfunction coerceLiteralValue(value: unknown): string | number | boolean | Date {\n  if (value instanceof Date) {\n    return value;\n  }\n  if (\n    typeof value === \"string\" ||\n    typeof value === \"number\" ||\n    typeof value === \"boolean\"\n  ) {\n    return value;\n  }\n  throw new Error(`Unsupported literal value type: ${typeof value}`);\n}\n\nfunction inferLiteralValueType(value: string | number | boolean): ValueType {\n  if (typeof value === \"string\") {\n    return \"string\";\n  }\n  if (typeof value === \"number\") {\n    return \"number\";\n  }\n  return \"boolean\";\n}\n\n/**\n * Creates a literal value.\n */\nfunction literal(value: string | number | boolean | Date): LiteralValue {\n  if (value instanceof Date) {\n    return { __type: \"literal\", value: value.toISOString(), valueType: \"date\" };\n  }\n  const valueType = inferLiteralValueType(value);\n  return {\n    __type: \"literal\",\n    value,\n    valueType,\n  };\n}\n\n/**\n * Creates a comparison predicate.\n */\nfunction comparison(\n  op: ComparisonOp,\n  field: FieldRef,\n  value: unknown,\n): Predicate {\n  if (isParameterRef(value)) {\n    const expr: ComparisonPredicate = {\n      __type: \"comparison\",\n      op,\n      left: field,\n      right: value,\n    };\n    return predicate(expr);\n  }\n  const coercedValue = coerceLiteralValue(value);\n  const expr: ComparisonPredicate = {\n    __type: \"comparison\",\n    op,\n    left: field,\n    right: literal(coercedValue),\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates an IN comparison predicate.\n */\nfunction inComparison(\n  op: \"in\" | \"notIn\",\n  field: FieldRef,\n  values: readonly unknown[],\n): Predicate {\n  const literals = values.map((value) => literal(coerceLiteralValue(value)));\n  const expr: ComparisonPredicate = {\n    __type: \"comparison\",\n    op,\n    left: field,\n    right: literals,\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates a string operation predicate.\n */\nfunction stringOp(\n  op: StringOp,\n  field: FieldRef,\n  pattern: string | ParameterRef,\n): Predicate {\n  if (isParameterRef(pattern)) {\n    const expr: StringPredicate = {\n      __type: \"string_op\",\n      op,\n      field,\n      pattern,\n    };\n    return predicate(expr);\n  }\n  const expr: StringPredicate = {\n    __type: \"string_op\",\n    op,\n    field,\n    pattern,\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates a null check predicate.\n */\nfunction nullCheck(op: NullCheckOp, field: FieldRef): Predicate {\n  const expr: NullPredicate = {\n    __type: \"null_check\",\n    op,\n    field,\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates a between predicate.\n */\nfunction between(\n  field: FieldRef,\n  lower: string | number | boolean | Date | ParameterRef,\n  upper: string | number | boolean | Date | ParameterRef,\n): Predicate {\n  const expr: BetweenPredicate = {\n    __type: \"between\",\n    field,\n    lower: isParameterRef(lower) ? lower : literal(lower),\n    upper: isParameterRef(upper) ? upper : literal(upper),\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates a base field builder with common operations.\n */\nfunction baseFieldBuilder(field: FieldRef): BaseFieldBuilder {\n  return {\n    eq: (value) => comparison(\"eq\", field, value),\n    neq: (value) => comparison(\"neq\", field, value),\n    isNull: () => nullCheck(\"isNull\", field),\n    isNotNull: () => nullCheck(\"isNotNull\", field),\n    in: (values) => inComparison(\"in\", field, values),\n    notIn: (values) => inComparison(\"notIn\", field, values),\n  };\n}\n\n/**\n * Creates a string field builder.\n *\n * Fulltext match is not a string-field operation — use\n * `n.$fulltext.matches(...)` at the node level. `searchable()`\n * declarations determine which node kinds expose `$fulltext`.\n */\nexport function stringField(field: FieldRef): StringFieldBuilder {\n  return {\n    ...baseFieldBuilder(field),\n    gt: (value) => comparison(\"gt\", field, value),\n    gte: (value) => comparison(\"gte\", field, value),\n    lt: (value) => comparison(\"lt\", field, value),\n    lte: (value) => comparison(\"lte\", field, value),\n    contains: (pattern) => stringOp(\"contains\", field, pattern),\n    startsWith: (pattern) => stringOp(\"startsWith\", field, pattern),\n    endsWith: (pattern) => stringOp(\"endsWith\", field, pattern),\n    like: (pattern) => stringOp(\"like\", field, pattern),\n    ilike: (pattern) => stringOp(\"ilike\", field, pattern),\n  };\n}\n\n/**\n * Default top-k for `$fulltext.matches()` when the caller does not pass\n * one. Large enough to leave headroom for downstream `.and()` filters,\n * small enough to keep latency reasonable on any dialect.\n */\nconst DEFAULT_FULLTEXT_MATCH_K = 50;\n\n/**\n * Node-level fulltext accessor. Always present on the `NodeAccessor`\n * type — a runtime check throws a clear error if the node kind has no\n * `searchable()` fields. `k` is the top-k cap applied inside the\n * fulltext CTE; defaults to `DEFAULT_FULLTEXT_MATCH_K`. Use a larger\n * value when feeding the result into RRF (`.fuseWith()` /\n * `store.search.hybrid()`).\n */\nexport type FulltextAccessor = Readonly<{\n  matches: (query: string, k?: number, options?: MatchesOptions) => Predicate;\n}>;\n\n/**\n * Creates a node-level fulltext accessor. The runtime check throws for\n * aliases whose node kind has no `searchable()` content, catching the\n * case where the field tag was dropped (e.g. by a schema refactor)\n * after the query was written.\n */\nexport function createFulltextAccessor(\n  alias: string,\n  hasSearchableField: () => boolean,\n): FulltextAccessor {\n  return {\n    matches: (query, k, options) => {\n      if (!hasSearchableField()) {\n        throw new UnsupportedPredicateError(\n          `Cannot call .$fulltext.matches() on alias \"${alias}\" — its ` +\n            `node kind has no fields declared with searchable(). Add at ` +\n            `least one: \\`title: searchable({ language: \"english\" })\\`.`,\n        );\n      }\n      return fulltextMatch(\n        fieldRef(alias, [\"$fulltext\"]),\n        query,\n        k ?? DEFAULT_FULLTEXT_MATCH_K,\n        options,\n      );\n    },\n  };\n}\n\n/**\n * Creates a fulltext match predicate.\n */\nfunction fulltextMatch(\n  field: FieldRef,\n  query: string,\n  limit: number,\n  options?: MatchesOptions,\n): Predicate {\n  if (!Number.isFinite(limit) || limit <= 0) {\n    throw new UnsupportedPredicateError(\n      `matches() limit must be a positive finite number, got ${String(limit)}`,\n    );\n  }\n  const expr: FulltextMatchPredicate = {\n    __type: \"fulltext_match\",\n    field,\n    query,\n    mode: options?.mode ?? \"websearch\",\n    limit,\n    ...(options?.language === undefined ? {} : { language: options.language }),\n    ...(options?.minScore === undefined ? {} : { minScore: options.minScore }),\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates a number field builder.\n */\nexport function numberField(field: FieldRef): NumberFieldBuilder {\n  return {\n    ...baseFieldBuilder(field),\n    gt: (value) => comparison(\"gt\", field, value),\n    gte: (value) => comparison(\"gte\", field, value),\n    lt: (value) => comparison(\"lt\", field, value),\n    lte: (value) => comparison(\"lte\", field, value),\n    between: (lower, upper) => between(field, lower, upper),\n  };\n}\n\n/**\n * Creates a date field builder.\n */\nexport function dateField(field: FieldRef): DateFieldBuilder {\n  return {\n    ...baseFieldBuilder(field),\n    gt: (value) => comparison(\"gt\", field, value),\n    gte: (value) => comparison(\"gte\", field, value),\n    lt: (value) => comparison(\"lt\", field, value),\n    lte: (value) => comparison(\"lte\", field, value),\n    between: (lower, upper) => between(field, lower, upper),\n  };\n}\n\n/**\n * Creates a base field builder (for booleans, enums, and unknown types).\n * Only provides the fundamental operations: eq, neq, isNull, isNotNull, in, notIn.\n */\nexport function baseField(field: FieldRef): BaseFieldBuilder {\n  return baseFieldBuilder(field);\n}\n\n/**\n * Creates an array operation predicate.\n */\nfunction arrayOp(\n  op: ArrayOp,\n  field: FieldRef,\n  values?: readonly unknown[],\n  length?: number,\n): Predicate {\n  const expr: ArrayPredicate = {\n    __type: \"array_op\",\n    op,\n    field,\n    ...(values !== undefined && {\n      values: values.map((value) => literal(coerceLiteralValue(value))),\n    }),\n    ...(length !== undefined && { length }),\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates an array field builder.\n */\nexport function arrayField<T = unknown>(field: FieldRef): ArrayFieldBuilder<T> {\n  // The type assertion is needed because ArrayFieldBuilder conditionally includes\n  // contains/containsAll/containsAny based on whether T extends ScalarValue.\n  // At runtime we always provide them - they just won't type-check if T isn't scalar.\n  return {\n    ...baseFieldBuilder(field),\n    contains: (value: T) => arrayOp(\"contains\", field, [value]),\n    containsAll: (values: readonly T[]) =>\n      arrayOp(\"containsAll\", field, values),\n    containsAny: (values: readonly T[]) =>\n      arrayOp(\"containsAny\", field, values),\n    isEmpty: () => arrayOp(\"isEmpty\", field),\n    isNotEmpty: () => arrayOp(\"isNotEmpty\", field),\n    lengthEq: (length: number) => arrayOp(\"lengthEq\", field, undefined, length),\n    lengthGt: (length: number) => arrayOp(\"lengthGt\", field, undefined, length),\n    lengthGte: (length: number) =>\n      arrayOp(\"lengthGte\", field, undefined, length),\n    lengthLt: (length: number) => arrayOp(\"lengthLt\", field, undefined, length),\n    lengthLte: (length: number) =>\n      arrayOp(\"lengthLte\", field, undefined, length),\n  } as unknown as ArrayFieldBuilder<T>;\n}\n\n/**\n * Creates a vector similarity predicate.\n */\nfunction vectorSimilarity(\n  field: FieldRef,\n  queryEmbedding: readonly number[],\n  limit: number,\n  options?: SimilarToOptions,\n): Predicate {\n  const expr: VectorSimilarityPredicate = {\n    __type: \"vector_similarity\",\n    field,\n    queryEmbedding,\n    // Leave metric unset when the caller didn't specify one, so the compiler\n    // resolves the field's declared metric per kind. Defaulting to \"cosine\"\n    // here would mis-rank l2/inner_product fields and bypass their ANN index.\n    ...(options?.metric !== undefined && { metric: options.metric }),\n    limit,\n    ...(options?.minScore !== undefined && { minScore: options.minScore }),\n    ...(options?.approximate !== undefined && {\n      approximate: options.approximate,\n    }),\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates an embedding field builder for vector similarity search.\n */\nexport function embeddingField(field: FieldRef): EmbeddingFieldBuilder {\n  return {\n    ...baseFieldBuilder(field),\n    similarTo: (queryEmbedding, k, options) =>\n      vectorSimilarity(field, queryEmbedding, k, options),\n  };\n}\n\nexport function buildFieldBuilderForTypeInfo(\n  field: FieldRef,\n  typeInfo: FieldTypeInfo | undefined,\n): BaseFieldBuilder {\n  if (!typeInfo) {\n    return baseField(field);\n  }\n\n  switch (typeInfo.valueType) {\n    case \"string\": {\n      return stringField(field);\n    }\n    case \"number\": {\n      return numberField(field);\n    }\n    case \"boolean\": {\n      return baseField(field);\n    }\n    case \"date\": {\n      return dateField(field);\n    }\n    case \"array\": {\n      return arrayField(field);\n    }\n    case \"object\": {\n      return objectField(field, { typeInfo });\n    }\n    case \"embedding\": {\n      return embeddingField(field);\n    }\n    case \"unknown\": {\n      return baseField(field);\n    }\n  }\n}\n\nfunction resolvePointerTypeInfo(\n  typeInfo: FieldTypeInfo | undefined,\n  pointer: JsonPointer,\n): FieldTypeInfo | undefined {\n  return resolveFieldTypeInfoAtJsonPointer(typeInfo, pointer);\n}\n\n/**\n * Creates an object operation predicate.\n */\ntype ObjectPredicateOptions = Readonly<{\n  valueType?: ValueType;\n  elementType?: ValueType;\n}>;\n\nfunction objectOp(\n  op: ObjectOp,\n  field: FieldRef,\n  pointer: JsonPointer,\n  value?: unknown,\n  options?: ObjectPredicateOptions,\n): Predicate {\n  const expr: ObjectPredicate = {\n    __type: \"object_op\",\n    op,\n    field,\n    pointer,\n    ...(value !== undefined && {\n      value: literal(coerceLiteralValue(value)),\n    }),\n    ...(options?.valueType !== undefined && { valueType: options.valueType }),\n    ...(options?.elementType !== undefined && {\n      elementType: options.elementType,\n    }),\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates an object/JSON field builder.\n */\ntype ObjectFieldOptions = Readonly<{\n  typeInfo?: FieldTypeInfo;\n}>;\n\nexport function objectField<\n  T extends Record<string, unknown> = Record<string, unknown>,\n>(field: FieldRef, options?: ObjectFieldOptions): ObjectFieldBuilder<T> {\n  const basePointer = field.jsonPointer;\n\n  return {\n    ...baseFieldBuilder(field),\n    get: <K extends keyof T & string>(key: K) => {\n      const pointer = jsonPointer([key]);\n      const nestedPointer = joinJsonPointers(basePointer, pointer);\n      const resolved = resolvePointerTypeInfo(options?.typeInfo, pointer);\n      const nestedRef = fieldRef(field.alias, field.path, {\n        jsonPointer: nestedPointer,\n        ...(resolved?.valueType !== undefined && {\n          valueType: resolved.valueType,\n        }),\n        ...(resolved?.elementType !== undefined && {\n          elementType: resolved.elementType,\n        }),\n      });\n      return buildFieldBuilderForTypeInfo(nestedRef, resolved) as ReturnType<\n        ObjectFieldBuilder<T>[\"get\"]\n      >;\n    },\n    hasKey: (key) => {\n      const pointer = jsonPointer([key]);\n      resolvePointerTypeInfo(options?.typeInfo, pointer);\n      return objectOp(\"hasKey\", field, pointer);\n    },\n    hasPath: <P extends JsonPointerInput<T>>(pointer: P) => {\n      const normalized = normalizeJsonPointer(pointer as JsonPointerInput<T>);\n      resolvePointerTypeInfo(options?.typeInfo, normalized);\n      return objectOp(\"hasPath\", field, normalized);\n    },\n    pathEquals: <P extends JsonPointerInput<T>>(\n      pointer: P,\n      value: string | number | boolean | Date,\n    ) => {\n      const normalized = normalizeJsonPointer(pointer as JsonPointerInput<T>);\n      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);\n      if (\n        resolved &&\n        (resolved.valueType === \"array\" || resolved.valueType === \"object\")\n      ) {\n        throw new Error(\"pathEquals is only supported for scalar JSON values\");\n      }\n      const predicateOptions: ObjectPredicateOptions | undefined =\n        resolved?.valueType === undefined ?\n          undefined\n        : { valueType: resolved.valueType };\n      return objectOp(\"pathEquals\", field, normalized, value, predicateOptions);\n    },\n    pathContains: <P extends JsonPointerInput<T>>(\n      pointer: P,\n      value: string | number | boolean | Date,\n    ) => {\n      const normalized = normalizeJsonPointer(pointer as JsonPointerInput<T>);\n      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);\n      if (resolved && resolved.valueType !== \"array\") {\n        throw new Error(\"pathContains is only supported for JSON array values\");\n      }\n      const predicateOptions: ObjectPredicateOptions | undefined =\n        resolved?.elementType === undefined ?\n          undefined\n        : { elementType: resolved.elementType };\n      return objectOp(\n        \"pathContains\",\n        field,\n        normalized,\n        value,\n        predicateOptions,\n      );\n    },\n    pathIsNull: <P extends JsonPointerInput<T>>(pointer: P) => {\n      const normalized = normalizeJsonPointer(pointer as JsonPointerInput<T>);\n      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);\n      const predicateOptions: ObjectPredicateOptions | undefined =\n        resolved?.valueType === undefined ?\n          undefined\n        : { valueType: resolved.valueType };\n      return objectOp(\n        \"pathIsNull\",\n        field,\n        normalized,\n        undefined,\n        predicateOptions,\n      );\n    },\n    pathIsNotNull: <P extends JsonPointerInput<T>>(pointer: P) => {\n      const normalized = normalizeJsonPointer(pointer as JsonPointerInput<T>);\n      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);\n      const predicateOptions: ObjectPredicateOptions | undefined =\n        resolved?.valueType === undefined ?\n          undefined\n        : { valueType: resolved.valueType };\n      return objectOp(\n        \"pathIsNotNull\",\n        field,\n        normalized,\n        undefined,\n        predicateOptions,\n      );\n    },\n    field: <P extends JsonPointerInput<T>>(pointer: P) => {\n      const normalized = normalizeJsonPointer(pointer as JsonPointerInput<T>);\n      const nestedPointer = joinJsonPointers(basePointer, normalized);\n      const resolved = resolvePointerTypeInfo(options?.typeInfo, normalized);\n      const nestedRef = fieldRef(field.alias, field.path, {\n        jsonPointer: nestedPointer,\n        ...(resolved?.valueType !== undefined && {\n          valueType: resolved.valueType,\n        }),\n        ...(resolved?.elementType !== undefined && {\n          elementType: resolved.elementType,\n        }),\n      });\n      return buildFieldBuilderForTypeInfo(nestedRef, resolved) as FieldBuilder<\n        ResolvedPointerInput<T, P>\n      >;\n    },\n  };\n}\n\n// ============================================================\n// Subquery Predicates\n// ============================================================\n\n/**\n * Creates an EXISTS subquery predicate.\n * Returns true if the subquery returns at least one row.\n *\n * @param subquery - The subquery AST to check for existence\n *\n * @example\n * ```typescript\n * // Find persons who have at least one order\n * query\n *   .from(\"Person\", \"p\")\n *   .whereNode(\"p\", () =>\n *     exists(\n *       query.from(\"Order\", \"o\")\n *         .whereNode(\"o\", (o) => o.customerId.eq(field(\"p.id\")))\n *         .select((ctx) => ({ id: ctx.o.id }))\n *         .toAst()\n *     )\n *   )\n * ```\n */\nexport function exists(subquery: QueryAst): Predicate {\n  const expr: ExistsSubquery = {\n    __type: \"exists\",\n    subquery,\n    negated: false,\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates a NOT EXISTS subquery predicate.\n * Returns true if the subquery returns no rows.\n *\n * @param subquery - The subquery AST to check for non-existence\n */\nexport function notExists(subquery: QueryAst): Predicate {\n  const expr: ExistsSubquery = {\n    __type: \"exists\",\n    subquery,\n    negated: true,\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates an IN subquery predicate.\n * Returns true if the field value is in the subquery results.\n *\n * @param field - The field to check\n * @param subquery - The subquery AST that returns a single column\n *\n * @example\n * ```typescript\n * // Find persons whose ID is in the VIP list\n * query\n *   .from(\"Person\", \"p\")\n *   .where(() =>\n *     inSubquery(\n *       fieldRef(\"p\", [\"id\"]),\n *       query.from(\"VIPMember\", \"v\")\n *         .aggregate({\n *           id: fieldRef(\"v\", [\"props\", \"personId\"], { valueType: \"string\" }),\n *         })\n *         .toAst()\n *     )\n *   )\n * ```\n */\nexport function inSubquery(field: FieldRef, subquery: QueryAst): Predicate {\n  assertSingleColumnSubquery(subquery);\n  assertCompatibleSubqueryValueTypes(field, subquery);\n  const expr: InSubquery = {\n    __type: \"in_subquery\",\n    field,\n    subquery,\n    negated: false,\n  };\n  return predicate(expr);\n}\n\n/**\n * Creates a NOT IN subquery predicate.\n * Returns true if the field value is not in the subquery results.\n *\n * @param field - The field to check\n * @param subquery - The subquery AST that returns a single column\n */\nexport function notInSubquery(field: FieldRef, subquery: QueryAst): Predicate {\n  assertSingleColumnSubquery(subquery);\n  assertCompatibleSubqueryValueTypes(field, subquery);\n  const expr: InSubquery = {\n    __type: \"in_subquery\",\n    field,\n    subquery,\n    negated: true,\n  };\n  return predicate(expr);\n}\n\n/**\n * Ensures IN/NOT IN subqueries project exactly one column.\n */\nfunction assertSingleColumnSubquery(subquery: QueryAst): void {\n  const columnCount = getSubqueryColumnCount(subquery);\n  if (columnCount === 1) return;\n\n  throw new UnsupportedPredicateError(\n    `IN/NOT IN subquery must project exactly 1 column, but got ${columnCount}`,\n    { subqueryColumnCount: columnCount },\n    {\n      suggestion:\n        \"Use aggregate() with exactly one projected field for scalar IN/NOT IN subqueries.\",\n    },\n  );\n}\n\n/**\n * Ensures IN/NOT IN subquery and field value types are compatible when known.\n */\nfunction assertCompatibleSubqueryValueTypes(\n  field: FieldRef,\n  subquery: QueryAst,\n): void {\n  const fieldValueType = field.valueType;\n  const subqueryValueType = getSingleSubqueryColumnValueType(subquery);\n  const resolvedValueType = fieldValueType ?? subqueryValueType;\n\n  if (isUnsupportedInSubqueryValueType(resolvedValueType)) {\n    throw new UnsupportedPredicateError(\n      `IN/NOT IN subquery does not support ${String(resolvedValueType)} values`,\n      { valueType: resolvedValueType },\n      {\n        suggestion:\n          \"Use scalar fields (string/number/boolean/date) in IN/NOT IN predicates.\",\n      },\n    );\n  }\n\n  if (isInSubqueryTypeCompatible(fieldValueType, subqueryValueType)) {\n    return;\n  }\n\n  throw new UnsupportedPredicateError(\n    `IN/NOT IN type mismatch: field type \"${String(fieldValueType)}\" does not match subquery column type \"${String(subqueryValueType)}\"`,\n    {\n      fieldValueType,\n      subqueryValueType,\n    },\n  );\n}\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 {\n  type GraphBackend,\n  type TransactionBackend,\n  type TransactionOptions,\n} from \"../../backend/types\";\nimport {\n  ConfigurationError,\n  type RecordedCaptureGuardCode,\n} from \"../../errors\";\nimport { createSqlSchema, type SqlSchema } from \"../../query/compiler/schema\";\nimport type { SqlDialect } from \"../../query/dialect/types\";\nimport { sql, type SqlFragment } from \"../../query/sql-fragment\";\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\nconst RECORDED_ISOLATION_REQUIRES_POSTGRES_CHECK = {\n  postgres: true,\n  sqlite: false,\n} as const satisfies Record<SqlDialect, boolean>;\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: SqlFragment,\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 (!RECORDED_ISOLATION_REQUIRES_POSTGRES_CHECK[backend.dialect]) return;\n  if (options?.accessMode === \"read_only\") 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  options?: TransactionOptions,\n): Promise<void> {\n  if (!RECORDED_ISOLATION_REQUIRES_POSTGRES_CHECK[target.dialect]) return;\n  if (options?.accessMode === \"read_only\") 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. The branchable `details.code` is set here so no\n * call site can omit it; any extra `details` merge underneath it.\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    {\n      ...details,\n      code: \"RECORDED_CAPTURE_REQUIRES_CALLBACK_TRANSACTION\" satisfies RecordedCaptureGuardCode,\n    },\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    {\n      code: \"RECORDED_CAPTURE_RAW_SQL_DISABLED\" satisfies RecordedCaptureGuardCode,\n    },\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    {\n      code: \"REVISION_TRACKING_RAW_SQL_DISABLED\" satisfies RecordedCaptureGuardCode,\n    },\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\nexport function throwHistoryUnsafeSqlAccess(): never {\n  throw historyUnsafeRawWriteError(\"tx.sql\");\n}\n\nexport function throwRevisionTrackingUnsafeSqlAccess(): never {\n  throw revisionTrackingUnsafeRawWriteError(\"tx.sql\");\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 GraphBackend } from \"../../backend/types\";\nimport {\n  createRecordedInstant,\n  parseRecordedInstant,\n  RECORDED_MAX_REVISION,\n} from \"../../core/temporal\";\nimport { ConfigurationError } from \"../../errors\";\nimport { type SqlSchema } from \"../../query/compiler/schema\";\nimport type { SqlDialect } from \"../../query/dialect/types\";\nimport { sql, type SqlFragment } from \"../../query/sql-fragment\";\nimport { asCompiledRowsSql } from \"../../query/sql-intent\";\nimport { canonicalizeDatabaseTimestamp, nowIso } from \"../../utils/date\";\nimport { generateId } from \"../../utils/id\";\nimport { executeStatement } from \"./guards\";\n\ntype ClockRow = Readonly<{ recorded_at: unknown; revision: unknown }>;\ntype RecordedClockParts = Readonly<{ recordedAt: string; revision: number }>;\nexport type AllocatedRecordedCommit = RecordedClockParts &\n  Readonly<{ instant: string }>;\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. Revision zero is reserved for\n * this internal row and is never exposed as a valid recorded instant.\n */\nconst RECORDED_MIN_REVISION = 0;\nconst RECORDED_MIN_TIME = \"1970-01-01T00:00:00.000Z\";\nconst RECORDED_CLOCK_ADVISORY_LOCK_NAMESPACE = \"typegraph:recorded-clock\";\nconst RECORDED_GRAPH_WRITE_ADVISORY_LOCK_NAMESPACE =\n  \"typegraph:recorded-graph-write\";\n\nconst USES_RECORDED_GRAPH_ADVISORY_LOCK = {\n  postgres: true,\n  sqlite: false,\n} as const satisfies Record<SqlDialect, boolean>;\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): SqlFragment {\n  return sql`\n    SELECT pg_advisory_xact_lock(\n      hashtext(${namespace}),\n      hashtext(${graphId})\n    )\n  `;\n}\n\nexport function recordedClockAdvisoryLockSql(graphId: string): SqlFragment {\n  return graphAdvisoryLockSql(RECORDED_CLOCK_ADVISORY_LOCK_NAMESPACE, graphId);\n}\n\nexport function recordedGraphWriteAdvisoryLockSql(\n  graphId: string,\n): SqlFragment {\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 * `SqlFragment` 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 (!USES_RECORDED_GRAPH_ADVISORY_LOCK[target.dialect]) {\n    return graphWriteLockEvidence();\n  }\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 failInvalidClock(value: unknown, cause?: unknown): never {\n  throw new ConfigurationError(\n    \"Recorded clock row contained an invalid revision or wall time\",\n    { value },\n    {\n      cause,\n      suggestion:\n        \"Run migrateLegacyRecordedTime() before using recorded-time tables created by the timestamp-only preview schema.\",\n    },\n  );\n}\n\nfunction recordedClockRevision(value: unknown): number {\n  const revision =\n    typeof value === \"bigint\" ? Number(value)\n    : typeof value === \"string\" && /^\\d+$/.test(value) ? Number(value)\n    : value;\n  if (\n    typeof revision !== \"number\" ||\n    !Number.isSafeInteger(revision) ||\n    revision < RECORDED_MIN_REVISION ||\n    revision >= RECORDED_MAX_REVISION\n  ) {\n    return failInvalidClock(value);\n  }\n  return revision;\n}\n\nfunction recordedClockWallTime(value: unknown): string {\n  return canonicalizeDatabaseTimestamp(value) ?? failInvalidClock(value);\n}\n\nfunction recordedClockParts(row: ClockRow): RecordedClockParts | undefined {\n  const revision = recordedClockRevision(row.revision);\n  if (revision === RECORDED_MIN_REVISION) return undefined;\n  return { revision, recordedAt: recordedClockWallTime(row.recorded_at) };\n}\n\nfunction nextRecordedCommitParts(\n  previous: RecordedClockParts | undefined,\n): RecordedClockParts {\n  const wallTime = nowIso();\n  if (previous === undefined) {\n    return { revision: 1, recordedAt: wallTime };\n  }\n\n  return {\n    revision: previous.revision + 1,\n    // Keep diagonal replay cumulative across backward clock corrections without\n    // manufacturing a new millisecond for same-ms commits. Throughput can make\n    // this component repeat, never run ahead of the greatest observed wall time.\n    recordedAt: nonDecreasingWallTime(wallTime, previous.recordedAt),\n  };\n}\n\nfunction nonDecreasingWallTime(current: string, previous: string): string {\n  if (current < previous) return previous;\n  return current;\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 parts = await readRecordedClockParts(target, schema, graphId);\n  return parts === undefined ? undefined : (\n      createRecordedInstant(parts.revision, parts.recordedAt)\n    );\n}\n\nasync function readRecordedClockParts(\n  target: Pick<GraphBackend, \"execute\">,\n  schema: SqlSchema,\n  graphId: string,\n): Promise<RecordedClockParts | undefined> {\n  const rows = await target.execute<ClockRow>(\n    asCompiledRowsSql(sql`\n      SELECT revision, recorded_at\n      FROM ${schema.recordedClockTable}\n      WHERE graph_id = ${graphId}\n    `),\n  );\n  const row = rows[0];\n  return row === undefined ? undefined : recordedClockParts(row);\n}\n\n/**\n * Reads the durable, random origin assigned to one graph's revision clock.\n * The origin namespaces an otherwise graph-local 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  parts: RecordedClockParts,\n): Promise<void> {\n  await executeStatement(\n    target,\n    sql`\n      INSERT INTO ${schema.recordedClockTable} (graph_id, revision, recorded_at)\n      VALUES (${graphId}, ${parts.revision}, ${parts.recordedAt})\n      ON CONFLICT (graph_id) DO UPDATE\n      SET revision = ${parts.revision}, recorded_at = ${parts.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  switch (target.dialect) {\n    case \"postgres\": {\n      await target.execute(\n        asCompiledRowsSql(recordedClockAdvisoryLockSql(graphId)),\n      );\n      return;\n    }\n    case \"sqlite\": {\n      // SQLite: the seed-UPSERT exists only to take the clock row's write lock\n      // before reading when the enclosing transaction did NOT already hold one.\n      // Bundled transactions open BEGIN IMMEDIATE, so the lock is already held.\n      if (ownsWriteLock) return;\n      await executeStatement(\n        target,\n        sql`\n          INSERT INTO ${schema.recordedClockTable} (graph_id, revision, recorded_at)\n          VALUES (${graphId}, ${RECORDED_MIN_REVISION}, ${RECORDED_MIN_TIME})\n          ON CONFLICT (graph_id) DO UPDATE SET revision = revision\n        `,\n      );\n      return;\n    }\n    default: {\n      target.dialect satisfies never;\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<AllocatedRecordedCommit> {\n  await lockRecordedClock(target, schema, graphId, ownsWriteLock);\n  const previous =\n    previousRevision === undefined ?\n      await readRecordedClockParts(target, schema, graphId)\n    : parseRecordedInstant(previousRevision, \"previous recorded revision\");\n  const { revision, recordedAt } = nextRecordedCommitParts(previous);\n  if (revision >= RECORDED_MAX_REVISION) {\n    throw new ConfigurationError(\n      `Recorded commit clock reached the open revision sentinel ${RECORDED_MAX_REVISION}`,\n      { graphId, revision },\n      {\n        suggestion:\n          \"Start a new graph before exhausting the per-graph recorded revision space.\",\n      },\n    );\n  }\n  const instant = createRecordedInstant(revision, recordedAt);\n  await writeRecordedClock(target, schema, graphId, { revision, recordedAt });\n  return { instant, revision, recordedAt };\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 revision 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 independently of wall-clock behavior. 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  const commit = await allocateRecordedCommit(\n    target,\n    schema,\n    graphId,\n    ownsWriteLock,\n    previousRevision,\n  );\n  return commit.instant;\n}\n","import { type GraphBackend } from \"./types\";\n\n/**\n * Runtime allowlist for the portable GraphBackend port.\n *\n * `satisfies` rejects misspelled/non-port keys. The coverage record below\n * rejects every newly added GraphBackend key until it is deliberately added\n * here, so a port expansion can neither leak through structural forwarding nor\n * silently disappear from a narrowed backend.\n */\nconst GRAPH_BACKEND_PROJECTION_KEYS = [\n  \"dialect\",\n  \"capabilities\",\n  \"tableNames\",\n  \"fulltextStrategy\",\n  \"vectorStrategy\",\n  \"insertNode\",\n  \"insertNodeNoReturn\",\n  \"insertNodesBatch\",\n  \"insertNodesBatchReturning\",\n  \"updateNode\",\n  \"deleteNode\",\n  \"hardDeleteNode\",\n  \"getNode\",\n  \"getNodes\",\n  \"insertEdge\",\n  \"insertEdgeNoReturn\",\n  \"insertEdgesBatch\",\n  \"insertEdgesBatchReturning\",\n  \"updateEdge\",\n  \"deleteEdge\",\n  \"hardDeleteEdge\",\n  \"deleteEdgesBatch\",\n  \"hardDeleteEdgesBatch\",\n  \"getEdge\",\n  \"getEdges\",\n  \"countEdgesFrom\",\n  \"edgeExistsBetween\",\n  \"findEdgesConnectedTo\",\n  \"findNodesByKind\",\n  \"countNodesByKind\",\n  \"findEdgesByKind\",\n  \"countEdgesByKind\",\n  \"insertUnique\",\n  \"insertUniqueBatch\",\n  \"deleteUnique\",\n  \"checkUnique\",\n  \"checkUniqueBatch\",\n  \"getActiveSchema\",\n  \"getSchemaVersion\",\n  \"commitSchemaVersion\",\n  \"setActiveVersion\",\n  \"upsertEmbedding\",\n  \"upsertEmbeddingBatch\",\n  \"deleteEmbedding\",\n  \"vectorSearch\",\n  \"createVectorIndex\",\n  \"dropVectorIndex\",\n  \"hybridSearch\",\n  \"upsertFulltext\",\n  \"deleteFulltext\",\n  \"upsertFulltextBatch\",\n  \"deleteFulltextBatch\",\n  \"fulltextSearch\",\n  \"ensureIndexMaterializationsTable\",\n  \"ensureRevisionOriginsTable\",\n  \"getIndexMaterialization\",\n  \"getIndexMaterializations\",\n  \"recordIndexMaterialization\",\n  \"claimIndexMaterialization\",\n  \"releaseIndexMaterializationClaim\",\n  \"ensureContributionMaterializationsTable\",\n  \"getContributionMaterialization\",\n  \"recordContributionMaterialization\",\n  \"assertRuntimeContributionsInitialized\",\n  \"ensureKindRemovalsTable\",\n  \"getPendingKindRemovals\",\n  \"getAllKindRemovals\",\n  \"recordKindRemoval\",\n  \"ensureReconciliationMarkersTable\",\n  \"ensureRuntimeContributions\",\n  \"ensureVectorSlotContribution\",\n  \"ensureVectorSlotContributions\",\n  \"assertVectorSlotInitialized\",\n  \"assertVectorSlotsInitialized\",\n  \"deleteVectorSlotContribution\",\n  \"ensureFulltextTable\",\n  \"getReconciliationMarker\",\n  \"setReconciliationMarker\",\n  \"clearGraph\",\n  \"bootstrapTables\",\n  \"refreshStatistics\",\n  \"trustedImport\",\n  \"execute\",\n  \"executeStatement\",\n  \"executeTemporaryStatement\",\n  \"executeRaw\",\n  \"compileSql\",\n  \"executeDdl\",\n  \"transaction\",\n  \"close\",\n] as const satisfies readonly (keyof GraphBackend)[];\n\ntype ProjectedGraphBackendKey = (typeof GRAPH_BACKEND_PROJECTION_KEYS)[number];\n\nconst MISSING_GRAPH_BACKEND_PROJECTION_KEYS: Record<\n  Exclude<keyof GraphBackend, ProjectedGraphBackendKey>,\n  never\n> = {};\nvoid MISSING_GRAPH_BACKEND_PROJECTION_KEYS;\n\n/** @internal */\nexport function projectBackendMembers<\n  TBackend extends object,\n  const TKey extends keyof TBackend,\n>(backend: TBackend, keys: readonly TKey[]): Readonly<Pick<TBackend, TKey>> {\n  const entries = keys.flatMap((key) => {\n    if (!Reflect.has(backend, key)) return [];\n    return [[key, Reflect.get(backend, key)] as const];\n  });\n\n  // Keys are constrained to TBackend and values are copied from that same\n  // object without reshaping. Optional members remain absent.\n  return Object.fromEntries(entries) as Readonly<Pick<TBackend, TKey>>;\n}\n\n/**\n * Creates a runtime GraphBackend projection.\n *\n * Structurally wider inputs (for example AdapterBackend) lose every property\n * not named by the portable GraphBackend allowlist. Optional port members stay\n * absent when the source does not provide them.\n *\n * @internal\n */\nexport function createGraphBackendProjection(\n  backend: GraphBackend,\n): GraphBackend {\n  return projectBackendMembers(backend, GRAPH_BACKEND_PROJECTION_KEYS);\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\";\nimport { requireDefined } from \"../utils/presence\";\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) => requireDefined(backend.insertNodeNoReturn)(params),\n    batch:\n      backend.insertNodesBatch === undefined ?\n        undefined\n      : (params) => requireDefined(backend.insertNodesBatch)(params),\n    batchReturning:\n      backend.insertNodesBatchReturning === undefined ?\n        undefined\n      : (params) => requireDefined(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) => requireDefined(backend.insertEdgeNoReturn)(params),\n    batch:\n      backend.insertEdgesBatch === undefined ?\n        undefined\n      : (params) => requireDefined(backend.insertEdgesBatch)(params),\n    batchReturning:\n      backend.insertEdgesBatchReturning === undefined ?\n        undefined\n      : (params) => requireDefined(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","/**\n * Predicate Expression Compilation\n *\n * Compiles predicate AST nodes to SQL using dialect adapters.\n * Handles comparisons, string operations, null checks, array/object predicates,\n * and subqueries.\n */\nimport { UnsupportedPredicateError } from \"../../errors\";\nimport { requireDefined } from \"../../utils/presence\";\nimport {\n  type ArrayPredicate,\n  type ExistsSubquery,\n  type FieldRef,\n  type FulltextMatchPredicate,\n  type InSubquery,\n  type LiteralValue,\n  type ObjectPredicate,\n  type ParameterRef,\n  type PredicateExpression,\n  type QueryAst,\n  type ValueType,\n  type VectorSimilarityPredicate,\n} from \"../ast\";\nimport {\n  LIKE_ESCAPE_CHARACTER,\n  likeEscapeClause,\n} from \"../dialect/like-escape\";\nimport { type DialectAdapter } from \"../dialect/types\";\nimport { type VectorStrategy } from \"../dialect/vector-strategy\";\nimport {\n  joinJsonPointers,\n  type JsonPointer,\n  jsonPointer,\n} from \"../json-pointer\";\nimport { isParameterRef } from \"../predicates\";\nimport { sql, type SqlFragment } from \"../sql-fragment\";\nimport {\n  getSingleSubqueryColumnValueType,\n  getSubqueryColumnCount,\n  isInSubqueryTypeCompatible,\n  isUnsupportedInSubqueryValueType,\n} from \"../subquery-utils\";\nimport { type SqlSchema, type VectorSlotMap } from \"./schema\";\nimport { type ReadInstantMode } from \"./temporal\";\n\nconst COMPARISON_OP_SQL: Record<string, string> = {\n  eq: \"=\",\n  neq: \"!=\",\n  gt: \">\",\n  gte: \">=\",\n  lt: \"<\",\n  lte: \"<=\",\n};\n\n// ============================================================\n// Field Reference Compilation\n// ============================================================\n\n/**\n * Compiles a field reference to a base column name.\n *\n * @param field - The field reference to compile\n * @param cteAlias - Optional CTE alias for main query context (e.g., \"cte_p\")\n * @param cteColumnPrefix - Optional prefix for CTE WHERE context:\n *   - undefined: Use aliased column names (e.g., \"p_props\")\n *   - \"\": Use raw column names (e.g., \"props\") for start CTE\n *   - \"n\": Use table-qualified names (e.g., \"n.props\") for traversal CTE\n */\nexport function compileFieldColumn(\n  field: FieldRef,\n  cteAlias?: string,\n  cteColumnPrefix?: string,\n): SqlFragment {\n  // When cteColumnPrefix is defined (including empty string), use raw column names\n  // This is for CTE WHERE clauses which operate on raw table columns\n  if (cteColumnPrefix !== undefined) {\n    const qualifier = cteColumnPrefix === \"\" ? \"\" : `${cteColumnPrefix}.`;\n\n    if (field.path.length === 1 && field.path[0] === \"id\") {\n      return sql.raw(`${qualifier}id`);\n    }\n    if (field.path.length === 1 && field.path[0] === \"kind\") {\n      return sql.raw(`${qualifier}kind`);\n    }\n    if (field.path.length > 0 && field.path[0] === \"props\") {\n      return sql.raw(`${qualifier}props`);\n    }\n\n    return sql.raw(`${qualifier}${field.path.join(\"_\")}`);\n  }\n\n  // Default behavior: use aliased column names (e.g., \"p_props\")\n  const prefix = field.alias;\n  const qualifier = cteAlias ? `${cteAlias}.` : \"\";\n\n  if (field.path.length === 1 && field.path[0] === \"id\") {\n    return sql.raw(`${qualifier}${prefix}_id`);\n  }\n  if (field.path.length === 1 && field.path[0] === \"kind\") {\n    return sql.raw(`${qualifier}${prefix}_kind`);\n  }\n  if (field.path.length > 0 && field.path[0] === \"props\") {\n    return sql.raw(`${qualifier}${prefix}_props`);\n  }\n\n  return sql.raw(`${qualifier}${prefix}_${field.path.join(\"_\")}`);\n}\n\n/**\n * Gets the JSON pointer for a field reference.\n */\nexport function getFieldPointer(field: FieldRef): JsonPointer | undefined {\n  if (field.jsonPointer !== undefined) {\n    return field.jsonPointer;\n  }\n\n  if (field.path.length > 1 && field.path[0] === \"props\") {\n    return jsonPointer(field.path.slice(1));\n  }\n\n  return undefined;\n}\n\n/**\n * Checks if a field reference points to a JSON props column.\n */\nfunction isJsonField(field: FieldRef): boolean {\n  return field.path.length > 0 && field.path[0] === \"props\";\n}\n\n/**\n * Normalizes a value type, treating \"unknown\" as undefined.\n */\nfunction normalizeValueType(\n  valueType: ValueType | undefined,\n): ValueType | undefined {\n  if (!valueType || valueType === \"unknown\") {\n    return undefined;\n  }\n  return valueType;\n}\n\n/**\n * Compiles a field reference to SQL with appropriate type extraction.\n */\nexport function compileFieldValue(\n  field: FieldRef,\n  dialect: DialectAdapter,\n  valueType?: ValueType,\n  cteAlias?: string,\n  pointerOverride?: JsonPointer,\n  cteColumnPrefix?: string,\n): SqlFragment {\n  const resolved = normalizeValueType(valueType);\n  const column = compileFieldColumn(field, cteAlias, cteColumnPrefix);\n\n  if (!isJsonField(field)) {\n    return column;\n  }\n\n  const pointer = pointerOverride ?? getFieldPointer(field);\n  if (!pointer || pointer === \"\") {\n    return column;\n  }\n\n  switch (resolved) {\n    case \"number\": {\n      return dialect.jsonExtractNumber(column, pointer);\n    }\n    case \"boolean\": {\n      return dialect.jsonExtractBoolean(column, pointer);\n    }\n    case \"date\": {\n      return dialect.jsonExtractDate(column, pointer);\n    }\n    case \"array\":\n    case \"object\":\n    case \"embedding\": {\n      // Embeddings are stored in a separate table, but if we need to\n      // extract from JSON, treat like a regular JSON value\n      return dialect.jsonExtract(column, pointer);\n    }\n    case \"string\":\n    case \"unknown\":\n    case undefined: {\n      return dialect.jsonExtractText(column, pointer);\n    }\n  }\n}\n\n/**\n * Compiles a field reference for text comparison.\n */\nfunction compileFieldTextValue(\n  field: FieldRef,\n  dialect: DialectAdapter,\n  cteAlias?: string,\n  pointerOverride?: JsonPointer,\n  cteColumnPrefix?: string,\n): SqlFragment {\n  const column = compileFieldColumn(field, cteAlias, cteColumnPrefix);\n  if (!isJsonField(field)) {\n    return column;\n  }\n\n  const pointer = pointerOverride ?? getFieldPointer(field);\n  if (!pointer || pointer === \"\") {\n    return column;\n  }\n\n  return dialect.jsonExtractText(column, pointer);\n}\n\n/**\n * Compiles a field reference for JSON value extraction.\n */\nfunction compileFieldJsonValue(\n  field: FieldRef,\n  dialect: DialectAdapter,\n  cteAlias?: string,\n  pointerOverride?: JsonPointer,\n  cteColumnPrefix?: string,\n): SqlFragment {\n  const column = compileFieldColumn(field, cteAlias, cteColumnPrefix);\n  if (!isJsonField(field)) {\n    return column;\n  }\n\n  const pointer = pointerOverride ?? getFieldPointer(field);\n  if (!pointer || pointer === \"\") {\n    return column;\n  }\n\n  return dialect.jsonExtract(column, pointer);\n}\n\n// ============================================================\n// Value Type Resolution\n// ============================================================\n\n/**\n * Resolves literal value types from an array of literals.\n */\nfunction resolveLiteralValueTypes(\n  literals: readonly LiteralValue[],\n): ValueType | undefined {\n  const resolved = new Set<ValueType>();\n\n  for (const literal of literals) {\n    const valueType = normalizeValueType(literal.valueType);\n    if (valueType) {\n      resolved.add(valueType);\n    }\n  }\n\n  if (resolved.size > 1) {\n    throw new UnsupportedPredicateError(\n      \"Mixed literal value types are not supported in predicates\",\n      { valueTypes: [...resolved] },\n    );\n  }\n\n  return resolved.values().next().value;\n}\n\n/**\n * Resolves the value type for a comparison predicate.\n */\nfunction resolveComparisonValueType(\n  field: FieldRef,\n  right: LiteralValue | readonly LiteralValue[] | ParameterRef,\n): ValueType | undefined {\n  if (isParameterRef(right)) {\n    return (\n      normalizeValueType(right.valueType) ?? normalizeValueType(field.valueType)\n    );\n  }\n  const literals = Array.isArray(right) ? right : [right];\n  const literalType = resolveLiteralValueTypes(literals);\n  const fieldType = normalizeValueType(field.valueType);\n\n  // Date fields compared with string literals should use date type\n  if (fieldType === \"date\" && literalType === \"string\") {\n    return fieldType;\n  }\n\n  if (literalType) {\n    return literalType;\n  }\n\n  return fieldType;\n}\n\n/**\n * Resolves value type with preference for explicit type.\n */\nfunction resolvePredicateValueType(\n  preferred: ValueType | undefined,\n  literal: LiteralValue | undefined,\n): ValueType | undefined {\n  const normalizedPreferred = normalizeValueType(preferred);\n  if (normalizedPreferred) {\n    return normalizedPreferred;\n  }\n\n  return literal ? normalizeValueType(literal.valueType) : undefined;\n}\n\n// ============================================================\n// Value Conversion\n// ============================================================\n\n/**\n * Converts a literal value for SQL binding.\n * Delegates to dialect adapter for proper type conversion (e.g., boolean → 0/1 for SQLite).\n */\nfunction convertValueForSql(value: unknown, dialect: DialectAdapter): unknown {\n  return dialect.bindValue(value);\n}\n\n// ============================================================\n// String Pattern Compilation\n// ============================================================\n\n/**\n * Compiles a string pattern for LIKE operations.\n */\nfunction compileStringPattern(op: string, pattern: string): string {\n  // Escape the escape character first so the wildcards we prefix below aren't\n  // double-escaped, then neutralize the LIKE wildcards. Mirrors\n  // escapeLikePatternParameter for the parameterized path. The emitted\n  // LIKE/ILIKE declares this same character as its ESCAPE (see likeEscapeClause).\n  const escaped = pattern\n    .replaceAll(\n      LIKE_ESCAPE_CHARACTER,\n      `${LIKE_ESCAPE_CHARACTER}${LIKE_ESCAPE_CHARACTER}`,\n    )\n    .replaceAll(\"%\", `${LIKE_ESCAPE_CHARACTER}%`)\n    .replaceAll(\"_\", `${LIKE_ESCAPE_CHARACTER}_`);\n\n  switch (op) {\n    case \"contains\": {\n      return `%${escaped}%`;\n    }\n    case \"startsWith\": {\n      return `${escaped}%`;\n    }\n    case \"endsWith\": {\n      return `%${escaped}`;\n    }\n    case \"like\":\n    case \"ilike\": {\n      return pattern;\n    }\n    default: {\n      return escaped;\n    }\n  }\n}\n\n/**\n * Escapes wildcard characters in a SQL pattern parameter. Mirrors\n * `compileStringPattern`'s escaping for the literal-pattern path, both driven\n * by the same {@link LIKE_ESCAPE_CHARACTER} so they can't drift apart.\n */\nfunction escapeLikePatternParameter(parameter: SqlFragment): SqlFragment {\n  const doubledEscape = `${LIKE_ESCAPE_CHARACTER}${LIKE_ESCAPE_CHARACTER}`;\n  return sql`REPLACE(REPLACE(REPLACE(${parameter}, ${LIKE_ESCAPE_CHARACTER}, ${doubledEscape}), '%', ${`${LIKE_ESCAPE_CHARACTER}%`}), '_', ${`${LIKE_ESCAPE_CHARACTER}_`})`;\n}\n\n/**\n * Builds a SQL pattern expression for parameterized string operations.\n */\nfunction compileParameterizedStringPattern(\n  op: string,\n  parameter: SqlFragment,\n): SqlFragment {\n  switch (op) {\n    case \"contains\": {\n      const escaped = escapeLikePatternParameter(parameter);\n      return sql`'%' || ${escaped} || '%'`;\n    }\n    case \"startsWith\": {\n      const escaped = escapeLikePatternParameter(parameter);\n      return sql`${escaped} || '%'`;\n    }\n    case \"endsWith\": {\n      const escaped = escapeLikePatternParameter(parameter);\n      return sql`'%' || ${escaped}`;\n    }\n    case \"like\":\n    case \"ilike\": {\n      return parameter;\n    }\n    default: {\n      return escapeLikePatternParameter(parameter);\n    }\n  }\n}\n\n// ============================================================\n// Predicate Compilation\n// ============================================================\n\n/**\n * Compiler context passed to recursive compilation functions.\n *\n * When compiling predicates inside CTE WHERE clauses, `cteColumnPrefix` specifies\n * how to reference columns:\n * - undefined: Use aliased column names (e.g., \"p_props\") - for main query context\n * - \"\": Use raw column names (e.g., \"props\") - for start CTE WHERE clause\n * - \"n\": Use table-qualified names (e.g., \"n.props\") - for traversal CTE WHERE clause\n */\nexport type PredicateCompilerContext = Readonly<{\n  dialect: DialectAdapter;\n  schema: SqlSchema;\n  compileQuery: (ast: QueryAst, graphId: string) => SqlFragment;\n  cteColumnPrefix?: string;\n  /**\n   * Active vector strategy for `field.similarTo(...)` compilation. When\n   * present, the embeddings CTE scans the strategy's per-`(kind, field)`\n   * tables and uses its `distanceExpression`; absent on backends without\n   * vector support (the vector pass rejects the predicate before the CTE\n   * builder runs).\n   */\n  vectorStrategy?: VectorStrategy;\n  /**\n   * Whether the active backend supports SQL window functions such as\n   * `ROW_NUMBER()`.\n   */\n  windowFunctions: boolean;\n  /**\n   * Declared embedding slots `(kind, fieldPath) -> {dimensions, metric,\n   * indexType}`. The embeddings CTE consults it to know which kinds in\n   * an alias actually declare the field — only those get a per-field\n   * table scan in the UNION ALL.\n   */\n  vectorSlots?: VectorSlotMap;\n  /** Per-kind declared fulltext language for constant-tsquery parsing. */\n  fulltextLanguages?: ReadonlyMap<string, string>;\n  /**\n   * Mutable collector: the emitter records each ANN slot index type it\n   * compiles an engine-form branch for, and the compiler entry brands\n   * the finished statement with them (see markAnnIndexScan).\n   */\n  annIndexTypes?: Set<string>;\n  /**\n   * How the temporal pass emits the \"current\" read instant. Threaded from\n   * {@link CompileQueryOptions.readInstant} so the standard and recursive\n   * pipelines can compile a reusable placeholder statement for the query\n   * builder's template cache. Absent means `\"literal\"`.\n   */\n  readInstant?: ReadInstantMode;\n}>;\n\n/**\n * Compiles a predicate expression to SQL.\n */\nexport function compilePredicateExpression(\n  expr: PredicateExpression,\n  ctx: PredicateCompilerContext,\n): SqlFragment {\n  const { dialect } = ctx;\n\n  const cteColumnPrefix = ctx.cteColumnPrefix;\n\n  switch (expr.__type) {\n    case \"comparison\": {\n      return compileComparisonPredicate(expr, dialect, cteColumnPrefix);\n    }\n\n    case \"string_op\": {\n      const field = compileFieldTextValue(\n        expr.field,\n        dialect,\n        undefined,\n        undefined,\n        cteColumnPrefix,\n      );\n\n      if (isParameterRef(expr.pattern)) {\n        const placeholder = sql`${sql.placeholder(expr.pattern.name)}`;\n        const pattern = compileParameterizedStringPattern(expr.op, placeholder);\n        if (\n          expr.op === \"ilike\" ||\n          expr.op === \"contains\" ||\n          expr.op === \"startsWith\" ||\n          expr.op === \"endsWith\"\n        ) {\n          return dialect.ilike(field, pattern);\n        }\n        return sql`${field} LIKE ${pattern} ${likeEscapeClause}`;\n      }\n\n      const pattern = compileStringPattern(expr.op, expr.pattern);\n      // Use case-insensitive matching for contains, startsWith, endsWith, and ilike\n      // This ensures consistent behavior across PostgreSQL (case-sensitive LIKE)\n      // and SQLite (case-insensitive LIKE for ASCII)\n      if (\n        expr.op === \"ilike\" ||\n        expr.op === \"contains\" ||\n        expr.op === \"startsWith\" ||\n        expr.op === \"endsWith\"\n      ) {\n        return dialect.ilike(field, pattern);\n      }\n      // Use case-sensitive LIKE only for explicit 'like' operator. The ESCAPE\n      // clause must match the parameterized path (above) and dialect.ilike so a\n      // raw '\\%' / '\\_' in a user pattern is a literal on SQLite too, not just\n      // on Postgres (whose default LIKE escape is already backslash).\n      return sql`${field} LIKE ${pattern} ${likeEscapeClause}`;\n    }\n\n    case \"null_check\": {\n      const field = compileFieldTextValue(\n        expr.field,\n        dialect,\n        undefined,\n        undefined,\n        cteColumnPrefix,\n      );\n      return expr.op === \"isNull\" ?\n          sql`${field} IS NULL`\n        : sql`${field} IS NOT NULL`;\n    }\n\n    case \"between\": {\n      const lowerIsParam = isParameterRef(expr.lower);\n      const upperIsParam = isParameterRef(expr.upper);\n\n      // Resolve value type from non-param bounds\n      const boundsForType: LiteralValue[] = [];\n      if (!lowerIsParam) boundsForType.push(expr.lower);\n      if (!upperIsParam) boundsForType.push(expr.upper);\n\n      const valueType =\n        boundsForType.length > 0 ?\n          resolveComparisonValueType(expr.field, boundsForType)\n        : normalizeValueType(expr.field.valueType);\n\n      if (valueType === \"array\" || valueType === \"object\") {\n        throw new UnsupportedPredicateError(\n          \"Between comparisons are not supported for JSON arrays or objects\",\n        );\n      }\n      const field = compileFieldValue(\n        expr.field,\n        dialect,\n        valueType,\n        undefined,\n        undefined,\n        cteColumnPrefix,\n      );\n      const lower =\n        lowerIsParam ?\n          sql.placeholder(expr.lower.name)\n        : convertValueForSql(expr.lower.value, dialect);\n      const upper =\n        upperIsParam ?\n          sql.placeholder(expr.upper.name)\n        : convertValueForSql(expr.upper.value, dialect);\n      return sql`${field} BETWEEN ${lower} AND ${upper}`;\n    }\n\n    case \"and\": {\n      const parts = expr.predicates.map((p) =>\n        compilePredicateExpression(p, ctx),\n      );\n      return sql`(${sql.join(parts, sql` AND `)})`;\n    }\n\n    case \"or\": {\n      const parts = expr.predicates.map((p) =>\n        compilePredicateExpression(p, ctx),\n      );\n      return sql`(${sql.join(parts, sql` OR `)})`;\n    }\n\n    case \"not\": {\n      const inner = compilePredicateExpression(expr.predicate, ctx);\n      return sql`NOT (${inner})`;\n    }\n\n    case \"array_op\": {\n      return compileArrayPredicate(expr, dialect, cteColumnPrefix);\n    }\n\n    case \"object_op\": {\n      return compileObjectPredicate(expr, dialect, cteColumnPrefix);\n    }\n\n    case \"aggregate_comparison\": {\n      return compileAggregatePredicate(expr, dialect);\n    }\n\n    case \"exists\": {\n      return compileExistsSubquery(expr, ctx);\n    }\n\n    case \"in_subquery\": {\n      return compileInSubquery(expr, ctx);\n    }\n\n    case \"vector_similarity\":\n    case \"fulltext_match\": {\n      // Structural predicates — handled by the main compiler via JOINs,\n      // ORDER BY, and LIMIT. Compile to 1=1 so they compose safely with\n      // surrounding AND branches.\n      return STRUCTURAL_PREDICATE_NOOP;\n    }\n  }\n}\n\nconst STRUCTURAL_PREDICATE_NOOP = sql.raw(\"1=1\");\n\n/**\n * Compiles a comparison predicate.\n */\nfunction compileComparisonPredicate(\n  expr: {\n    __type: \"comparison\";\n    op: string;\n    left: FieldRef;\n    right: LiteralValue | readonly LiteralValue[] | ParameterRef;\n  },\n  dialect: DialectAdapter,\n  cteColumnPrefix?: string,\n): SqlFragment {\n  // Handle ParameterRef on the right side\n  if (isParameterRef(expr.right)) {\n    const parameterValueType =\n      normalizeValueType(expr.right.valueType) ??\n      normalizeValueType(expr.left.valueType);\n    const left = compileFieldValue(\n      expr.left,\n      dialect,\n      parameterValueType,\n      undefined,\n      undefined,\n      cteColumnPrefix,\n    );\n    const opSql = COMPARISON_OP_SQL[expr.op];\n    if (!opSql) {\n      throw new UnsupportedPredicateError(\n        `Comparison operation \"${expr.op}\" is not supported for parameterized predicates`,\n      );\n    }\n    return sql`${left} ${sql.raw(opSql)} ${sql.placeholder(expr.right.name)}`;\n  }\n\n  const valueType = resolveComparisonValueType(expr.left, expr.right);\n\n  if (valueType === \"array\" || valueType === \"object\") {\n    throw new UnsupportedPredicateError(\n      `Comparison operation \"${expr.op}\" is not supported for ${valueType} values`,\n    );\n  }\n\n  const left = compileFieldValue(\n    expr.left,\n    dialect,\n    valueType,\n    undefined,\n    undefined,\n    cteColumnPrefix,\n  );\n\n  if (expr.op === \"in\" || expr.op === \"notIn\") {\n    const values: readonly LiteralValue[] =\n      Array.isArray(expr.right) ? expr.right : [expr.right as LiteralValue];\n    if (values.length === 0) {\n      return expr.op === \"in\" ? sql.raw(\"1=0\") : sql.raw(\"1=1\");\n    }\n    const convertedValues = values.map((value) =>\n      convertValueForSql(value.value, dialect),\n    );\n    return dialect.inList(left, convertedValues, expr.op === \"notIn\");\n  }\n\n  // For single-value comparisons, extract the literal value\n  const right = expr.right;\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- Type narrowing with Array.isArray\n  const rightValue: LiteralValue =\n    Array.isArray(right) ? requireDefined(right[0]) : right;\n\n  const convertedRight = convertValueForSql(rightValue.value, dialect);\n  const opSql = COMPARISON_OP_SQL[expr.op];\n  if (!opSql) {\n    throw new UnsupportedPredicateError(\n      `Comparison operation \"${expr.op}\" is not supported`,\n    );\n  }\n  return sql`${left} ${sql.raw(opSql)} ${convertedRight}`;\n}\n\n/**\n * Compiles an array predicate.\n */\nfunction compileArrayPredicate(\n  expr: ArrayPredicate,\n  dialect: DialectAdapter,\n  cteColumnPrefix?: string,\n): SqlFragment {\n  const field = compileFieldJsonValue(\n    expr.field,\n    dialect,\n    undefined,\n    undefined,\n    cteColumnPrefix,\n  );\n  const values =\n    expr.values?.map((v) => convertValueForSql(v.value, dialect)) ?? [];\n\n  switch (expr.op) {\n    case \"isEmpty\": {\n      return sql`(${field} IS NULL OR ${dialect.jsonArrayLength(field)} = 0)`;\n    }\n    case \"isNotEmpty\": {\n      return sql`(${field} IS NOT NULL AND ${dialect.jsonArrayLength(field)} > 0)`;\n    }\n    case \"lengthEq\": {\n      return sql`${dialect.jsonArrayLength(field)} = ${expr.length}`;\n    }\n    case \"lengthGt\": {\n      return sql`${dialect.jsonArrayLength(field)} > ${expr.length}`;\n    }\n    case \"lengthGte\": {\n      return sql`${dialect.jsonArrayLength(field)} >= ${expr.length}`;\n    }\n    case \"lengthLt\": {\n      return sql`${dialect.jsonArrayLength(field)} < ${expr.length}`;\n    }\n    case \"lengthLte\": {\n      return sql`${dialect.jsonArrayLength(field)} <= ${expr.length}`;\n    }\n    case \"contains\": {\n      const value = values[0];\n      if (value === undefined) {\n        return sql.raw(\"1=0\");\n      }\n      return dialect.jsonArrayContains(field, value);\n    }\n    case \"containsAll\": {\n      return dialect.jsonArrayContainsAll(field, values);\n    }\n    case \"containsAny\": {\n      return dialect.jsonArrayContainsAny(field, values);\n    }\n  }\n}\n\n/**\n * Compiles an object/JSON predicate.\n */\nfunction compileObjectPredicate(\n  expr: ObjectPredicate,\n  dialect: DialectAdapter,\n  cteColumnPrefix?: string,\n): SqlFragment {\n  const basePointer = getFieldPointer(expr.field);\n  const pointer = joinJsonPointers(basePointer, expr.pointer);\n  const column = compileFieldColumn(expr.field, undefined, cteColumnPrefix);\n\n  switch (expr.op) {\n    case \"hasKey\":\n    case \"hasPath\": {\n      return dialect.jsonHasPath(column, pointer);\n    }\n\n    case \"pathEquals\": {\n      if (!expr.value) {\n        throw new UnsupportedPredicateError(\n          \"pathEquals requires a comparison value\",\n        );\n      }\n      const valueType = resolvePredicateValueType(expr.valueType, expr.value);\n      if (valueType === \"array\" || valueType === \"object\") {\n        throw new UnsupportedPredicateError(\n          \"pathEquals is not supported for JSON arrays or objects\",\n        );\n      }\n      const left = compileFieldValue(\n        expr.field,\n        dialect,\n        valueType,\n        undefined,\n        pointer,\n        cteColumnPrefix,\n      );\n      return sql`${left} = ${convertValueForSql(expr.value.value, dialect)}`;\n    }\n\n    case \"pathContains\": {\n      if (!expr.value) {\n        throw new UnsupportedPredicateError(\n          \"pathContains requires a comparison value\",\n        );\n      }\n      const arrayField = compileFieldJsonValue(\n        expr.field,\n        dialect,\n        undefined,\n        pointer,\n        cteColumnPrefix,\n      );\n      return dialect.jsonArrayContains(\n        arrayField,\n        convertValueForSql(expr.value.value, dialect),\n      );\n    }\n\n    case \"pathIsNull\": {\n      return dialect.jsonPathIsNull(column, pointer);\n    }\n\n    case \"pathIsNotNull\": {\n      return dialect.jsonPathIsNotNull(column, pointer);\n    }\n  }\n}\n\n/**\n * AggregateExpr structure from AST.\n */\ntype AggregateExprInput = Readonly<{\n  __type: \"aggregate\";\n  function: string;\n  field: FieldRef;\n}>;\n\n/**\n * Compiles an aggregate comparison predicate.\n */\nfunction compileAggregatePredicate(\n  expr: {\n    __type: \"aggregate_comparison\";\n    op: string;\n    aggregate: AggregateExprInput;\n    value: LiteralValue;\n  },\n  dialect: DialectAdapter,\n): SqlFragment {\n  const aggregate = compileAggregateExpr(expr.aggregate, dialect);\n\n  const op = COMPARISON_OP_SQL[expr.op];\n  if (!op) {\n    throw new UnsupportedPredicateError(\n      `Comparison operation \"${expr.op}\" is not supported for aggregate predicates`,\n    );\n  }\n\n  const convertedValue = convertValueForSql(expr.value.value, dialect);\n  return sql`${aggregate} ${sql.raw(op)} ${convertedValue}`;\n}\n\n/**\n * Compiles an aggregate expression.\n */\nfunction compileAggregateExpr(\n  expr: AggregateExprInput,\n  dialect: DialectAdapter,\n): SqlFragment {\n  const cteAlias = `cte_${expr.field.alias}`;\n  const field = compileFieldValue(\n    expr.field,\n    dialect,\n    expr.field.valueType,\n    cteAlias,\n  );\n\n  switch (expr.function) {\n    case \"count\": {\n      return sql`COUNT(${field})`;\n    }\n    case \"countDistinct\": {\n      return sql`COUNT(DISTINCT ${field})`;\n    }\n    case \"sum\": {\n      return sql`SUM(${field})`;\n    }\n    case \"avg\": {\n      return sql`AVG(${field})`;\n    }\n    case \"min\": {\n      return sql`MIN(${field})`;\n    }\n    case \"max\": {\n      return sql`MAX(${field})`;\n    }\n    default: {\n      throw new UnsupportedPredicateError(\n        `Unknown aggregate function: ${expr.function}`,\n      );\n    }\n  }\n}\n\n/**\n * Compiles an EXISTS subquery predicate.\n */\nfunction compileExistsSubquery(\n  expr: ExistsSubquery,\n  ctx: PredicateCompilerContext,\n): SqlFragment {\n  if (expr.subquery.graphId === undefined) {\n    throw new UnsupportedPredicateError(\"EXISTS subquery must have a graphId\");\n  }\n  const subSql = ctx.compileQuery(expr.subquery, expr.subquery.graphId);\n  return expr.negated ? sql`NOT EXISTS (${subSql})` : sql`EXISTS (${subSql})`;\n}\n\n/**\n * Compiles an IN subquery predicate.\n */\nfunction compileInSubquery(\n  expr: InSubquery,\n  ctx: PredicateCompilerContext,\n): SqlFragment {\n  const subqueryColumnCount = getSubqueryColumnCount(expr.subquery);\n  if (subqueryColumnCount !== 1) {\n    throw new UnsupportedPredicateError(\n      `IN/NOT IN subquery must project exactly 1 column, but got ${subqueryColumnCount}`,\n      { subqueryColumnCount },\n    );\n  }\n\n  const fieldValueType = normalizeValueType(expr.field.valueType);\n  const subqueryValueType = getSingleSubqueryColumnValueType(expr.subquery);\n  const resolvedValueType = fieldValueType ?? subqueryValueType;\n\n  if (isUnsupportedInSubqueryValueType(resolvedValueType)) {\n    throw new UnsupportedPredicateError(\n      `IN/NOT IN subquery does not support ${String(resolvedValueType)} values`,\n      { valueType: resolvedValueType },\n    );\n  }\n\n  if (!isInSubqueryTypeCompatible(fieldValueType, subqueryValueType)) {\n    throw new UnsupportedPredicateError(\n      `IN/NOT IN type mismatch: field type \"${String(fieldValueType)}\" does not match subquery column type \"${String(subqueryValueType)}\"`,\n      {\n        fieldValueType,\n        subqueryValueType,\n      },\n    );\n  }\n\n  const valueType = fieldValueType ?? subqueryValueType;\n  if (expr.subquery.graphId === undefined) {\n    throw new UnsupportedPredicateError(\n      \"IN/NOT IN subquery must have a graphId\",\n    );\n  }\n  const fieldSql = compileFieldValue(\n    expr.field,\n    ctx.dialect,\n    valueType,\n    undefined,\n    undefined,\n    ctx.cteColumnPrefix,\n  );\n  const subSql = ctx.compileQuery(expr.subquery, expr.subquery.graphId);\n  return expr.negated ?\n      sql`${fieldSql} NOT IN (${subSql})`\n    : sql`${fieldSql} IN (${subSql})`;\n}\n\n/**\n * Compiles a vector similarity predicate.\n *\n * Vector similarity predicates require special handling at the query compilation\n * level to handle:\n * - JOIN to embeddings table\n * - ORDER BY distance ASC\n * - LIMIT k\n *\n * This function handles the minScore filter if present. The main query compiler\n * must detect vector_similarity predicates and set up the appropriate JOINs\n * and ordering.\n */\n\n// ============================================================\n// Structural Predicate Extraction\n// ============================================================\n\n/**\n * Extracts all instances of a \"structural\" predicate (one that rewrites\n * the query into JOIN + ORDER BY + LIMIT, rather than acting as a\n * boolean WHERE clause). Both `vector_similarity` and `fulltext_match`\n * have the same placement rules: top-level or under AND only — nesting\n * under OR/NOT is rejected because the rewrite is incompatible with\n * disjunction and negation.\n */\nfunction extractStructuralPredicates<T extends PredicateExpression>(\n  predicates: readonly { expression: PredicateExpression }[],\n  isMatch: (expr: PredicateExpression) => expr is T,\n  rejectionMessage: string,\n): T[] {\n  const results: T[] = [];\n\n  function visit(expr: PredicateExpression, inDisallowedBranch: boolean): void {\n    if (isMatch(expr)) {\n      if (inDisallowedBranch) {\n        throw new UnsupportedPredicateError(rejectionMessage);\n      }\n      results.push(expr);\n      return;\n    }\n    switch (expr.__type) {\n      case \"and\": {\n        for (const child of expr.predicates) visit(child, inDisallowedBranch);\n        return;\n      }\n      case \"or\": {\n        for (const child of expr.predicates) visit(child, true);\n        return;\n      }\n      case \"not\": {\n        visit(expr.predicate, true);\n        return;\n      }\n      case \"comparison\":\n      case \"string_op\":\n      case \"null_check\":\n      case \"between\":\n      case \"array_op\":\n      case \"object_op\":\n      case \"aggregate_comparison\":\n      case \"exists\":\n      case \"in_subquery\":\n      case \"vector_similarity\":\n      case \"fulltext_match\": {\n        return;\n      }\n    }\n  }\n\n  for (const pred of predicates) visit(pred.expression, false);\n  return results;\n}\n\nexport function extractVectorSimilarityPredicates(\n  predicates: readonly { expression: PredicateExpression }[],\n): VectorSimilarityPredicate[] {\n  return extractStructuralPredicates(\n    predicates,\n    (expr): expr is VectorSimilarityPredicate =>\n      expr.__type === \"vector_similarity\",\n    \"Vector similarity predicates cannot be nested under OR or NOT. \" +\n      \"Use top-level AND combinations instead.\",\n  );\n}\n\nexport function extractFulltextMatchPredicates(\n  predicates: readonly { expression: PredicateExpression }[],\n): FulltextMatchPredicate[] {\n  return extractStructuralPredicates(\n    predicates,\n    (expr): expr is FulltextMatchPredicate => expr.__type === \"fulltext_match\",\n    \"Fulltext match predicates cannot be nested under OR or NOT. \" +\n      \"Use top-level AND combinations instead.\",\n  );\n}\n\n// ============================================================\n// Exports for aggregate compilation\n// ============================================================\n\nexport { compileAggregateExpr };\n","import type { KindEntity } from \"../../core/types\";\nimport { CompilerInvariantError } from \"../../errors\";\nimport {\n  type FulltextMatchPredicate,\n  type NodePredicate,\n  type QueryAst,\n  type VectorSimilarityPredicate,\n} from \"../ast\";\nimport { sql, type SqlFragment } from \"../sql-fragment\";\nimport {\n  compilePredicateExpression,\n  type PredicateCompilerContext,\n} from \"./predicates\";\n\nconst EMPTY_PREDICATES: readonly NodePredicate[] = [];\n\n/**\n * Builds a comma-separated bound-parameter list for an `IN (...)` clause. Each\n * value is parameterized, never interpolated.\n */\nexport function sqlValueList(values: readonly string[]): SqlFragment {\n  return sql.join(\n    values.map((value) => sql`${value}`),\n    sql`, `,\n  );\n}\n\nexport type PredicateIndex = Readonly<{\n  byAliasAndType: ReadonlyMap<string, readonly NodePredicate[]>;\n}>;\n\nfunction buildPredicateIndexKey(alias: string, targetType: KindEntity): string {\n  return `${alias}\\u0000${targetType}`;\n}\n\nfunction resolvePredicateTargetType(predicate: NodePredicate): KindEntity {\n  return predicate.targetType === \"edge\" ? \"edge\" : \"node\";\n}\n\nexport function buildPredicateIndex(ast: QueryAst): PredicateIndex {\n  const byAliasAndType = new Map<string, NodePredicate[]>();\n  for (const predicate of ast.predicates) {\n    const key = buildPredicateIndexKey(\n      predicate.targetAlias,\n      resolvePredicateTargetType(predicate),\n    );\n    const existing = byAliasAndType.get(key);\n    if (existing === undefined) {\n      byAliasAndType.set(key, [predicate]);\n    } else {\n      existing.push(predicate);\n    }\n  }\n  return { byAliasAndType };\n}\n\nexport function getPredicatesForAlias(\n  predicateIndex: PredicateIndex,\n  alias: string,\n  targetType: KindEntity,\n): readonly NodePredicate[] {\n  return (\n    predicateIndex.byAliasAndType.get(\n      buildPredicateIndexKey(alias, targetType),\n    ) ?? EMPTY_PREDICATES\n  );\n}\n\nexport function compilePredicateClauses(\n  predicates: readonly NodePredicate[],\n  predicateContext: PredicateCompilerContext,\n): SqlFragment[] {\n  return predicates.map((predicate) =>\n    compilePredicateExpression(predicate.expression, predicateContext),\n  );\n}\n\nexport function compileKindFilter(\n  column: SqlFragment,\n  kinds: readonly string[],\n): SqlFragment {\n  if (kinds.length === 0) {\n    return sql`1 = 0`;\n  }\n  if (kinds.length === 1) {\n    return sql`${column} = ${kinds[0]}`;\n  }\n  return sql`${column} IN (${sqlValueList(kinds)})`;\n}\n\nexport function getNodeKindsForAlias(\n  ast: QueryAst,\n  alias: string,\n): readonly string[] {\n  if (alias === ast.start.alias) {\n    return ast.start.kinds;\n  }\n\n  for (const traversal of ast.traversals) {\n    if (traversal.nodeAlias === alias) {\n      return traversal.nodeKinds;\n    }\n  }\n\n  throw new CompilerInvariantError(`Unknown traversal source alias: ${alias}`);\n}\n\n/**\n * Returns the shared alias when a hybrid (vector + fulltext) query has\n * both predicates targeting the same alias — that's the case where the\n * emitter can fuse ranks via `HYBRID_CANDIDATES_CTE_ALIAS` / RRF.\n * Returns `undefined` when either predicate is missing or the two\n * predicates target different aliases.\n */\nexport function getHybridTargetAlias(\n  vectorPredicate: VectorSimilarityPredicate | undefined,\n  fulltextPredicate: FulltextMatchPredicate | undefined,\n): string | undefined {\n  if (!vectorPredicate || !fulltextPredicate) return undefined;\n  return vectorPredicate.field.alias === fulltextPredicate.field.alias ?\n      vectorPredicate.field.alias\n    : undefined;\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 { requireDefined } from \"../utils/presence\";\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) => requireDefined(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 { requireDefined } from \"../utils/presence\";\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) => requireDefined(backend.getNodes)(graphId, kind, batchIds),\n    one: (id) => backend.getNode(graphId, kind, id),\n  });\n}\n","import {\n  type EdgeRow,\n  type NodeRow,\n  rowPropsToJsonText,\n  type TransactionBackend,\n} from \"../../backend/types\";\nimport { RECORDED_MAX_REVISION } from \"../../core/temporal\";\nimport { ConfigurationError } from \"../../errors\";\nimport { sql, type SqlFragment } from \"../../query/sql-fragment\";\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  recordedRevision: number,\n  operation: RecordedOperation,\n) => SqlFragment;\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 sqlNull(value: string | undefined): SqlFragment {\n  return value === undefined ? sql.raw(\"NULL\") : sql`${value}`;\n}\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, recordedRevision) => sql`${recordedRevision}`,\n    recorded_to: () => sql`${RECORDED_MAX_REVISION}`,\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  recordedRevision: number,\n  operation: RecordedOperation,\n): SqlFragment {\n  const tuple = columns.map((column) =>\n    cells[column](row, recordedRevision, operation),\n  );\n  return sql`(${sql.join(tuple, sql`, `)})`;\n}\n\nasync function insertRecordedRows<Row, Column extends string>(\n  target: TransactionBackend,\n  table: SqlFragment,\n  columnList: SqlFragment,\n  columns: readonly Column[],\n  cells: Record<Column, RecordedCellBuilder<Row>>,\n  inserts: readonly RecordedInsert<Row>[],\n  recordedRevision: number,\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      recordedRevision,\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: SqlFragment,\n  inserts: readonly RecordedInsert<NodeRow>[],\n  recordedRevision: number,\n): Promise<void> {\n  return insertRecordedRows(\n    target,\n    table,\n    RECORDED_NODE_COLUMN_LIST,\n    RECORDED_NODE_COLUMNS,\n    recordedNodeCells,\n    inserts,\n    recordedRevision,\n  );\n}\n\nexport function insertRecordedEdgeRows(\n  target: TransactionBackend,\n  table: SqlFragment,\n  inserts: readonly RecordedInsert<EdgeRow>[],\n  recordedRevision: number,\n): Promise<void> {\n  return insertRecordedRows(\n    target,\n    table,\n    RECORDED_EDGE_COLUMN_LIST,\n    RECORDED_EDGE_COLUMNS,\n    recordedEdgeCells,\n    inserts,\n    recordedRevision,\n  );\n}\n","import {\n  type EdgeRow,\n  type HardDeleteNodeParams,\n  type NodeRow,\n  type TransactionBackend,\n} from \"../../backend/types\";\nimport { RECORDED_MAX_REVISION } from \"../../core/temporal\";\nimport { sqlValueList } from \"../../query/compiler/predicate-utils\";\nimport { type SqlSchema } from \"../../query/compiler/schema\";\nimport { sql, type SqlFragment } from \"../../query/sql-fragment\";\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: SqlFragment,\n  graphId: string,\n  ids: readonly string[],\n  recordedRevision: number,\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 = ${recordedRevision}\n      WHERE graph_id = ${graphId}\n        ${kindFilter}\n        AND recorded_to = ${RECORDED_MAX_REVISION}\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  recordedRevision: number,\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        recordedRevision,\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        recordedRevision,\n      );\n    }\n  }\n}\n\nexport async function flushEdges(\n  target: TransactionBackend,\n  schema: SqlSchema,\n  graphId: string,\n  entities: readonly TouchedEdge[],\n  recordedRevision: number,\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      recordedRevision,\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      recordedRevision,\n    );\n  }\n}\n\nasync function closeOpenByKind(\n  target: TransactionBackend,\n  table: SqlFragment,\n  graphId: string,\n  kind: string,\n  recordedRevision: number,\n): Promise<void> {\n  await executeStatement(\n    target,\n    sql`\n      UPDATE ${table}\n      SET recorded_to = ${recordedRevision}\n      WHERE graph_id = ${graphId}\n        AND kind = ${kind}\n        AND recorded_to = ${RECORDED_MAX_REVISION}\n    `,\n  );\n}\n\nasync function closeOpenEdgesByNodeKind(\n  target: TransactionBackend,\n  schema: SqlSchema,\n  graphId: string,\n  nodeKind: string,\n  recordedRevision: number,\n): Promise<void> {\n  await executeStatement(\n    target,\n    sql`\n      UPDATE ${schema.recordedEdgesTable}\n      SET recorded_to = ${recordedRevision}\n      WHERE graph_id = ${graphId}\n        AND (from_kind = ${nodeKind} OR to_kind = ${nodeKind})\n        AND recorded_to = ${RECORDED_MAX_REVISION}\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.revision,\n    );\n    await closeOpenEdgesByNodeKind(\n      target,\n      schema,\n      graphId,\n      removal.kind,\n      recordedCommit.revision,\n    );\n    return;\n  }\n  await closeOpenByKind(\n    target,\n    schema.recordedEdgesTable,\n    graphId,\n    removal.kind,\n    recordedCommit.revision,\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 { type GraphBackend } from \"../../backend/types\";\nimport { ConfigurationError } from \"../../errors\";\nimport { type SqlSchema } from \"../../query/compiler/schema\";\nimport { sql } from \"../../query/sql-fragment\";\nimport { asCompiledRowsSql } from \"../../query/sql-intent\";\n\ntype ColumnRow = Readonly<{ name: unknown; type: unknown }>;\n\ntype RecordedColumnKind = \"revision\" | \"wall-time\";\n\ntype RequiredRecordedColumn = Readonly<{\n  column: string;\n  kind: RecordedColumnKind;\n  table: string;\n}>;\n\nfunction normalizedColumnType(value: unknown): string | undefined {\n  if (typeof value !== \"string\") return undefined;\n  const normalized = value.trim().toLowerCase();\n  return normalized.length === 0 ? undefined : normalized;\n}\n\nasync function readColumnTypes(\n  backend: Pick<GraphBackend, \"dialect\" | \"execute\">,\n  table: string,\n): Promise<ReadonlyMap<string, string>> {\n  const rows =\n    backend.dialect === \"sqlite\" ?\n      await backend.execute<ColumnRow>(\n        asCompiledRowsSql(sql`PRAGMA table_info(${sql.identifier(table)})`),\n      )\n    : await backend.execute<ColumnRow>(\n        asCompiledRowsSql(sql`\n          SELECT column_name AS name, data_type AS type\n          FROM information_schema.columns\n          WHERE table_schema = current_schema()\n            AND table_name = ${table}\n        `),\n      );\n  return new Map(\n    rows.flatMap((row) => {\n      if (typeof row.name !== \"string\") return [];\n      const type = normalizedColumnType(row.type);\n      return type === undefined ? [] : [[row.name, type] as const];\n    }),\n  );\n}\n\nfunction hasSqliteAffinity(\n  declaredType: string,\n  kind: RecordedColumnKind,\n): boolean {\n  if (kind === \"revision\") return declaredType.includes(\"int\");\n  return (\n    declaredType.includes(\"char\") ||\n    declaredType.includes(\"clob\") ||\n    declaredType.includes(\"text\")\n  );\n}\n\nfunction isCompatibleColumnType(\n  dialect: GraphBackend[\"dialect\"],\n  declaredType: string,\n  kind: RecordedColumnKind,\n): boolean {\n  if (dialect === \"sqlite\") return hasSqliteAffinity(declaredType, kind);\n  return kind === \"revision\" ?\n      declaredType === \"bigint\"\n    : declaredType === \"timestamp with time zone\";\n}\n\nfunction requiredRecordedColumns(\n  schema: SqlSchema,\n): readonly RequiredRecordedColumn[] {\n  return [\n    {\n      table: schema.tables.recordedNodes,\n      column: \"recorded_from\",\n      kind: \"revision\",\n    },\n    {\n      table: schema.tables.recordedNodes,\n      column: \"recorded_to\",\n      kind: \"revision\",\n    },\n    {\n      table: schema.tables.recordedEdges,\n      column: \"recorded_from\",\n      kind: \"revision\",\n    },\n    {\n      table: schema.tables.recordedEdges,\n      column: \"recorded_to\",\n      kind: \"revision\",\n    },\n    {\n      table: schema.tables.recordedClock,\n      column: \"revision\",\n      kind: \"revision\",\n    },\n    {\n      table: schema.tables.recordedClock,\n      column: \"recorded_at\",\n      kind: \"wall-time\",\n    },\n  ];\n}\n\n/**\n * Verifies that a history-enabled async store open targets the current\n * physical recorded schema. The synchronous `createStore` attach path cannot\n * perform this I/O and retains its fail-loud first-operation behavior.\n */\nexport async function assertCurrentRecordedSchema(\n  backend: Pick<GraphBackend, \"dialect\" | \"execute\">,\n  schema: SqlSchema,\n): Promise<void> {\n  const requirements = requiredRecordedColumns(schema);\n  const tables = [...new Set(requirements.map((entry) => entry.table))];\n  const columnTypes = new Map(\n    await Promise.all(\n      tables.map(\n        async (table) =>\n          [table, await readColumnTypes(backend, table)] as const,\n      ),\n    ),\n  );\n  const incompatible = requirements.flatMap((requirement) => {\n    const actual = columnTypes.get(requirement.table)?.get(requirement.column);\n    if (\n      actual !== undefined &&\n      isCompatibleColumnType(backend.dialect, actual, requirement.kind)\n    ) {\n      return [];\n    }\n    return [{ ...requirement, actual: actual ?? \"missing\" }];\n  });\n  if (incompatible.length === 0) return;\n\n  throw new ConfigurationError(\n    \"Recorded-time schema is incompatible with history capture.\",\n    {\n      code: \"RECORDED_SCHEMA_INCOMPATIBLE\",\n      dialect: backend.dialect,\n      incompatible,\n    },\n    {\n      suggestion:\n        \"Run migrateLegacyRecordedTime({ backend }) before opening a store with history: true. If these are not preview-schema tables, provision the current recorded relations first.\",\n    },\n  );\n}\n","import { createGraphBackendProjection } from \"../backend/graph-backend-projection\";\nimport {\n  createBackendOverlay,\n  type DeleteEdgesBatchParams,\n  type EdgeRow,\n  type GraphBackend,\n  type InsertEdgeParams,\n  type InsertNodeParams,\n  type InternalTransactionOptions,\n  type NodeRow,\n  type TransactionBackend,\n} from \"../backend/types\";\nimport { ConfigurationError } from \"../errors\";\nimport { type SqlSchema } from \"../query/compiler/schema\";\nimport { groupBy } from \"../utils/array\";\nimport { requireDefined } from \"../utils/presence\";\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  rawWriteGuards,\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} from \"./recorded-capture/clock\";\nexport { closeRecordedHardDeletedKind } from \"./recorded-capture/flush\";\nexport {\n  assertRecordedCaptureTransactionIsolation,\n  assertRevisionTrackableBackend,\n  recordedCaptureRequiresCallbackTransactionError,\n  throwHistoryUnsafeSqlAccess,\n  throwRevisionTrackingUnsafeSqlAccess,\n  withRecordedRelationsPrecondition,\n} from \"./recorded-capture/guards\";\nexport {\n  RECORDED_EDGE_COLUMNS,\n  RECORDED_NODE_COLUMNS,\n} from \"./recorded-capture/relations\";\nexport { assertCurrentRecordedSchema } from \"./recorded-capture/schema-version\";\nexport {\n  RECORDED_OPTIONAL_WRITE_METHODS,\n  RECORDED_REQUIRED_WRITE_METHODS,\n} from \"./recorded-capture/write-surface\";\n\ntype RecordedCaptureSession = Readonly<{\n  /**\n   * Throws if the session is sealed. Called at the TOP of every overlay write\n   * method, *before* the live write runs, so a write through a context retained\n   * past its `withRecordedTransaction` callback fails loud instead of committing\n   * an uncaptured live row. (`touch*` also re-checks after the write; this is\n   * the pre-write guard that actually prevents the live mutation.)\n   */\n  assertOpen: () => void;\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 = InternalTransactionOptions &\n  Readonly<{\n    [RECORDED_FLUSH_OBSERVER]?: RecordedFlushObserver;\n  }>;\n\nfunction readRecordedFlushObserver(\n  options: InternalTransactionOptions | undefined,\n): RecordedFlushObserver | undefined {\n  return (options as RecordedFlushObserverOptions | undefined)?.[\n    RECORDED_FLUSH_OBSERVER\n  ];\n}\n\nfunction stripRecordedFlushObserver(\n  options: InternalTransactionOptions | undefined,\n): InternalTransactionOptions | 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: InternalTransactionOptions | undefined,\n  observer: RecordedFlushObserver,\n): InternalTransactionOptions {\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 recordedCaptureSealedError(\n  details: Record<string, unknown>,\n): ConfigurationError {\n  return new ConfigurationError(\n    \"Recorded-time capture session is sealed: a graph write happened after the transaction's capture was flushed.\",\n    details,\n    {\n      suggestion:\n        \"Perform all writes inside the withRecordedTransaction callback; do not reuse the transaction context after it returns.\",\n    },\n  );\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 recordedCaptureSealedError({\n        entity: entity.entity,\n        graphId: entity.graphId,\n        id: entity.id,\n      });\n    }\n    touched.set(entityKey(entity), entity);\n  }\n\n  return {\n    assertOpen(): void {\n      if (sealed) throw recordedCaptureSealedError({});\n    },\n\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.instant);\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(\n          target,\n          schema,\n          graphId,\n          nodes,\n          recordedCommit.revision,\n        );\n        await flushEdges(\n          target,\n          schema,\n          graphId,\n          edges,\n          recordedCommit.revision,\n        );\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      session.assertOpen();\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          session.assertOpen();\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          session.assertOpen();\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          session.assertOpen();\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      session.assertOpen();\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      session.assertOpen();\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      session.assertOpen();\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      session.assertOpen();\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          session.assertOpen();\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          session.assertOpen();\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          session.assertOpen();\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      session.assertOpen();\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      session.assertOpen();\n      await lockGraph(params.graphId);\n      await target.deleteEdge(params);\n      session.touchEdge(params.graphId, params.id);\n    },\n\n    async hardDeleteEdge(params) {\n      session.assertOpen();\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          session.assertOpen();\n          await lockGraph(params.graphId);\n          await requireDefined(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          session.assertOpen();\n          await lockGraph(params.graphId);\n          await requireDefined(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?: InternalTransactionOptions,\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  const projectedBackend = createGraphBackendProjection(backend);\n  return createBackendOverlay(projectedBackend, {\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) =>\n            requireDefined(target.deleteEdgesBatch)(params),\n          );\n        },\n      }),\n\n    ...(backend.hardDeleteEdgesBatch === undefined ?\n      {}\n    : {\n        async hardDeleteEdgesBatch(\n          params: DeleteEdgesBatchParams,\n        ): Promise<void> {\n          await capture((target) =>\n            requireDefined(target.hardDeleteEdgesBatch)(params),\n          );\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, backendOptions);\n        const readOnly = backendOptions?.accessMode === \"read_only\";\n        const scope = createRecordedTransactionScope(target, schema, !readOnly);\n        const result = await fn(scope.backend);\n        const instants = await scope.flush();\n        observer?.(instants);\n        return result;\n      }, backendOptions);\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({\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"]}