@nicia-ai/typegraph 0.50.0 → 0.51.1

package/dist/chunk-TYGGUWMS.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/backend/drizzle/execution/postgres-execution.ts","../src/backend/drizzle/execution/statement-queue.ts","../src/backend/drizzle/postgres.ts"],"names":["getOrCreateLru","sql","compileQueryWithDialect","isSqlFragment","toDrizzleSql","shouldForceCustomPlan","ConfigurationError","TransactionClosedError","EMBEDDING_UPSERT_PARAM_COUNT","FIND_EDGES_ENDPOINT_FIXED_PARAM_COUNT","isPostgresConcurrentDdlRaceError","isInsufficientResourcesError","pgvectorStrategy","createNodeRowMapper","POSTGRES_ROW_MAPPER_CONFIG","createEdgeRowMapper","createUniqueRowMapper","createSchemaVersionRowMapper","POSTGRES_CAPABILITIES","buildVectorCapabilities","buildFulltextCapabilities","resolveDeclaredBackendResource","tables","tsvectorStrategy","POSTGRES_MAX_BIND_PARAMETERS","normalizeGraphAnalyticsCapabilities","contributionRebuildSupported","getTableName","createPostgresOperationStrategy","createCachedTableExistence","generatePgCreateTableSQL","DATABASE_EXTENSION_NAMES","createPostgresTables","postgresContributions","and","eq","mapContributionMaterializationRow","POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS","buildContributionInsertValues","buildContributionOnConflictSet","tableExistsFromRow","createContributionMaterializer","backend","gateFulltext","requireDefined","deriveBackend","lockPostgresTrustedImportTables","assertTrustedImportDatabaseEmpty","suspendPostgresSecondaryIndexes","createPostgresTrustedImportSession","restoreSecondaryIndexes","analyzeImportedTables","generatePostgresDDL","options","gateFulltextMethods","mapMaterializationRow","POSTGRES_INDEX_MAT_TIMESTAMPS","inArray","buildMaterializationInsertValues","buildMaterializationOnConflictSet","isNull","mapKindRemovalRow","POSTGRES_KIND_REMOVAL_TIMESTAMPS","buildKindRemovalInsertValues","buildKindRemovalOnConflictSet","commitSchemaVersionIfKindsEmpty","INTERNAL_TEMPORARY_WRITES","assertAdoptedDialect","PgTransaction","auditBackendResource","resolveEfSearchOverride","vectorSearchFrontierTuning","CompilerInvariantError","createCommonOperationBackend","nowIso","vectorSlotFromParams","mapVectorWriteError","chunk","assertVectorSearchLimit","assertPgvectorEfSearch","buildLiveNodeCandidates","mapHybridSearchRow","assertActiveSchemaVersion","StaleVersionError","vectorSlotFromCreateIndexParams","coerceNumericScore","vectorSlotFromDropIndexParams","isMissingTableError","annIndexScanTypes"],"mappings":"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","file":"chunk-TYGGUWMS.cjs","sourcesContent":["import { type SQL as DrizzleSql } from \"drizzle-orm\";\nimport {\n  type PgDatabase,\n  type PgQueryResultHKT,\n  type PgTransaction,\n} from \"drizzle-orm/pg-core\";\nimport { type ExtractTablesWithRelations } from \"drizzle-orm/relations\";\n\nimport { ConfigurationError } from \"../../../errors\";\nimport { isSqlFragment } from \"../../../query/sql-fragment\";\nimport { shouldForceCustomPlan } from \"../../../query/sql-intent\";\nimport { getOrCreateLru } from \"./lru\";\nimport {\n  type CompiledSqlQuery,\n  compileQueryWithDialect,\n  type ExecutableSql,\n  type PreparedSqlStatement,\n  type SqlExecutionAdapter,\n  toDrizzleSql,\n} from \"./types\";\n\n/**\n * Edge-safe: this module is loaded on Cloudflare Workers / Vercel Edge\n * via `@neondatabase/serverless`, so it must not statically import any\n * `node:*` module. Use only platform-neutral primitives.\n */\n\ntype PgQueryResult = Readonly<{\n  rows: readonly unknown[];\n}>;\n\n/**\n * The wire-protocol-shaped client the fast path calls. Both the wrapped\n * node-postgres and postgres-js clients normalize to this signature; what\n * differs is whether the underlying driver gets a server-side prepared\n * statement (node-postgres path) or relies on its own internal preparation\n * (postgres-js).\n */\ntype PgQueryClient = Readonly<{\n  query: (\n    sqlText: string,\n    params: readonly unknown[],\n  ) => Promise<PgQueryResult>;\n  /**\n   * Executes WITHOUT a named server-side prepared statement, so the\n   * server plans against the actual parameter values on every call.\n   * Used for statements marked `markForceCustomPlan` (see sql-intent).\n   */\n  queryUnnamed: (\n    sqlText: string,\n    params: readonly unknown[],\n  ) => Promise<PgQueryResult>;\n}>;\n\n/**\n * Minimal shape of the node-postgres / @neondatabase/serverless client\n * we rely on. Both accept either positional `query(text, values)`\n * (unnamed) or the configuration-object form `query({name, text, values})`\n * which uses a server-side prepared statement keyed by `name`.\n */\ntype NodePgQueryConfig = Readonly<{\n  name: string;\n  text: string;\n  values: readonly unknown[];\n}>;\n\ntype NodePgClient = Readonly<{\n  query: ((\n    sqlText: string,\n    params?: readonly unknown[],\n  ) => Promise<PgQueryResult>) &\n    ((config: NodePgQueryConfig) => Promise<PgQueryResult>);\n}>;\n\n/**\n * Minimal shape of the postgres-js tagged-template `Sql` client we rely on\n * for the raw fast path. `unsafe(sqlText, params)` is postgres-js's\n * parameterized-raw-SQL entry point and resolves to a row array.\n */\ntype PostgresJsClient = ((...args: readonly unknown[]) => unknown) &\n  Readonly<{\n    unsafe: (\n      sqlText: string,\n      params?: readonly unknown[],\n      queryOptions?: Readonly<{ prepare?: boolean }>,\n    ) => PromiseLike<readonly unknown[]>;\n  }>;\n\ntype PgSessionCarrier = Readonly<{\n  client?: unknown;\n  constructor?: Readonly<{ name?: string }>;\n}>;\n\ntype PgClientCarrier = Readonly<{\n  $client?: unknown;\n  /** Drizzle's transaction handle keeps the pinned driver here. */\n  session?: PgSessionCarrier;\n  /** Defensive fallback for Drizzle builds exposing only the internal bag. */\n  _?: Readonly<{\n    session?: PgSessionCarrier;\n  }>;\n}>;\n\nexport type AnyPgDatabase = PgDatabase<\n  PgQueryResultHKT,\n  Record<string, unknown>\n>;\n\n/**\n * A driver-agnostic Drizzle PostgreSQL transaction handle.\n *\n * Unlike {@link AnyPgDatabase}, this type cannot be satisfied by a root\n * database. It is the native handle exposed to adapter-aware stores and\n * accepted when adopting a caller-owned PostgreSQL transaction.\n */\nexport type AnyPgTransaction = PgTransaction<\n  PgQueryResultHKT,\n  Record<string, unknown>,\n  ExtractTablesWithRelations<Record<string, unknown>>\n>;\n\nexport type PostgresExecutionAdapter = SqlExecutionAdapter;\n\n/**\n * Duck-typing primitive for the client-shape predicates: `value` carries a\n * callable `property`. Shared with the serialized-resource detection in\n * `../postgres.ts` so both spell \"has this method\" the same way.\n */\nexport function hasFunctionProperty<K extends string>(\n  value: unknown,\n  property: K,\n): value is Readonly<Record<K, (...args: readonly unknown[]) => unknown>> {\n  if (value === undefined || value === null) {\n    return false;\n  }\n  const candidate = value as Readonly<Record<K, unknown>>;\n  return typeof candidate[property] === \"function\";\n}\n\nfunction isPgNativeClient(candidate: unknown): candidate is NodePgClient {\n  // pg `Pool` / `Client` and @neondatabase/serverless `Pool` / `Client`\n  // are object instances with a `.query` method. We require non-callable\n  // here so we don't accidentally swallow the postgres-js or neon-http\n  // tagged-template clients (both callable, both also expose `.query`).\n  return (\n    typeof candidate === \"object\" && hasFunctionProperty(candidate, \"query\")\n  );\n}\n\nfunction isPgliteClient(candidate: unknown): candidate is NodePgClient {\n  // PGlite (Postgres-in-WASM) exposes `.query(sql, params, options)` like\n  // node-postgres and so also satisfies `isPgNativeClient` — but it does NOT\n  // accept the `{name, text, values}` named-statement config form. Passing\n  // that object doesn't merely fail the call: it desyncs PGlite's single\n  // wire connection, so every subsequent query errors with `08P01`. Detect\n  // PGlite structurally via `dumpDataDir` (a PGlite-specific method absent on\n  // pg `Pool`/`Client`) so `resolvePgClient` can route it to the unnamed\n  // positional wrapper regardless of `prepareStatements`. Duck-typed with no\n  // static import, keeping this module dependency-free and edge-safe.\n  return (\n    typeof candidate === \"object\" &&\n    hasFunctionProperty(candidate, \"query\") &&\n    hasFunctionProperty(candidate, \"dumpDataDir\")\n  );\n}\n\n/**\n * PGlite 0.5.x serializes the wire-protocol parameter count as a signed\n * 16-bit integer. At 32,768 binds it silently returns no rows and leaves the\n * client returning false-empty results, so the advertised budget must stay at\n * the largest signed 16-bit value.\n */\nexport const PGLITE_MAX_BIND_PARAMETERS = 32_767;\n\n/** Returns the PGlite client that owns a root Drizzle database, if present. */\nexport function getPgliteClient(db: AnyPgDatabase): object | undefined {\n  const client = (db as PgClientCarrier).$client;\n  return isPgliteClient(client) ? client : undefined;\n}\n\n/** Detects a root Drizzle database backed by PGlite without importing it. */\nexport function isPgliteDatabase(db: AnyPgDatabase): boolean {\n  return getPgliteClient(db) !== undefined;\n}\n\nfunction transactionSession(\n  carrier: PgClientCarrier,\n): PgSessionCarrier | undefined {\n  return carrier.session ?? carrier._?.session;\n}\n\nfunction hasPgliteSession(carrier: PgClientCarrier): boolean {\n  return transactionSession(carrier)?.constructor?.name === \"PgliteSession\";\n}\n\n/**\n * Single owner of \"this callable client is postgres-js\". Shared with the\n * serialized-resource detection in `../postgres.ts`, which reads `options.max`\n * off the same client shape, so the fast path and the marking predicate cannot\n * drift about which callables are postgres-js.\n */\nexport function isPostgresJsClient(\n  candidate: unknown,\n): candidate is PostgresJsClient {\n  // postgres-js's tagged-template Sql is callable, has `.unsafe` (raw\n  // parameterized executor), and has `.begin` (transaction starter). The\n  // transaction-scoped `TransactionSql` replaces `.begin` with `.savepoint`;\n  // accept either so a Drizzle transaction keeps the fast path pinned.\n  // Neon HTTP is also callable + has `.unsafe`, but that `.unsafe` is a\n  // fragment builder rather than a query executor, so we discriminate\n  // on `.begin` / `.savepoint` (postgres-js only).\n  return (\n    typeof candidate === \"function\" &&\n    hasFunctionProperty(candidate, \"unsafe\") &&\n    (hasFunctionProperty(candidate, \"begin\") ||\n      hasFunctionProperty(candidate, \"savepoint\"))\n  );\n}\n\n/**\n * @neondatabase/serverless's `neon(url)` HTTP-only tagged-template\n * function. Distinguishing markers vs postgres-js: `.transaction`\n * (an HTTP-batch transaction submitter) instead of `.begin`. Its\n * `.query`/`.unsafe` methods have different signatures from pg's, so\n * the fast path can't drive them safely — Drizzle's neon-http session\n * handles them correctly via the `db.execute` slow path.\n *\n * Exported so the backend factory can auto-disable the `transactions`\n * capability when this driver is detected (HTTP can't hold a session,\n * so multi-statement transactions are not available regardless).\n */\nexport function isNeonHttpClient(db: AnyPgDatabase): boolean {\n  const candidate = (db as PgClientCarrier).$client;\n  return (\n    typeof candidate === \"function\" &&\n    hasFunctionProperty(candidate, \"transaction\") &&\n    !hasFunctionProperty(candidate, \"begin\")\n  );\n}\n\n/**\n * Default cap on the number of distinct SQL strings tracked for\n * server-side prepared statements. Mirrors the SQLite adapter's\n * `DEFAULT_PREPARED_STATEMENT_CACHE_MAX`. High-cardinality SQL text —\n * variable-length IN-list expansions, generated aliases, custom\n * `backend.execute()` calls — would otherwise grow this map (and the\n * matching per-session prepared-statement memory inside PostgreSQL)\n * without bound.\n */\nconst DEFAULT_POSTGRES_STATEMENT_CACHE_MAX = 256;\n\n/**\n * Module-scope cache mapping each unique SQL text to a stable\n * prepared-statement name. PostgreSQL only requires statement names to\n * be unique per session, so a monotonic counter is sufficient — and\n * avoids depending on a hash primitive (`node:crypto` doesn't exist on\n * Cloudflare Workers, Web Crypto's digest is async).\n *\n * The cache is module-scope on purpose: pg `Pool` reuses connections,\n * and the same SQL text needs the same statement name across every\n * adapter that might end up driving the same connection. Without\n * shared naming, two adapters could try to register two different\n * statements under the same name on a recycled connection.\n *\n * Bounded by `cacheMax` per call (LRU eviction). The counter is\n * deliberately independent of the cache size so eviction never\n * recycles a name — a recycled name could collide with a still-cached\n * statement on a long-lived pg connection (\"prepared statement\n * already exists\" error with different text).\n */\nconst STATEMENT_NAME_CACHE = new Map<string, string>();\nlet nextStatementId = 0;\n\nfunction statementNameFor(sqlText: string, cacheMax: number): string {\n  return getOrCreateLru(STATEMENT_NAME_CACHE, sqlText, cacheMax, () => {\n    const name = `tg_${nextStatementId}`;\n    nextStatementId += 1;\n    return name;\n  });\n}\n\n/**\n * Test-only: reset the module-scope statement-name state. Used to\n * isolate tests that assert on counter values or eviction behavior.\n */\nexport function resetStatementNameCacheForTests(): void {\n  STATEMENT_NAME_CACHE.clear();\n  nextStatementId = 0;\n}\n\n/**\n * Walks a row and replaces any `Date` instance with its ISO-string\n * equivalent. Used to normalize node-postgres / neon-serverless output\n * when we bypass Drizzle's session: pg's default type parsers return\n * `Date` objects for `timestamptz` / `timestamp` / `date` columns, but\n * TypeGraph's row contract everywhere downstream is \"timestamps come\n * back as ISO strings.\" Drizzle's session installs a per-query type\n * override that does the same thing; this is the dependency-free,\n * edge-safe equivalent.\n *\n * O(columns × rows) — negligible for the row counts TypeGraph queries\n * return (typical: 1–100 rows × 5–30 columns).\n */\nfunction normalizeRow(row: unknown): unknown {\n  if (row === null || typeof row !== \"object\") return row;\n  let mutated: Record<string, unknown> | undefined;\n  for (const key of Object.keys(row)) {\n    const value = (row as Record<string, unknown>)[key];\n    if (value instanceof Date) {\n      mutated ??= { ...(row as Record<string, unknown>) };\n      mutated[key] = value.toISOString();\n    }\n  }\n  return mutated ?? row;\n}\n\nfunction normalizeRows(rows: readonly unknown[]): readonly unknown[] {\n  // Single-pass scan; only allocate a new array if any row contained a\n  // Date that needed normalizing. Most rows on most queries don't.\n  let mutated: unknown[] | undefined;\n  for (let index = 0; index < rows.length; index += 1) {\n    const original = rows[index];\n    const normalized = normalizeRow(original);\n    if (normalized !== original) {\n      mutated ??= [...rows] as unknown[];\n      mutated[index] = normalized;\n    }\n  }\n  return mutated ?? rows;\n}\n\n/**\n * Wraps a node-postgres / neon-serverless client so every call goes\n * through a server-side prepared statement keyed by a stable name. The\n * first call on each connection parses + plans + executes; subsequent\n * calls with the same statement name reuse the cached plan and skip\n * both parse and plan phases. Measurable on multi-CTE TypeGraph\n * queries: 3-hop drops from ~7-12ms (parse + plan + execute every call)\n * to ~0.8ms median (execute only).\n *\n * Returned rows are normalized so that `Date` objects from default pg\n * type parsers become ISO strings, matching the row shape Drizzle's\n * session would produce. Without this, `ctx.<alias>.meta.createdAt`\n * style accessors in the SELECT-result path return Date instances,\n * breaking user code that expects strings.\n */\nfunction wrapNodePgClient(\n  client: NodePgClient,\n  cacheMax: number,\n): PgQueryClient {\n  return {\n    async query(\n      sqlText: string,\n      params: readonly unknown[],\n    ): Promise<PgQueryResult> {\n      const result = await client.query({\n        name: statementNameFor(sqlText, cacheMax),\n        text: sqlText,\n        values: params,\n      });\n      return { rows: normalizeRows(result.rows) };\n    },\n    async queryUnnamed(\n      sqlText: string,\n      params: readonly unknown[],\n    ): Promise<PgQueryResult> {\n      const result = await client.query(sqlText, params);\n      return { rows: normalizeRows(result.rows) };\n    },\n  };\n}\n\n/**\n * Variant that bypasses server-side prepared statements entirely.\n * Required for pgbouncer in transaction-pool mode (named statements\n * registered on one backend connection aren't visible on the next),\n * and useful when memory-sensitive workloads can't afford to keep\n * prepared statements warm across the pool.\n *\n * Same Date→ISO normalization as `wrapNodePgClient` so the row contract\n * downstream stays identical.\n */\nfunction wrapNodePgClientUnnamed(client: NodePgClient): PgQueryClient {\n  async function queryUnnamed(\n    sqlText: string,\n    params: readonly unknown[],\n  ): Promise<PgQueryResult> {\n    const result = await client.query(sqlText, params);\n    return { rows: normalizeRows(result.rows) };\n  }\n  return {\n    query: queryUnnamed,\n    queryUnnamed,\n  };\n}\n\nfunction adaptPostgresJsClient(sql: PostgresJsClient): PgQueryClient {\n  async function query(\n    sqlText: string,\n    params: readonly unknown[],\n  ): Promise<PgQueryResult> {\n    // postgres-js handles its own statement preparation internally\n    // (controlled by the `prepare` connection option, default true),\n    // so we don't need to name statements here ourselves.\n    const rows = await sql.unsafe(sqlText, params);\n    return { rows };\n  }\n  return {\n    query,\n    async queryUnnamed(\n      sqlText: string,\n      params: readonly unknown[],\n    ): Promise<PgQueryResult> {\n      // Per-call opt-out of postgres-js's internal preparation\n      // (verified: `unsafe(text, params, { prepare: false })` leaves\n      // pg_prepared_statements empty), so custom-plan-preferring\n      // statements are re-planned against their actual parameters on\n      // every call — same contract as the node-postgres unnamed path.\n      const rows = await sql.unsafe(sqlText, params, { prepare: false });\n      return { rows };\n    },\n  };\n}\n\n/**\n * Resolves a Drizzle-wrapped PostgreSQL client to a uniform `{query}` shape\n * that the fast path can call. Supports:\n *\n * - `drizzle-orm/node-postgres` (pg Pool / Client) — wrapped to use\n *   server-side prepared statements with stable counter-derived names\n *   keyed by the SQL text (see `statementNameFor`). When\n *   `prepareStatements` is `false`, falls back to unnamed\n *   `client.query(text, values)` for pgbouncer transaction-pool\n *   compatibility.\n * - `drizzle-orm/neon-serverless` (@neondatabase/serverless Pool) —\n *   pg-Pool-compatible, takes the same wrapper as node-postgres\n * - `drizzle-orm/postgres-js` (postgres-js tagged-template Sql) — adapted\n *   via `.unsafe(sql, params)`. Safe because Drizzle installs transparent\n *   parsers on the same client instance at `drizzle()` time, so direct\n *   calls and Drizzle-routed calls produce identical row shapes.\n * - `drizzle-orm/pglite` (PGlite, Postgres-in-WASM) — routed to the unnamed\n *   wrapper unconditionally. PGlite's `.query` has no named-statement config\n *   form (and server-side prepared statements buy nothing for an in-process\n *   engine), so `prepareStatements` is ignored for it.\n *\n * Returns `undefined` for `drizzle-orm/neon-http` and any other driver we\n * don't recognize; callers fall back to `db.execute(sql)`, which goes\n * through the Drizzle session and is always correct (just without the\n * server-side prepared-statement perf win).\n */\nfunction resolvePgClient(\n  db: AnyPgDatabase,\n  prepareStatements: boolean,\n  cacheMax: number,\n  useTransactionClient: boolean,\n): PgQueryClient | undefined {\n  // Order matters: neon-http and postgres-js are both callable + have\n  // `.unsafe`, but neon-http's `.unsafe` is a fragment builder (not a\n  // query executor) and its `.query` doesn't accept the {name, text,\n  // values} config form. Skip the fast path entirely for neon-http and\n  // let Drizzle's session route the call.\n  if (isNeonHttpClient(db)) {\n    return undefined;\n  }\n  const carrier = db as PgClientCarrier;\n  // Top-level Drizzle databases expose `$client`. Transaction objects do not;\n  // they retain the exact pinned pool/client transaction on `session.client`.\n  // Reading that structural internal is what keeps trusted import on the same\n  // connection that will COMMIT/ROLLBACK, instead of accidentally using the\n  // outer pool while a transaction is open.\n  const client =\n    carrier.$client ??\n    (useTransactionClient ? transactionSession(carrier)?.client : undefined);\n  // Must precede `isPgNativeClient`: PGlite matches it too (object with\n  // `.query`), but only the unnamed wrapper is safe for it (see\n  // `isPgliteClient`).\n  if (\n    isPgliteClient(client) ||\n    (useTransactionClient && hasPgliteSession(carrier))\n  ) {\n    if (!isPgNativeClient(client)) return undefined;\n    return wrapNodePgClientUnnamed(client);\n  }\n  if (isPgNativeClient(client)) {\n    return prepareStatements ?\n        wrapNodePgClient(client, cacheMax)\n      : wrapNodePgClientUnnamed(client);\n  }\n  if (isPostgresJsClient(client)) {\n    // postgres-js handles its own preparation internally (controlled\n    // by the driver's own `prepare` connection option) — the\n    // `prepareStatements` flag here only affects the node-postgres\n    // path.\n    return adaptPostgresJsClient(client);\n  }\n  return undefined;\n}\n\n/**\n * Normalizes the result shape of `db.execute(sql)` across drivers.\n *\n * - `drizzle-orm/node-postgres` / `drizzle-orm/neon-serverless` return a\n *   pg-style `{ rows, rowCount, ... }` object.\n * - `drizzle-orm/postgres-js` returns the raw postgres-js result, which is\n *   a plain array of rows (with extra non-enumerable properties like\n *   `count` / `command`).\n *\n * The backend contract is \"a row array.\" Normalize here so every caller\n * downstream can assume the same shape.\n */\nasync function executeDrizzleQuery<TRow>(\n  db: AnyPgDatabase,\n  query: DrizzleSql,\n): Promise<readonly TRow[]> {\n  const result = await db.execute(query);\n  if (Array.isArray(result)) {\n    return result as readonly TRow[];\n  }\n  return (result as Readonly<{ rows: readonly TRow[] }>).rows;\n}\n\nfunction createPgPreparedStatement(\n  pgClient: PgQueryClient,\n  sqlText: string,\n  maxBindParameters: number | undefined,\n): PreparedSqlStatement {\n  return {\n    async execute<TRow>(params: readonly unknown[]): Promise<readonly TRow[]> {\n      assertWithinBindParameterLimit(params.length, maxBindParameters);\n      const result = await pgClient.query(sqlText, params);\n      return result.rows as readonly TRow[];\n    },\n  };\n}\n\n/**\n * Tuning options for the PostgreSQL execution fast path.\n *\n * Defaults are correct for `drizzle-orm/node-postgres` against a\n * standalone PostgreSQL or session-pooled deployment. Override when:\n *\n * - **Pooling through pgbouncer in transaction-pool mode.** Set\n *   `prepareStatements: false`. Named statements registered on one\n *   pooled backend connection aren't visible to the next, so the\n *   server-side prepared-statement cache must be off.\n * - **High-cardinality SQL text.** If the application emits many\n *   distinct compiled SQL strings (variable-length IN-list expansions,\n *   custom `backend.execute()` calls, generated aliases), tune\n *   `preparedStatementCacheMax` down to bound per-session memory more\n *   aggressively, or up if memory is plentiful and you want fewer\n *   re-PREPAREs.\n */\nexport type PostgresExecutionAdapterOptions = Readonly<{\n  /**\n   * When `true` (default), node-postgres / neon-serverless calls go\n   * through `client.query({name, text, values})` so PostgreSQL caches\n   * the parsed/planned statement per session. Set to `false` to issue\n   * unnamed `client.query(text, values)` calls — required for\n   * pgbouncer transaction-pool mode.\n   */\n  prepareStatements?: boolean;\n  /**\n   * Maximum number of distinct SQL strings tracked for prepared-\n   * statement naming. Defaults to `DEFAULT_POSTGRES_STATEMENT_CACHE_MAX`\n   * (256). Ignored when `prepareStatements` is `false`.\n   */\n  preparedStatementCacheMax?: number;\n  /**\n   * Maximum parameters that one statement may dispatch. Backend factories\n   * pass their normalized capability here so every execution surface has a\n   * final fail-loud guard after batch sizing.\n   */\n  maxBindParameters?: number;\n  /**\n   * @internal Resolve Drizzle's pinned transaction client. Trusted import uses\n   * this on its private adapter; ordinary transaction backends deliberately do\n   * not expose a new raw-execution surface that would change routing behavior.\n   */\n  useTransactionClient?: boolean;\n}>;\n\nexport function createPostgresExecutionAdapter(\n  db: AnyPgDatabase,\n  options: PostgresExecutionAdapterOptions = {},\n): PostgresExecutionAdapter {\n  const prepareStatements = options.prepareStatements ?? true;\n  const cacheMax =\n    options.preparedStatementCacheMax ?? DEFAULT_POSTGRES_STATEMENT_CACHE_MAX;\n  const maxBindParameters = options.maxBindParameters;\n  const pgClient = resolvePgClient(\n    db,\n    prepareStatements,\n    cacheMax,\n    options.useTransactionClient ?? false,\n  );\n\n  function compile(query: ExecutableSql): CompiledSqlQuery {\n    return compileQueryWithDialect(db, query, \"PostgreSQL\");\n  }\n\n  function assertCompiledWithinBindParameterLimit(\n    compiledQuery: CompiledSqlQuery,\n  ): void {\n    assertWithinBindParameterLimit(\n      compiledQuery.params.length,\n      maxBindParameters,\n    );\n  }\n\n  if (pgClient === undefined) {\n    return {\n      compile,\n      async execute<TRow>(query: ExecutableSql): Promise<readonly TRow[]> {\n        assertCompiledWithinBindParameterLimit(compile(query));\n        return executeDrizzleQuery<TRow>(\n          db,\n          isSqlFragment(query) ? toDrizzleSql(query, \"postgres\") : query,\n        );\n      },\n    };\n  }\n\n  const pgQueryClient = pgClient;\n\n  async function executeCompiled<TRow>(\n    compiledQuery: CompiledSqlQuery,\n  ): Promise<readonly TRow[]> {\n    assertCompiledWithinBindParameterLimit(compiledQuery);\n    const result = await pgQueryClient.query(\n      compiledQuery.sql,\n      compiledQuery.params,\n    );\n    return result.rows as readonly TRow[];\n  }\n\n  return {\n    compile,\n    async execute<TRow>(query: ExecutableSql): Promise<readonly TRow[]> {\n      // Fast path: compile via Drizzle's dialect, then execute through\n      // the wrapped client directly. Bypasses Drizzle's session\n      // overhead (logging spans, plan-cache bookkeeping for typed\n      // queries we don't use), and on node-postgres this also enables\n      // the server-side prepared-statement path because the wrapped\n      // client assigns each unique SQL a stable statement name.\n      const compiled = compile(query);\n      assertCompiledWithinBindParameterLimit(compiled);\n      if (isSqlFragment(query) && shouldForceCustomPlan(query)) {\n        const result = await pgQueryClient.queryUnnamed(\n          compiled.sql,\n          compiled.params,\n        );\n        return result.rows as readonly TRow[];\n      }\n      return executeCompiled<TRow>(compiled);\n    },\n    executeCompiled,\n    prepare(sqlText: string): PreparedSqlStatement {\n      return createPgPreparedStatement(\n        pgQueryClient,\n        sqlText,\n        maxBindParameters,\n      );\n    },\n  };\n}\n\nfunction assertWithinBindParameterLimit(\n  parameterCount: number,\n  maxBindParameters: number | undefined,\n): void {\n  if (maxBindParameters === undefined || parameterCount <= maxBindParameters) {\n    return;\n  }\n  throw new ConfigurationError(\n    `PostgreSQL statement uses ${parameterCount} bound parameters, exceeding ` +\n      `this backend's limit of ${maxBindParameters}.`,\n    {\n      capability: \"maxBindParameters\",\n      maxBindParameters,\n      parameterCount,\n    },\n    {\n      suggestion:\n        \"Split the operation into smaller batches or lower the batch size before retrying.\",\n    },\n  );\n}\n","/**\n * Per-connection statement serialization for transaction-scoped backends.\n *\n * A pooled backend hands every statement its own connection, so concurrent\n * work is genuinely concurrent. A transaction is the opposite: every\n * statement shares one pinned connection, and the PostgreSQL wire protocol\n * has no request pipelining a driver could use to keep two in flight. Drivers\n * paper over this with an internal queue — node-postgres queues on\n * `Client._queryQueue` — but that queue is deprecated as of `pg@8.22` and is\n * removed in `pg@9`:\n *\n * > Calling client.query() when the client is already executing a query is\n * > deprecated and will be removed in pg@9.0. Use async/await or an external\n * > async flow control mechanism instead.\n *\n * TypeGraph overlaps statements on a pinned connection by construction: the\n * node write pipeline issues embedding and fulltext sync concurrently, and\n * `store.transaction()` invites callers to `Promise.all` their writes. This\n * queue is the \"external async flow control mechanism\" the deprecation asks\n * for — it keeps the concurrency at the API surface while presenting exactly\n * one statement at a time to the connection.\n *\n * Wrapping is deliberately confined to transaction-scoped adapters. On a pool\n * the queue would serialize independent connections and destroy throughput.\n *\n * Edge-safe: no `node:*` imports (loaded on Workers via neon-serverless).\n */\nimport { TransactionClosedError } from \"../../../errors\";\nimport {\n  type CompiledSqlQuery,\n  type ExecutableSql,\n  type PreparedSqlStatement,\n  type SqlExecutionAdapter,\n} from \"./types\";\n\n/**\n * A {@link SqlExecutionAdapter} that runs one statement at a time and can be\n * shut so that late statements never reach the connection.\n */\nexport type SerialExecutionAdapter = SqlExecutionAdapter &\n  Readonly<{\n    runExclusive: NonNullable<SqlExecutionAdapter[\"runExclusive\"]>;\n    /**\n     * Waits for the statement currently on the wire, then refuses every\n     * later one with a {@link TransactionClosedError}.\n     *\n     * Callers invoke this at the transaction boundary, before the driver\n     * emits `COMMIT` / `ROLLBACK` on the same connection. The driver's control\n     * statement does not travel through this queue, so without the drain it\n     * would overlap a live statement; without the close, a statement the\n     * callback left running could land after the pool reclaimed the\n     * connection — inside an unrelated transaction.\n     *\n     * Idempotent.\n     */\n    drainAndClose: () => Promise<void>;\n  }>;\n\ntype StatementQueue = Readonly<{\n  /** Runs tasks one at a time, in the order they were submitted. */\n  enqueue: <T>(task: () => Promise<T>) => Promise<T>;\n  drainAndClose: () => Promise<void>;\n}>;\n\n/**\n * Swallows a statement's outcome so the queue's tail always fulfills. The\n * caller owns the result promise; the tail only tracks completion, and an\n * untouched rejection here would surface as an unhandled rejection.\n */\nfunction ignoreOutcome(): void {\n  // Intentionally empty: see above.\n}\n\nfunction createStatementQueue(): StatementQueue {\n  // Always fulfilled: a failed statement must not strand its successors, and\n  // an untouched rejection here would surface as an unhandled rejection.\n  let tail: Promise<void> = Promise.resolve();\n  let closed = false;\n\n  return {\n    enqueue<T>(task: () => Promise<T>): Promise<T> {\n      if (closed) return Promise.reject(new TransactionClosedError());\n      // Chained synchronously, so queue order is submission order.\n      const result = tail.then(() => task());\n      tail = result.then(ignoreOutcome, ignoreOutcome);\n      return result;\n    },\n\n    async drainAndClose(): Promise<void> {\n      // Close first: a statement whose continuation enqueues a successor must\n      // find the queue already shut, or it would slip in behind the drain.\n      closed = true;\n      await tail;\n    },\n  };\n}\n\n/**\n * Wraps `adapter` so at most one statement is in flight on its connection.\n *\n * Only the I/O members are queued. `compile` is pure — it renders a Drizzle\n * `SQL` to text and params without touching the connection — so it stays\n * synchronous and unqueued.\n *\n * The queue is a leaf: nothing it runs re-enters it, so a queued statement\n * can never wait on a statement queued behind it.\n */\nexport function createSerialExecutionAdapter(\n  adapter: SqlExecutionAdapter,\n): SerialExecutionAdapter {\n  const { enqueue, drainAndClose } = createStatementQueue();\n  const { executeCompiled, prepare } = adapter;\n\n  return {\n    drainAndClose,\n\n    compile(query: ExecutableSql): CompiledSqlQuery {\n      return adapter.compile(query);\n    },\n\n    execute<TRow>(query: ExecutableSql): Promise<readonly TRow[]> {\n      return enqueue(() => adapter.execute<TRow>(query));\n    },\n\n    runExclusive<T>(\n      critical: (connection: SqlExecutionAdapter) => Promise<T>,\n    ): Promise<T> {\n      // One queue slot for the whole group. `critical` receives the UNQUEUED\n      // adapter: re-entering the queue from inside the slot it already holds\n      // would deadlock, and it needs no serializing anyway — nothing else can\n      // reach the connection until the slot is released.\n      return enqueue(() => critical(adapter));\n    },\n\n    ...(executeCompiled === undefined ?\n      {}\n    : {\n        executeCompiled<TRow>(\n          compiledQuery: CompiledSqlQuery,\n        ): Promise<readonly TRow[]> {\n          return enqueue(() => executeCompiled<TRow>(compiledQuery));\n        },\n      }),\n\n    ...(prepare === undefined ?\n      {}\n    : {\n        prepare(sqlText: string): PreparedSqlStatement {\n          const statement = prepare(sqlText);\n          return {\n            execute<TRow>(\n              params: readonly unknown[],\n            ): Promise<readonly TRow[]> {\n              return enqueue(() => statement.execute<TRow>(params));\n            },\n          };\n        },\n      }),\n  };\n}\n","/**\n * PostgreSQL backend adapter for TypeGraph.\n *\n * Works with any Drizzle PostgreSQL database instance. Tested against:\n * - `drizzle-orm/node-postgres` (pg Pool / Client)\n * - `drizzle-orm/postgres-js` (postgres-js tagged-template client)\n * - `drizzle-orm/neon-serverless` (@neondatabase/serverless Pool / Client)\n * - `drizzle-orm/neon-http` (@neondatabase/serverless `neon(url)`) —\n *   transactions are auto-disabled because HTTP can't hold a session;\n *   use `drizzle-orm/neon-serverless` if you need transactional writes.\n *\n * - `drizzle-orm/pglite` (PGlite, Postgres-in-WASM) — the execution\n *   fast path detects PGlite and routes it correctly (its `.query` has no\n *   named-statement form). For a batteries-included in-process setup, see\n *   `createLocalPgliteBackend` in `@nicia-ai/typegraph/adapters/drizzle/postgres/pglite`.\n *\n * Other pg-protocol Drizzle adapters (Vercel Postgres, Supabase via pg)\n * work unchanged because they all expose a compatible `db.execute()` /\n * `db.transaction()` surface.\n *\n * @example\n * ```typescript\n * import { drizzle } from \"drizzle-orm/node-postgres\";\n * import { Pool } from \"pg\";\n * import { createPostgresBackend, tables } from \"@nicia-ai/typegraph/adapters/drizzle/postgres\";\n *\n * const pool = new Pool({ connectionString: process.env.DATABASE_URL });\n * const db = drizzle(pool);\n * const backend = createPostgresBackend(db, { tables });\n * ```\n */\nimport {\n  and,\n  eq,\n  getTableName,\n  inArray,\n  isNull,\n  type SQL,\n  sql,\n} from \"drizzle-orm\";\nimport { PgTransaction } from \"drizzle-orm/pg-core\";\n\nimport {\n  CompilerInvariantError,\n  ConfigurationError,\n  StaleVersionError,\n} from \"../../errors\";\nimport type { ResolvedSqlTableNames } from \"../../query/compiler/schema\";\nimport {\n  buildFulltextCapabilities,\n  type FulltextStrategy,\n  tsvectorStrategy,\n} from \"../../query/dialect/fulltext-strategy\";\nimport {\n  assertPgvectorEfSearch,\n  pgvectorStrategy,\n} from \"../../query/dialect/vector/pgvector-strategy\";\nimport {\n  assertVectorSearchLimit,\n  buildVectorCapabilities,\n  resolveEfSearchOverride,\n  vectorSearchFrontierTuning,\n  type VectorSlot,\n  type VectorStrategy,\n} from \"../../query/dialect/vector-strategy\";\nimport {\n  isSqlFragment,\n  sql as portableSql,\n  type SqlFragment,\n} from \"../../query/sql-fragment\";\nimport {\n  annIndexScanTypes,\n  type CompiledRowsSql,\n} from \"../../query/sql-intent\";\nimport { chunk as chunkArray } from \"../../utils/array\";\nimport { requireDefined } from \"../../utils/presence\";\nimport {\n  isInsufficientResourcesError,\n  isMissingTableError,\n  isPostgresConcurrentDdlRaceError,\n} from \"../../utils/sql-errors\";\nimport { deriveBackend } from \"../derive-backend\";\nimport { FIND_EDGES_ENDPOINT_FIXED_PARAM_COUNT } from \"../edge-endpoint-sets\";\nimport { buildLiveNodeCandidates } from \"../live-node-candidates\";\nimport {\n  coerceNumericScore,\n  createEdgeRowMapper,\n  createNodeRowMapper,\n  createSchemaVersionRowMapper,\n  createUniqueRowMapper,\n  nowIso,\n  POSTGRES_ROW_MAPPER_CONFIG,\n} from \"../row-mappers\";\nimport {\n  auditBackendResource,\n  resolveDeclaredBackendResource,\n  type SerializedResourceDeclaration,\n} from \"../transaction-resource\";\nimport {\n  type AdapterBackend,\n  type BackendCapabilities,\n  type ClaimIndexMaterializationParams,\n  type CommitSchemaVersionIfKindsEmptyResult,\n  type CommitSchemaVersionParams,\n  type ContributionDiagnostic,\n  type ContributionMaterializationIdentity,\n  type ContributionMaterializationRow,\n  type ContributionProbeEntry,\n  type ContributionRebuildResult,\n  type ContributionRebuildScope,\n  type ContributionRepairResult,\n  type ContributionRepopulationStats,\n  type CreateVectorIndexParams,\n  DATABASE_EXTENSION_NAMES,\n  type DatabaseExtensionName,\n  type DeleteEmbeddingParams,\n  type DeleteFulltextBatchParams,\n  type DeleteFulltextParams,\n  type DropVectorIndexParams,\n  type FulltextSearchParams,\n  type FulltextSearchResult,\n  type HybridSearchParams,\n  type HybridSearchRow,\n  type IdentityTableNames,\n  type IndexMaterializationRow,\n  INTERNAL_TEMPORARY_WRITES,\n  type InternalTransactionOptions,\n  type KindRemovalRow,\n  type LockSchemaVersionForWriteParams,\n  normalizeGraphAnalyticsCapabilities,\n  POSTGRES_CAPABILITIES,\n  POSTGRES_MAX_BIND_PARAMETERS,\n  type RecordContributionMaterializationParams,\n  type RecordIndexMaterializationParams,\n  type RecordKindRemovalParams,\n  type ReleaseIndexMaterializationClaimParams,\n  type SchemaKindEmptinessProbe,\n  type SchemaVersionRow,\n  type SchemaWriteTransactionBackend,\n  type SetActiveVersionParams,\n  type TransactionBackend,\n  type TrustedImportOptions,\n  type TrustedImportSession,\n  type UpsertEmbeddingBatchParams,\n  type UpsertEmbeddingParams,\n  type UpsertFulltextBatchParams,\n  type UpsertFulltextParams,\n  type VectorSearchParams,\n  type VectorSearchResult,\n} from \"../types\";\nimport {\n  buildContributionInsertValues,\n  buildContributionOnConflictSet,\n  type ContributionMaterializer,\n  contributionRebuildSupported,\n  createContributionMaterializer,\n  gateFulltext,\n  gateFulltextMethods,\n  mapContributionMaterializationRow,\n  POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS,\n} from \"./contribution-materializations\";\nimport {\n  generatePgCreateTableSQL,\n  generatePostgresDDL,\n  postgresContributions,\n} from \"./ddl\";\nimport {\n  type AnyPgDatabase,\n  type AnyPgTransaction,\n  createPostgresExecutionAdapter,\n  getPgliteClient,\n  hasFunctionProperty,\n  isNeonHttpClient,\n  isPgliteDatabase,\n  isPostgresJsClient,\n  PGLITE_MAX_BIND_PARAMETERS,\n  type PostgresExecutionAdapter,\n  type PostgresExecutionAdapterOptions,\n} from \"./execution/postgres-execution\";\nimport { createSerialExecutionAdapter } from \"./execution/statement-queue\";\nimport { type ExecutableSql, toDrizzleSql } from \"./execution/types\";\nimport {\n  buildMaterializationInsertValues,\n  buildMaterializationOnConflictSet,\n  mapMaterializationRow,\n  POSTGRES_INDEX_MAT_TIMESTAMPS,\n} from \"./index-materializations\";\nimport {\n  buildKindRemovalInsertValues,\n  buildKindRemovalOnConflictSet,\n  mapKindRemovalRow,\n  POSTGRES_KIND_REMOVAL_TIMESTAMPS,\n} from \"./kind-removals\";\nimport {\n  assertActiveSchemaVersion,\n  assertAdoptedDialect,\n  commitSchemaVersionIfKindsEmpty,\n  createCommonOperationBackend,\n  type InternalOperationBackend,\n} from \"./operation-backend-core\";\nimport { mapHybridSearchRow } from \"./operations/hybrid\";\nimport {\n  createCachedTableExistence,\n  createPostgresOperationStrategy,\n  tableExistsFromRow,\n} from \"./operations/strategy\";\nimport {\n  createPostgresTables as buildPostgresTables,\n  type PostgresTables,\n  tables as defaultTables,\n} from \"./schema/postgres\";\nimport {\n  analyzeImportedTables,\n  assertTrustedImportDatabaseEmpty,\n  createPostgresTrustedImportSession,\n  lockPostgresTrustedImportTables,\n  restoreSecondaryIndexes,\n  suspendPostgresSecondaryIndexes,\n} from \"./trusted-import\";\nimport {\n  EMBEDDING_UPSERT_PARAM_COUNT,\n  mapVectorWriteError,\n  vectorSlotFromCreateIndexParams,\n  vectorSlotFromDropIndexParams,\n  vectorSlotFromParams,\n} from \"./vector-runtime\";\n\n// ============================================================\n// Types\n// ============================================================\n\n/**\n * Options for creating a PostgreSQL backend.\n */\nexport type PostgresBackendOptions = Readonly<{\n  /**\n   * Custom table definitions. Use createPostgresTables() to customize table names.\n   * Defaults to standard TypeGraph table names.\n   */\n  tables?: PostgresTables;\n  /**\n   * Fulltext strategy override. Defaults to `tsvectorStrategy`\n   * (Postgres built-in `tsvector` + GIN). Pass a custom strategy here to\n   * swap the entire fulltext stack — DDL, MATCH condition, rank\n   * expression, and snippet generation — for alternate Postgres\n   * backends like ParadeDB (`pg_search`), pg_trgm similarity, or\n   * pgroonga without forking TypeGraph.\n   */\n  fulltext?: FulltextStrategy;\n  /**\n   * Vector strategy override. Defaults to `pgvectorStrategy` (pgvector's\n   * `vector(N)` columns + HNSW/IVFFlat). The strategy owns per-`(kind,\n   * field)` typed storage — DDL, upsert, delete, similarity search, and\n   * ANN index lifecycle — and advertises `strategy.capabilities` as\n   * `capabilities.vector`. Pass a custom strategy to swap the entire\n   * vector stack for an alternate Postgres extension without forking\n   * TypeGraph.\n   *\n   * Pass `false` to disable vector support entirely. The backend then\n   * advertises no `capabilities.vector` and omits the embedding/search\n   * methods, mirroring a SQLite connection without sqlite-vec. Required\n   * for an in-process Postgres (e.g. PGlite) built without the pgvector\n   * extension: the default `pgvectorStrategy` assumes `vector(N)` exists,\n   * so any embedding write or `CREATE EXTENSION vector` would otherwise\n   * hard-fail at runtime.\n   */\n  vector?: VectorStrategy | false;\n  /**\n   * Override specific backend capabilities. Useful when the underlying\n   * driver doesn't support a feature TypeGraph would otherwise assume —\n   * for example, an HTTP-only Postgres driver that can't hold a session\n   * across statements would need `{ transactions: false }` so\n   * TypeGraph falls through to non-transactional execution paths.\n   *\n   * `drizzle-orm/neon-http` is auto-detected and has `transactions`\n   * disabled without an explicit override; this option exists for\n   * other HTTP-style drivers and for tests that need to simulate a\n   * capability gap.\n   */\n  capabilities?: Partial<BackendCapabilities>;\n  /**\n   * Use server-side prepared statements (named statements cached per\n   * pg connection) on the node-postgres / neon-serverless fast path.\n   * Defaults to `true`. Set to `false` when pooling through pgbouncer\n   * in transaction-pool mode — pgbouncer routes successive statements\n   * over different backend connections, and a `name` registered on one\n   * is invisible on the next.\n   *\n   * No effect on `drizzle-orm/postgres-js` (handles preparation\n   * internally) or `drizzle-orm/neon-http` (no fast path).\n   */\n  prepareStatements?: boolean;\n  /**\n   * Cap on the number of distinct SQL strings tracked for\n   * prepared-statement naming. Defaults to 256. The cache is LRU-\n   * bounded so high-cardinality SQL text (variable-length IN-lists,\n   * generated aliases, `backend.execute()` calls with one-off SQL)\n   * doesn't grow unbounded in either the Node process or in\n   * PostgreSQL's per-session prepared-statement memory. Worst-case\n   * server-side footprint is roughly `cap × pool size` statements\n   * across all pooled connections. Ignored when\n   * `prepareStatements` is `false`.\n   */\n  preparedStatementCacheMax?: number;\n  /**\n   * Declare the connection this backend serializes every statement onto, when\n   * TypeGraph's driver predicates cannot see it (Bun `SQL` at `{ max: 1 }`,\n   * `pg-proxy`, a postgres-js client capped through a non-numeric string the\n   * driver does not coerce) — or declare that it serializes on nothing, when\n   * detection is wrong for your topology.\n   *\n   * Defaults to `{ mode: \"detect\" }`. See\n   * {@link SerializedResourceDeclaration} for what each mode means and for the\n   * one refusal it cannot lift (`same-sqlite-backend`, which is SQLite-only and\n   * therefore never reached from here).\n   */\n  serializedResource?: SerializedResourceDeclaration;\n}>;\n\nconst NODE_INSERT_PARAM_COUNT = 9;\nconst EDGE_INSERT_PARAM_COUNT = 12;\nconst GET_NODES_FIXED_PARAM_COUNT = 2;\nconst GET_EDGES_FIXED_PARAM_COUNT = 1;\nconst FULLTEXT_UPSERT_PARAM_COUNT = 6;\nconst FULLTEXT_DELETE_FIXED_PARAM_COUNT = 2;\nconst CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT = 3;\nconst UNIQUE_DELETE_FIXED_PARAM_COUNT = 2;\nconst UNIQUE_INSERT_PARAM_COUNT = 6;\n\ntype PostgresBatchChunkSizes = Readonly<{\n  checkUniqueBatchChunkSize: number;\n  edgeInsertBatchSize: number;\n  embeddingUpsertBatchSize: number;\n  findEdgesEndpointChunkSize: number;\n  fulltextDeleteChunkSize: number;\n  fulltextUpsertBatchSize: number;\n  getEdgesChunkSize: number;\n  getNodesChunkSize: number;\n  nodeInsertBatchSize: number;\n  uniqueDeleteChunkSize: number;\n  uniqueInsertBatchSize: number;\n}>;\n\nfunction computePostgresBatchChunkSizes(\n  maxBindParameters: number,\n): PostgresBatchChunkSizes {\n  return {\n    checkUniqueBatchChunkSize: Math.max(\n      1,\n      maxBindParameters - CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT,\n    ),\n    edgeInsertBatchSize: Math.max(\n      1,\n      Math.floor(maxBindParameters / EDGE_INSERT_PARAM_COUNT),\n    ),\n    embeddingUpsertBatchSize: Math.max(\n      1,\n      Math.floor(maxBindParameters / EMBEDDING_UPSERT_PARAM_COUNT),\n    ),\n    findEdgesEndpointChunkSize: Math.max(\n      1,\n      maxBindParameters - FIND_EDGES_ENDPOINT_FIXED_PARAM_COUNT,\n    ),\n    fulltextDeleteChunkSize: Math.max(\n      1,\n      maxBindParameters - FULLTEXT_DELETE_FIXED_PARAM_COUNT,\n    ),\n    fulltextUpsertBatchSize: Math.max(\n      1,\n      Math.floor(maxBindParameters / FULLTEXT_UPSERT_PARAM_COUNT),\n    ),\n    getEdgesChunkSize: Math.max(\n      1,\n      maxBindParameters - GET_EDGES_FIXED_PARAM_COUNT,\n    ),\n    getNodesChunkSize: Math.max(\n      1,\n      maxBindParameters - GET_NODES_FIXED_PARAM_COUNT,\n    ),\n    nodeInsertBatchSize: Math.max(\n      1,\n      Math.floor(maxBindParameters / NODE_INSERT_PARAM_COUNT),\n    ),\n    uniqueDeleteChunkSize: Math.max(\n      1,\n      maxBindParameters - UNIQUE_DELETE_FIXED_PARAM_COUNT,\n    ),\n    uniqueInsertBatchSize: Math.max(\n      1,\n      Math.floor(maxBindParameters / UNIQUE_INSERT_PARAM_COUNT),\n    ),\n  };\n}\n\n/**\n * Barrel keys (contribution logical names) of the four relations that hold\n * Operational Identity state: current assertions, recorded-time assertions,\n * the derived closure, and the derived separation relation.\n * `ensureIdentityTables()` scopes its idempotent CREATE TABLE / CREATE INDEX\n * to exactly these when identity is first enabled on an existing database.\n */\nconst IDENTITY_TABLE_LOGICAL_NAMES: ReadonlySet<string> = new Set([\n  \"identityAssertions\",\n  \"recordedIdentityAssertions\",\n  \"identityClosure\",\n  \"identitySeparation\",\n]);\n\n/**\n * THE one-shot retry every idempotent catalog write in this backend shares.\n *\n * PostgreSQL's IF NOT EXISTS check cannot see another session's uncommitted\n * catalog row. The loser waits for the winner and is then handed the winner's\n * conflict instead of a harmless notice; retrying after that wait observes the\n * committed object. Which failures mean that is\n * {@link isPostgresConcurrentDdlRaceError}'s single decision — anything else\n * (and anything the retry cannot clear) stays loud.\n *\n * Takes a thunk rather than a statement because one caller — the extension\n * install — runs its statement inside its own transaction, and the retry\n * decision must be the same one whether the unit of work is one statement or a\n * locked pair.\n */\nasync function withConcurrentCreateRetry<T>(run: () => Promise<T>): Promise<T> {\n  try {\n    return await run();\n  } catch (error) {\n    if (!isPostgresConcurrentDdlRaceError(error)) throw error;\n    return await run();\n  }\n}\n\n/**\n * The advisory-lock key an extension install serializes on.\n *\n * Per extension rather than one global key: the fence exists to stop two\n * installers of the SAME catalog row from colliding, and a shared key would\n * additionally queue `vector` behind `pg_trgm` at boot for no benefit. The\n * names it interpolates are allowlisted before they reach here.\n */\nfunction extensionDdlLockKey(extension: DatabaseExtensionName): string {\n  return `typegraph:extension-ddl:${extension}`;\n}\n\ntype ExecutePostgresStatement = (statement: ExecutableSql) => Promise<void>;\n\nfunction parallelWorkerResetSql(tableName: string): string {\n  return `ALTER TABLE \"${tableName.replaceAll('\"', '\"\"')}\" RESET (parallel_workers);`;\n}\n\nfunction parallelWorkerResetError(\n  tableName: string,\n  resetError: unknown,\n): Error {\n  return new Error(\n    `PostgreSQL did not restore the durable parallel_workers setting on vector table ${JSON.stringify(tableName)}. Run ${parallelWorkerResetSql(tableName)} before retrying index materialization.`,\n    { cause: resetError },\n  );\n}\n\nfunction vectorSerialFallbackPreparationError(\n  step: \"drop-index\" | \"disable-parallel-workers\",\n  parallelBuildError: unknown,\n  preparationError: unknown,\n): AggregateError {\n  const action =\n    step === \"drop-index\" ?\n      \"drop the partial vector index\"\n    : \"disable parallel workers for the serial retry\";\n  return new AggregateError(\n    [preparationError],\n    `PostgreSQL could not ${action} after the parallel vector index build exhausted resources.`,\n    { cause: parallelBuildError },\n  );\n}\n\nfunction reportParallelWorkerResetFailure(\n  tableName: string,\n  resetError: unknown,\n): void {\n  try {\n    if (typeof console === \"undefined\" || typeof console.error !== \"function\") {\n      return;\n    }\n    const reported = (console.error as (...data: readonly unknown[]) => unknown)(\n      `[typegraph] The serial vector index rebuild failed and cleanup also failed. ${parallelWorkerResetError(tableName, resetError).message}`,\n      resetError,\n    );\n    void Promise.resolve(reported).catch(() => {\n      // Reporting must not displace the index-build failure.\n    });\n  } catch {\n    // A hostile or replaced logger cannot displace the index-build failure.\n  }\n}\n\nasync function resetVectorParallelWorkers(\n  execute: ExecutePostgresStatement,\n  tableName: string,\n): Promise<void> {\n  try {\n    await execute(\n      portableSql`ALTER TABLE ${portableSql.identifier(tableName)} RESET (parallel_workers)`,\n    );\n  } catch (resetError) {\n    throw parallelWorkerResetError(tableName, resetError);\n  }\n}\n\n/** @internal */\nexport async function runVectorIndexBuildWithSerialFallback(\n  execute: ExecutePostgresStatement,\n  tableName: string,\n  indexStatement: ExecutableSql,\n  dropStatement?: ExecutableSql,\n): Promise<void> {\n  // The strategy table is TypeGraph-owned, and parallel_workers is only set\n  // temporarily by the fallback below. Reset it before every materialization\n  // attempt so cleanup survives backend and process recreation. Keep this\n  // outside the resource-failure catch: a cleanup error must never be\n  // mistaken for a failed parallel build whose valid index should be dropped.\n  await resetVectorParallelWorkers(execute, tableName);\n  try {\n    await execute(indexStatement);\n  } catch (error) {\n    if (!isInsufficientResourcesError(error)) throw error;\n    if (dropStatement !== undefined) {\n      try {\n        await execute(dropStatement);\n      } catch (dropError) {\n        throw vectorSerialFallbackPreparationError(\n          \"drop-index\",\n          error,\n          dropError,\n        );\n      }\n    }\n    await runSerialVectorIndexBuild(\n      execute,\n      tableName,\n      indexStatement,\n      error,\n    );\n  }\n}\n\n/** @internal */\nexport async function runPostgresVectorIndexBuild(\n  vectorStrategy: VectorStrategy,\n  execute: ExecutePostgresStatement,\n  tableName: string,\n  indexStatement: ExecutableSql,\n  dropStatement?: ExecutableSql,\n): Promise<void> {\n  if (vectorStrategy !== pgvectorStrategy) {\n    await execute(indexStatement);\n    return;\n  }\n  await runVectorIndexBuildWithSerialFallback(\n    execute,\n    tableName,\n    indexStatement,\n    dropStatement,\n  );\n}\n\n/** @internal */\nexport async function runSerialVectorIndexBuild(\n  execute: ExecutePostgresStatement,\n  tableName: string,\n  indexStatement: ExecutableSql,\n  parallelBuildError?: unknown,\n): Promise<void> {\n  const table = portableSql.identifier(tableName);\n  try {\n    await execute(portableSql`ALTER TABLE ${table} SET (parallel_workers = 0)`);\n  } catch (setError) {\n    if (parallelBuildError === undefined) throw setError;\n    throw vectorSerialFallbackPreparationError(\n      \"disable-parallel-workers\",\n      parallelBuildError,\n      setError,\n    );\n  }\n\n  let buildFailure: Readonly<{ error: unknown }> | undefined;\n  try {\n    await execute(indexStatement);\n  } catch (error) {\n    buildFailure = { error };\n  }\n\n  try {\n    await execute(portableSql`ALTER TABLE ${table} RESET (parallel_workers)`);\n  } catch (resetError) {\n    if (buildFailure === undefined) {\n      throw parallelWorkerResetError(tableName, resetError);\n    }\n    reportParallelWorkerResetFailure(tableName, resetError);\n  }\n\n  if (buildFailure !== undefined) throw buildFailure.error;\n}\n\n// ============================================================\n// Utilities\n// ============================================================\n\nconst toNodeRow = createNodeRowMapper(POSTGRES_ROW_MAPPER_CONFIG);\nconst toEdgeRow = createEdgeRowMapper(POSTGRES_ROW_MAPPER_CONFIG);\nconst toUniqueRow = createUniqueRowMapper(POSTGRES_ROW_MAPPER_CONFIG);\nconst toSchemaVersionRow = createSchemaVersionRowMapper(\n  POSTGRES_ROW_MAPPER_CONFIG,\n);\n\nfunction buildPostgresCapabilities(\n  fulltextStrategy: FulltextStrategy,\n  vectorStrategy: VectorStrategy | undefined,\n): BackendCapabilities {\n  return {\n    ...POSTGRES_CAPABILITIES,\n    ...(vectorStrategy === undefined ?\n      {}\n    : { vector: buildVectorCapabilities(vectorStrategy) }),\n    fulltext: buildFulltextCapabilities(fulltextStrategy),\n  };\n}\n\n// ============================================================\n// Backend Factory\n// ============================================================\n\n/**\n * Creates a TypeGraph backend for PostgreSQL databases.\n *\n * Works with any Drizzle PostgreSQL instance regardless of the underlying driver.\n *\n * @param db - A Drizzle PostgreSQL database instance\n * @param options - Backend configuration\n * @returns A GraphBackend implementation\n */\nexport function createPostgresBackend(\n  db: AnyPgDatabase,\n  options: PostgresBackendOptions = {},\n): AdapterBackend<AnyPgTransaction> {\n  // Resolved before the backend exists so marking it below is a lookup, never\n  // work that could fail after a wrapper already observed an unmarked backend.\n  // A `serializedResource` declaration that contradicts detection is refused\n  // here too, before any object a caller could hold has been built.\n  const resourceAudit = resolveDeclaredBackendResource(\n    getSerializedPostgresClient(db),\n    options.serializedResource,\n  );\n  const tables = options.tables ?? defaultTables;\n  const fulltextStrategy = options.fulltext ?? tsvectorStrategy;\n  // pgvector is compiled into a standalone Postgres server, so it is wired\n  // unconditionally by default (overridable for alternate Postgres vector\n  // stacks). `vector: false` disables it — required for an in-process\n  // Postgres (PGlite) built without the pgvector extension, where the\n  // default strategy's `vector(N)` DDL would hard-fail.\n  const vectorStrategy =\n    options.vector === false ? undefined : (options.vector ?? pgvectorStrategy);\n  // One probe per backend instance, shared with every transaction-scoped\n  // backend so the pgvector version check runs — and its pre-0.8 warning\n  // fires — at most once per backend, not once per `store.transaction()`.\n  const iterativeScanProbe = createIterativeScanProbe();\n  const baseCapabilities = buildPostgresCapabilities(\n    fulltextStrategy,\n    vectorStrategy,\n  );\n  // HTTP-only drivers (notably `drizzle-orm/neon-http`) can't hold a\n  // session across statements, so multi-statement transactions are\n  // unavailable regardless of what we declare. Auto-detect and downgrade\n  // the capability so callers get correct fallback behavior without\n  // having to remember to override it themselves.\n  const httpOnlyOverrides =\n    isNeonHttpClient(db) ?\n      {\n        transactions: false,\n        graphAnalytics: {\n          ...(baseCapabilities.graphAnalytics ?? { mathFunctions: true }),\n          supported: false,\n        },\n      }\n    : {};\n  const configuredMaxBindParameters =\n    options.capabilities?.maxBindParameters ?? POSTGRES_MAX_BIND_PARAMETERS;\n  const driverBindParameterOverrides =\n    isPgliteDatabase(db) ?\n      {\n        maxBindParameters: Math.min(\n          configuredMaxBindParameters,\n          PGLITE_MAX_BIND_PARAMETERS,\n        ),\n      }\n    : {};\n  const declaredCapabilities = normalizeGraphAnalyticsCapabilities({\n    ...baseCapabilities,\n    ...httpOnlyOverrides,\n    ...options.capabilities,\n    ...driverBindParameterOverrides,\n  });\n  // Derived last and not overridable: how far up the contribution health\n  // ladder this backend goes is a structural fact about the wiring below\n  // (durable markers, a catalog probe, a strategy that declares teardown\n  // DDL, a transactional schema fence), and a caller who declared a\n  // rebuild this backend cannot perform would be advertising a lie. The\n  // HTTP-only drivers land on `rebuild: false` here because they cannot\n  // hold a session across statements, so there is no fence to run under.\n  const capabilities: BackendCapabilities = {\n    ...declaredCapabilities,\n    contributions: {\n      supported: true,\n      probe: true,\n      rebuild: contributionRebuildSupported(\n        fulltextStrategy,\n        tables.fulltextTableName,\n        declaredCapabilities.transactions,\n      ),\n    },\n  };\n  const adapterOptions: PostgresExecutionAdapterOptions = {\n    ...(options.prepareStatements === undefined ?\n      {}\n    : { prepareStatements: options.prepareStatements }),\n    ...(options.preparedStatementCacheMax === undefined ?\n      {}\n    : { preparedStatementCacheMax: options.preparedStatementCacheMax }),\n    maxBindParameters:\n      capabilities.maxBindParameters ?? POSTGRES_MAX_BIND_PARAMETERS,\n  };\n  const executionAdapter = createPostgresExecutionAdapter(db, adapterOptions);\n  const tableNames: ResolvedSqlTableNames = {\n    nodes: getTableName(tables.nodes),\n    edges: getTableName(tables.edges),\n    recordedNodes: getTableName(tables.recordedNodes),\n    recordedEdges: getTableName(tables.recordedEdges),\n    recordedClock: getTableName(tables.recordedClock),\n    revisionOrigins: getTableName(tables.revisionOrigins),\n    identityAssertions: getTableName(tables.identityAssertions),\n    recordedIdentityAssertions: getTableName(tables.recordedIdentityAssertions),\n    identityClosure: getTableName(tables.identityClosure),\n    identitySeparation: getTableName(tables.identitySeparation),\n    fulltext: tables.fulltextTableName,\n    uniques: getTableName(tables.uniques),\n    edgeClaims: getTableName(tables.edgeClaims),\n  };\n  // Pre-quote identifiers so refreshStatistics() doesn't rebuild the\n  // ANALYZE statements on every call. The recorded and identity relations\n  // are ANALYZEd separately under an existence guard (see refreshStatistics):\n  // a schema created before recorded-time history or Operational Identity\n  // landed (bring-your-own-pool, no DDL re-run) has no recorded_* / identity_*\n  // tables, and Postgres fails the whole ANALYZE if any named relation is\n  // missing. Per-field vector tables are created lazily and live outside this\n  // base set, so they are not ANALYZEd here.\n  //\n  // ONE statement per table with SKIP_LOCKED, never `ANALYZE a, b, c`:\n  // ANALYZE takes a ShareUpdateExclusive lock, the same class CREATE INDEX\n  // CONCURRENTLY holds for its whole build — and a CIC in another session\n  // waits on every regular transaction's snapshot, ANALYZE's included. An\n  // ANALYZE that queues on a CIC's table lock while that CIC waits on the\n  // ANALYZE's snapshot is a two-node deadlock (observed when two\n  // materializeIndexes callers race). SKIP_LOCKED makes ANALYZE skip a\n  // locked table instead of queuing, so it can never join a wait cycle;\n  // a skipped table is covered by the next refresh or autovacuum.\n  const coreAnalyzeStatements = [\n    tableNames.nodes,\n    tableNames.edges,\n    getTableName(tables.uniques),\n    tableNames.fulltext,\n  ].map((name) =>\n    toDrizzleSql(\n      portableSql`ANALYZE (SKIP_LOCKED) ${portableSql.identifier(name)}`,\n      \"postgres\",\n    ),\n  );\n  const guardedAnalyzeTables = [\n    tableNames.recordedNodes,\n    tableNames.recordedEdges,\n    tableNames.recordedClock,\n    tableNames.recordedIdentityAssertions,\n    tableNames.identityAssertions,\n    tableNames.identityClosure,\n    tableNames.identitySeparation,\n  ] as const;\n  const operationStrategy = createPostgresOperationStrategy(\n    tables,\n    fulltextStrategy,\n  );\n\n  // Whether `tableName` currently exists, via the same catalog probe `clear()`\n  // uses — so refreshStatistics() never ANALYZEs a recorded or identity\n  // relation that a bring-your-own-pool schema has not yet created. The\n  // Postgres probe is search_path-aware, so positive results are deliberately\n  // not cached by bare table name.\n  const guardedTableExists = createCachedTableExistence(\n    async (tableName) => {\n      const rows = await executionAdapter.execute<Record<string, unknown>>(\n        operationStrategy.buildTableExists(tableName),\n      );\n      return rows[0];\n    },\n    { cacheExisting: false },\n  );\n\n  // Durable fulltext + vector materialization (#135): the dialect-specific\n  // marker-table primitives. Orchestration (materialize / assert /\n  // per-instance cache) lives once in `createContributionMaterializer`,\n  // shared by the outer backend and every transaction-scoped backend so a\n  // slot's marker is resolved at most once per process. Built before\n  // `operations` so the operation backend's vector methods can assert/\n  // ensure through it instead of issuing DDL on the hot path.\n  const matTable = tables.contributionMaterializations;\n\n  /**\n   * Runs one IDEMPOTENT DDL statement — `CREATE ... IF NOT EXISTS` or\n   * `ALTER TABLE ... ADD COLUMN IF NOT EXISTS` — with the one-shot retry a\n   * concurrent boot needs.\n   */\n  async function executeConcurrentCreateDdl(ddl: string): Promise<void> {\n    const statement = sql.raw(ddl);\n    await withConcurrentCreateRetry(async () => {\n      await db.execute(statement);\n    });\n  }\n\n  async function ensureTableWithConcurrentCreateRetry(\n    table: Parameters<typeof generatePgCreateTableSQL>[0],\n  ): Promise<void> {\n    await executeConcurrentCreateDdl(generatePgCreateTableSQL(table));\n  }\n\n  /**\n   * THE one place this backend installs a database extension, for every\n   * extension and every caller.\n   *\n   * An extension is database-global while the claims that reach it are not (an\n   * index-materialization claim is per index), so two callers wanting different\n   * objects still race on `pg_extension_name_index`. Two fences answer that,\n   * and both are here because they answer different halves of it:\n   *\n   *  - the advisory lock serializes same-key installers inside this process\n   *    group so the common case never raises at all (#475). It is keyed on the\n   *    extension so installing `vector` does not queue behind `pg_trgm`;\n   *  - {@link withConcurrentCreateRetry} clears the 23505 an installer that did\n   *    NOT take this lock can still hand us — a peer on an older version, whose\n   *    lock key differs, or a `capabilities.transactions: false` backend which\n   *    has no transaction to hang a `pg_advisory_xact_lock` on (#446).\n   *\n   * The lock runs in its own transaction on purpose: a 23505 poisons an\n   * enclosing transaction (the next statement fails `25P02`), so the retry is\n   * sound only when the failed unit of work is one this function owns\n   * end-to-end.\n   */\n  async function ensureDatabaseExtension(\n    name: DatabaseExtensionName,\n  ): Promise<void> {\n    // The name reaches DDL by interpolation, so the allowlist — not the\n    // caller's type — is what makes the identifier trustworthy at runtime.\n    const validated = DATABASE_EXTENSION_NAMES.find(\n      (candidate) => candidate === name,\n    );\n    if (validated === undefined) {\n      throw new ConfigurationError(\n        `Unsupported database extension \"${name}\".`,\n        { extension: name, supported: DATABASE_EXTENSION_NAMES },\n        {\n          suggestion: `Request one of: ${DATABASE_EXTENSION_NAMES.join(\", \")}.`,\n        },\n      );\n    }\n    const ddl = `CREATE EXTENSION IF NOT EXISTS \"${validated}\";`;\n    if (!capabilities.transactions) {\n      await executeConcurrentCreateDdl(ddl);\n      return;\n    }\n    await withConcurrentCreateRetry(async () => {\n      await db.transaction(async (tx) => {\n        await tx.execute(\n          sql`SELECT pg_advisory_xact_lock(hashtext(${extensionDdlLockKey(validated)}), 0)`,\n        );\n        await tx.execute(sql.raw(ddl));\n      });\n    });\n  }\n\n  async function ensureContributionMaterializationsTableImpl(): Promise<void> {\n    await ensureTableWithConcurrentCreateRetry(matTable);\n  }\n\n  /**\n   * The contribution descriptors for exactly the identity relations, under\n   * caller-supplied physical names. Pure — nothing is executed here — and the\n   * single owner of \"which DDL belongs to the identity relations\", shared by\n   * `ensureIdentityTables` (which runs it) and `identityTableDdl` (which hands\n   * it to a transaction).\n   */\n  function identityContributionsFor(\n    identityTableNames: IdentityTableNames,\n  ): ReturnType<typeof postgresContributions> {\n    const identityTables = buildPostgresTables({\n      identityAssertions: identityTableNames.identityAssertions,\n      recordedIdentityAssertions: identityTableNames.recordedIdentityAssertions,\n      identityClosure: identityTableNames.identityClosure,\n      identitySeparation: identityTableNames.identitySeparation,\n    });\n    return postgresContributions(identityTables, fulltextStrategy).filter(\n      (contribution) =>\n        IDENTITY_TABLE_LOGICAL_NAMES.has(contribution.logicalName),\n    );\n  }\n\n  async function getContributionMaterializationRow(\n    identity: ContributionMaterializationIdentity,\n  ): Promise<ContributionMaterializationRow | undefined> {\n    const rows = await db\n      .select()\n      .from(matTable)\n      .where(\n        and(\n          eq(matTable.graphId, identity.graphId),\n          eq(matTable.logicalName, identity.logicalName),\n          eq(matTable.owner, identity.owner),\n          eq(matTable.tableName, identity.tableName),\n        ),\n      );\n    const row = rows[0];\n    if (row === undefined) return undefined;\n    return mapContributionMaterializationRow(\n      row,\n      POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS.decode,\n    );\n  }\n\n  async function getContributionMaterializationRows(\n    graphId: string,\n  ): Promise<readonly ContributionMaterializationRow[]> {\n    const rows = await db\n      .select()\n      .from(matTable)\n      .where(eq(matTable.graphId, graphId));\n    return rows.map((row) =>\n      mapContributionMaterializationRow(\n        row,\n        POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS.decode,\n      ),\n    );\n  }\n\n  async function recordContributionMaterializationRow(\n    params: RecordContributionMaterializationParams,\n  ): Promise<void> {\n    await db\n      .insert(matTable)\n      .values(\n        buildContributionInsertValues(\n          params,\n          POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS.encode,\n        ),\n      )\n      .onConflictDoUpdate({\n        target: [\n          matTable.graphId,\n          matTable.logicalName,\n          matTable.owner,\n          matTable.tableName,\n        ],\n        set: buildContributionOnConflictSet(\n          matTable.materializedAt,\n          params.materializedAt,\n        ),\n      });\n  }\n\n  async function deleteContributionMaterializationRow(\n    identity: ContributionMaterializationIdentity,\n  ): Promise<void> {\n    await db\n      .delete(matTable)\n      .where(\n        and(\n          eq(matTable.graphId, identity.graphId),\n          eq(matTable.logicalName, identity.logicalName),\n          eq(matTable.owner, identity.owner),\n          eq(matTable.tableName, identity.tableName),\n        ),\n      );\n  }\n\n  /**\n   * Uncached catalog probe backing `verifyContributions`. The shared\n   * `createCachedTableExistence` wrapper is deliberately NOT used: this\n   * diagnostic's whole job is to notice that a table confirmed present\n   * earlier has since been dropped.\n   */\n  async function contributionTableExists(tableName: string): Promise<boolean> {\n    const rows = await executionAdapter.execute<Record<string, unknown>>(\n      operationStrategy.buildTableExists(tableName),\n    );\n    return tableExistsFromRow(rows[0]);\n  }\n\n  const contributionMaterializer = createContributionMaterializer({\n    dialect: \"postgres\",\n    fulltextStrategy,\n    fulltextTableName: tables.fulltextTableName,\n    vectorStrategy,\n    // Contribution DDL is `CREATE ... IF NOT EXISTS` reached from every\n    // booting replica, so it carries the same concurrent-create retry the\n    // other create sites use. Without it the loser's 23505 is recorded as\n    // `lastError` on the marker row and reported as a failed materialization,\n    // when the table it wanted is in fact present.\n    execDdl: async (statement) => {\n      await executeConcurrentCreateDdl(statement);\n    },\n    ensureMarkerTable: ensureContributionMaterializationsTableImpl,\n    getMarkers: getContributionMaterializationRows,\n    recordMarker: recordContributionMaterializationRow,\n    deleteMarker: deleteContributionMaterializationRow,\n    tableExists: contributionTableExists,\n    // Withheld rather than wired-and-throwing when the driver cannot hold\n    // a session: the rebuild must refuse with its own typed error naming\n    // the absent fence, matching `capabilities.contributions.rebuild`.\n    ...(capabilities.transactions ?\n      {\n        schemaWriteTransaction: <T>(\n          graphId: string,\n          fn: (tx: SchemaWriteTransactionBackend) => Promise<T>,\n        ) => runSchemaWriteTransaction(graphId, (target) => fn(target)),\n      }\n    : {}),\n  });\n\n  const operations = createPostgresOperationBackend({\n    db,\n    executionAdapter,\n    adapterOptions,\n    operationStrategy,\n    tableNames,\n    capabilities,\n    fulltextStrategy,\n    vectorStrategy,\n    contributionMaterializer,\n    iterativeScanProbe,\n    schemaVersionsTable: tables.schemaVersions,\n    transactionScoped: false,\n  });\n\n  /**\n   * Runs `fn` inside a Postgres transaction, holding an\n   * `pg_advisory_xact_lock` keyed on the graph id. The advisory lock\n   * serializes all schema commits per-graph: the read-then-write CAS in\n   * `commitSchemaVersion` is safe even for the initial-commit case\n   * where there is no row yet to `SELECT ... FOR UPDATE`.\n   *\n   * Refuses on backends that don't support transactions\n   * (`drizzle-orm/neon-http`). The orphan-row crash window cannot be\n   * eliminated without atomicity, so silent best-effort degradation is\n   * worse than a typed error.\n   */\n  function runSchemaWriteTransaction<T>(\n    graphId: string,\n    fn: (tx: InternalOperationBackend) => Promise<T>,\n  ): Promise<T> {\n    if (!capabilities.transactions) {\n      throw new ConfigurationError(\n        \"Schema writes and removal cleanup require atomic transactions, \" +\n          \"but this Postgres backend does not provide them. The drizzle-orm/neon-http \" +\n          \"driver communicates over HTTP and cannot hold a session across statements; \" +\n          \"use drizzle-orm/neon-serverless (websocket) for transactional writes.\",\n        {\n          backend: \"postgres\",\n          capability: \"transactions\",\n          supportsTransactions: false,\n        },\n      );\n    }\n\n    return db.transaction(async (tx) => {\n      // Advisory lock: hashtext($graphId) is collision-tolerant for the\n      // size of an active graph set; collisions just serialize unrelated\n      // graphs which is harmless. Held until the transaction commits.\n      //\n      // The ONE-ARGUMENT (bigint) form is deliberate and load-bearing: it\n      // occupies a different lock space than the two-argument (int4, int4)\n      // form every namespaced TypeGraph lock uses (`typegraph:identity`,\n      // `typegraph:identity-ddl`, the recorded-write clock). PostgreSQL stores\n      // the two forms with different locktag field4 values, so a bigint key can\n      // never collide with an (int4, int4) key however the hashes land — the\n      // schema fence is therefore independent of every lock taken INSIDE it.\n      // Normalizing this to the two-argument form would merge the spaces and\n      // put that independence at the mercy of `hashtext` collisions.\n      await tx.execute(sql`SELECT pg_advisory_xact_lock(hashtext(${graphId}))`);\n      // Managed entity writers lock this row FOR SHARE. Locking it FOR UPDATE\n      // before any emptiness probe makes a writer-first commit wait; a\n      // schema-first snapshot-isolated writer gets PostgreSQL's native\n      // serialization failure instead of validating a stale row version.\n      await tx.execute(sql`\n        SELECT ${tables.schemaVersions.version}\n        FROM ${tables.schemaVersions}\n        WHERE ${tables.schemaVersions.graphId} = ${graphId}\n          AND ${tables.schemaVersions.isActive} = TRUE\n        FOR UPDATE\n      `);\n      // Advisory lock is held here, so the schema-write-capable\n      // InternalOperationBackend is used intentionally (see its type).\n      const { backend: txBackend, drainAndClose } = createTransactionBackend({\n        db: tx,\n        adapterOptions,\n        operationStrategy,\n        tableNames,\n        capabilities,\n        fulltextStrategy,\n        vectorStrategy,\n        contributionMaterializer,\n        iterativeScanProbe,\n        schemaVersionsTable: tables.schemaVersions,\n      });\n      try {\n        return await fn(txBackend);\n      } finally {\n        await drainAndClose();\n      }\n    });\n  }\n\n  // Shared by `transaction()` (TypeGraph opens the tx) and\n  // `adoptTransaction()` (#134 — the caller already opened it): bind a\n  // tx-scoped backend to the *literal* `tx` client and gate fulltext on\n  // the durable marker (a cached SELECT, never DDL).\n  function bindTransactionBackend(tx: AnyPgTransaction): Readonly<{\n    backend: TransactionBackend;\n    drainAndClose: () => Promise<void>;\n  }> {\n    const { backend, drainAndClose } = createTransactionBackend({\n      db: tx,\n      adapterOptions,\n      operationStrategy,\n      tableNames,\n      capabilities,\n      fulltextStrategy,\n      vectorStrategy,\n      contributionMaterializer,\n      iterativeScanProbe,\n      schemaVersionsTable: tables.schemaVersions,\n    });\n    return {\n      backend: gateFulltext(\n        backend,\n        contributionMaterializer.assertInitialized,\n        contributionMaterializer.refuseUnavailableFulltext,\n      ),\n      drainAndClose,\n    };\n  }\n\n  const backend: AdapterBackend<AnyPgTransaction> = {\n    ...operations,\n\n    ...((\n      capabilities.transactions &&\n      executionAdapter.executeCompiled !== undefined\n    ) ?\n      {\n        async trustedImport<T>(\n          fn: (session: TrustedImportSession) => Promise<T>,\n          options_?: TrustedImportOptions,\n        ): Promise<T> {\n          return backend.transactionWithNative(async (tx, rawSql) => {\n            if (options_?.schemaWrite !== undefined) {\n              await requireDefined(tx.lockSchemaVersionForWrite)({\n                ...options_.schemaWrite,\n              });\n            }\n            const trustedExecutionAdapter = createPostgresExecutionAdapter(\n              rawSql,\n              { ...adapterOptions, useTransactionClient: true },\n            );\n            const executeCompiled = trustedExecutionAdapter.executeCompiled;\n            if (executeCompiled === undefined) {\n              throw new ConfigurationError(\n                \"Trusted import could not bind raw execution to the PostgreSQL transaction.\",\n                { capability: \"trustedImport\", dialect: \"postgres\" },\n              );\n            }\n            const trustedTx = deriveBackend(tx, {\n              executeRaw<T>(\n                sqlText: string,\n                params: readonly unknown[],\n              ): Promise<readonly T[]> {\n                return executeCompiled<T>({ params, sql: sqlText });\n              },\n            });\n            await lockPostgresTrustedImportTables(trustedTx, tableNames);\n            await assertTrustedImportDatabaseEmpty(trustedTx, tableNames);\n            const indexDefinitions = await suspendPostgresSecondaryIndexes(\n              trustedTx,\n              tableNames,\n            );\n            const result = await fn(\n              createPostgresTrustedImportSession(trustedTx, tableNames),\n            );\n            await restoreSecondaryIndexes(trustedTx, indexDefinitions);\n            await analyzeImportedTables(trustedTx, tableNames);\n            return result;\n          });\n        },\n      }\n    : {}),\n\n    async bootstrapTables(): Promise<void> {\n      const statements = generatePostgresDDL(tables, fulltextStrategy);\n      for (const statement of statements) {\n        // Cold boot is the single most contended DDL path there is — two\n        // replicas starting at once run exactly this loop against the same\n        // database — so it takes the concurrent-create retry rather than\n        // trusting IF NOT EXISTS, for the reason `executeConcurrentCreateDdl`\n        // documents.\n        await executeConcurrentCreateDdl(statement);\n      }\n    },\n\n    async ensureRevisionOriginsTable(): Promise<void> {\n      await ensureTableWithConcurrentCreateRetry(tables.revisionOrigins);\n    },\n\n    async ensureIdentityTables(\n      identityTableNames,\n      options,\n    ): Promise<readonly string[]> {\n      // First enablement of Operational Identity on an existing populated\n      // database: createStore / createPostgresBackend run no DDL, so the\n      // four identity relations the enablement preflight reads/writes may\n      // not exist yet. Ensure them (and their indexes and CHECK constraints)\n      // idempotently — CREATE TABLE / CREATE INDEX IF NOT EXISTS — reusing the same contribution\n      // DDL bootstrapTables emits, scoped to the identity relations. Stores\n      // run this before opening the schema-commit transaction so DDL does not\n      // re-enter its per-graph write lock.\n      const identityContributions =\n        identityContributionsFor(identityTableNames);\n      const missing = [] as string[];\n      for (const contribution of identityContributions) {\n        if (!(await contributionTableExists(contribution.tableName))) {\n          missing.push(contribution.logicalName);\n        }\n      }\n      // Do not turn a missing assertion ledger on an already-enabled graph\n      // into an empty-but-present table. Otherwise the first open fails, then\n      // a retry silently accepts lost identity truth. First enablement opts\n      // into provisioning; when all tables exist, idempotent DDL still repairs\n      // missing secondary indexes.\n      if (missing.length === 0 || options.provisionMissing) {\n        for (const contribution of identityContributions) {\n          for (const ddl of contribution.createDdl) {\n            await executeConcurrentCreateDdl(ddl);\n          }\n        }\n      }\n      return missing;\n    },\n\n    identityTableDdl(identityTableNames): readonly string[] {\n      return identityContributionsFor(identityTableNames).flatMap(\n        (contribution) => [...contribution.createDdl],\n      );\n    },\n\n    // Every fulltext-touching method asserts the durable marker instead\n    // of lazily emitting DDL. Steady state performs zero ensure; an\n    // uninitialized database throws `StoreNotInitializedError` loudly\n    // rather than self-healing on a read/write path (#135). Shared\n    // verbatim with the tx-scoped gate via `gateFulltextMethods`.\n    ...gateFulltextMethods(\n      operations,\n      contributionMaterializer.assertInitialized,\n      contributionMaterializer.refuseUnavailableFulltext,\n    ),\n\n    async executeDdl(ddl: string): Promise<void> {\n      await db.execute(sql.raw(ddl));\n    },\n\n    ensureExtension: ensureDatabaseExtension,\n\n    async ensureIndexMaterializationsTable(): Promise<void> {\n      await ensureTableWithConcurrentCreateRetry(tables.indexMaterializations);\n      // Deployments created before the build-claim columns existed get\n      // them additively; fresh installs already have them from the\n      // CREATE TABLE above.\n      //\n      // These take the concurrent-DDL retry for the same reason the CREATE\n      // does, and it is the same loop two replicas run at boot: ADD COLUMN IF\n      // NOT EXISTS cannot see another session's uncommitted pg_attribute row,\n      // so the loser waits and is then handed 42701 (or `tuple concurrently\n      // updated`) instead of the notice — a spuriously failed boot (#445).\n      const tableName = getTableName(tables.indexMaterializations);\n      await executeConcurrentCreateDdl(\n        `ALTER TABLE \"${tableName}\" ADD COLUMN IF NOT EXISTS \"building_since\" timestamptz;`,\n      );\n      await executeConcurrentCreateDdl(\n        `ALTER TABLE \"${tableName}\" ADD COLUMN IF NOT EXISTS \"claim_token\" text;`,\n      );\n    },\n\n    ensureTrigramExtension(): Promise<void> {\n      return ensureDatabaseExtension(\"pg_trgm\");\n    },\n\n    async claimIndexMaterialization(\n      params: ClaimIndexMaterializationParams,\n    ): Promise<boolean> {\n      const t = tables.indexMaterializations;\n      // Atomic claim: insert a fresh claim row, or take over an existing\n      // row only when no live claim is on it (NULL or lease-expired\n      // building_since). The WHERE on the conflict update makes losing\n      // racers see zero returned rows — the row's own atomicity is the\n      // mutex, so this works identically through pools and across\n      // processes (unlike session advisory locks, which pin a\n      // connection).\n      const rows = await db.execute(sql`\n        INSERT INTO ${t} (\n          \"index_name\", \"graph_id\", \"entity\", \"kind\", \"signature\",\n          \"schema_version\", \"last_attempted_at\", \"building_since\",\n          \"claim_token\"\n        )\n        VALUES (\n          ${params.indexName}, ${params.graphId}, ${params.entity},\n          ${params.kind}, ${params.signature}, ${params.schemaVersion},\n          now(), now(), ${params.token}\n        )\n        ON CONFLICT (\"index_name\") DO UPDATE SET\n          \"building_since\" = now(),\n          \"claim_token\" = EXCLUDED.\"claim_token\"\n        WHERE ${t}.\"building_since\" IS NULL\n           OR ${t}.\"building_since\" < now() - (${params.leaseMs} * interval '1 millisecond')\n        RETURNING \"index_name\"\n      `);\n      const result = rows;\n      const returned =\n        Array.isArray(result) ? result : (\n          ((result as Readonly<{ rows?: readonly unknown[] }>).rows ?? [])\n        );\n      return returned.length > 0;\n    },\n\n    async releaseIndexMaterializationClaim(\n      params: ReleaseIndexMaterializationClaimParams,\n    ): Promise<void> {\n      const t = tables.indexMaterializations;\n      // Token-guarded: a lease-expired claim taken over by another\n      // materializer must not be released by the original holder.\n      await db.execute(sql`\n        UPDATE ${t}\n        SET \"building_since\" = NULL, \"claim_token\" = NULL\n        WHERE \"index_name\" = ${params.indexName}\n          AND \"claim_token\" = ${params.token}\n      `);\n    },\n\n    async getIndexMaterialization(\n      indexName: string,\n    ): Promise<IndexMaterializationRow | undefined> {\n      const t = tables.indexMaterializations;\n      const rows = await db.select().from(t).where(eq(t.indexName, indexName));\n      const row = rows[0];\n      if (row === undefined) return undefined;\n      return mapMaterializationRow(row, POSTGRES_INDEX_MAT_TIMESTAMPS.decode);\n    },\n\n    async getIndexMaterializations(\n      statusKeys: readonly string[],\n    ): Promise<readonly IndexMaterializationRow[]> {\n      if (statusKeys.length === 0) return [];\n      const t = tables.indexMaterializations;\n      const rows = await db\n        .select()\n        .from(t)\n        .where(inArray(t.indexName, [...statusKeys]));\n      return rows.map((row) =>\n        mapMaterializationRow(row, POSTGRES_INDEX_MAT_TIMESTAMPS.decode),\n      );\n    },\n\n    async recordIndexMaterialization(\n      params: RecordIndexMaterializationParams,\n    ): Promise<void> {\n      const t = tables.indexMaterializations;\n      await db\n        .insert(t)\n        .values(\n          buildMaterializationInsertValues(\n            params,\n            POSTGRES_INDEX_MAT_TIMESTAMPS.encode,\n          ),\n        )\n        .onConflictDoUpdate({\n          target: t.indexName,\n          set: buildMaterializationOnConflictSet(params.materializedAt),\n        });\n    },\n\n    async ensureContributionMaterializationsTable(): Promise<void> {\n      await ensureContributionMaterializationsTableImpl();\n    },\n\n    async getContributionMaterialization(\n      identity: ContributionMaterializationIdentity,\n    ): Promise<ContributionMaterializationRow | undefined> {\n      return getContributionMaterializationRow(identity);\n    },\n\n    async recordContributionMaterialization(\n      params: RecordContributionMaterializationParams,\n    ): Promise<void> {\n      await recordContributionMaterializationRow(params);\n    },\n\n    async assertRuntimeContributionsInitialized(\n      graphId: string,\n    ): Promise<void> {\n      await contributionMaterializer.assertInitialized(graphId);\n    },\n\n    async ensureKindRemovalsTable(): Promise<void> {\n      await ensureTableWithConcurrentCreateRetry(tables.kindRemovals);\n    },\n\n    async getPendingKindRemovals(\n      graphId: string,\n    ): Promise<readonly KindRemovalRow[]> {\n      const t = tables.kindRemovals;\n      const rows = await db\n        .select()\n        .from(t)\n        .where(and(eq(t.graphId, graphId), isNull(t.removedAt)));\n      return rows.map((row) =>\n        mapKindRemovalRow(row, POSTGRES_KIND_REMOVAL_TIMESTAMPS.decode),\n      );\n    },\n\n    async getAllKindRemovals(\n      graphId: string,\n    ): Promise<readonly KindRemovalRow[]> {\n      const t = tables.kindRemovals;\n      const rows = await db.select().from(t).where(eq(t.graphId, graphId));\n      return rows.map((row) =>\n        mapKindRemovalRow(row, POSTGRES_KIND_REMOVAL_TIMESTAMPS.decode),\n      );\n    },\n\n    async recordKindRemoval(params: RecordKindRemovalParams): Promise<void> {\n      const t = tables.kindRemovals;\n      await db\n        .insert(t)\n        .values(\n          buildKindRemovalInsertValues(\n            params,\n            POSTGRES_KIND_REMOVAL_TIMESTAMPS.encode,\n          ),\n        )\n        .onConflictDoUpdate({\n          target: [t.graphId, t.kindName, t.entity, t.schemaVersion],\n          set: buildKindRemovalOnConflictSet(t.removedAt, params.removedAt),\n        });\n    },\n\n    async ensureReconciliationMarkersTable(): Promise<void> {\n      await ensureTableWithConcurrentCreateRetry(tables.reconciliationMarkers);\n    },\n\n    async ensureRuntimeContributions(graphId: string): Promise<void> {\n      await contributionMaterializer.ensureRuntimeContributions(graphId);\n    },\n\n    /**\n     * Superseded by `ensureRuntimeContributions(graphId)` (#129).\n     * Retained as a thin back-compat wrapper for callers predating\n     * #129; #135 routed it through the durable-marker writer.\n     */\n    async ensureFulltextTable(graphId: string): Promise<void> {\n      await contributionMaterializer.ensureRuntimeContributions(graphId);\n    },\n\n    async verifyContributions(\n      graphId: string,\n      vectorSlots: readonly VectorSlot[],\n    ): Promise<readonly ContributionDiagnostic[]> {\n      return contributionMaterializer.verifyContributions(graphId, vectorSlots);\n    },\n\n    async repairContributions(\n      graphId: string,\n      vectorSlots: readonly VectorSlot[],\n    ): Promise<ContributionRepairResult> {\n      return contributionMaterializer.repairContributions(graphId, vectorSlots);\n    },\n\n    async probeContributions(\n      graphId: string,\n      vectorSlots: readonly VectorSlot[],\n    ): Promise<readonly ContributionProbeEntry[]> {\n      return contributionMaterializer.probeContributions(graphId, vectorSlots);\n    },\n\n    async rebuildContribution(\n      graphId: string,\n      scope: ContributionRebuildScope,\n      repopulate: (\n        target: TransactionBackend,\n      ) => Promise<ContributionRepopulationStats>,\n    ): Promise<ContributionRebuildResult> {\n      return contributionMaterializer.rebuildContribution(\n        graphId,\n        scope,\n        repopulate,\n      );\n    },\n\n    // Vector counterparts of the runtime-contribution methods. Present\n    // only when a vector strategy is wired (omitted under `vector: false`,\n    // mirroring the embedding/search methods), so a no-vector backend\n    // doesn't advertise vector materialization it can't perform.\n    ...(vectorStrategy === undefined ?\n      {}\n    : {\n        async ensureVectorSlotContribution(\n          slot: VectorSlot,\n          options_?: Readonly<{ force?: boolean; onDrift?: \"throw\" | \"skip\" }>,\n        ): Promise<void> {\n          await contributionMaterializer.ensureVectorSlot(slot, options_);\n        },\n\n        async ensureVectorSlotContributions(\n          slots: readonly VectorSlot[],\n          options_?: Readonly<{ force?: boolean; onDrift?: \"throw\" | \"skip\" }>,\n        ): Promise<void> {\n          await contributionMaterializer.ensureVectorSlots(slots, options_);\n        },\n\n        async assertVectorSlotInitialized(slot: VectorSlot): Promise<void> {\n          await contributionMaterializer.assertVectorSlot(slot);\n        },\n\n        async assertVectorSlotsInitialized(\n          slots: readonly VectorSlot[],\n        ): Promise<void> {\n          await contributionMaterializer.assertVectorSlots(slots);\n        },\n\n        async deleteVectorSlotContribution(slot: VectorSlot): Promise<void> {\n          await contributionMaterializer.dropVectorSlot(slot);\n        },\n      }),\n\n    async getReconciliationMarker(\n      graphId: string,\n    ): Promise<number | undefined> {\n      const t = tables.reconciliationMarkers;\n      const rows = await db.select().from(t).where(eq(t.graphId, graphId));\n      return rows[0]?.reconciledToVersion;\n    },\n\n    async setReconciliationMarker(\n      graphId: string,\n      version: number,\n    ): Promise<void> {\n      const t = tables.reconciliationMarkers;\n      await db\n        .insert(t)\n        .values({ graphId, reconciledToVersion: version })\n        .onConflictDoUpdate({\n          target: t.graphId,\n          set: { reconciledToVersion: version },\n        });\n    },\n\n    async refreshStatistics(): Promise<void> {\n      // Scoped to TypeGraph-managed tables only — we don't touch\n      // unrelated tables in the same database. Without fresh stats\n      // after a bulk load the planner can pick a reverse-index scan\n      // with a filter (5ms forward traversal instead of 0.5ms) until\n      // autovacuum catches up. Sequential per-table statements — see\n      // coreAnalyzeStatements for why they are never combined.\n      for (const statement of coreAnalyzeStatements) {\n        await db.execute(statement);\n      }\n      // The recorded and identity relations may be absent on a schema created\n      // before recorded-time history or Operational Identity landed\n      // (bring-your-own-pool, no DDL re-run). Postgres fails an ANALYZE naming\n      // a missing relation, so ANALYZE only the guarded tables that exist.\n      const tablePresence = await Promise.all(\n        guardedAnalyzeTables.map(async (tableName) => ({\n          tableName,\n          exists: await guardedTableExists(tableName),\n        })),\n      );\n      const presentGuardedTables = tablePresence\n        .filter((entry) => entry.exists)\n        .map((entry) => entry.tableName);\n      for (const tableName of presentGuardedTables) {\n        await db.execute(\n          toDrizzleSql(\n            portableSql`ANALYZE (SKIP_LOCKED) ${portableSql.identifier(tableName)}`,\n            \"postgres\",\n          ),\n        );\n      }\n    },\n\n    async commitSchemaVersion(\n      params: CommitSchemaVersionParams,\n    ): Promise<SchemaVersionRow> {\n      return runSchemaWriteTransaction(params.graphId, (target) =>\n        target.commitSchemaVersion(params),\n      );\n    },\n\n    async commitSchemaVersionIfKindsEmpty(\n      params: CommitSchemaVersionParams,\n      probes: readonly SchemaKindEmptinessProbe[],\n    ): Promise<CommitSchemaVersionIfKindsEmptyResult> {\n      return runSchemaWriteTransaction(params.graphId, (target) =>\n        commitSchemaVersionIfKindsEmpty(target, params, probes),\n      );\n    },\n\n    async commitSchemaVersionWithPreflight(\n      params: CommitSchemaVersionParams,\n      // The schema-write target, not the narrowed transaction backend: a\n      // preflight may have to CREATE the storage it then fills, and that DDL\n      // belongs in this transaction rather than before it.\n      preflight: (target: SchemaWriteTransactionBackend) => Promise<void>,\n    ): Promise<SchemaVersionRow> {\n      return runSchemaWriteTransaction(params.graphId, async (target) => {\n        await preflight(target);\n        return target.commitSchemaVersion(params);\n      });\n    },\n\n    async setActiveVersion(params: SetActiveVersionParams): Promise<void> {\n      await runSchemaWriteTransaction(params.graphId, (target) =>\n        target.setActiveVersion(params),\n      );\n    },\n\n    async schemaWriteTransaction<T>(\n      graphId: string,\n      fn: (tx: SchemaWriteTransactionBackend) => Promise<T>,\n    ): Promise<T> {\n      return runSchemaWriteTransaction(graphId, (target) => fn(target));\n    },\n\n    async transaction<T>(\n      fn: (tx: TransactionBackend) => Promise<T>,\n      options?: InternalTransactionOptions,\n    ): Promise<T> {\n      return backend.transactionWithNative((tx) => fn(tx), options);\n    },\n\n    async transactionWithNative<T>(\n      fn: (tx: TransactionBackend, sql: AnyPgTransaction) => Promise<T>,\n      options?: InternalTransactionOptions,\n    ): Promise<T> {\n      // #134/#135: NO DDL or ensure here. The tx-scoped backend's\n      // fulltext-touching methods assert the durable contribution\n      // marker (one cached SELECT — never DDL) at point of use, exactly\n      // like the non-tx wrappers. A transaction that never touches\n      // fulltext never asserts; one that does runs pure DML against an\n      // already-materialized table, with the \"no DDL in the business\n      // transaction\" guarantee backed by the durable fact.\n      const temporaryWrites =\n        options?.temporaryWrites === INTERNAL_TEMPORARY_WRITES;\n      if (temporaryWrites && options.accessMode !== \"read_only\") {\n        throw new ConfigurationError(\n          \"Temporary-write transactions must be semantically read-only.\",\n          { dialect: \"postgres\" },\n        );\n      }\n      const txConfig =\n        (\n          options?.isolationLevel !== undefined ||\n          options?.accessMode !== undefined ||\n          temporaryWrites\n        ) ?\n          {\n            ...(options.isolationLevel === undefined ?\n              {}\n            : {\n                isolationLevel: options.isolationLevel.replace(\"_\", \" \") as\n                  | \"read uncommitted\"\n                  | \"read committed\"\n                  | \"repeatable read\"\n                  | \"serializable\",\n              }),\n            ...(options.accessMode === undefined && !temporaryWrites ?\n              {}\n            : {\n                accessMode:\n                  temporaryWrites ?\n                    (\"read write\" as const)\n                  : (requireDefined(options.accessMode).replace(\"_\", \" \") as\n                      \"read only\" | \"read write\"),\n              }),\n          }\n        : undefined;\n\n      return db.transaction(async (tx) => {\n        const { backend: txBackend, drainAndClose } =\n          bindTransactionBackend(tx);\n        try {\n          return await fn(txBackend, tx);\n        } finally {\n          // Drizzle emits COMMIT / ROLLBACK on this same pinned connection the\n          // instant the callback settles, and those control statements do not\n          // travel through the backend's statement queue. Wait for whatever is\n          // on the wire, and refuse anything the callback left running — a\n          // `Promise.all` that rejects orphans its siblings, whose statements\n          // would otherwise overlap the ROLLBACK and then land on a connection\n          // the pool had already handed to somebody else.\n          await drainAndClose();\n        }\n      }, txConfig);\n    },\n\n    adoptTransaction(externalTx: AnyPgTransaction): TransactionBackend {\n      // #134: cross-store atomicity is unsafe without real rollback —\n      // the caller's relational write on `externalTx` *would* still\n      // commit even though the graph write could not be undone. Refuse\n      // loudly rather than silently degrade.\n      if (!capabilities.transactions) {\n        throw new ConfigurationError(\n          \"Cross-store atomicity is unavailable on this Postgres backend: \" +\n            \"its driver does not support transactions (drizzle-orm/neon-http, \" +\n            \"Cloudflare D1). Adopting an external transaction here would let \" +\n            \"the caller's relational write commit with no way to roll back \" +\n            \"the graph write. Use a node-postgres or neon-serverless \" +\n            \"(Pool/WebSocket) connection for cross-store transactions.\",\n          {\n            backend: \"postgres\",\n            capability: \"transactions\",\n            supportsTransactions: false,\n          },\n        );\n      }\n      assertAdoptedDialect<AnyPgTransaction>(\n        externalTx,\n        PgTransaction,\n        \"postgres\",\n      );\n      // The caller owns BEGIN/COMMIT/ROLLBACK via its own\n      // `db.transaction(...)`. We adopt the literal `tx` client and run\n      // pure DML on it — no transaction is opened or closed here, and no\n      // DDL is emitted inside the caller's business transaction.\n      //\n      // Statements still serialize onto the pinned connection, but the queue\n      // is never closed: only the caller knows when their transaction ends,\n      // so it is on them to await every graph write before committing.\n      return bindTransactionBackend(externalTx).backend;\n    },\n\n    async close(): Promise<void> {\n      // Drizzle doesn't expose a close method\n      // Users manage connection lifecycle themselves\n    },\n  };\n\n  // INVARIANT: audit before any wrapper can observe this backend — see\n  // transaction-resource.ts. Unconditional: an abstention recorded as\n  // \"independent\" is a verdict the guards can tell apart from a backend nobody\n  // looked at.\n  auditBackendResource(backend, resourceAudit);\n  return backend;\n}\n\n/**\n * Returns the client object a Drizzle Postgres database serializes ALL of its\n * statements onto, or `undefined` when statements can run on independent\n * connections.\n *\n * Marked (single connection — an open transaction on one wrapper blocks or\n * captures every other wrapper's statements):\n *\n * - **PGlite** — one in-process WASM Postgres connection.\n * - **A bare `pg` / `@neondatabase/serverless` `Client`** — one owned socket.\n *   An export's `BEGIN ... READ ONLY` stays open across the whole stream, so a\n *   concurrent import's INSERT lands inside it (\"cannot execute INSERT in a\n *   read-only transaction\").\n * - **A `Pool` whose resolved cap is one connection** — the export checks out the\n *   pool's only connection for the duration, so a concurrent import waits for a\n *   connection that is never released. Every spelling pg-pool resolves into that\n *   cap counts; {@link isSingleConnectionPgPoolCap} owns which ones those are.\n * - **A postgres-js client whose resolved cap is one connection** — the same cap\n *   on a CALLABLE client. postgres-js's `begin` reserves a connection from its\n *   own pool for the transaction, so with a pool of one an export snapshot holds\n *   the only connection every other wrapper's statement needs.\n *   {@link isSingleConnectionPostgresJsCap} owns that driver's reading of a cap,\n *   which is NOT the same decision as pg-pool's.\n *\n * Deliberately NOT marked: a default pool (independent connection per\n * checkout), a postgres-js client at default size (`max` defaults to 10), a\n * neon-http tagged template (session-less HTTP), and anything unrecognized. A\n * false positive refuses legitimate concurrent work, so the predicate requires\n * positive evidence and abstains otherwise. A pool capped at one connection by\n * means other than the cap pg-pool resolves (a global `pg.defaults.max`, a\n * `pg` connection string's `?max=1` — neither of which pg honors, so neither\n * caps anything) is therefore not detected, and a serialized-connection import\n * there still fails the way it did before this guard existed.\n */\nfunction getSerializedPostgresClient(db: AnyPgDatabase): object | undefined {\n  const pgliteClient = getPgliteClient(db);\n  if (pgliteClient !== undefined) return pgliteClient;\n  const client: unknown = (db as Readonly<{ $client?: unknown }>).$client;\n  // Callable clients are examined before the object arms: a tagged-template\n  // client is a FUNCTION, so `typeof client !== \"object\"` would drop it before\n  // its connection cap was ever read.\n  if (typeof client === \"function\") {\n    return isSingleConnectionCallablePgClient(client) ? client : undefined;\n  }\n  if (typeof client !== \"object\" || client === null) return undefined;\n  const candidate = client as Readonly<Record<string, unknown>>;\n  if (!hasFunctionProperty(candidate, \"query\")) return undefined;\n  if (isSingleConnectionPgPool(candidate)) return client;\n  return isBarePgClient(candidate) ? client : undefined;\n}\n\n/** Whether a `pg`-shaped client is a pool whose only connection is shared. */\nfunction isSingleConnectionPgPool(\n  candidate: Readonly<Record<string, unknown>>,\n): boolean {\n  // `options` is a pg.Pool member (pg.Client has none), and holds the resolved\n  // pool configuration. The default is 10, so an absent/other `max` says\n  // nothing; what a cap of one looks like is the cap predicate's decision.\n  const options: unknown = candidate[\"options\"];\n  if (typeof options !== \"object\" || options === null) return false;\n  return isSingleConnectionPgPoolCap(\n    (options as Readonly<Record<string, unknown>>)[\"max\"],\n  );\n}\n\n/**\n * Whether a pg-pool `options.max` means ONE connection.\n *\n * Numeric 1 is the obvious form. A STRING `\"1\"` is not a typo: pg-pool's\n * `options.max = options.max || options.poolSize || 10` (pg-pool 3.x\n * `index.js:89`) never coerces, so `new Pool({ max: process.env.PG_MAX })` —\n * and the legacy `new Pool({ poolSize: \"1\" })`, which lands in the same\n * `options.max` — keeps a string that its own `this._clients.length >=\n * this.options.max` comparison (`index.js:120`) then coerces. The pool really\n * is capped at one.\n *\n * `\"5\"` is NOT evidence: `1 >= \"5\"` is false, so that pool genuinely opens five\n * connections. This is the whole reason the decision is per driver — postgres-js\n * reads the identical value differently, and\n * {@link isSingleConnectionPostgresJsCap} owns that reading.\n */\nfunction isSingleConnectionPgPoolCap(value: unknown): boolean {\n  return value === 1 || (typeof value === \"string\" && Number(value) === 1);\n}\n\n/**\n * Whether a CALLABLE Postgres client (a tagged-template `Sql`) is capped at one\n * connection, and is therefore one serialized resource for every wrapper over it.\n *\n * Two pieces of positive evidence, both required:\n *\n * - {@link isPostgresJsClient} — the driver identity, owned by the execution\n *   adapter that already discriminates postgres-js from the other callable\n *   client (neon-http). Without it, `options.max` on an unknown callable means\n *   nothing we can act on.\n * - {@link isSingleConnectionPostgresJsCap} — postgres-js exposes its RESOLVED\n *   options on the callable, and its `max` defaults to 10, so only a cap of one\n *   says \"every statement lands on the same connection\". An absent or larger\n *   `max` abstains: postgres-js at default size hands each `begin` its own\n *   connection and marking it would refuse concurrent work that succeeds.\n *\n * NOT covered: Bun's `SQL`. Nothing in this package positively identifies that\n * driver (the SQLite side recognizes `BunSQLiteSession`; there is no Postgres\n * equivalent), and a cap we cannot attribute to a known driver is not evidence.\n * A `Bun.SQL` capped at one connection remains a known gap (#434).\n */\nfunction isSingleConnectionCallablePgClient(client: unknown): boolean {\n  if (client === undefined || client === null) return false;\n  // Read before the driver check narrows the type: postgres-js's `Sql` type\n  // declares no `options` member, so the property is reached through the\n  // untyped client rather than the narrowed one.\n  const options: unknown = (client as Readonly<Record<string, unknown>>)[\n    \"options\"\n  ];\n  if (!isPostgresJsClient(client)) return false;\n  if (typeof options !== \"object\" || options === null) return false;\n  return isSingleConnectionPostgresJsCap(\n    (options as Readonly<Record<string, unknown>>)[\"max\"],\n  );\n}\n\n/**\n * Whether a postgres-js `options.max` means ONE connection.\n *\n * postgres-js resolves `max` from the options object, the URL query string and\n * the `PGMAX` environment variable, and does not coerce it (`max` is absent from\n * its `ints` list, postgres@3.4.9 `src/index.js:447`). So `postgres(url +\n * \"?max=1\")` and `PGMAX=1` both yield the STRING `\"1\"`, which is one connection\n * and is marked, exactly as the numeric `postgres(url, { max: 1 })` is.\n *\n * KNOWN, DELIBERATE GAP: `[...Array(options.max)]` (`src/index.js:65`) yields\n * length 1 for ANY non-numeric string, so `postgres(url + \"?max=5\")` also opens\n * exactly one connection today and can genuinely wedge a stream pair. It is NOT\n * marked, because marking on it means marking on an upstream bug: the moment\n * postgres-js coerces `max`, that configuration becomes a five-connection pool\n * and the mark would refuse legitimate concurrent work. This is why the decision\n * is separate from {@link isSingleConnectionPgPoolCap} — the two predicates read\n * the same value with two justifications, and it is those justifications, not\n * the bodies, that will diverge as either driver changes.\n */\nfunction isSingleConnectionPostgresJsCap(value: unknown): boolean {\n  return value === 1 || (typeof value === \"string\" && Number(value) === 1);\n}\n\n/** Whether a `pg`-shaped client owns exactly one connection (Client, not Pool). */\nfunction isBarePgClient(candidate: Readonly<Record<string, unknown>>): boolean {\n  // Refuse every pool marker first: `Pool` exposes checkout accounting and its\n  // resolved `options`; `Client` exposes none of them.\n  if (\n    candidate[\"options\"] !== undefined ||\n    candidate[\"totalCount\"] !== undefined ||\n    candidate[\"idleCount\"] !== undefined ||\n    candidate[\"waitingCount\"] !== undefined\n  ) {\n    return false;\n  }\n  // Positive `pg.Client` evidence: the connection lifecycle pair plus\n  // `escapeIdentifier`, which pg defines on Client and not on Pool.\n  return (\n    hasFunctionProperty(candidate, \"connect\") &&\n    hasFunctionProperty(candidate, \"end\") &&\n    hasFunctionProperty(candidate, \"escapeIdentifier\")\n  );\n}\n\n/**\n * Exported for unit tests that assert the marking predicate directly against\n * real `pg` `Client` / `Pool` instances; production code reaches it only\n * through {@link createPostgresBackend}.\n *\n * @internal\n */\nexport function isSerializedPostgresClient(client: unknown): boolean {\n  return (\n    getSerializedPostgresClient({\n      $client: client,\n    } as unknown as AnyPgDatabase) !== undefined\n  );\n}\n\n/**\n * Memoized \"does this server's pgvector support the iterative scan (>= 0.8)?\"\n * probe, plus a one-shot warning when it does not.\n *\n * Created once per {@link createPostgresBackend} and shared with every\n * transaction-scoped operation backend, so the probe query runs once and the\n * pre-0.8 warning fires once per backend instance rather than once per\n * `store.transaction()`. The answer is connection-independent\n * (`pg_extension.extversion`), so caching it across connections is sound.\n */\nexport type IterativeScanProbe = Readonly<{\n  isSupported: (\n    execAll: <T>(query: SQL) => Promise<readonly T[]>,\n  ) => Promise<boolean>;\n}>;\n\n/**\n * Exported for unit testing the memoization / warn-once behavior in isolation;\n * production code reaches it only through {@link createPostgresBackend}.\n */\nexport function createIterativeScanProbe(): IterativeScanProbe {\n  let probe: Promise<boolean> | undefined;\n  let warned = false;\n\n  function warnUnavailable(version: string): void {\n    if (warned) return;\n    warned = true;\n    if (typeof console === \"undefined\" || typeof console.warn !== \"function\") {\n      return;\n    }\n    console.warn(\n      `[typegraph] pgvector ${version} has no iterative scan (added in 0.8), ` +\n        \"so a filtered approximate vector search stays ef_search-bounded and \" +\n        \"can return fewer rows than `limit` while more matches exist. Upgrade \" +\n        \"pgvector to >= 0.8, or use an exact search (`approximate: false`) \" +\n        \"where a full page matters.\",\n    );\n  }\n\n  return {\n    isSupported(execAll) {\n      // Probing the GUC directly is unreliable — extension GUCs register only\n      // once the extension library has loaded into the session, so a fresh\n      // pooled connection reports NULL even on 0.8+. `extversion` is truth.\n      probe ??= (async () => {\n        try {\n          const [row] = await execAll<{ v: string | null }>(\n            sql`SELECT extversion AS v FROM pg_extension WHERE extname = 'vector'`,\n          );\n          if (typeof row?.v !== \"string\") return false;\n          const [major = 0, minor = 0] = row.v\n            .split(\".\")\n            .map((part) => Number.parseInt(part, 10));\n          const supported = major > 0 || (major === 0 && minor >= 8);\n          if (!supported) warnUnavailable(row.v);\n          return supported;\n        } catch {\n          return false;\n        }\n      })();\n      return probe;\n    },\n  };\n}\n\ntype CreatePostgresOperationBackendOptions = Readonly<{\n  db: AnyPgDatabase;\n  executionAdapter: PostgresExecutionAdapter;\n  /**\n   * Adapter tuning (prepared-statement cache settings). Used to bind a\n   * fresh, equivalently-configured adapter to a transaction client when\n   * a per-search `efSearch` override opens its own transaction.\n   */\n  adapterOptions?: PostgresExecutionAdapterOptions | undefined;\n  operationStrategy: ReturnType<typeof createPostgresOperationStrategy>;\n  tableNames: ResolvedSqlTableNames;\n  capabilities: BackendCapabilities;\n  fulltextStrategy: FulltextStrategy;\n  /**\n   * Active vector strategy (`pgvectorStrategy` unless overridden), or\n   * `undefined` when vector support is disabled (`vector: false`).\n   */\n  vectorStrategy: VectorStrategy | undefined;\n  /**\n   * Shared durable-marker materializer. The vector methods assert a\n   * slot's marker (SELECT, never DDL) on the hot path and `createVectorIndex`\n   * ensures it (privileged) — replacing the old in-process ensure-latch.\n   * Shared across the outer backend and every transaction-scoped backend\n   * so a slot's marker is resolved at most once per process.\n   */\n  contributionMaterializer: ContributionMaterializer;\n  /**\n   * Shared pgvector iterative-scan probe (memoized version check + one-shot\n   * pre-0.8 warning). Owned by the top-level backend and reused by every\n   * transaction backend so the warning fires once per backend instance.\n   */\n  iterativeScanProbe: IterativeScanProbe;\n  schemaVersionsTable: PostgresTables[\"schemaVersions\"];\n  /** Whether this operation backend is bound to an explicit transaction. */\n  transactionScoped: boolean;\n}>;\n\ntype CreatePostgresTransactionBackendOptions = Readonly<{\n  db: AnyPgDatabase;\n  adapterOptions?: PostgresExecutionAdapterOptions;\n  operationStrategy: ReturnType<typeof createPostgresOperationStrategy>;\n  tableNames: ResolvedSqlTableNames;\n  capabilities: BackendCapabilities;\n  fulltextStrategy: FulltextStrategy;\n  /** Active vector strategy. See {@link CreatePostgresOperationBackendOptions}. */\n  vectorStrategy: VectorStrategy | undefined;\n  /** Shared durable-marker materializer. See {@link CreatePostgresOperationBackendOptions}. */\n  contributionMaterializer: ContributionMaterializer;\n  /** Shared iterative-scan probe. See {@link CreatePostgresOperationBackendOptions}. */\n  iterativeScanProbe: IterativeScanProbe;\n  schemaVersionsTable: PostgresTables[\"schemaVersions\"];\n}>;\n\nfunction createPostgresOperationBackend(\n  options: CreatePostgresOperationBackendOptions,\n): InternalOperationBackend {\n  const {\n    db,\n    executionAdapter,\n    adapterOptions,\n    operationStrategy,\n    tableNames,\n    capabilities,\n    fulltextStrategy,\n    vectorStrategy,\n    contributionMaterializer,\n    iterativeScanProbe,\n    schemaVersionsTable,\n    transactionScoped,\n  } = options;\n  // Route through the execution adapter so driver-specific result shapes\n  // (`{rows}` for node-postgres / neon-serverless; bare array for\n  // postgres-js) are normalized in one place.\n  async function execAll<T>(query: ExecutableSql): Promise<readonly T[]> {\n    return executionAdapter.execute<T>(query);\n  }\n\n  async function execGet<T>(query: ExecutableSql): Promise<T | undefined> {\n    const rows = await executionAdapter.execute<T>(query);\n    return rows[0];\n  }\n\n  async function execRun(query: ExecutableSql): Promise<void> {\n    await executionAdapter.execute(query);\n  }\n\n  type VectorSearchRow = Readonly<{ node_id: string; score: number }>;\n\n  /** One transaction-local GUC override applied around a vector SELECT. */\n  type SearchGucOverride = Readonly<{ name: string; value: string }>;\n\n  // `hnsw.iterative_scan` exists on pgvector >= 0.8. The probe + \"warn once\"\n  // state lives on the top-level backend and is SHARED with every\n  // transaction-scoped operation backend (see `iterativeScanProbe` in the\n  // options), so a pre-0.8 server is probed and warned about once per backend\n  // instance — not once per `store.transaction()`.\n  function pgvectorIterativeScanSupported(): Promise<boolean> {\n    return iterativeScanProbe.isSupported(execAll);\n  }\n\n  /**\n   * The transaction-local GUC overrides for one vector search:\n   *\n   * - `hnsw.ef_search` when the caller supplied `efSearch` (validated\n   *   upstream; whether it may be applied at all — and under which parameter\n   *   name — is {@link resolveEfSearchOverride}, the predicate the SQLite\n   *   backend reads too, which refuses a non-HNSW slot and a transactionless\n   *   driver where `SET LOCAL` cannot be scoped).\n   * - `hnsw.iterative_scan = strict_order` on HNSW slots (pgvector >= 0.8):\n   *   the search SQL constrains results to live candidate nodes (and\n   *   optionally `minScore`), and a plain HNSW scan yields only `ef_search`\n   *   candidates BEFORE those filters — so a filter-heavy neighborhood can\n   *   under-fill top-k. The iterative scan keeps yielding until `LIMIT`\n   *   rows pass or it hits `hnsw.max_scan_tuples` — better recall, not a\n   *   full-page guarantee. `strict_order` preserves the distance ordering the\n   *   plan relies on (`relaxed_order` may emit slightly out of order beneath\n   *   our LIMIT). On pgvector < 0.8 the search stays `ef_search`-bounded and\n   *   the backend warns once (see `warnIterativeScanUnavailable`).\n   * - `ivfflat.iterative_scan = relaxed_order` on IVFFlat slots (same\n   *   pgvector floor): IVFFlat has no strict_order mode, so the strategy's\n   *   IVFFlat search SQL re-sorts the relaxed candidate set inside a\n   *   MATERIALIZED wrapper (see `buildSearch`) to restore exact ordering.\n   */\n  async function vectorSearchGucOverrides(\n    params: Pick<VectorSearchParams, \"efSearch\" | \"indexType\">,\n  ): Promise<readonly SearchGucOverride[]> {\n    const overrides: SearchGucOverride[] = [];\n    const efSearchParameter = resolveEfSearchOverride({\n      efSearch: params.efSearch,\n      indexType: params.indexType,\n      tuning: vectorSearchFrontierTuning(vectorStrategy),\n      transactions: capabilities.transactions,\n      dialect: \"PostgreSQL\",\n      engine: vectorStrategy?.name ?? \"this backend\",\n    });\n    if (efSearchParameter !== undefined) {\n      overrides.push({\n        name: efSearchParameter,\n        value: String(params.efSearch),\n      });\n    }\n    if (\n      params.indexType === \"hnsw\" &&\n      capabilities.transactions &&\n      (await pgvectorIterativeScanSupported())\n    ) {\n      overrides.push({ name: \"hnsw.iterative_scan\", value: \"strict_order\" });\n    }\n    if (\n      params.indexType === \"ivfflat\" &&\n      capabilities.transactions &&\n      (await pgvectorIterativeScanSupported())\n    ) {\n      overrides.push({\n        name: \"ivfflat.iterative_scan\",\n        value: \"relaxed_order\",\n      });\n    }\n    return overrides;\n  }\n\n  /**\n   * Runs the vector SELECT, applying the given GUC overrides\n   * transaction-locally. `SET LOCAL` semantics (via\n   * `set_config(name, value, is_local => true)`, the parameterizable form)\n   * only take effect inside an explicit transaction — issued in autocommit\n   * they roll off with the statement and the next pooled query (notably\n   * under transaction-mode pgbouncer) sees the session default again. So\n   * with overrides present we bundle `BEGIN; SET …; SELECT …; COMMIT;`\n   * onto one connection. With none we take the unchanged single-statement\n   * fast path and open no transaction.\n   */\n  /**\n   * The `SET LOCAL`-scoped vector SELECT, run as one exclusive group on the\n   * transaction's connection. See {@link runVectorSearch}.\n   */\n  async function runVectorSearchGucGroup<Row>(\n    overrides: readonly SearchGucOverride[],\n    query: ExecutableSql,\n  ): Promise<readonly Row[]> {\n    const runExclusive = executionAdapter.runExclusive;\n    if (runExclusive === undefined) {\n      throw new CompilerInvariantError(\n        \"A transaction-scoped Postgres backend must expose runExclusive; \" +\n          \"its execution adapter was not wrapped by createSerialExecutionAdapter.\",\n      );\n    }\n    return runExclusive(async (connection) => {\n      const snapshots: SearchGucOverride[] = [];\n      for (const override of overrides) {\n        const [setting] = await connection.execute<{ v: string }>(\n          sql`SELECT current_setting(${override.name}) AS v`,\n        );\n        if (setting !== undefined) {\n          snapshots.push({ name: override.name, value: setting.v });\n        }\n        await connection.execute(\n          sql`SELECT set_config(${override.name}, ${override.value}, true)`,\n        );\n      }\n      const rows = await connection.execute<Row>(query);\n      // Restore only on success: a failed SELECT aborts the caller's\n      // transaction, so its rollback discards the overrides anyway and a\n      // restore here would just fail against the aborted tx, masking the\n      // real error.\n      for (const snapshot of snapshots) {\n        await connection.execute(\n          sql`SELECT set_config(${snapshot.name}, ${snapshot.value}, true)`,\n        );\n      }\n      return rows;\n    });\n  }\n\n  async function runVectorSearch<Row = VectorSearchRow>(\n    overrides: readonly SearchGucOverride[],\n    query: ExecutableSql,\n  ): Promise<readonly Row[]> {\n    if (overrides.length === 0) {\n      return execAll<Row>(query);\n    }\n    if (db instanceof PgTransaction) {\n      // Already inside the caller's transaction (low-level\n      // backend.transaction / adoptTransaction). `executionAdapter` is\n      // bound to this tx client, but SET LOCAL persists to the end of the\n      // caller's transaction — leaking the override into their later\n      // vector searches and breaking the per-search contract. Snapshot\n      // the current values, apply the overrides, then restore them once\n      // the SELECT has materialized so the overrides stay scoped to this\n      // one search.\n      //\n      // The four steps are ONE critical section, not four serialized\n      // statements. A transaction has a single GUC namespace, so two searches\n      // that merely take turns interleave as `A snapshot → B snapshot → A set\n      // → B set → A select` and `A` runs under `B`'s efSearch. `runExclusive`\n      // holds the connection for the whole group; it is always present on a\n      // transaction-scoped adapter (see `createTransactionBackend`).\n      return runVectorSearchGucGroup(overrides, query);\n    }\n    return db.transaction(async (tx) => {\n      // Bind an equivalently-configured adapter to the tx client so the\n      // SELECT keeps the driver result-shape normalization rather than a\n      // bespoke execute. A Drizzle transaction carries no `$client`, so this\n      // adapter routes through Drizzle's session (no server-side prepared\n      // statement) — correct either way, and the statements below are\n      // sequential, so they need no serializing wrapper.\n      const txAdapter = createPostgresExecutionAdapter(tx, adapterOptions);\n      for (const override of overrides) {\n        await txAdapter.execute(\n          sql`SELECT set_config(${override.name}, ${override.value}, true)`,\n        );\n      }\n      return txAdapter.execute<Row>(query);\n    });\n  }\n\n  const batchConfig = computePostgresBatchChunkSizes(\n    capabilities.maxBindParameters ?? POSTGRES_MAX_BIND_PARAMETERS,\n  );\n\n  const commonOperationMembers = createCommonOperationBackend({\n    batchConfig,\n    execution: {\n      execAll,\n      execGet,\n      execRun,\n    },\n    nowIso,\n    maxBindParameters:\n      capabilities.maxBindParameters ?? POSTGRES_MAX_BIND_PARAMETERS,\n    operationStrategy,\n    rowMappers: {\n      toEdgeRow,\n      toNodeRow,\n      toSchemaVersionRow,\n      toUniqueRow,\n    },\n    tableExistenceCache: { cacheExisting: false },\n  });\n\n  const executeCompiled = executionAdapter.executeCompiled;\n  const executeRawMethod: Pick<TransactionBackend, \"executeRaw\"> =\n    executeCompiled === undefined ?\n      {}\n    : {\n        async executeRaw<T>(\n          sqlText: string,\n          params: readonly unknown[],\n        ): Promise<readonly T[]> {\n          return executeCompiled<T>({ params, sql: sqlText });\n        },\n      };\n\n  // Embedding write/search methods are present only when a vector strategy\n  // is wired. With `vector: false` (e.g. PGlite without pgvector) they are\n  // omitted, so `capabilities.vector` is absent and the store never routes\n  // embedding work here — mirroring a SQLite connection without sqlite-vec.\n  const vectorEmbeddingMethods =\n    vectorStrategy === undefined ?\n      {}\n    : {\n        async upsertEmbedding(params: UpsertEmbeddingParams): Promise<void> {\n          const slot = vectorSlotFromParams(params);\n          // Assert the slot's durable marker (SELECT, cached) — never DDL.\n          // The per-field table is provisioned by the privileged migrator\n          // (`createStoreWithSchema` → `materializeVectorContributions`), so\n          // a least-privilege runtime role writes embeddings without CREATE.\n          await contributionMaterializer.assertVectorSlot(slot);\n          const statements = vectorStrategy.buildUpsert(slot, params, nowIso());\n          try {\n            for (const statement of statements) {\n              await execRun(statement);\n            }\n          } catch (error) {\n            throw mapVectorWriteError(error, params);\n          }\n        },\n\n        async upsertEmbeddingBatch(\n          params: UpsertEmbeddingBatchParams,\n        ): Promise<void> {\n          if (params.rows.length === 0) return;\n          const slot = vectorSlotFromParams(params);\n          // Same SELECT-only marker assert as the single-row path — never DDL.\n          await contributionMaterializer.assertVectorSlot(slot);\n          // Last-write-wins dedupe: a multi-row upsert cannot affect one\n          // row twice.\n          const rowsById = new Map(\n            params.rows.map((row) => [row.nodeId, row] as const),\n          );\n          const rows = [...rowsById.values()];\n          const timestamp = nowIso();\n          try {\n            for (const chunk of chunkArray(\n              rows,\n              batchConfig.embeddingUpsertBatchSize,\n            )) {\n              const statements =\n                vectorStrategy.buildUpsertBatch === undefined ?\n                  chunk.flatMap((row) =>\n                    vectorStrategy.buildUpsert(\n                      slot,\n                      {\n                        graphId: params.graphId,\n                        nodeKind: params.nodeKind,\n                        nodeId: row.nodeId,\n                        fieldPath: params.fieldPath,\n                        embedding: row.embedding,\n                        dimensions: params.dimensions,\n                        metric: params.metric,\n                        indexType: params.indexType,\n                      },\n                      timestamp,\n                    ),\n                  )\n                : vectorStrategy.buildUpsertBatch(\n                    slot,\n                    { ...params, rows: chunk },\n                    timestamp,\n                  );\n              for (const statement of statements) {\n                await execRun(statement);\n              }\n            }\n          } catch (error) {\n            throw mapVectorWriteError(error, params);\n          }\n        },\n\n        async deleteEmbedding(params: DeleteEmbeddingParams): Promise<void> {\n          // Assert the slot's durable marker before deleting. A delete can\n          // run before any embedding was ever written for the field (e.g. a\n          // node hard-deleted having never carried one); the per-field table\n          // was provisioned at boot, so the DELETE targets an existing\n          // (possibly empty) table and is a clean no-op — never a DELETE\n          // against a missing relation, which would abort an enclosing\n          // Postgres transaction. SELECT-only assert, never DDL.\n          const slot = vectorSlotFromParams(params);\n          await contributionMaterializer.assertVectorSlot(slot);\n          const statements = vectorStrategy.buildDelete(slot, params);\n          for (const statement of statements) {\n            await execRun(statement);\n          }\n        },\n        async deleteEmbeddingBatch(\n          params: Omit<DeleteEmbeddingParams, \"nodeId\"> &\n            Readonly<{ nodeIds: readonly string[] }>,\n        ): Promise<void> {\n          if (params.nodeIds.length === 0) return;\n          const slot = vectorSlotFromParams(params);\n          await contributionMaterializer.assertVectorSlot(slot);\n          for (const nodeIds of chunkArray(\n            [...new Set(params.nodeIds)],\n            batchConfig.embeddingUpsertBatchSize,\n          )) {\n            const statements = vectorStrategy.buildDeleteBatch(slot, {\n              ...params,\n              nodeIds,\n            });\n            for (const statement of statements) await execRun(statement);\n          }\n        },\n\n        async vectorSearch(\n          params: VectorSearchParams,\n        ): Promise<readonly VectorSearchResult[]> {\n          assertVectorSearchLimit(params.limit);\n          // Validate `efSearch` against pgvector's `hnsw.ef_search` ceiling\n          // before `runVectorSearch` applies it via `set_config`.\n          assertPgvectorEfSearch(params.efSearch);\n          const slot = vectorSlotFromParams(params);\n          // Deliberately NOT marker-gated: search is read-only (no DDL\n          // hazard to gate), and its params carry the caller's runtime\n          // metric override, which legitimately diverges from the\n          // provisioned shape on strategies that bake the metric into the\n          // DDL (sqlite-vec; pgvector's table DDL is metric-free but the\n          // contract is kept identical across dialects). An unprovisioned\n          // slot surfaces the engine's missing-relation error — the same\n          // contract as a query-builder `similarTo()` predicate;\n          // `createVerifiedStore` catches both at attach.\n          const query = vectorStrategy.buildSearch(\n            slot,\n            params,\n            // Store-compiled candidates (predicates + subclass + currency)\n            // take precedence; the live-node default covers direct backend use.\n            params.candidates ??\n              buildLiveNodeCandidates(\n                tableNames.nodes,\n                params.graphId,\n                params.nodeKind,\n                nowIso(),\n              ),\n          );\n          const gucOverrides = await vectorSearchGucOverrides(params);\n          let rows: readonly { node_id: string; score: number }[];\n          try {\n            rows = await runVectorSearch(gucOverrides, query);\n          } catch (error) {\n            // A query vector whose dimension no longer matches the stored\n            // column surfaces the same typed error as the write path.\n            throw mapVectorWriteError(error, params);\n          }\n          return rows.map((row) => ({\n            nodeId: row.node_id,\n            score: row.score,\n          }));\n        },\n        // Single-statement hybrid needs ROW_NUMBER(); a capability\n        // profile that disables window functions keeps the store's\n        // multi-statement fallback by simply not exposing the member.\n        ...(capabilities.windowFunctions ?\n          {\n            async hybridSearch(\n              params: HybridSearchParams,\n            ): Promise<readonly HybridSearchRow[]> {\n              assertVectorSearchLimit(params.limit);\n              // Source depths get the same boundary validation the fallback\n              // path applies (vectorSearch validates its limit; the fulltext\n              // depth is validated inside buildFulltextSearch).\n              assertVectorSearchLimit(params.vector.k);\n              assertPgvectorEfSearch(params.vector.efSearch);\n              const slot = vectorSlotFromParams({\n                graphId: params.graphId,\n                nodeKind: params.nodeKind,\n                fieldPath: params.vector.fieldPath,\n                dimensions: params.vector.dimensions,\n                metric: params.vector.metric,\n                indexType: params.vector.indexType,\n              });\n              // Read-only, not marker-gated — see vectorSearch above.\n              const candidates =\n                params.candidates ??\n                buildLiveNodeCandidates(\n                  tableNames.nodes,\n                  params.graphId,\n                  params.nodeKind,\n                  nowIso(),\n                );\n              const vectorParams: VectorSearchParams = {\n                graphId: params.graphId,\n                nodeKind: params.nodeKind,\n                fieldPath: params.vector.fieldPath,\n                queryEmbedding: params.vector.queryEmbedding,\n                metric: params.vector.metric,\n                dimensions: params.vector.dimensions,\n                indexType: params.vector.indexType,\n                limit: params.vector.k,\n                ...(params.vector.minScore === undefined ?\n                  {}\n                : { minScore: params.vector.minScore }),\n              };\n              // The vector leg references the statement's shared\n              // tg_hybrid_cand CTE; the actual candidates SQL is emitted\n              // once by buildHybridSearch.\n              const vectorSql = vectorStrategy.buildSearch(\n                slot,\n                vectorParams,\n                portableSql.raw(\"SELECT node_id FROM tg_hybrid_cand\"),\n              );\n              const statement = operationStrategy.buildHybridSearch(\n                { ...params, candidates },\n                toDrizzleSql(vectorSql, \"postgres\"),\n                params.vector.metric === \"cosine\",\n              );\n              const gucOverrides = await vectorSearchGucOverrides({\n                indexType: params.vector.indexType,\n                ...(params.vector.efSearch === undefined ?\n                  {}\n                : { efSearch: params.vector.efSearch }),\n              });\n              let raw: readonly Record<string, unknown>[];\n              try {\n                raw = await runVectorSearch<Record<string, unknown>>(\n                  gucOverrides,\n                  statement,\n                );\n              } catch (error) {\n                throw mapVectorWriteError(error, vectorParams);\n              }\n              return raw.map((row) => mapHybridSearchRow(row, toNodeRow));\n            },\n          }\n        : {}),\n      };\n\n  /**\n   * Takes the transaction-scoped share lock on the graph's active schema row,\n   * returning the version it locked — or `undefined` when the statement found\n   * no active row to lock, which at `read committed` does not by itself mean the\n   * graph has no active version — see the fence that calls this.\n   */\n  async function lockActiveSchemaVersion(\n    graphId: string,\n  ): Promise<number | undefined> {\n    const active = await execGet<{ version: number }>(sql`\n      SELECT ${schemaVersionsTable.version} AS version\n      FROM ${schemaVersionsTable}\n      WHERE ${schemaVersionsTable.graphId} = ${graphId}\n        AND ${schemaVersionsTable.isActive} = TRUE\n      FOR SHARE\n    `);\n    return active?.version;\n  }\n\n  const operationBackend: InternalOperationBackend = {\n    ...commonOperationMembers,\n    ...executeRawMethod,\n    ...vectorEmbeddingMethods,\n    /**\n     * Transaction-scoped contribution marker stamp. Present so the\n     * destructive rebuild can commit its marker with the DDL that\n     * produced it; without it the stamp would land outside the\n     * transaction and could survive a rolled-back drop.\n     *\n     * States the row outright rather than reusing the top-level upsert,\n     * whose `materialized_at` COALESCE preserves an earlier success so a\n     * failed re-attempt cannot erase it. A completed rebuild replaced the\n     * storage, so the recorded timestamp must be the rebuild's.\n     */\n    async recordContributionMaterialization(\n      params: RecordContributionMaterializationParams,\n    ): Promise<void> {\n      await execRun(\n        operationStrategy.buildInsertContributionMaterialization(params),\n      );\n    },\n\n    async deleteSchemaVectorSlotContribution(slot: VectorSlot): Promise<void> {\n      if (vectorStrategy === undefined) return;\n      for (const contribution of vectorStrategy.ownedTables(slot)) {\n        await execRun(\n          operationStrategy.buildDeleteContributionMaterialization({\n            graphId: slot.graphId,\n            logicalName: contribution.logicalName,\n            owner: contribution.owner,\n            tableName: contribution.tableName,\n          }),\n        );\n      }\n      // Eviction is conservative if the surrounding transaction later rolls\n      // back: the next access re-reads the still-durable marker.\n      contributionMaterializer.evictVectorSlot(slot);\n    },\n    capabilities,\n    fulltextStrategy,\n    ...(vectorStrategy === undefined ? {} : { vectorStrategy }),\n    dialect: \"postgres\",\n    tableNames,\n\n    async lockSchemaVersionForWrite(\n      params: LockSchemaVersionForWriteParams,\n    ): Promise<void> {\n      if (!transactionScoped) {\n        throw new ConfigurationError(\n          \"The schema write fence requires an explicit PostgreSQL transaction.\",\n          {\n            code: \"SCHEMA_WRITE_FENCE_TRANSACTION_REQUIRED\",\n            graphId: params.graphId,\n          },\n        );\n      }\n      const locked = await lockActiveSchemaVersion(params.graphId);\n      if (locked !== undefined) {\n        assertActiveSchemaVersion(\n          params.graphId,\n          params.expectedVersion,\n          locked,\n        );\n        return;\n      }\n\n      // An empty locked read is not evidence of an absent active version. At\n      // `read committed`, a `FOR SHARE` read that blocks behind an in-flight\n      // schema commit rechecks only the row versions its own statement snapshot\n      // saw: once that commit lands, the row this statement waited on no longer\n      // satisfies `is_active = TRUE`, and the winner's freshly inserted active\n      // row was never in the snapshot to be substituted in.\n      //\n      // Either way this transaction holds no share lock on an active row, so the\n      // write is rejected. That is why the version reported below needs no lock\n      // of its own — and why the fence must NOT retry the locked read: the\n      // dropped row keeps the share lock the first read took on it, so a second\n      // `FOR SHARE` waits on the row the *next* schema commit has already taken\n      // `FOR UPDATE` while that commit waits on the dropped row in its\n      // deactivate-all. PostgreSQL breaks the cycle by killing one of the two,\n      // and the schema commit — waiting first, so timing out first — is the one\n      // that dies.\n      //\n      // A non-locking read names the version honestly: a schema commit's\n      // deactivate-then-insert pair is atomic, so no committed state has zero\n      // active rows for a graph that has one, and an ordinary read never waits\n      // and so has no recheck to be fooled by. It yields `0` only for a graph\n      // that genuinely has no active version. A rollback landing back on\n      // `expectedVersion` reports `expected === actual`; the rejection stands,\n      // because nothing is holding the fence.\n      const settled = await commonOperationMembers.getActiveSchema(\n        params.graphId,\n      );\n      throw new StaleVersionError({\n        graphId: params.graphId,\n        expected: params.expectedVersion,\n        actual: settled?.version ?? 0,\n      });\n    },\n\n    // === Vector Index Operations ===\n\n    async createVectorIndex(params: CreateVectorIndexParams): Promise<void> {\n      if (vectorStrategy === undefined) return;\n      const slot = vectorSlotFromCreateIndexParams(params);\n      // Ensure the per-field table + its durable marker first (privileged,\n      // idempotent), then create its ANN index. pgvector's `ownedTables`\n      // builds the table only — the HNSW/IVFFlat index is created here (and\n      // only here) so it picks up the declared `m`/`ef_construction`/`lists`\n      // from `slot.indexParams` rather than defaults.\n      await contributionMaterializer.ensureVectorSlot(slot);\n      // Honor the `concurrent` flag materializeIndexes passes on Postgres so the\n      // ANN build doesn't take a write-blocking lock on a live table. execRun is\n      // autocommit, which CONCURRENTLY requires.\n      const indexStatement = vectorStrategy.buildCreateIndex?.(slot, {\n        concurrent: params.concurrent === true,\n      });\n      if (indexStatement !== undefined) {\n        const strategyTableName = vectorStrategy.tableName(\n          slot.graphId,\n          slot.nodeKind,\n          slot.fieldPath,\n        );\n        // Built-in pgvector HNSW/IVFFlat builds stage the build graph in dynamic\n        // shared memory, and resource-constrained hosts reject the\n        // allocation (SQLSTATE class 53 — e.g. containers with the 64MB\n        // /dev/shm default fail a 50k x 384-dim HNSW build with 53100\n        // from dsm_impl_posix). Retry serially: drop the INVALID\n        // leftover the failed CONCURRENTLY build leaves behind (its\n        // IF NOT EXISTS would otherwise mask the retry), pin the\n        // strategy table to parallel_workers = 0 (maintenance builds\n        // take min(storage parameter, max_parallel_maintenance_workers)),\n        // rebuild in local memory, and restore the setting.\n        await runPostgresVectorIndexBuild(\n          vectorStrategy,\n          execRun,\n          strategyTableName,\n          indexStatement,\n          vectorStrategy.buildDropIndex?.(slot),\n        );\n      }\n    },\n\n    // === Fulltext Operations ===\n\n    async upsertFulltext(params: UpsertFulltextParams): Promise<void> {\n      const timestamp = nowIso();\n      const statements = operationStrategy.buildUpsertFulltext(\n        params,\n        timestamp,\n      );\n      for (const stmt of statements) {\n        await execRun(stmt);\n      }\n    },\n\n    async deleteFulltext(params: DeleteFulltextParams): Promise<void> {\n      const statements = operationStrategy.buildDeleteFulltext(params);\n      for (const stmt of statements) {\n        await execRun(stmt);\n      }\n    },\n\n    async upsertFulltextBatch(\n      params: UpsertFulltextBatchParams,\n    ): Promise<void> {\n      if (params.rows.length === 0) return;\n      const timestamp = nowIso();\n      // The strategy emits ONE statement over every row it is given, so\n      // the bind budget is enforced here — same contract as node/edge\n      // batch inserts.\n      for (const rows of chunkArray(\n        params.rows,\n        batchConfig.fulltextUpsertBatchSize,\n      )) {\n        const statements = operationStrategy.buildUpsertFulltextBatch(\n          { ...params, rows },\n          timestamp,\n        );\n        for (const stmt of statements) {\n          await execRun(stmt);\n        }\n      }\n    },\n\n    async deleteFulltextBatch(\n      params: DeleteFulltextBatchParams,\n    ): Promise<void> {\n      if (params.nodeIds.length === 0) return;\n      for (const nodeIds of chunkArray(\n        params.nodeIds,\n        batchConfig.fulltextDeleteChunkSize,\n      )) {\n        const statements = operationStrategy.buildDeleteFulltextBatch({\n          ...params,\n          nodeIds,\n        });\n        for (const stmt of statements) {\n          await execRun(stmt);\n        }\n      }\n    },\n\n    async fulltextSearch(\n      params: FulltextSearchParams,\n    ): Promise<readonly FulltextSearchResult[]> {\n      const query = operationStrategy.buildFulltextSearch(params);\n      // pg returns `numeric` as a string to preserve precision; coerce at the\n      // backend boundary so FulltextSearchResult.score is always `number`.\n      const rows = await execAll<{\n        node_id: string;\n        score: number | string;\n        snippet: string | null;\n      }>(query);\n      return rows.map((row, index) => ({\n        nodeId: row.node_id,\n        score: coerceNumericScore(row.score),\n        rank: index + 1,\n        ...(row.snippet === null ? {} : { snippet: row.snippet }),\n      }));\n    },\n\n    async dropVectorIndex(params: DropVectorIndexParams): Promise<void> {\n      if (vectorStrategy === undefined) return;\n      const slot = vectorSlotFromDropIndexParams(params);\n      const dropStatement = vectorStrategy.buildDropIndex?.(slot);\n      if (dropStatement === undefined) return;\n      try {\n        await execRun(dropStatement);\n      } catch (error) {\n        // The per-field table (and thus its index) may never have been\n        // materialized; treat a missing relation as already-dropped.\n        if (!isMissingTableError(error)) throw error;\n      }\n    },\n\n    // === Query Execution ===\n\n    async execute<T>(query: CompiledRowsSql): Promise<readonly T[]> {\n      // Statements the compiler branded as containing an ANN index scan\n      // (inline `approximate: true`) get the same pgvector GUC wrapping\n      // the search facade applies — most importantly\n      // `hnsw.iterative_scan = strict_order`, without which a filtered\n      // approximate query starves at the default ef_search frontier.\n      // On pgvector < 0.8 the override list is empty and this falls\n      // through to the plain fast path.\n      const annTypes =\n        isSqlFragment(query) ? annIndexScanTypes(query) : undefined;\n      if (annTypes !== undefined && vectorStrategy !== undefined) {\n        const overrides: SearchGucOverride[] = [];\n        for (const indexType of annTypes) {\n          if (indexType !== \"hnsw\" && indexType !== \"ivfflat\") continue;\n          overrides.push(...(await vectorSearchGucOverrides({ indexType })));\n        }\n        return runVectorSearch<T>(overrides, query);\n      }\n      return executionAdapter.execute<T>(query);\n    },\n\n    compileSql(\n      query: SqlFragment,\n    ): Readonly<{ sql: string; params: readonly unknown[] }> {\n      return executionAdapter.compile(query);\n    },\n  };\n\n  return operationBackend;\n}\n\n/**\n * A transaction-scoped backend plus the hook that shuts its statement queue\n * at the transaction boundary. See {@link SerialExecutionAdapter.drainAndClose}.\n */\ntype BoundTransactionBackend = Readonly<{\n  backend: InternalOperationBackend;\n  drainAndClose: () => Promise<void>;\n}>;\n\nfunction createTransactionBackend(\n  options: CreatePostgresTransactionBackendOptions,\n): BoundTransactionBackend {\n  // Every statement this backend issues rides one pinned connection, which\n  // can carry exactly one query at a time. Serialize them here rather than\n  // relying on the driver's own queue: node-postgres deprecated\n  // `client.query()` on a busy client in 8.22 and removes the queue in pg@9.\n  // The wrap is unconditional because the overlap is created inside TypeGraph\n  // (the node write pipeline syncs embeddings and fulltext concurrently), not\n  // only by user code.\n  const txExecutionAdapter = createSerialExecutionAdapter(\n    createPostgresExecutionAdapter(options.db, options.adapterOptions),\n  );\n\n  // The transaction-scoped backend shares the outer backend's\n  // contribution materializer: the per-field vector table is provisioned\n  // (DDL) only by the privileged outer backend, so a tx-scoped vector op\n  // only ASSERTS the durable marker (SELECT, never DDL) and can't poison\n  // anything on rollback. The shared per-instance cache means a slot\n  // confirmed once stays a pure `Set.has` inside every later transaction.\n  const backend = createPostgresOperationBackend({\n    db: options.db,\n    executionAdapter: txExecutionAdapter,\n    adapterOptions: options.adapterOptions,\n    operationStrategy: options.operationStrategy,\n    tableNames: options.tableNames,\n    capabilities: options.capabilities,\n    fulltextStrategy: options.fulltextStrategy,\n    vectorStrategy: options.vectorStrategy,\n    contributionMaterializer: options.contributionMaterializer,\n    // The probe is process-wide truth, so the outer instance's is reused\n    // rather than a fresh one per transaction.\n    iterativeScanProbe: options.iterativeScanProbe,\n    schemaVersionsTable: options.schemaVersionsTable,\n    transactionScoped: true,\n  });\n\n  return { backend, drainAndClose: txExecutionAdapter.drainAndClose };\n}\n\n// Re-export schema utilities\nexport type { PostgresTableNames, PostgresTables } from \"./schema/postgres\";\nexport { createPostgresTables, tables } from \"./schema/postgres\";\n"]}

package/dist/chunk-U3Z7XKAG.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/backend/sqlite/local-options.ts","../src/backend/sqlite/local.ts"],"names":["tables"],"mappings":"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","file":"chunk-U3Z7XKAG.js","sourcesContent":["/** Journal modes accepted by local SQLite connections. */\nexport type LocalSqliteJournalMode =\n  \"wal\" | \"delete\" | \"truncate\" | \"persist\" | \"memory\" | \"off\";\n\n/** Synchronous levels accepted by local SQLite connections. */\nexport type LocalSqliteSynchronousMode = \"off\" | \"normal\" | \"full\" | \"extra\";\n\n/** Connection pragmas applied when TypeGraph opens a local SQLite database. */\nexport type LocalSqlitePragmaOptions = Readonly<{\n  /** `PRAGMA journal_mode`. Default: `\"wal\"` (no-op on `\":memory:\"`). */\n  journalMode?: LocalSqliteJournalMode;\n  /** `PRAGMA synchronous`. Default: `\"normal\"`. */\n  synchronous?: LocalSqliteSynchronousMode;\n  /** `PRAGMA busy_timeout`, in milliseconds. Default: `5000`. */\n  busyTimeoutMs?: number;\n  /**\n   * `PRAGMA cache_size`, expressed as a negative KiB value. Positive values\n   * mean pages in SQLite and are rejected to prevent accidental oversizing.\n   */\n  cacheSizeKib?: number | undefined;\n  /** `PRAGMA mmap_size`, in non-negative bytes. */\n  mmapSizeBytes?: number | undefined;\n  /**\n   * `PRAGMA wal_autocheckpoint`, in WAL pages. Use `0` to disable automatic\n   * checkpoints and run them explicitly after controlled bulk loads.\n   */\n  walAutocheckpointPages?: number | undefined;\n}>;\n\n/** Defaults for TypeGraph-owned local SQLite connections. */\nexport const DEFAULT_LOCAL_SQLITE_PRAGMAS: Required<LocalSqlitePragmaOptions> =\n  {\n    journalMode: \"wal\",\n    synchronous: \"normal\",\n    busyTimeoutMs: 5000,\n    cacheSizeKib: undefined,\n    mmapSizeBytes: undefined,\n    walAutocheckpointPages: undefined,\n  };\n","/**\n * Local SQLite backend using better-sqlite3.\n *\n * This module depends on the `better-sqlite3` native addon and should only\n * be imported in Node.js environments. For bundler-friendly SQLite DDL\n * generation and Drizzle backend creation, import from `@nicia-ai/typegraph/adapters/drizzle/sqlite`.\n *\n * @example In-memory database (default)\n * ```typescript\n * import { createLocalSqliteBackend } from \"@nicia-ai/typegraph/adapters/drizzle/sqlite/local\";\n *\n * const { backend, db } = createLocalSqliteBackend();\n * const store = createStore(graph, backend);\n * ```\n *\n * @example File-based database for persistent local development\n * ```typescript\n * import { createLocalSqliteBackend } from \"@nicia-ai/typegraph/adapters/drizzle/sqlite/local\";\n *\n * const { backend, db } = createLocalSqliteBackend({ path: \"./dev.db\" });\n * const store = createStore(graph, backend);\n * ```\n */\nimport { createRequire } from \"node:module\";\n\nimport Database from \"better-sqlite3\";\nimport {\n  type BetterSQLite3Database,\n  drizzle,\n} from \"drizzle-orm/better-sqlite3\";\n\nimport { ConfigurationError } from \"../../errors\";\nimport { sqliteVecStrategy } from \"../../query/dialect/vector/sqlite-vec-strategy\";\nimport { wrapWithManagedClose } from \"../derive-backend\";\nimport { generateSqliteDDL } from \"../drizzle/ddl\";\nimport { type AnySqliteDatabase } from \"../drizzle/execution\";\nexport type { AnySqliteDatabase } from \"../drizzle/execution\";\nimport {\n  createSqliteBackend,\n  type SqliteTables,\n  tables as defaultTables,\n} from \"../drizzle/sqlite\";\nimport {\n  DEFAULT_LOCAL_SQLITE_PRAGMAS,\n  type LocalSqliteJournalMode,\n  type LocalSqlitePragmaOptions,\n  type LocalSqliteSynchronousMode,\n} from \"./local-options\";\n\nexport {\n  DEFAULT_LOCAL_SQLITE_PRAGMAS,\n  type LocalSqliteJournalMode,\n  type LocalSqlitePragmaOptions,\n  type LocalSqliteSynchronousMode,\n} from \"./local-options\";\nimport { type AdapterBackend, type BackendCapabilities } from \"../types\";\n\nexport type {\n  ContributionDiagnostic,\n  ContributionDiagnosticState,\n  ContributionRepairEntry,\n  ContributionRepairResult,\n} from \"../types\";\n\nconst nodeRequire = createRequire(import.meta.url);\n\n// ============================================================\n// Native Addon Helpers\n// ============================================================\n\ntype NodeModuleVersionMismatch = Readonly<{\n  compiled: number;\n  required: number;\n}>;\n\nfunction getUnknownErrorMessage(error: unknown): string {\n  if (error instanceof Error) return error.message;\n  return String(error);\n}\n\nfunction parseNodeModuleVersionMismatchMessage(\n  message: string,\n): NodeModuleVersionMismatch | undefined {\n  const regexp =\n    /NODE_MODULE_VERSION (?<compiled>\\d+)[\\s\\S]*?NODE_MODULE_VERSION (?<required>\\d+)/;\n  const match = regexp.exec(message);\n  if (!match?.groups) return undefined;\n\n  const compiled = Number(match.groups[\"compiled\"]);\n  const required = Number(match.groups[\"required\"]);\n\n  if (!Number.isFinite(compiled) || !Number.isFinite(required))\n    return undefined;\n\n  return { compiled, required };\n}\n\nfunction createDatabase(path: string): Database.Database {\n  try {\n    return new Database(path);\n  } catch (error) {\n    const message = getUnknownErrorMessage(error);\n    const mismatch = parseNodeModuleVersionMismatchMessage(message);\n    if (!mismatch) throw error;\n\n    throw new ConfigurationError(\n      [\n        \"Failed to load better-sqlite3 native addon.\",\n        `It was compiled for NODE_MODULE_VERSION ${mismatch.compiled}, but this Node.js runtime requires ${mismatch.required}.`,\n        \"This usually happens after switching Node versions without rebuilding native dependencies.\",\n        \"Rebuild with: pnpm rebuild better-sqlite3 (or npm rebuild better-sqlite3).\",\n      ].join(\" \"),\n      {\n        nodeVersion: process.version,\n        nodeModuleVersion: process.versions.modules,\n        compiledNodeModuleVersion: mismatch.compiled,\n        requiredNodeModuleVersion: mismatch.required,\n      },\n      { cause: error },\n    );\n  }\n}\n\n// ============================================================\n// Types\n// ============================================================\n\nconst LOCAL_SQLITE_JOURNAL_MODES: readonly LocalSqliteJournalMode[] = [\n  \"wal\",\n  \"delete\",\n  \"truncate\",\n  \"persist\",\n  \"memory\",\n  \"off\",\n];\n\nconst LOCAL_SQLITE_SYNCHRONOUS_MODES: readonly LocalSqliteSynchronousMode[] = [\n  \"off\",\n  \"normal\",\n  \"full\",\n  \"extra\",\n];\n\nconst SQLITE_MAX_WAL_AUTOCHECKPOINT_PAGES = 2_147_483_647;\n\nfunction applyConnectionPragmas(\n  sqlite: Database.Database,\n  pragmas: LocalSqlitePragmaOptions | false | undefined,\n): void {\n  if (pragmas === false) return;\n  const resolved: Required<LocalSqlitePragmaOptions> = {\n    ...DEFAULT_LOCAL_SQLITE_PRAGMAS,\n    ...pragmas,\n  };\n\n  // Runtime guards mirror the compile-time unions: pragma values are spliced\n  // into pragma statements, so reject anything outside the allowlists rather\n  // than forwarding it to SQLite.\n  if (!LOCAL_SQLITE_JOURNAL_MODES.includes(resolved.journalMode)) {\n    throw new ConfigurationError(\n      `Invalid journalMode pragma: ${resolved.journalMode}. ` +\n        `Expected one of: ${LOCAL_SQLITE_JOURNAL_MODES.join(\", \")}.`,\n      { journalMode: resolved.journalMode },\n    );\n  }\n  if (!LOCAL_SQLITE_SYNCHRONOUS_MODES.includes(resolved.synchronous)) {\n    throw new ConfigurationError(\n      `Invalid synchronous pragma: ${resolved.synchronous}. ` +\n        `Expected one of: ${LOCAL_SQLITE_SYNCHRONOUS_MODES.join(\", \")}.`,\n      { synchronous: resolved.synchronous },\n    );\n  }\n  if (\n    !Number.isSafeInteger(resolved.busyTimeoutMs) ||\n    resolved.busyTimeoutMs < 0\n  ) {\n    throw new ConfigurationError(\n      `Invalid busyTimeoutMs pragma: ${String(resolved.busyTimeoutMs)}. ` +\n        \"Expected a non-negative integer number of milliseconds.\",\n      { busyTimeoutMs: resolved.busyTimeoutMs },\n    );\n  }\n  if (\n    resolved.cacheSizeKib !== undefined &&\n    (!Number.isSafeInteger(resolved.cacheSizeKib) || resolved.cacheSizeKib >= 0)\n  ) {\n    throw new ConfigurationError(\n      `Invalid cacheSizeKib pragma: ${String(resolved.cacheSizeKib)}. ` +\n        \"Expected a negative safe integer — SQLite's own cache_size pragma \" +\n        \"interprets a positive value as a page count, not KiB, so a caller \" +\n        'who passes e.g. 131072 meaning \"131072 KiB\" silently gets ' +\n        \"131072 pages (~512MiB at the default 4KiB page size) instead.\",\n      { cacheSizeKib: resolved.cacheSizeKib },\n    );\n  }\n  if (\n    resolved.mmapSizeBytes !== undefined &&\n    (!Number.isSafeInteger(resolved.mmapSizeBytes) ||\n      resolved.mmapSizeBytes < 0)\n  ) {\n    throw new ConfigurationError(\n      `Invalid mmapSizeBytes pragma: ${String(resolved.mmapSizeBytes)}. ` +\n        \"Expected a non-negative safe integer number of bytes.\",\n      { mmapSizeBytes: resolved.mmapSizeBytes },\n    );\n  }\n  if (\n    resolved.walAutocheckpointPages !== undefined &&\n    (!Number.isSafeInteger(resolved.walAutocheckpointPages) ||\n      resolved.walAutocheckpointPages < 0 ||\n      resolved.walAutocheckpointPages > SQLITE_MAX_WAL_AUTOCHECKPOINT_PAGES)\n  ) {\n    throw new ConfigurationError(\n      `Invalid walAutocheckpointPages pragma: ${String(resolved.walAutocheckpointPages)}. ` +\n        `Expected an integer between 0 and ${SQLITE_MAX_WAL_AUTOCHECKPOINT_PAGES} ` +\n        \"WAL pages (0 disables automatic checkpointing entirely).\",\n      { walAutocheckpointPages: resolved.walAutocheckpointPages },\n    );\n  }\n\n  // \":memory:\" databases always journal in memory; SQLite answers the WAL\n  // request with \"memory\" instead of erroring, so no special-casing needed.\n  sqlite.pragma(`journal_mode = ${resolved.journalMode}`);\n  sqlite.pragma(`synchronous = ${resolved.synchronous}`);\n  sqlite.pragma(`busy_timeout = ${resolved.busyTimeoutMs}`);\n  if (resolved.cacheSizeKib !== undefined) {\n    sqlite.pragma(`cache_size = ${resolved.cacheSizeKib}`);\n  }\n  if (resolved.mmapSizeBytes !== undefined) {\n    sqlite.pragma(`mmap_size = ${resolved.mmapSizeBytes}`);\n  }\n  if (resolved.walAutocheckpointPages !== undefined) {\n    sqlite.pragma(`wal_autocheckpoint = ${resolved.walAutocheckpointPages}`);\n  }\n}\n\n/**\n * Options for creating a local SQLite backend.\n */\nexport type LocalSqliteBackendOptions = Readonly<{\n  /**\n   * Path to the SQLite database file.\n   * Defaults to \":memory:\" for an in-memory database.\n   */\n  path?: string;\n\n  /**\n   * Connection pragmas applied at open. Defaults to\n   * {@link DEFAULT_LOCAL_SQLITE_PRAGMAS} (WAL, `synchronous=NORMAL`, 5s busy\n   * timeout, and SQLite's own tiny built-in page cache / disabled mmap\n   * left untouched). Individual values merge over the defaults; pass\n   * `false` to skip pragma configuration entirely and keep the driver\n   * defaults (rollback journal, `synchronous=FULL`, and better-sqlite3's\n   * own 5s busy timeout from its `timeout` constructor option). Set\n   * `cacheSizeKib`/`mmapSizeBytes` explicitly once a database's working\n   * set is known to exceed SQLite's 2MiB default cache — otherwise every\n   * query pays a fresh disk read per page past that tiny working set. Set\n   * `walAutocheckpointPages` explicitly for a bulk-insert-heavy workload —\n   * SQLite's own default checkpoints every ~4MiB of WAL growth, which gets\n   * more expensive as the database file grows over a large load.\n   */\n  pragmas?: LocalSqlitePragmaOptions | false;\n\n  /**\n   * Custom table definitions.\n   * Defaults to standard TypeGraph table names.\n   */\n  tables?: SqliteTables;\n\n  /**\n   * Override specific backend capabilities — e.g. to simulate an engine-level\n   * gap like missing SQL window functions in tests. Forwarded to\n   * createSqliteBackend.\n   */\n  capabilities?: Partial<BackendCapabilities>;\n}>;\n\n/**\n * Result of creating a local SQLite backend.\n */\nexport type LocalSqliteBackendResult = Readonly<{\n  /**\n   * The GraphBackend instance for use with createStore.\n   */\n  backend: AdapterBackend<AnySqliteDatabase>;\n\n  /**\n   * The underlying Drizzle database instance.\n   * Useful for direct SQL access or cleanup.\n   */\n  db: BetterSQLite3Database;\n}>;\n\n// ============================================================\n// Factory Function\n// ============================================================\n\n/**\n * Creates a SQLite backend with minimal configuration.\n *\n * This is a convenience function for local development and testing.\n * It handles database creation, schema migration, and backend setup.\n *\n * For production deployments or custom configurations, use createSqliteBackend\n * directly with your own Drizzle database instance.\n *\n * @param options - Configuration options\n * @returns Backend and database instances\n *\n * @example In-memory database (default)\n * ```typescript\n * const { backend } = createLocalSqliteBackend();\n * const store = createStore(graph, backend);\n * ```\n *\n * @example File-based database\n * ```typescript\n * const { backend, db } = createLocalSqliteBackend({ path: \"./data.db\" });\n * const store = createStore(graph, backend);\n * ```\n */\nexport function createLocalSqliteBackend(\n  options: LocalSqliteBackendOptions = {},\n): LocalSqliteBackendResult {\n  const path = options.path ?? \":memory:\";\n  const tables = options.tables ?? defaultTables;\n\n  const sqlite = createDatabase(path);\n  try {\n    applyConnectionPragmas(sqlite, options.pragmas);\n\n    // Best-effort: load sqlite-vec so embedding fields are persisted to\n    // per-`(kind, field)` `vec0` storage. Without it, nodes with\n    // `embedding()` fields validate and insert but their vectors are silently\n    // dropped. When the user has installed sqlite-vec as a peer dep we load\n    // it and wire the strategy; otherwise we proceed without vector support.\n    const hasSqliteVec = tryLoadSqliteVec(sqlite);\n\n    const db = drizzle(sqlite);\n\n    // Generate and execute DDL from schema\n    const ddlStatements = generateSqliteDDL(tables);\n    for (const statement of ddlStatements) {\n      sqlite.exec(statement);\n    }\n\n    const backend = createSqliteBackend(db, {\n      executionProfile: {\n        isSync: true,\n      },\n      tables,\n      ...(hasSqliteVec ? { vector: sqliteVecStrategy } : {}),\n      capabilities: {\n        ...options.capabilities,\n        graphAnalytics: {\n          supported:\n            options.capabilities?.graphAnalytics?.supported ??\n            options.capabilities?.transactions !== false,\n          mathFunctions:\n            options.capabilities?.graphAnalytics?.mathFunctions ?? true,\n        },\n      },\n    });\n    const managedBackend = wrapWithManagedClose(backend, () => {\n      sqlite.close();\n    });\n\n    return { backend: managedBackend, db };\n  } catch (error) {\n    try {\n      sqlite.close();\n    } catch {\n      // Preserve the provisioning error; a cleanup failure is secondary.\n    }\n    throw error;\n  }\n}\n\nfunction tryLoadSqliteVec(sqlite: Database.Database): boolean {\n  try {\n    // `sqlite-vec` is an optional peer dep; resolved via createRequire so\n    // bundlers don't mark it as a hard import. Node resolves the package\n    // only when it's actually installed.\n    const module_: unknown = nodeRequire(\"sqlite-vec\");\n    if (\n      typeof module_ === \"object\" &&\n      module_ !== null &&\n      \"load\" in module_ &&\n      typeof module_.load === \"function\"\n    ) {\n      (module_ as { load: (db: Database.Database) => void }).load(sqlite);\n      return true;\n    }\n    return false;\n  } catch {\n    return false;\n  }\n}\nexport type { GraphIdentityConfig } from \"../../core/define-graph\";\n"]}