@nicia-ai/typegraph 0.31.0 → 0.33.0

package/dist/chunk-BF3ZDEUE.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/backend/drizzle/execution/postgres-execution.ts","../src/backend/drizzle/postgres.ts"],"names":["getOrCreateLru","sql","compileQueryWithDialect","POSTGRES_MAX_BIND_PARAMETERS","createNodeRowMapper","POSTGRES_ROW_MAPPER_CONFIG","createEdgeRowMapper","createUniqueRowMapper","createSchemaVersionRowMapper","POSTGRES_CAPABILITIES","buildVectorCapabilities","buildFulltextCapabilities","tables","tsvectorStrategy","pgvectorStrategy","createVectorSlotLatch","getTableName","quoteIdentifier","createPostgresOperationStrategy","createCachedTableExistence","ConfigurationError","generatePgCreateTableSQL","and","eq","mapContributionMaterializationRow","POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS","buildContributionInsertValues","buildContributionOnConflictSet","createContributionMaterializer","gateFulltext","generatePostgresDDL","gateFulltextMethods","mapMaterializationRow","POSTGRES_INDEX_MAT_TIMESTAMPS","inArray","buildMaterializationInsertValues","buildMaterializationOnConflictSet","isNull","mapKindRemovalRow","POSTGRES_KIND_REMOVAL_TIMESTAMPS","buildKindRemovalInsertValues","buildKindRemovalOnConflictSet","options","assertAdoptedDialect","PgDatabase","PgTransaction","createCommonOperationBackend","nowIso","vectorSlotFromParams","mapVectorWriteError","assertVectorSearchLimit","assertPgvectorEfSearch","vectorSlotFromCreateIndexParams","coerceNumericScore","vectorSlotFromDropIndexParams","isMissingTableError"],"mappings":"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","file":"chunk-BF3ZDEUE.cjs","sourcesContent":["import { type SQL } from \"drizzle-orm\";\nimport { type PgDatabase, type PgQueryResultHKT } from \"drizzle-orm/pg-core\";\n\nimport { getOrCreateLru } from \"./lru\";\nimport {\n  type CompiledSqlQuery,\n  compileQueryWithDialect,\n  type PreparedSqlStatement,\n  type SqlExecutionAdapter,\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: (sqlText: string, params: readonly unknown[]) => 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    ) => PromiseLike<readonly unknown[]>;\n  }>;\n\ntype PgClientCarrier = Readonly<{\n  $client?: unknown;\n}>;\n\nexport type AnyPgDatabase = PgDatabase<PgQueryResultHKT, Record<string, unknown>>;\n\nexport type PostgresExecutionAdapter = SqlExecutionAdapter;\n\nfunction 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 typeof candidate === \"object\" && hasFunctionProperty(candidate, \"query\");\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\nfunction isPostgresJsClient(candidate: unknown): candidate is PostgresJsClient {\n  // postgres-js's tagged-template Sql is callable, has `.unsafe` (raw\n  // parameterized executor), and has `.begin` (transaction starter).\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` (postgres-js only).\n  return (\n    typeof candidate === \"function\" &&\n    hasFunctionProperty(candidate, \"unsafe\") &&\n    hasFunctionProperty(candidate, \"begin\")\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(\n  rows: readonly unknown[],\n): 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  };\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  return {\n    async query(\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\nfunction adaptPostgresJsClient(sql: PostgresJsClient): PgQueryClient {\n  return {\n    async 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  };\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): 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 client = (db as PgClientCarrier).$client;\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 (isPgliteClient(client)) {\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: SQL,\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): PreparedSqlStatement {\n  return {\n    async execute<TRow>(params: readonly unknown[]): Promise<readonly TRow[]> {\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\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 pgClient = resolvePgClient(db, prepareStatements, cacheMax);\n\n  function compile(query: SQL): CompiledSqlQuery {\n    return compileQueryWithDialect(db, query, \"PostgreSQL\");\n  }\n\n  if (pgClient === undefined) {\n    return {\n      compile,\n      async execute<TRow>(query: SQL): Promise<readonly TRow[]> {\n        return executeDrizzleQuery<TRow>(db, query);\n      },\n    };\n  }\n\n  const pgQueryClient = pgClient;\n\n  async function executeCompiled<TRow>(\n    compiledQuery: CompiledSqlQuery,\n  ): Promise<readonly TRow[]> {\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: SQL): 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      return executeCompiled<TRow>(compiled);\n    },\n    executeCompiled,\n    prepare(sqlText: string): PreparedSqlStatement {\n      return createPgPreparedStatement(pgQueryClient, sqlText);\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/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/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 { PgDatabase, PgTransaction } from \"drizzle-orm/pg-core\";\n\nimport { ConfigurationError } from \"../../errors\";\nimport type { ResolvedSqlTableNames } from \"../../query/compiler/schema\";\nimport { quoteIdentifier } from \"../../query/compiler/utils\";\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  type VectorSlot,\n  type VectorStrategy,\n} from \"../../query/dialect/vector-strategy\";\nimport { isMissingTableError } from \"../../utils/sql-errors\";\nimport {\n  type AdoptedTransaction,\n  type BackendCapabilities,\n  type CommitSchemaVersionParams,\n  type ContributionMaterializationIdentity,\n  type ContributionMaterializationRow,\n  type CreateVectorIndexParams,\n  type DeleteEmbeddingParams,\n  type DeleteFulltextBatchParams,\n  type DeleteFulltextParams,\n  type DropVectorIndexParams,\n  type FulltextSearchParams,\n  type FulltextSearchResult,\n  type GraphBackend,\n  type IndexMaterializationRow,\n  type KindRemovalRow,\n  POSTGRES_CAPABILITIES,\n  POSTGRES_MAX_BIND_PARAMETERS,\n  type RecordContributionMaterializationParams,\n  type RecordIndexMaterializationParams,\n  type RecordKindRemovalParams,\n  type SchemaVersionRow,\n  type SetActiveVersionParams,\n  type TransactionBackend,\n  type TransactionOptions,\n  type UpsertEmbeddingParams,\n  type UpsertFulltextBatchParams,\n  type UpsertFulltextParams,\n  type VectorSearchParams,\n  type VectorSearchResult,\n} from \"../types\";\nimport {\n  buildContributionInsertValues,\n  buildContributionOnConflictSet,\n  createContributionMaterializer,\n  gateFulltext,\n  gateFulltextMethods,\n  mapContributionMaterializationRow,\n  POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS,\n} from \"./contribution-materializations\";\nimport { generatePgCreateTableSQL, generatePostgresDDL } from \"./ddl\";\nimport {\n  type AnyPgDatabase,\n  createPostgresExecutionAdapter,\n  isNeonHttpClient,\n  type PostgresExecutionAdapter,\n  type PostgresExecutionAdapterOptions,\n} from \"./execution/postgres-execution\";\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  assertAdoptedDialect,\n  type CommonOperationBackend,\n  createCommonOperationBackend,\n  type InternalOperationBackend,\n} from \"./operation-backend-core\";\nimport {\n  createCachedTableExistence,\n  createPostgresOperationStrategy,\n} from \"./operations/strategy\";\nimport {\n  coerceNumericScore,\n  createEdgeRowMapper,\n  createNodeRowMapper,\n  createSchemaVersionRowMapper,\n  createUniqueRowMapper,\n  nowIso,\n  POSTGRES_ROW_MAPPER_CONFIG,\n} from \"./row-mappers\";\nimport {\n  type PostgresTables,\n  tables as defaultTables,\n} from \"./schema/postgres\";\nimport {\n  createVectorSlotLatch,\n  mapVectorWriteError,\n  vectorSlotFromCreateIndexParams,\n  vectorSlotFromDropIndexParams,\n  vectorSlotFromParams,\n  type VectorSlotLatch,\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\nconst NODE_INSERT_PARAM_COUNT = 9;\nconst EDGE_INSERT_PARAM_COUNT = 12;\nconst POSTGRES_NODE_INSERT_BATCH_SIZE = Math.max(\n  1,\n  Math.floor(POSTGRES_MAX_BIND_PARAMETERS / NODE_INSERT_PARAM_COUNT),\n);\nconst POSTGRES_EDGE_INSERT_BATCH_SIZE = Math.max(\n  1,\n  Math.floor(POSTGRES_MAX_BIND_PARAMETERS / EDGE_INSERT_PARAM_COUNT),\n);\nconst POSTGRES_GET_NODES_ID_CHUNK_SIZE = Math.max(\n  1,\n  POSTGRES_MAX_BIND_PARAMETERS - 2,\n);\nconst POSTGRES_GET_EDGES_ID_CHUNK_SIZE = Math.max(\n  1,\n  POSTGRES_MAX_BIND_PARAMETERS - 1,\n);\nconst CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT = 3;\nconst POSTGRES_CHECK_UNIQUE_BATCH_CHUNK_SIZE = Math.max(\n  1,\n  POSTGRES_MAX_BIND_PARAMETERS - CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT,\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): GraphBackend {\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 latch per backend instance, shared with every transaction-scoped\n  // backend so a slot's per-field table is created at most once per process.\n  // Absent when vector support is disabled.\n  const vectorSlotLatch =\n    vectorStrategy === undefined ? undefined : createVectorSlotLatch();\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 = isNeonHttpClient(db) ? { transactions: false } : {};\n  const capabilities: BackendCapabilities = {\n    ...baseCapabilities,\n    ...httpOnlyOverrides,\n    ...options.capabilities,\n  };\n  const adapterOptions: PostgresExecutionAdapterOptions = {\n    ...(options.prepareStatements === undefined ?\n      {}\n    : { prepareStatements: options.prepareStatements }),\n    ...(options.preparedStatementCacheMax === undefined ?\n      {}\n    : { preparedStatementCacheMax: options.preparedStatementCacheMax }),\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    fulltext: tables.fulltextTableName,\n    uniques: getTableName(tables.uniques),\n  };\n  // Pre-quote identifiers so refreshStatistics() doesn't rebuild the\n  // ANALYZE statement on every call. The recorded relations are ANALYZEd\n  // separately under an existence guard (see refreshStatistics): a schema\n  // created before recorded-time history landed (bring-your-own-pool, no DDL\n  // re-run) has no recorded tables, and Postgres fails the whole ANALYZE if any\n  // named relation is missing. Per-field vector tables are created lazily and\n  // live outside this base set, so they are not ANALYZEd here.\n  const coreAnalyzeStatement = sql`ANALYZE ${sql.join(\n    [\n      tableNames.nodes,\n      tableNames.edges,\n      getTableName(tables.uniques),\n      tableNames.fulltext,\n    ].map((name) => quoteIdentifier(name)),\n    sql`, `,\n  )}`;\n  const recordedAnalyzeTables = [\n    tableNames.recordedNodes,\n    tableNames.recordedEdges,\n    tableNames.recordedClock,\n  ] as const;\n  const operationStrategy = createPostgresOperationStrategy(\n    tables,\n    fulltextStrategy,\n  );\n  const operations = createPostgresOperationBackend({\n    db,\n    executionAdapter,\n    adapterOptions,\n    operationStrategy,\n    tableNames,\n    capabilities,\n    fulltextStrategy,\n    vectorStrategy,\n    vectorSlotLatch,\n  });\n\n  // Whether `tableName` currently exists, via the same catalog probe `clear()`\n  // uses — so refreshStatistics() never ANALYZEs a recorded relation that a\n  // bring-your-own-pool schema has not yet created. The Postgres probe is\n  // search_path-aware, so positive results are deliberately not cached by bare\n  // table name.\n  const recordedTableExists = 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  /**\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: CommonOperationBackend) => Promise<T>,\n  ): Promise<T> {\n    if (!capabilities.transactions) {\n      throw new ConfigurationError(\n        \"commitSchemaVersion and setActiveVersion 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      await tx.execute(sql`SELECT pg_advisory_xact_lock(hashtext(${graphId}))`);\n      // Advisory lock is held here, so the schema-write-capable\n      // InternalOperationBackend is used intentionally (see its type).\n      const txBackend = createTransactionBackend({\n        db: tx,\n        adapterOptions,\n        operationStrategy,\n        tableNames,\n        capabilities,\n        fulltextStrategy,\n        vectorStrategy,\n        vectorSlotLatch,\n      });\n      return fn(txBackend);\n    });\n  }\n\n  // Durable fulltext materialization (#135): the dialect-specific\n  // marker-table primitives. Orchestration (materialize / assert /\n  // per-instance cache) lives once in `createContributionMaterializer`.\n  const matTable = tables.contributionMaterializations;\n\n  async function ensureContributionMaterializationsTableImpl(): Promise<void> {\n    await db.execute(sql.raw(generatePgCreateTableSQL(matTable)));\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 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  const contributionMaterializer = createContributionMaterializer({\n    dialect: \"postgres\",\n    fulltextStrategy,\n    fulltextTableName: tables.fulltextTableName,\n    execDdl: async (statement) => {\n      await db.execute(sql.raw(statement));\n    },\n    ensureMarkerTable: ensureContributionMaterializationsTableImpl,\n    getMarker: getContributionMaterializationRow,\n    recordMarker: recordContributionMaterializationRow,\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: AnyPgDatabase): TransactionBackend {\n    const txBackend = createTransactionBackend({\n      db: tx,\n      adapterOptions,\n      operationStrategy,\n      tableNames,\n      capabilities,\n      fulltextStrategy,\n      vectorStrategy,\n      vectorSlotLatch,\n    });\n    return gateFulltext(txBackend, contributionMaterializer.assertInitialized);\n  }\n\n  const backend: GraphBackend = {\n    ...operations,\n\n    async bootstrapTables(): Promise<void> {\n      const statements = generatePostgresDDL(tables, fulltextStrategy);\n      for (const statement of statements) {\n        await db.execute(sql.raw(statement));\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    ),\n\n    async executeDdl(ddl: string): Promise<void> {\n      await db.execute(sql.raw(ddl));\n    },\n\n    async ensureIndexMaterializationsTable(): Promise<void> {\n      await db.execute(\n        sql.raw(generatePgCreateTableSQL(tables.indexMaterializations)),\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(\n            t.materializedAt,\n            params.materializedAt,\n          ),\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 db.execute(sql.raw(generatePgCreateTableSQL(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 db.execute(\n        sql.raw(generatePgCreateTableSQL(tables.reconciliationMarkers)),\n      );\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 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.\n      await db.execute(coreAnalyzeStatement);\n      // The recorded relations may be absent on a schema created before\n      // recorded-time history landed (bring-your-own-pool, no DDL re-run).\n      // Postgres fails the entire ANALYZE if any named relation is missing, so\n      // ANALYZE only the recorded tables that exist.\n      const tablePresence = await Promise.all(\n        recordedAnalyzeTables.map(async (tableName) => ({\n          tableName,\n          exists: await recordedTableExists(tableName),\n        })),\n      );\n      const presentRecordedTables = tablePresence\n        .filter((entry) => entry.exists)\n        .map((entry) => entry.tableName);\n      if (presentRecordedTables.length > 0) {\n        await db.execute(\n          sql`ANALYZE ${sql.join(\n            presentRecordedTables.map((name) => quoteIdentifier(name)),\n            sql`, `,\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 setActiveVersion(params: SetActiveVersionParams): Promise<void> {\n      await runSchemaWriteTransaction(params.graphId, (target) =>\n        target.setActiveVersion(params),\n      );\n    },\n\n    async transaction<T>(\n      fn: (tx: TransactionBackend, sql: AdoptedTransaction) => Promise<T>,\n      options?: TransactionOptions,\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 txConfig =\n        options?.isolationLevel ?\n          {\n            isolationLevel: options.isolationLevel.replace(\"_\", \" \") as\n              | \"read uncommitted\"\n              | \"read committed\"\n              | \"repeatable read\"\n              | \"serializable\",\n          }\n        : undefined;\n\n      return db.transaction(\n        async (tx) => fn(bindTransactionBackend(tx), tx),\n        txConfig,\n      );\n    },\n\n    adoptTransaction(externalTx: AdoptedTransaction): 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<AnyPgDatabase>(externalTx, PgDatabase, \"postgres\");\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      return bindTransactionBackend(externalTx);\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  return backend;\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 per-`(kind, field)` storage-ensure latch. Paired with\n   * `vectorStrategy`: both present, or both `undefined`.\n   */\n  vectorSlotLatch: VectorSlotLatch | undefined;\n}>;\n\ntype CreatePostgresTransactionBackendOptions = Readonly<{\n  db: AnyPgDatabase;\n  executionAdapter?: PostgresExecutionAdapter;\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 storage-ensure latch. See {@link CreatePostgresOperationBackendOptions}. */\n  vectorSlotLatch: VectorSlotLatch | undefined;\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    vectorSlotLatch,\n  } = options;\n\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: SQL): Promise<readonly T[]> {\n    return executionAdapter.execute<T>(query);\n  }\n\n  async function execGet<T>(query: SQL): Promise<T | undefined> {\n    const rows = await executionAdapter.execute<T>(query);\n    return rows[0];\n  }\n\n  async function execRun(query: SQL): Promise<void> {\n    await executionAdapter.execute(query);\n  }\n\n  type VectorSearchRow = Readonly<{ node_id: string; score: number }>;\n\n  // One warning per backend instance when `efSearch` is supplied but the\n  // driver can't hold a transaction to scope `SET LOCAL` to.\n  let efSearchUnsupportedWarned = false;\n  function warnEfSearchUnsupported(): void {\n    if (efSearchUnsupportedWarned) return;\n    efSearchUnsupportedWarned = true;\n    if (typeof console === \"undefined\" || typeof console.warn !== \"function\") {\n      return;\n    }\n    console.warn(\n      \"[typegraph] efSearch (hnsw.ef_search override) was ignored: this \" +\n        \"Postgres backend has transactions disabled (e.g. drizzle-orm/neon-http), \" +\n        \"and SET LOCAL needs a transaction to scope the override. Use a \" +\n        \"transactional driver (node-postgres / neon-serverless / postgres-js) \" +\n        \"to apply efSearch.\",\n    );\n  }\n\n  /**\n   * Runs the vector SELECT, applying `hnsw.ef_search` transaction-locally\n   * when requested. `SET LOCAL` only takes effect inside an explicit\n   * transaction — issued in autocommit it rolls off with the statement\n   * and the next pooled query (notably under transaction-mode pgbouncer)\n   * sees the session default again. So when `efSearch` is set we bundle\n   * `BEGIN; SET LOCAL …; SELECT …; COMMIT;` onto one connection. When\n   * absent we take the unchanged single-statement fast path and open no\n   * transaction.\n   */\n  async function runVectorSearch(\n    efSearch: number | undefined,\n    query: SQL,\n  ): Promise<readonly VectorSearchRow[]> {\n    if (efSearch === undefined) {\n      return execAll<VectorSearchRow>(query);\n    }\n    if (!capabilities.transactions) {\n      warnEfSearchUnsupported();\n      return execAll<VectorSearchRow>(query);\n    }\n    // `SET` cannot be parameterized; `efSearch` is validated as an\n    // integer in 1..MAX_HNSW_EF_SEARCH before we get here, so inlining\n    // it is injection-safe.\n    const setEfSearch = sql.raw(`SET LOCAL hnsw.ef_search = ${efSearch}`);\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 frontier, apply the override, then restore it once\n      // the SELECT has materialized so the override stays scoped to this\n      // one search.\n      const [setting] = await execAll<{ ef_search: string }>(\n        sql`SELECT current_setting('hnsw.ef_search') AS ef_search`,\n      );\n      await execRun(setEfSearch);\n      const rows = await execAll<VectorSearchRow>(query);\n      // Restore only on success: a failed SELECT aborts the caller's\n      // transaction, so its rollback discards the SET LOCAL anyway and a\n      // restore here would just fail against the aborted tx, masking the\n      // real error. `set_config(_, _, true)` is the parameterizable form\n      // of SET LOCAL.\n      if (setting !== undefined) {\n        await execRun(\n          sql`SELECT set_config('hnsw.ef_search', ${setting.ef_search}, true)`,\n        );\n      }\n      return rows;\n    }\n    return db.transaction(async (tx) => {\n      // Bind an equivalently-configured adapter to the tx client so the\n      // SELECT keeps the server-side prepared-statement fast path and the\n      // driver result-shape normalization, rather than a bespoke execute.\n      const txAdapter = createPostgresExecutionAdapter(tx, adapterOptions);\n      await txAdapter.execute(setEfSearch);\n      return txAdapter.execute<VectorSearchRow>(query);\n    });\n  }\n\n  // Runs the strategy's per-field DDL on this backend's connection (the tx\n  // client for a transaction-scoped backend) so a slot's table exists\n  // before the first write/search hits it.\n  async function ensureVectorSlotStorage(slot: VectorSlot): Promise<void> {\n    if (vectorStrategy === undefined || vectorSlotLatch === undefined) return;\n    await vectorSlotLatch.ensure(vectorStrategy, slot, async (statement) => {\n      await execRun(sql.raw(statement));\n    });\n  }\n\n  const commonBackend = createCommonOperationBackend({\n    batchConfig: {\n      checkUniqueBatchChunkSize: POSTGRES_CHECK_UNIQUE_BATCH_CHUNK_SIZE,\n      edgeInsertBatchSize: POSTGRES_EDGE_INSERT_BATCH_SIZE,\n      getEdgesChunkSize: POSTGRES_GET_EDGES_ID_CHUNK_SIZE,\n      getNodesChunkSize: POSTGRES_GET_NODES_ID_CHUNK_SIZE,\n      nodeInsertBatchSize: POSTGRES_NODE_INSERT_BATCH_SIZE,\n    },\n    execution: {\n      execAll,\n      execGet,\n      execRun,\n    },\n    nowIso,\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          await ensureVectorSlotStorage(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 deleteEmbedding(params: DeleteEmbeddingParams): Promise<void> {\n          // Ensure the per-field table exists 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), and on Postgres a\n          // DELETE against a missing relation INSIDE a transaction aborts the\n          // whole transaction — swallowing the JS error can't un-abort it.\n          // The idempotent ensure makes the DELETE target an existing\n          // (possibly empty) table, so it's always a clean no-op.\n          const slot = vectorSlotFromParams(params);\n          await ensureVectorSlotStorage(slot);\n          const statements = vectorStrategy.buildDelete(slot, params);\n          for (const statement of statements) {\n            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` inlines it into `SET LOCAL`.\n          assertPgvectorEfSearch(params.efSearch);\n          const slot = vectorSlotFromParams(params);\n          await ensureVectorSlotStorage(slot);\n          const query = vectorStrategy.buildSearch(slot, params);\n          let rows: readonly { node_id: string; score: number }[];\n          try {\n            rows = await runVectorSearch(params.efSearch, 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      };\n\n  const operationBackend: InternalOperationBackend = {\n    ...commonBackend,\n    ...executeRawMethod,\n    ...vectorEmbeddingMethods,\n    capabilities,\n    fulltextStrategy,\n    ...(vectorStrategy === undefined ? {} : { vectorStrategy }),\n    dialect: \"postgres\",\n    tableNames,\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 exists first (idempotent), then create its\n      // ANN index. pgvector's `ownedTables` builds the table only — the HNSW/\n      // IVFFlat index is created here (and only here) so it picks up the\n      // declared `m`/`ef_construction`/`lists` from `slot.indexParams` rather\n      // than defaults.\n      await ensureVectorSlotStorage(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        await execRun(indexStatement);\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      const statements = operationStrategy.buildUpsertFulltextBatch(\n        params,\n        timestamp,\n      );\n      for (const stmt of statements) {\n        await execRun(stmt);\n      }\n    },\n\n    async deleteFulltextBatch(\n      params: DeleteFulltextBatchParams,\n    ): Promise<void> {\n      if (params.nodeIds.length === 0) return;\n      const statements = operationStrategy.buildDeleteFulltextBatch(params);\n      for (const stmt of statements) {\n        await execRun(stmt);\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: SQL): Promise<readonly T[]> {\n      return executionAdapter.execute<T>(query);\n    },\n\n    compileSql(\n      query: SQL,\n    ): Readonly<{ sql: string; params: readonly unknown[] }> {\n      return executionAdapter.compile(query);\n    },\n  };\n\n  return operationBackend;\n}\n\nfunction createTransactionBackend(\n  options: CreatePostgresTransactionBackendOptions,\n): InternalOperationBackend {\n  const txExecutionAdapter =\n    options.executionAdapter ??\n    createPostgresExecutionAdapter(options.db, options.adapterOptions);\n\n  // A transaction-scoped backend gets its OWN per-field ensure-latch, never\n  // the outer process-global one: a `CREATE TABLE/INDEX` that runs inside the\n  // caller's transaction and then rolls back must not leave the shared latch\n  // marking the slot \"ensured\" (which would skip the re-CREATE and make every\n  // later write fail with \"relation does not exist\"). The fresh latch is\n  // discarded with the transaction, so the next write re-ensures idempotently.\n  // No latch when vector support is disabled (`vector: false`).\n  return 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    vectorSlotLatch:\n      options.vectorStrategy === undefined ? undefined : createVectorSlotLatch(),\n  });\n}\n\n// Re-export schema utilities\nexport type { PostgresTableNames, PostgresTables } from \"./schema/postgres\";\nexport { createPostgresTables, tables } from \"./schema/postgres\";\n"]}

package/dist/{chunk-2HZGWCB4.js → chunk-C4C4Q7A6.js}

@@ -436,7 +436,7 @@ function assertVectorMinScore(minScore, metric, label = "minScore") {
   if (!Number.isFinite(minScore)) {
     throw new RangeError(`${label} must be a finite number, got: ${minScore}`);
   }
-  if (metric === "cosine" && (minScore < -1 || minScore > 1)) {
+  if (metric === "cosine" && Math.abs(minScore) > 1) {
     throw new RangeError(
       `${label} for the cosine metric must be between -1 and 1, got: ${minScore}`
     );
@@ -1034,5 +1034,5 @@ function escapeStringLiteral(value) {
 }
 
 export { BASE_CONTRIBUTION_OWNER, VECTOR_CONTRIBUTION_PREFIX, assertFiniteEmbedding, assertVectorMinScore, assertVectorSearchLimit, buildFulltextCapabilities, buildVectorCapabilities, compileEdgeIndexKeys, compileIndexWhere, compileNodeIndexFieldKeys, compileNodeIndexKeys, edgeColumnList, fts5Strategy, getDialect, nodeColumnList, quoteIdentifier2 as quoteIdentifier, quotedColumn, quotedTableName, sqlNull, tsvectorStrategy, vectorMinScoreCondition, vectorPhysicalName, vectorScoreExpression };
-//# sourceMappingURL=chunk-2HZGWCB4.js.map
-//# sourceMappingURL=chunk-2HZGWCB4.js.map
+//# sourceMappingURL=chunk-C4C4Q7A6.js.map
+//# sourceMappingURL=chunk-C4C4Q7A6.js.map

package/dist/chunk-C4C4Q7A6.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/backend/drizzle/operations/shared.ts","../src/backend/table-contribution.ts","../src/query/dialect/fulltext-strategy.ts","../src/query/dialect/vector-strategy.ts","../src/query/dialect/postgres.ts","../src/query/dialect/sqlite.ts","../src/query/dialect/index.ts","../src/indexes/compiler.ts"],"names":["sql","quoteIdentifier"],"mappings":"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","file":"chunk-C4C4Q7A6.js","sourcesContent":["import { type SQL, sql } from \"drizzle-orm\";\n\nimport type { PostgresTables } from \"../schema/postgres\";\nimport type { SqliteTables } from \"../schema/sqlite\";\n\nexport type Tables = SqliteTables | PostgresTables;\n\n/**\n * Converts undefined to SQL NULL for use in template literals.\n * Drizzle doesn't handle undefined in sql`` templates correctly.\n */\nexport function sqlNull(value: string | undefined): SQL | string {\n  return value ?? sql.raw(\"NULL\");\n}\n\nexport function quotedColumn(column: { name: string }): SQL {\n  return sql.raw(`\"${column.name.replaceAll('\"', '\"\"')}\"`);\n}\n\n/**\n * Returns a quoted SQL identifier for a bare table name string.\n * Use when the operation targets a table that isn't represented as a\n * Drizzle table object (e.g. the FTS5 virtual table).\n */\nexport function quotedTableName(tableName: string): SQL {\n  return sql.raw(`\"${tableName.replaceAll('\"', '\"\"')}\"`);\n}\n\nexport function nodeColumnList(nodes: Tables[\"nodes\"]): SQL {\n  return sql.raw(`\"${nodes.graphId.name}\", \"${nodes.kind.name}\", \"${nodes.id.name}\", \"${nodes.props.name}\", \"${nodes.version.name}\", \"${nodes.validFrom.name}\", \"${nodes.validTo.name}\", \"${nodes.createdAt.name}\", \"${nodes.updatedAt.name}\"`);\n}\n\nexport function edgeColumnList(edges: Tables[\"edges\"]): SQL {\n  return sql.raw(`\"${edges.graphId.name}\", \"${edges.id.name}\", \"${edges.kind.name}\", \"${edges.fromKind.name}\", \"${edges.fromId.name}\", \"${edges.toKind.name}\", \"${edges.toId.name}\", \"${edges.props.name}\", \"${edges.validFrom.name}\", \"${edges.validTo.name}\", \"${edges.createdAt.name}\", \"${edges.updatedAt.name}\"`);\n}\n","/**\n * Unified table-contribution contract (#129).\n *\n * Every table TypeGraph owns — whether modeled as a Drizzle table or\n * emitted as strategy-owned raw DDL — is described by a single\n * {@link TableContribution} shape. This is the one place that answers\n * \"what tables does this backend/strategy own?\", replacing the\n * previously split surfaces (Drizzle named exports, tables-factory\n * recursion, strategy raw DDL, per-table `ensureXTable` methods).\n *\n * Lives in the neutral `backend/` layer (sibling of `backend/types.ts`,\n * which `query/dialect` already depends on) and is deliberately\n * Drizzle-free, so declaring contributions does not pull the concrete\n * Drizzle backend runtime into the query/dialect layer.\n *\n * ## Identity vs. signature (prerequisite for #135)\n *\n * #135 (durable fulltext/contribution materialization) needs to make\n * \"not materialized\" vs. \"materialized but stale\" a decidable, durable\n * fact instead of an in-memory per-backend latch. That requires two\n * conceptually separate things, and #129's job is only to make both\n * *derivable* from the contract:\n *\n * - **Materialization identity** — `owner` + `logicalName` +\n *   resolved physical `tableName`. Keying on `logicalName` alone is\n *   insufficient: custom per-deployment table names must be\n *   distinguishable, otherwise two deployments with different physical\n *   names would collide on one durable marker. (#135 additionally\n *   scopes this by `graphId` at persistence time.)\n * - **Drift signature** — a hash of the strategy identity/version,\n *   the resolved table name(s), and the normalized `createDdl`. #129\n *   guarantees `createDdl` is deterministic for a given resolved\n *   configuration so the hash #135 computes is meaningful.\n *\n * The signature is intentionally **not** eagerly carried on the\n * contribution: hashing is async (Web Crypto, see `utils/hash`) and\n * #135 already owns signature persistence the same way\n * `materializeIndexes` does for declared indexes.\n */\n\n/**\n * `logicalName` of the strategy-owned fulltext slot. Used as a logic\n * discriminant (latch routing, runtime-ensure) across the strategies\n * and both backends — a shared constant so a strategy declaring a\n * different name fails loudly at the call site instead of silently\n * skipping the latched fulltext path.\n */\nexport const FULLTEXT_CONTRIBUTION_NAME = \"fulltext\";\n\n/** `owner` of core/base schema tables (not strategy-owned). */\nexport const BASE_CONTRIBUTION_OWNER = \"base\";\n\n/**\n * A single table TypeGraph owns.\n */\nexport type TableContribution = Readonly<{\n  /**\n   * Stable, graph- and deployment-independent identity for the logical\n   * slot this contribution fills (e.g. `\"fulltext\"`). NOT the physical\n   * table name. Stable across table-name overrides and across strategy\n   * swaps of the *same* logical slot, so #135's durable marker can\n   * survive both.\n   */\n  logicalName: string;\n  /**\n   * Identifies the producer of this contribution (e.g. a strategy id\n   * like `\"tsvector\"` / `\"fts5\"`, or `\"base\"` for core schema tables).\n   * Part of the #135 materialization identity and an input to the\n   * drift signature — a strategy swap on the same `logicalName` is a\n   * legitimate, detectable drift, not a silent reuse.\n   */\n  owner: string;\n  /**\n   * Resolved physical table name after any per-deployment name\n   * override. Part of the #135 materialization identity (custom names\n   * must be distinguishable) and used by diagnostics / the focused\n   * bootstrap ensure.\n   */\n  tableName: string;\n  /**\n   * Idempotent (`CREATE ... IF NOT EXISTS`) statements that\n   * materialize this contribution's table **and its supporting\n   * indexes**. Running the full list is how the runtime ensure\n   * self-heals partial states (table present, index missing) — it is\n   * not a probe-and-skip. Deterministic for a given resolved\n   * configuration: the canonical normalized input to #135's drift\n   * signature.\n   */\n  createDdl: readonly string[];\n  /**\n   * When `true`, the post-schema-load focused ensure\n   * (`loadActiveSchemaWithBootstrap`) materializes this contribution\n   * on every successful schema load.\n   *\n   * **Invariant: only strategy-declared contributions may set this.**\n   * Core/base tables are always `false` — they are created by\n   * drizzle-kit / `bootstrapTables`. This is what lets the boot path\n   * derive runtime contributions straight from the strategy\n   * (`fulltextStrategy.ownedTables`) without walking — and generating\n   * DDL for — every base table.\n   */\n  runtimeEnsure: boolean;\n}>;\n\n/**\n * A table a {@link FulltextStrategy} declares it owns. An alias, not a\n * distinct shape: a strategy's declaration is already authoritative\n * (no resolution step). The name documents the producer role.\n */\nexport type StrategyTableContribution = TableContribution;\n","/**\n * Fulltext Strategy — pluggable DDL + SQL generation for a dialect's\n * fulltext stack. A strategy owns every SQL statement that touches its\n * backing table: DDL, upsert (single + batch), delete (single + batch),\n * MATCH condition, rank expression, and snippet expression.\n *\n * A dialect picks one as its default; `createPostgresBackend` /\n * `createSqliteBackend` accept an override for alternate Postgres stacks\n * (pg_trgm, ParadeDB/pg_search, pgroonga) to swap the entire fulltext\n * pipeline without forking TypeGraph.\n */\nimport { type SQL, sql } from \"drizzle-orm\";\n\nimport { quotedTableName } from \"../../backend/drizzle/operations/shared\";\nimport {\n  FULLTEXT_CONTRIBUTION_NAME,\n  type StrategyTableContribution,\n} from \"../../backend/table-contribution\";\nimport {\n  type DeleteFulltextBatchParams,\n  type DeleteFulltextParams,\n  type FulltextBatchRow,\n  type FulltextCapabilities,\n  type FulltextQueryMode,\n  type UpsertFulltextBatchParams,\n  type UpsertFulltextParams,\n} from \"../../backend/types\";\n\n/**\n * Every `FulltextQueryMode` both shipped strategies accept.\n */\nexport const ALL_FULLTEXT_MODES: readonly FulltextQueryMode[] = [\n  \"websearch\",\n  \"phrase\",\n  \"plain\",\n  \"raw\",\n] as const;\n\n/**\n * Derives the `FulltextCapabilities` backends advertise from the active\n * strategy, so the two never drift.\n */\nexport function buildFulltextCapabilities(\n  strategy: FulltextStrategy,\n): FulltextCapabilities {\n  return {\n    supported: true,\n    languages: strategy.languages,\n    phraseQueries: strategy.supportedModes.includes(\"phrase\"),\n    prefixQueries: strategy.supportsPrefix,\n    highlighting: strategy.supportsSnippets,\n  };\n}\n\n/**\n * A pluggable fulltext implementation. Each strategy is expected to be\n * self-contained: given a table name, a query string, and a parse mode,\n * it emits every SQL statement the compiler and backend need — DDL,\n * reads, and writes. No out-of-band conventions across layers.\n */\nexport interface FulltextStrategy {\n  /** Human-readable identifier used in error messages and telemetry. */\n  readonly name: string;\n\n  /**\n   * Parse modes this strategy can translate. Callers validate against\n   * this list before emitting SQL; a mode outside the set means the\n   * strategy rejects the query at compile time.\n   */\n  readonly supportedModes: readonly FulltextQueryMode[];\n\n  /**\n   * Whether the strategy can emit a per-row highlighted snippet. When\n   * false, `snippetExpression` returns a literal `NULL` so callers can\n   * leave the `snippet` column in place without a branch.\n   */\n  readonly supportsSnippets: boolean;\n\n  /**\n   * Whether the strategy supports prefix queries (`foo*`). Used to\n   * populate `BackendCapabilities.fulltext.prefixQueries`. A strategy\n   * may support prefix queries via dedicated syntax without advertising\n   * \"raw\" mode (and vice-versa).\n   */\n  readonly supportsPrefix: boolean;\n\n  /**\n   * Whether a per-query `language` override is honored. Postgres' tsvector\n   * accepts any installed regconfig at query time; SQLite FTS5's tokenizer\n   * is fixed at table-create time, so the override is silently ignored.\n   * Callers may surface a warning when the user passes `language` to a\n   * strategy that doesn't honor it.\n   */\n  readonly supportsLanguageOverride: boolean;\n\n  /**\n   * Languages / tokenizer names understood by the strategy. Advisory — a\n   * runtime backend like Postgres may accept other installed regconfigs.\n   * Used to populate `BackendCapabilities.fulltext.languages`.\n   */\n  readonly languages: readonly string[];\n\n  /**\n   * Emits the WHERE-side MATCH expression.\n   *\n   * @example\n   * tsvector: `\"typegraph_node_fulltext\".\"tsv\" @@ websearch_to_tsquery('english', 'cats')`\n   * fts5:     `\"typegraph_node_fulltext\" MATCH '\"cats\"'`\n   */\n  matchCondition(\n    tableName: string,\n    query: string,\n    mode: FulltextQueryMode,\n    language?: string,\n  ): SQL;\n\n  /**\n   * Emits the relevance expression. Higher values = more relevant. The\n   * compiler orders by this expression DESC, and both builder and\n   * backend-direct paths use the same form so their top-k results agree.\n   */\n  rankExpression(\n    tableName: string,\n    query: string,\n    mode: FulltextQueryMode,\n    language?: string,\n  ): SQL;\n\n  /**\n   * Emits a per-row highlighted snippet expression, or `NULL` when\n   * `supportsSnippets` is false. Snippet markup is `<mark>…</mark>` in\n   * both shipped strategies so consumers can apply one stylesheet.\n   */\n  snippetExpression(\n    tableName: string,\n    query: string,\n    mode: FulltextQueryMode,\n    language?: string,\n  ): SQL;\n\n  /**\n   * The tables this strategy owns, as Drizzle-free, already\n   * authoritative `TableContribution`s (`logicalName`, `owner`,\n   * resolved `tableName`, idempotent `createDdl` for the table **and\n   * its supporting indexes**, `runtimeEnsure`). A strategy never\n   * constructs a Drizzle table itself; drizzle-kit visibility, when\n   * applicable, is the schema barrel's responsibility (the default\n   * Postgres strategy's `schema/postgres.ts` exports a matching\n   * `tables.fulltext` — a non-default strategy must export its own).\n   *\n   * Replaces the former `generateDdl(tableName)`: DDL is now one field\n   * of a contribution rather than the strategy's whole storage\n   * surface. (Public API change — see #129.)\n   */\n  ownedTables(primaryTableName: string): readonly StrategyTableContribution[];\n\n  /**\n   * Emits the statements that upsert a single fulltext row. Returns one\n   * or more statements — some backends (SQLite FTS5) cannot emulate\n   * upsert in a single statement and need DELETE + INSERT.\n   */\n  buildUpsert(\n    tableName: string,\n    params: UpsertFulltextParams,\n    timestamp: string,\n  ): readonly SQL[];\n\n  /**\n   * Emits the statements that upsert many fulltext rows at once. Input\n   * rows are expected to be de-duplicated last-write-wins by the\n   * strategy if the underlying SQL statement cannot tolerate duplicate\n   * conflict keys. Returns `[]` when `params.rows` is empty.\n   */\n  buildBatchUpsert(\n    tableName: string,\n    params: UpsertFulltextBatchParams,\n    timestamp: string,\n  ): readonly SQL[];\n\n  /**\n   * Emits the statements that delete a single fulltext row. Normally a\n   * single PK-scoped DELETE, but strategies that maintain auxiliary\n   * indexes (delete-triggered external stores, ParadeDB-style secondary\n   * structures) may need more.\n   */\n  buildDelete(tableName: string, params: DeleteFulltextParams): readonly SQL[];\n\n  /**\n   * Emits the statements that delete many fulltext rows at once. Returns\n   * `[]` when `params.nodeIds` is empty.\n   */\n  buildBatchDelete(\n    tableName: string,\n    params: DeleteFulltextBatchParams,\n  ): readonly SQL[];\n}\n\n// ============================================================\n// Internal helpers\n// ============================================================\n\nfunction quoteIdentifier(name: string): string {\n  return `\"${name.replaceAll('\"', '\"\"')}\"`;\n}\n\nfunction tsvectorColumn(tableName: string): SQL {\n  return sql`${quotedTableName(tableName)}.\"tsv\"`;\n}\n\n/**\n * Dedupes batch rows last-write-wins by nodeId. Returns a plain array\n * in insertion order of the last occurrence of each id. Shared by both\n * shipped strategies.\n */\nfunction dedupeFulltextBatchRows(\n  rows: readonly FulltextBatchRow[],\n): FulltextBatchRow[] {\n  const seen = new Map<string, FulltextBatchRow>();\n  for (const row of rows) seen.set(row.nodeId, row);\n  return [...seen.values()];\n}\n\nfunction buildPkScopedDelete(\n  tableName: string,\n  params: DeleteFulltextParams,\n): SQL {\n  const table = quotedTableName(tableName);\n  return sql`\n    DELETE FROM ${table}\n    WHERE \"graph_id\" = ${params.graphId}\n      AND \"node_kind\" = ${params.nodeKind}\n      AND \"node_id\" = ${params.nodeId}\n  `;\n}\n\nfunction buildPkScopedBatchDelete(\n  tableName: string,\n  params: DeleteFulltextBatchParams,\n): SQL | undefined {\n  if (params.nodeIds.length === 0) return undefined;\n  const unique = [...new Set(params.nodeIds)];\n  const table = quotedTableName(tableName);\n  return sql`\n    DELETE FROM ${table}\n    WHERE \"graph_id\" = ${params.graphId}\n      AND \"node_kind\" = ${params.nodeKind}\n      AND \"node_id\" IN (${sql.join(\n        unique.map((id) => sql`${id}`),\n        sql`, `,\n      )})\n  `;\n}\n\n// ============================================================\n// tsvector strategy (PostgreSQL built-in)\n// ============================================================\n\nfunction postgresTsquery(\n  mode: FulltextQueryMode,\n  query: string,\n  language: string | undefined,\n): SQL {\n  // The `language` column is already `regconfig`, so the non-override\n  // path references the column directly. The per-query override path\n  // still arrives as a bound text parameter and needs the cast.\n  const langExpr: SQL =\n    language === undefined ? sql`\"language\"` : sql`${language}::regconfig`;\n  switch (mode) {\n    case \"websearch\": {\n      return sql`websearch_to_tsquery(${langExpr}, ${query})`;\n    }\n    case \"phrase\": {\n      return sql`phraseto_tsquery(${langExpr}, ${query})`;\n    }\n    case \"plain\": {\n      return sql`plainto_tsquery(${langExpr}, ${query})`;\n    }\n    case \"raw\": {\n      return sql`to_tsquery(${langExpr}, ${query})`;\n    }\n    default: {\n      const _exhaustive: never = mode;\n      throw new Error(`Unsupported fulltext mode: ${String(_exhaustive)}`);\n    }\n  }\n}\n\nexport const tsvectorStrategy: FulltextStrategy = {\n  name: \"tsvector\",\n  supportedModes: ALL_FULLTEXT_MODES,\n  supportsSnippets: true,\n  // `raw` mode exposes `foo:*` prefix-match syntax to callers.\n  supportsPrefix: true,\n  supportsLanguageOverride: true,\n  // Canonical Postgres stemmers; every stock install ships these plus a\n  // few others. Runtime `to_tsvector` accepts any installed regconfig\n  // name — this list is advisory for capability discovery.\n  languages: [\n    \"simple\",\n    \"english\",\n    \"french\",\n    \"german\",\n    \"italian\",\n    \"portuguese\",\n    \"russian\",\n    \"spanish\",\n    \"swedish\",\n  ] as const,\n\n  matchCondition(tableName, query, mode, language) {\n    const q = postgresTsquery(mode, query, language);\n    return sql`${tsvectorColumn(tableName)} @@ ${q}`;\n  },\n\n  rankExpression(tableName, query, mode, language) {\n    const q = postgresTsquery(mode, query, language);\n    return sql`ts_rank_cd(${tsvectorColumn(tableName)}, ${q})`;\n  },\n\n  snippetExpression(_tableName, query, mode, language) {\n    const langExpr: SQL =\n      language === undefined ? sql`\"language\"` : sql`${language}::regconfig`;\n    const q = postgresTsquery(mode, query, language);\n    return sql`ts_headline(${langExpr}, \"content\", ${q}, 'StartSel=<mark>,StopSel=</mark>,MaxFragments=1,MinWords=5,MaxWords=30,ShortWord=3')`;\n  },\n\n  ownedTables(primaryTableName) {\n    const name = quoteIdentifier(primaryTableName);\n    const gin = quoteIdentifier(`${primaryTableName}_tsv_idx`);\n    const kind = quoteIdentifier(`${primaryTableName}_kind_idx`);\n    // `language` is `regconfig` so `to_tsvector(\"language\", \"content\")`\n    // is an immutable expression — Postgres can then compute `tsv` as a\n    // GENERATED STORED column and own the `content → tsv` invariant.\n    // (The text→regconfig cast happens once at INSERT time against the\n    // bound parameter, which is fine because it's not inside the\n    // generated expression.)\n    const createDdl = [\n      `CREATE TABLE IF NOT EXISTS ${name} (\n  \"graph_id\" TEXT NOT NULL,\n  \"node_kind\" TEXT NOT NULL,\n  \"node_id\" TEXT NOT NULL,\n  \"content\" TEXT NOT NULL,\n  \"language\" regconfig NOT NULL,\n  \"tsv\" tsvector NOT NULL\n    GENERATED ALWAYS AS (to_tsvector(\"language\", \"content\")) STORED,\n  \"updated_at\" TIMESTAMPTZ NOT NULL,\n  PRIMARY KEY (\"graph_id\", \"node_kind\", \"node_id\")\n);`,\n      `CREATE INDEX IF NOT EXISTS ${gin} ON ${name} USING GIN (\"tsv\");`,\n      `CREATE INDEX IF NOT EXISTS ${kind} ON ${name} (\"graph_id\", \"node_kind\");`,\n    ];\n    // drizzle-kit visibility for this default strategy comes from\n    // `schema/postgres.ts` exporting the matching `tables.fulltext`\n    // pgTable through the barrel — one object, not two. `runtimeEnsure`\n    // because drizzle-kit-managed setups create every base table except\n    // this strategy-owned one.\n    return [\n      {\n        logicalName: FULLTEXT_CONTRIBUTION_NAME,\n        owner: \"tsvector\",\n        tableName: primaryTableName,\n        createDdl,\n        runtimeEnsure: true,\n      },\n    ];\n  },\n\n  buildUpsert(tableName, params, timestamp) {\n    const table = quotedTableName(tableName);\n    // `tsv` is a GENERATED STORED column — Postgres computes it from\n    // `content` + `language`, so it must not appear in the column list\n    // or the ON CONFLICT update set.\n    return [\n      sql`\n        INSERT INTO ${table} (\"graph_id\", \"node_kind\", \"node_id\", \"content\", \"language\", \"updated_at\")\n        VALUES (\n          ${params.graphId}, ${params.nodeKind}, ${params.nodeId},\n          ${params.content}, ${params.language}::regconfig,\n          ${timestamp}\n        )\n        ON CONFLICT (\"graph_id\", \"node_kind\", \"node_id\")\n        DO UPDATE SET\n          \"content\" = EXCLUDED.\"content\",\n          \"language\" = EXCLUDED.\"language\",\n          \"updated_at\" = EXCLUDED.\"updated_at\"\n      `,\n    ];\n  },\n\n  buildBatchUpsert(tableName, params, timestamp) {\n    const rows = dedupeFulltextBatchRows(params.rows);\n    if (rows.length === 0) return [];\n\n    const table = quotedTableName(tableName);\n    const valueTuples = rows.map(\n      (row) => sql`\n        (\n              ${params.graphId}, ${params.nodeKind}, ${row.nodeId},\n              ${row.content}, ${row.language}::regconfig,\n              ${timestamp}\n            )\n      `,\n    );\n\n    return [\n      sql`\n        INSERT INTO ${table} (\"graph_id\", \"node_kind\", \"node_id\", \"content\", \"language\", \"updated_at\")\n        VALUES ${sql.join(valueTuples, sql`, `)}\n        ON CONFLICT (\"graph_id\", \"node_kind\", \"node_id\")\n        DO UPDATE SET\n          \"content\" = EXCLUDED.\"content\",\n          \"language\" = EXCLUDED.\"language\",\n          \"updated_at\" = EXCLUDED.\"updated_at\"\n      `,\n    ];\n  },\n\n  buildDelete(tableName, params) {\n    return [buildPkScopedDelete(tableName, params)];\n  },\n\n  buildBatchDelete(tableName, params) {\n    const stmt = buildPkScopedBatchDelete(tableName, params);\n    return stmt === undefined ? [] : [stmt];\n  },\n};\n\n// ============================================================\n// FTS5 strategy (SQLite)\n// ============================================================\n\nfunction translateToFts5Query(query: string, mode: FulltextQueryMode): string {\n  switch (mode) {\n    case \"phrase\": {\n      return `\"${query.replaceAll('\"', '\"\"')}\"`;\n    }\n    case \"plain\": {\n      return query\n        .trim()\n        .split(/\\s+/u)\n        .filter((token) => token.length > 0)\n        .map((token) => `\"${token.replaceAll('\"', '\"\"')}\"`)\n        .join(\" \");\n    }\n    case \"websearch\": {\n      return translateWebsearchToFts5(query);\n    }\n    case \"raw\": {\n      return query;\n    }\n    default: {\n      const _exhaustive: never = mode;\n      throw new Error(`Unsupported fulltext mode: ${String(_exhaustive)}`);\n    }\n  }\n}\n\nfunction translateWebsearchToFts5(query: string): string {\n  const tokens: string[] = [];\n  let index = 0;\n\n  function skipWhitespace(): void {\n    while (index < query.length && /\\s/u.test(query[index] ?? \"\")) {\n      index += 1;\n    }\n  }\n\n  function readPhrase(): string {\n    index += 1;\n    let content = \"\";\n    while (index < query.length && query[index] !== '\"') {\n      content += query[index] ?? \"\";\n      index += 1;\n    }\n    if (query[index] === '\"') index += 1;\n    return `\"${content.replaceAll('\"', '\"\"')}\"`;\n  }\n\n  function readBareTerm(): string {\n    let term = \"\";\n    while (index < query.length && !/\\s/u.test(query[index] ?? \"\")) {\n      term += query[index] ?? \"\";\n      index += 1;\n    }\n    return term;\n  }\n\n  while (index < query.length) {\n    skipWhitespace();\n    if (index >= query.length) break;\n    const ch = query[index];\n    if (ch === '\"') {\n      tokens.push(readPhrase());\n      continue;\n    }\n    if (ch === \"-\") {\n      index += 1;\n      const term =\n        query[index] === '\"' ?\n          readPhrase()\n        : `\"${readBareTerm().replaceAll('\"', '\"\"')}\"`;\n      tokens.push(`NOT ${term}`);\n      continue;\n    }\n    if (ch === \"+\") {\n      index += 1;\n      continue;\n    }\n    const bare = readBareTerm();\n    if (bare.length === 0) continue;\n    if (bare.toUpperCase() === \"OR\") {\n      tokens.push(\"OR\");\n      continue;\n    }\n    tokens.push(`\"${bare.replaceAll('\"', '\"\"')}\"`);\n  }\n\n  if (tokens.length > 0 && tokens[0]?.startsWith(\"NOT \")) {\n    tokens.shift();\n  }\n\n  return tokens.join(\" \");\n}\n\nexport const fts5Strategy: FulltextStrategy = {\n  name: \"fts5\",\n  supportedModes: ALL_FULLTEXT_MODES,\n  supportsSnippets: true,\n  // FTS5 supports `foo*` prefix matching natively.\n  supportsPrefix: true,\n  // FTS5 tokenizer is fixed at table-create time; per-row / per-query\n  // language metadata is stored but not consulted.\n  supportsLanguageOverride: false,\n  // The built-in tokenizer is `porter unicode61 remove_diacritics 2`; the\n  // `language` field on searchable() is recorded for future use but not\n  // applied at query time.\n  languages: [\"porter\", \"unicode61\", \"trigram\"] as const,\n\n  matchCondition(tableName, query, mode, _language) {\n    const matchExpression = translateToFts5Query(query, mode);\n    return sql`${quotedTableName(tableName)} MATCH ${matchExpression}`;\n  },\n\n  rankExpression(tableName, _query, _mode, _language) {\n    // FTS5 bm25() returns a negative score where lower = more relevant.\n    // Negate so callers see higher = better (uniform with tsvector).\n    return sql`-bm25(${quotedTableName(tableName)})`;\n  },\n\n  snippetExpression(tableName, _query, _mode, _language) {\n    return sql`snippet(${quotedTableName(tableName)}, -1, '<mark>', '</mark>', '…', 20)`;\n  },\n\n  ownedTables(primaryTableName) {\n    const name = quoteIdentifier(primaryTableName);\n    // FTS5 virtual tables cannot be modeled as a Drizzle table, so this\n    // contribution is raw-ddl: emitted verbatim and invisible to\n    // drizzle-kit. `runtimeEnsure` because no drizzle-kit-managed setup\n    // can create it.\n    return [\n      {\n        logicalName: FULLTEXT_CONTRIBUTION_NAME,\n        owner: \"fts5\",\n        tableName: primaryTableName,\n        createDdl: [\n          `CREATE VIRTUAL TABLE IF NOT EXISTS ${name} USING fts5(\n  graph_id UNINDEXED,\n  node_kind UNINDEXED,\n  node_id UNINDEXED,\n  language UNINDEXED,\n  updated_at UNINDEXED,\n  content,\n  tokenize='porter unicode61 remove_diacritics 2'\n);`,\n        ],\n        runtimeEnsure: true,\n      },\n    ];\n  },\n\n  buildUpsert(tableName, params, timestamp) {\n    const table = quotedTableName(tableName);\n    // FTS5 virtual tables don't support ON CONFLICT — emulate with\n    // DELETE + INSERT, atomic under the caller's outer transaction.\n    return [\n      sql`\n        DELETE FROM ${table}\n        WHERE \"graph_id\" = ${params.graphId}\n          AND \"node_kind\" = ${params.nodeKind}\n          AND \"node_id\" = ${params.nodeId}\n      `,\n      sql`\n        INSERT INTO ${table} (graph_id, node_kind, node_id, content, language, updated_at)\n        VALUES (${params.graphId}, ${params.nodeKind}, ${params.nodeId}, ${params.content}, ${params.language}, ${timestamp})\n      `,\n    ];\n  },\n\n  buildBatchUpsert(tableName, params, timestamp) {\n    const rows = dedupeFulltextBatchRows(params.rows);\n    if (rows.length === 0) return [];\n\n    const table = quotedTableName(tableName);\n    const nodeIds = rows.map((row) => row.nodeId);\n\n    const deleteStmt = sql`\n      DELETE FROM ${table}\n      WHERE \"graph_id\" = ${params.graphId}\n        AND \"node_kind\" = ${params.nodeKind}\n        AND \"node_id\" IN (${sql.join(\n          nodeIds.map((id) => sql`${id}`),\n          sql`, `,\n        )})\n    `;\n\n    const valueTuples = rows.map(\n      (row) => sql`\n        (\n              ${params.graphId}, ${params.nodeKind}, ${row.nodeId},\n              ${row.content}, ${row.language}, ${timestamp}\n            )\n      `,\n    );\n\n    const insertStmt = sql`\n      INSERT INTO ${table} (graph_id, node_kind, node_id, content, language, updated_at)\n      VALUES ${sql.join(valueTuples, sql`, `)}\n    `;\n\n    return [deleteStmt, insertStmt];\n  },\n\n  buildDelete(tableName, params) {\n    return [buildPkScopedDelete(tableName, params)];\n  },\n\n  buildBatchDelete(tableName, params) {\n    const stmt = buildPkScopedBatchDelete(tableName, params);\n    return stmt === undefined ? [] : [stmt];\n  },\n};\n","/**\n * Vector Strategy — pluggable storage + SQL generation for a backend's\n * vector stack. The sibling of {@link FulltextStrategy}: a strategy owns\n * every statement that touches its embedding storage — the per-field DDL,\n * upsert, delete, similarity search, and (optional) ANN index lifecycle —\n * plus the capability advertisement and the distance/score expressions the\n * query compiler splices into its relevance CTE.\n *\n * ## Why a strategy, and why per-(kind, field) storage\n *\n * The spike behind #157 established that \"real\" ANN on every engine we\n * support converges on a\n * **typed, fixed-dimension structure per `(nodeKind, fieldPath)`**:\n *\n * - pgvector: a `vector(N)` column + HNSW/IVFFlat;\n * - libSQL native: an `F32_BLOB(N)` column + `libsql_vector_idx` +\n *   `vector_top_k` (a plain `BLOB` or dimensionless `F32_BLOB` is rejected\n *   by the index — the dimension must live in the column type);\n * - sqlite-vec: a `vec0(embedding float[N])` virtual table.\n *\n * The legacy single shared `typegraph_node_embeddings` table (one generic\n * column holding mixed-dimension vectors) can only ever be brute-forced;\n * pgvector was the sole engine that hid this, because its index supplies the\n * dimension via a `::vector(N)` cast expression. So storage is the\n * strategy's to own, slot by slot, rather than a fixed global table.\n *\n * Brute force remains a legitimate, capability-advertised mode (libSQL's\n * `vector_distance_cos` over a column with no index, sqlite-vec's\n * `vec_distance_cosine`): a strategy whose `capabilities.indexTypes` is\n * `[\"none\"]` simply never emits an ANN index and `buildSearch` always scans.\n */\nimport { type SQL, sql } from \"drizzle-orm\";\n\nimport { type StrategyTableContribution } from \"../../backend/table-contribution\";\nimport {\n  type DeleteEmbeddingParams,\n  type UpsertEmbeddingParams,\n  type VectorCapabilities,\n  type VectorIndexType,\n  type VectorMetric,\n  type VectorSearchParams,\n} from \"../../backend/types\";\n\n/**\n * `logicalName` prefix of a strategy-owned vector slot. Each\n * `(nodeKind, fieldPath)` pair fills one logical vector slot; the full\n * logical name is `${VECTOR_CONTRIBUTION_PREFIX}:${nodeKind}.${fieldPath}`,\n * stable across table-name overrides and strategy swaps so #135's durable\n * materialization marker survives both.\n */\nexport const VECTOR_CONTRIBUTION_PREFIX = \"vector\";\n\n/**\n * The resolved identity of one embedding field's storage in a graph —\n * everything a strategy needs to DDL, address, and index it.\n *\n * Graph-scoped: each `(graphId, nodeKind, fieldPath)` gets its own physical\n * table. TypeGraph supports many graphs per physical database, and the same\n * `(kind, field)` can carry different embedding dimensions across graphs — a\n * shared per-`(kind, field)` table would collide on the fixed column type\n * (`vector(N)` / `F32_BLOB(N)`). Graph-scoping also makes libSQL's\n * table-global `vector_top_k` per-graph-exact (no cross-graph recall bleed).\n */\nexport type VectorSlot = Readonly<{\n  /** Graph the embedding belongs to — scopes the physical table. */\n  graphId: string;\n  /** Node kind owning the embedding field (e.g. `\"Document\"`). */\n  nodeKind: string;\n  /** Dot-path of the embedding field within the node props (e.g. `\"embedding\"`). */\n  fieldPath: string;\n  /** Fixed vector dimension `N` for this field — carried into the column type. */\n  dimensions: number;\n  /** Distance metric the field's index is built for. */\n  metric: VectorMetric;\n  /**\n   * Index type to materialize. `\"none\"` means brute-force only (no ANN\n   * index emitted); the strategy still stores and searches the field.\n   */\n  indexType: VectorIndexType;\n  /**\n   * Optional ANN index tuning carried into the index DDL (pgvector\n   * `m`/`ef_construction`/`lists`). Present on the create-index / re-embed\n   * paths (resolved from the field's `embedding()` declaration); omitted on\n   * the write/search ensure paths, where the strategy falls back to defaults.\n   */\n  indexParams?: Readonly<{\n    m?: number;\n    efConstruction?: number;\n    lists?: number;\n  }>;\n}>;\n\n/**\n * Derives the `VectorCapabilities` a backend advertises from its active\n * strategy, so the two never drift (mirrors `buildFulltextCapabilities`).\n * The strategy is the single source of truth; there are no per-call-site\n * `SQLITE_VECTOR_*` constants.\n */\nexport function buildVectorCapabilities(\n  strategy: VectorStrategy,\n): VectorCapabilities {\n  return strategy.capabilities;\n}\n\n/**\n * A pluggable vector implementation. Each strategy is self-contained:\n * given a {@link VectorSlot}, it emits every statement the backend and\n * compiler need — per-field storage DDL, writes, similarity search, ANN\n * index lifecycle — and advertises exactly the metrics and index types it\n * can honor. Adding the Nth backend is one of these objects; no core edits.\n */\nexport interface VectorStrategy {\n  /** Human-readable identifier used in error messages and telemetry. */\n  readonly name: string;\n\n  /**\n   * The metrics, index types, and dimension ceiling this strategy honors —\n   * advertised verbatim as `backend.capabilities.vector`. Asymmetry across\n   * engines is legitimate and explicit here (pgvector has `inner_product`;\n   * libSQL/sqlite-vec do not), never a silent runtime failure.\n   */\n  readonly capabilities: VectorCapabilities;\n\n  /**\n   * Deterministic physical table (or virtual-table) name backing a field in\n   * a graph. The compiler references this to scan the right per-field storage,\n   * and the backend uses it to route upserts/deletes. Must be a stable,\n   * collision-safe SQL identifier derived from `(graphId, nodeKind, fieldPath)`.\n   */\n  tableName(graphId: string, nodeKind: string, fieldPath: string): string;\n\n  /**\n   * The per-field storage this strategy owns for `slot`, as Drizzle-free\n   * `StrategyTableContribution`s (resolved `tableName`, deterministic\n   * idempotent `createDdl` for the table **and** its ANN index when the\n   * slot's `indexType` warrants one, `runtimeEnsure`). Rides the #129/#135\n   * table-contribution + durable-materialization machinery exactly as the\n   * FTS5 / tsvector virtual tables do — these are materialized per graph by\n   * `materializeIndexes()`, not by global `bootstrapTables`.\n   */\n  ownedTables(slot: VectorSlot): readonly StrategyTableContribution[];\n\n  /**\n   * Emits the statement(s) that upsert a single embedding into the slot's\n   * storage. Multiple statements are allowed for engines that cannot upsert\n   * a vector in one statement (e.g. a `vec0` virtual table → DELETE+INSERT).\n   */\n  buildUpsert(\n    slot: VectorSlot,\n    params: UpsertEmbeddingParams,\n    timestamp: string,\n  ): readonly SQL[];\n\n  /** Emits the statement(s) that delete a single embedding from the slot. */\n  buildDelete(slot: VectorSlot, params: DeleteEmbeddingParams): readonly SQL[];\n\n  /**\n   * Raw DDL statement(s) that drop the slot's entire physical storage\n   * (table + ANN index, and any engine-managed shadow tables). Used by the\n   * destructive `store.reembedVectorField()` path to recreate a field's\n   * storage at a new dimension. Returned as raw strings (like\n   * `ownedTables(...).createDdl`) for `backend.executeDdl`; must be idempotent\n   * (`IF EXISTS`).\n   */\n  buildDropStorage(slot: VectorSlot): readonly string[];\n\n  /**\n   * Emits the similarity-search query for the `backend.vectorSearch` path,\n   * returning rows shaped `{ node_id, score }` ordered best-first. The\n   * strategy picks brute-force vs ANN based on whether `slot.indexType`\n   * materialized an index — the caller never branches. `score` follows the\n   * shared convention (cosine → similarity `1 - distance`; l2 /\n   * inner_product → raw distance), so `coerceVectorScore` / fusion stay\n   * dialect-neutral.\n   */\n  buildSearch(slot: VectorSlot, params: VectorSearchParams): SQL;\n\n  /**\n   * The distance expression over the slot's embedding column, used by the\n   * **query compiler** to splice vector relevance into its CTE. This is the\n   * one genuinely engine-specific fragment (`vec_distance_cosine` vs\n   * `<=>` vs `vector_distance_cos`); the surrounding score / minScore /\n   * ORDER BY math is shared (see {@link vectorScoreExpression} etc.).\n   *\n   * `embeddingColumn` is the already-qualified column SQL; `queryEmbedding`\n   * is formatted by the strategy into its engine's literal form.\n   */\n  distanceExpression(\n    embeddingColumn: SQL,\n    queryEmbedding: readonly number[],\n    metric: VectorMetric,\n  ): SQL;\n\n  /**\n   * Emits the ANN index creation statement for a slot, or `undefined` when\n   * indexing is inline (vec0) or unsupported (brute-force-only strategies).\n   * Invoked through `backend.createVectorIndex` during `materializeIndexes`.\n   */\n  buildCreateIndex?(\n    slot: VectorSlot,\n    options?: Readonly<{ concurrent?: boolean }>,\n  ): SQL | undefined;\n\n  /** Emits the ANN index drop statement, or `undefined` when not applicable. */\n  buildDropIndex?(slot: VectorSlot): SQL | undefined;\n}\n\n// ============================================================\n// Shared, dialect-neutral expression math\n// ============================================================\n//\n// These transforms are identical across pgvector / sqlite-vec / libSQL —\n// only `distanceExpression` differs — so they live once here and are reused\n// by both `buildSearch` implementations and the compiler CTE builder.\n\n/**\n * Converts a distance expression into a score expression (higher = better).\n * Cosine distance is mapped to similarity (`1 - d`); l2 and inner_product\n * are returned as-is (lower distance already ranks better, ordered ASC).\n */\nexport function vectorScoreExpression(\n  distanceExpression: SQL,\n  metric: VectorMetric,\n): SQL {\n  switch (metric) {\n    case \"cosine\": {\n      return sql`(1 - (${distanceExpression}))`;\n    }\n    case \"l2\":\n    case \"inner_product\": {\n      return distanceExpression;\n    }\n    default: {\n      const _exhaustive: never = metric;\n      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);\n    }\n  }\n}\n\n/**\n * Builds the `minScore` WHERE condition against a distance expression,\n * translating the score threshold back into the metric's distance space.\n */\nexport function vectorMinScoreCondition(\n  distanceExpression: SQL,\n  metric: VectorMetric,\n  minScore: number,\n): SQL {\n  // Validate against the RESOLVED metric — both the compiler's relevance CTE\n  // and the backend search path funnel here, so an out-of-range floor (e.g. a\n  // cosine minScore of 5 → `distance <= 1 - 5`, which matches nothing) is\n  // rejected loudly instead of silently returning zero rows.\n  assertVectorMinScore(minScore, metric);\n  switch (metric) {\n    case \"cosine\": {\n      return sql`${distanceExpression} <= ${1 - minScore}`;\n    }\n    case \"l2\": {\n      return sql`${distanceExpression} <= ${minScore}`;\n    }\n    case \"inner_product\": {\n      return sql`${distanceExpression} <= ${-minScore}`;\n    }\n    default: {\n      const _exhaustive: never = metric;\n      throw new Error(`Unsupported vector metric: ${String(_exhaustive)}`);\n    }\n  }\n}\n\n/**\n * Validates that every value in an embedding is a finite number. Shared by\n * strategies so a NaN/Infinity is reported with the offending index before\n * it reaches engine-specific literal formatting (which would mask it).\n */\nexport function assertFiniteEmbedding(\n  embedding: readonly number[],\n  name: string,\n): void {\n  for (const [index, value] of embedding.entries()) {\n    if (typeof value !== \"number\" || !Number.isFinite(value)) {\n      throw new TypeError(\n        `${name}[${index}] must be a finite number, got: ${value}`,\n      );\n    }\n  }\n}\n\n/**\n * Validates a vector-search `limit` is a positive integer. Enforced by the\n * backend's `vectorSearch` (defense in depth — the store boundary also\n * checks) so a direct backend call with `limit: 0` fails loudly instead of\n * silently scanning nothing.\n */\nexport function assertVectorSearchLimit(limit: number): void {\n  if (!Number.isInteger(limit) || limit <= 0) {\n    throw new RangeError(\n      `vectorSearch limit must be a positive integer, got: ${limit}`,\n    );\n  }\n}\n\n/**\n * Validates a `minScore` floor against its (resolved) metric: it must be finite,\n * and for cosine it must lie in [-1, 1] (a cosine score is the `1 - distance`\n * similarity). Shared by the store facade, the compiler's relevance CTE\n * ({@link vectorMinScoreCondition}), and the backend search path so every entry\n * point rejects the same out-of-range floor instead of silently returning none.\n */\nexport function assertVectorMinScore(\n  minScore: number,\n  metric: VectorMetric,\n  label = \"minScore\",\n): void {\n  if (!Number.isFinite(minScore)) {\n    throw new RangeError(`${label} must be a finite number, got: ${minScore}`);\n  }\n  if (metric === \"cosine\" && Math.abs(minScore) > 1) {\n    throw new RangeError(\n      `${label} for the cosine metric must be between -1 and 1, got: ${minScore}`,\n    );\n  }\n}\n\n// ============================================================\n// Shared physical naming\n// ============================================================\n\n/**\n * pgvector inherits Postgres' 63-byte identifier ceiling; SQLite/libSQL are\n * far more generous, so the smallest common cap keeps one naming scheme\n * across every strategy.\n */\nconst MAX_VECTOR_IDENTIFIER_LENGTH = 63;\n\nfunction sanitizeIdentifierPart(value: string): string {\n  return value.toLowerCase().replaceAll(/[^a-z0-9_]/g, \"_\");\n}\n\n/**\n * Deterministic 8-char hash for collision-safe truncation of over-long\n * identifiers. Self-contained so the strategy layer has no backend-runtime\n * dependency.\n */\nfunction shortHash(input: string): string {\n  let h1 = 0xde_ad_be_ef;\n  let h2 = 0x41_c6_ce_57;\n  for (let index = 0; index < input.length; index++) {\n    const ch = input.codePointAt(index)!;\n    h1 = Math.imul(h1 ^ ch, 0x9e_37_79_b1);\n    h2 = Math.imul(h2 ^ ch, 0x5f_35_64_95);\n  }\n  h1 =\n    Math.imul(h1 ^ (h1 >>> 16), 0x85_eb_ca_6b) ^\n    Math.imul(h2 ^ (h2 >>> 13), 0xc2_b2_ae_35);\n  h2 =\n    Math.imul(h2 ^ (h2 >>> 16), 0x85_eb_ca_6b) ^\n    Math.imul(h1 ^ (h1 >>> 13), 0xc2_b2_ae_35);\n  const hi = (h2 >>> 0).toString(16).padStart(8, \"0\");\n  const lo = (h1 >>> 0).toString(16).padStart(8, \"0\");\n  return `${hi}${lo}`.slice(0, 8);\n}\n\n/**\n * Deterministic per-`(graphId, nodeKind, fieldPath)` physical name. Shared by\n * every strategy's `tableName`, by index naming, and by the compiler's\n * per-field table resolution so all three agree on which physical object backs\n * a field in a graph. Truncated with a hash suffix past the 63-char ceiling;\n * the hash covers all three parts, so truncation stays collision-safe even\n * when long graph ids dominate the prefix.\n *\n * @example `vectorPhysicalName(\"tg_vec\", \"g1\", \"Document\", \"embedding\")`\n *          → `\"tg_vec_g1_document_embedding_<hash8>\"`\n */\nexport function vectorPhysicalName(\n  prefix: string,\n  graphId: string,\n  nodeKind: string,\n  fieldPath: string,\n): string {\n  const readable = `${prefix}_${sanitizeIdentifierPart(graphId)}_${sanitizeIdentifierPart(nodeKind)}_${sanitizeIdentifierPart(fieldPath)}`;\n  // Always suffix a hash of the EXACT (graphId, nodeKind, fieldPath) tuple.\n  // Sanitization is lossy (case-folding, every non-`[a-z0-9_]` char → `_`) and\n  // the `_` join is ambiguous, so distinct fields can share a readable part —\n  // e.g. (\"a_b\",\"c\") vs (\"a\",\"b_c\"), or \"Doc-A\" vs \"Doc_A\" vs \"doc\". The hash\n  // keeps their physical tables distinct so writes/searches never cross fields.\n  const hash = shortHash(JSON.stringify([graphId, nodeKind, fieldPath]));\n  const full = `${readable}_${hash}`;\n  if (full.length <= MAX_VECTOR_IDENTIFIER_LENGTH) return full;\n  // Over the ceiling: truncate the readable part, always keep the hash.\n  return `${readable.slice(0, MAX_VECTOR_IDENTIFIER_LENGTH - 1 - hash.length)}_${hash}`;\n}\n\n/**\n * Double-quote a SQL identifier, escaping embedded quotes. Dialect-neutral\n * (both SQLite and Postgres use `\"...\"`), so the three vector strategies share\n * one implementation for quoting their per-field table / index names.\n */\nexport function quoteIdentifier(name: string): string {\n  return `\"${name.replaceAll('\"', '\"\"')}\"`;\n}\n","/**\n * PostgreSQL Dialect Adapter\n *\n * Implements dialect-specific SQL generation for PostgreSQL databases.\n * Uses PostgreSQL's native JSONB operators for JSON operations.\n */\nimport { type SQL, sql } from \"drizzle-orm\";\n\nimport { type JsonPointer, parseJsonPointer } from \"../json-pointer\";\nimport { tsvectorStrategy } from \"./fulltext-strategy\";\nimport { type DialectAdapter } from \"./types\";\n\n/**\n * Escapes a string for use in a PostgreSQL string literal.\n * Uses single quotes and escapes embedded single quotes.\n */\nfunction escapePostgresLiteral(value: string): string {\n  // PostgreSQL uses '' to escape single quotes inside string literals\n  return `'${value.replaceAll(\"'\", \"''\")}'`;\n}\n\n/**\n * Converts a JSON pointer to PostgreSQL's text array path.\n *\n * Uses raw SQL (non-parameterized) to ensure the same expression text\n * is generated when the same field is used in multiple clauses (SELECT, GROUP BY).\n * This is safe because JSON pointers come from schema definitions, not user input.\n *\n * @example\n * \"/name\" → ARRAY['name']\n * \"/items/0\" → ARRAY['items', '0']\n * \"/a/b/c\" → ARRAY['a', 'b', 'c']\n */\nfunction toPostgresPath(pointer: JsonPointer): SQL {\n  if (!pointer || pointer === \"\" || pointer === \"/\") {\n    return sql.raw(\"ARRAY[]::text[]\");\n  }\n\n  const segments = parseJsonPointer(pointer);\n  if (segments.length === 0) {\n    return sql.raw(\"ARRAY[]::text[]\");\n  }\n\n  // Use raw SQL for path segments to ensure identical SQL text\n  // when the same field is used in multiple clauses (e.g., SELECT and GROUP BY)\n  const escapedSegments = segments\n    .map((segment) => escapePostgresLiteral(segment))\n    .join(\", \");\n  return sql.raw(`ARRAY[${escapedSegments}]`);\n}\n\n/**\n * PostgreSQL dialect adapter implementation.\n */\nexport const postgresDialect: DialectAdapter = {\n  name: \"postgres\",\n  capabilities: {\n    standardQueryStrategy: \"cte_project\",\n    recursiveQueryStrategy: \"recursive_cte\",\n    materializeIntermediateTraversalCtes: false,\n    emitNotMaterializedHint: true,\n    forceRecursiveWorktableOuterJoinOrder: false,\n    vectorPredicateStrategy: \"native\",\n    vectorMetrics: [\"cosine\", \"l2\", \"inner_product\"] as const,\n    supportsFulltext: true,\n  },\n\n  // ============================================================\n  // JSON Path Operations\n  // ============================================================\n\n  compilePath(pointer) {\n    return toPostgresPath(pointer);\n  },\n\n  jsonExtract(column, pointer) {\n    // #> returns JSONB value at path\n    const path = toPostgresPath(pointer);\n    return sql`${column} #> ${path}`;\n  },\n\n  jsonExtractText(column, pointer) {\n    // #>> returns text value at path\n    const path = toPostgresPath(pointer);\n    return sql`${column} #>> ${path}`;\n  },\n\n  jsonExtractNumber(column, pointer) {\n    // Extract as text then cast to numeric\n    const path = toPostgresPath(pointer);\n    return sql`(${column} #>> ${path})::numeric`;\n  },\n\n  jsonExtractBoolean(column, pointer) {\n    // Extract as text then cast to boolean\n    const path = toPostgresPath(pointer);\n    return sql`(${column} #>> ${path})::boolean`;\n  },\n\n  jsonExtractDate(column, pointer) {\n    // Extract as text then cast to timestamptz\n    const path = toPostgresPath(pointer);\n    return sql`(${column} #>> ${path})::timestamptz`;\n  },\n\n  // ============================================================\n  // JSON Array Operations\n  // ============================================================\n\n  jsonArrayLength(column) {\n    return sql`jsonb_array_length(${column})`;\n  },\n\n  jsonArrayContains(column, value) {\n    // @> checks if left contains right\n    const jsonValue = JSON.stringify([value]);\n    return sql`${column} @> ${jsonValue}::jsonb`;\n  },\n\n  jsonArrayContainsAll(column, values) {\n    if (values.length === 0) {\n      return sql.raw(\"1=1\");\n    }\n\n    // @> with full array checks all values\n    const jsonValue = JSON.stringify(values);\n    return sql`${column} @> ${jsonValue}::jsonb`;\n  },\n\n  jsonArrayContainsAny(column, values) {\n    if (values.length === 0) {\n      return sql.raw(\"1=0\");\n    }\n\n    // Check each value with @> and OR them together\n    // PostgreSQL doesn't have a native \"overlaps\" for jsonb arrays\n    const conditions = values.map((value) => {\n      const jsonValue = JSON.stringify([value]);\n      return sql`${column} @> ${jsonValue}::jsonb`;\n    });\n    return sql`(${sql.join(conditions, sql` OR `)})`;\n  },\n\n  // ============================================================\n  // JSON Object Operations\n  // ============================================================\n\n  jsonHasPath(column, pointer) {\n    const path = toPostgresPath(pointer);\n    return sql`${column} #> ${path} IS NOT NULL`;\n  },\n\n  jsonPathIsNull(column, pointer) {\n    const path = toPostgresPath(pointer);\n    // Check both SQL NULL and JSON null literal\n    return sql`(${column} #> ${path} IS NULL OR ${column} #>> ${path} = 'null')`;\n  },\n\n  jsonPathIsNotNull(column, pointer) {\n    const path = toPostgresPath(pointer);\n    return sql`(${column} #> ${path} IS NOT NULL AND ${column} #>> ${path} != 'null')`;\n  },\n\n  // ============================================================\n  // Comparison Operations\n  // ============================================================\n\n  nullSafeEquals(left, right) {\n    return sql`${left} IS NOT DISTINCT FROM ${right}`;\n  },\n\n  // ============================================================\n  // String Operations\n  // ============================================================\n\n  ilike(column, pattern) {\n    // PostgreSQL has native ILIKE operator\n    return sql`${column} ILIKE ${pattern}`;\n  },\n\n  // ============================================================\n  // Set Operations\n  // ============================================================\n\n  wrapSetOperationOperand(inner) {\n    // PostgreSQL allows a complete SELECT (incl. its own WITH) as a\n    // parenthesized compound operand.\n    return sql`(${inner})`;\n  },\n\n  // ============================================================\n  // Recursive CTE Path Operations\n  // ============================================================\n\n  initializePath(nodeId) {\n    // PostgreSQL uses text arrays: ARRAY[id]\n    return sql`ARRAY[${nodeId}]`;\n  },\n\n  extendPath(currentPath, nodeId) {\n    // Array concatenation: path || id\n    return sql`${currentPath} || ${nodeId}`;\n  },\n\n  cycleCheck(nodeId, path) {\n    // Check that id is NOT in array path\n    // Returns TRUE if no cycle (id not in array)\n    return sql`${nodeId} != ALL(${path})`;\n  },\n\n  // ============================================================\n  // Type Utilities\n  // ============================================================\n\n  currentTimestamp() {\n    return sql`NOW()`;\n  },\n\n  // ============================================================\n  // Value Binding & Literals\n  // ============================================================\n\n  bindValue(value) {\n    // PostgreSQL supports native booleans, no conversion needed\n    return value;\n  },\n\n  booleanLiteral(value) {\n    return sql.raw(this.booleanLiteralString(value));\n  },\n\n  booleanLiteralString(value) {\n    return value ? \"TRUE\" : \"FALSE\";\n  },\n\n  quoteIdentifier(name) {\n    // PostgreSQL uses double quotes, escape embedded quotes by doubling\n    return `\"${name.replaceAll('\"', '\"\"')}\"`;\n  },\n\n  // ============================================================\n  // Vector Operations\n  // ============================================================\n\n  // Compile-time gate for `field.similarTo(...)`; the active\n  // `VectorStrategy` (pgvector) owns the distance SQL.\n  supportsVectors: true,\n\n  // ============================================================\n  // Fulltext Operations\n  // ============================================================\n\n  fulltext: tsvectorStrategy,\n};\n","/**\n * SQLite Dialect Adapter\n *\n * Implements dialect-specific SQL generation for SQLite databases.\n * Uses SQLite's JSON1 extension for JSON operations.\n */\nimport { sql } from \"drizzle-orm\";\n\nimport { type JsonPointer, parseJsonPointer } from \"../json-pointer\";\nimport { fts5Strategy } from \"./fulltext-strategy\";\nimport { type DialectAdapter } from \"./types\";\n\n/**\n * Escapes a string for use in a SQLite string literal.\n * SQLite uses single quotes and escapes embedded single quotes by doubling them.\n */\nfunction escapeSqliteLiteral(value: string): string {\n  return `'${value.replaceAll(\"'\", \"''\")}'`;\n}\n\n/**\n * Converts a JSON pointer to SQLite's JSON path syntax.\n *\n * @example\n * \"/name\" → \"$.\\\"name\\\"\"\n * \"/items/0\" → \"$.\\\"items\\\"[0]\"\n * \"/a/b/c\" → \"$.\\\"a\\\".\\\"b\\\".\\\"c\\\"\"\n */\nfunction toSqlitePath(pointer: JsonPointer): string {\n  if (!pointer || pointer === \"\" || pointer === \"/\") {\n    return \"$\";\n  }\n\n  const segments = parseJsonPointer(pointer);\n  const parts: string[] = [\"$\"];\n\n  for (const segment of segments) {\n    if (isArrayIndex(segment)) {\n      parts.push(`[${segment}]`);\n    } else {\n      // Quote the key to handle special characters\n      parts.push(`.${JSON.stringify(segment)}`);\n    }\n  }\n\n  return parts.join(\"\");\n}\n\n/**\n * Checks if a JSON pointer segment is an array index.\n */\nfunction isArrayIndex(segment: string): boolean {\n  return /^\\d+$/.test(segment);\n}\n\n/**\n * SQLite dialect adapter implementation.\n */\nexport const sqliteDialect: DialectAdapter = {\n  name: \"sqlite\",\n  capabilities: {\n    standardQueryStrategy: \"cte_project\",\n    recursiveQueryStrategy: \"recursive_cte\",\n    materializeIntermediateTraversalCtes: true,\n    emitNotMaterializedHint: false,\n    forceRecursiveWorktableOuterJoinOrder: true,\n    vectorPredicateStrategy: \"native\",\n    vectorMetrics: [\"cosine\", \"l2\"] as const,\n    supportsFulltext: true,\n  },\n\n  // ============================================================\n  // JSON Path Operations\n  // ============================================================\n\n  compilePath(pointer) {\n    // Use raw SQL to ensure the path is a literal, which allows expression\n    // indexes on json_extract(...) to be used by the query planner.\n    return sql.raw(escapeSqliteLiteral(toSqlitePath(pointer)));\n  },\n\n  jsonExtract(column, pointer) {\n    const path = toSqlitePath(pointer);\n    return sql`json_extract(${column}, ${sql.raw(escapeSqliteLiteral(path))})`;\n  },\n\n  jsonExtractText(column, pointer) {\n    // SQLite's json_extract returns the native JSON type, which works\n    // for text comparisons. For explicit text, we use the same function.\n    const path = toSqlitePath(pointer);\n    return sql`json_extract(${column}, ${sql.raw(escapeSqliteLiteral(path))})`;\n  },\n\n  jsonExtractNumber(column, pointer) {\n    // SQLite json_extract returns numbers natively when the value is numeric\n    const path = toSqlitePath(pointer);\n    return sql`json_extract(${column}, ${sql.raw(escapeSqliteLiteral(path))})`;\n  },\n\n  jsonExtractBoolean(column, pointer) {\n    // SQLite json_extract returns 0/1 for boolean values\n    const path = toSqlitePath(pointer);\n    return sql`json_extract(${column}, ${sql.raw(escapeSqliteLiteral(path))})`;\n  },\n\n  jsonExtractDate(column, pointer) {\n    // SQLite stores dates as ISO strings, json_extract returns them as text\n    const path = toSqlitePath(pointer);\n    return sql`json_extract(${column}, ${sql.raw(escapeSqliteLiteral(path))})`;\n  },\n\n  // ============================================================\n  // JSON Array Operations\n  // ============================================================\n\n  jsonArrayLength(column) {\n    return sql`json_array_length(${column})`;\n  },\n\n  jsonArrayContains(column, value) {\n    return sql`EXISTS (SELECT 1 FROM json_each(${column}) WHERE json_each.value = ${value})`;\n  },\n\n  jsonArrayContainsAll(column, values) {\n    if (values.length === 0) {\n      return sql.raw(\"1=1\");\n    }\n\n    const conditions = values.map(\n      (value) =>\n        sql`EXISTS (SELECT 1 FROM json_each(${column}) WHERE json_each.value = ${value})`,\n    );\n    return sql`(${sql.join(conditions, sql` AND `)})`;\n  },\n\n  jsonArrayContainsAny(column, values) {\n    if (values.length === 0) {\n      return sql.raw(\"1=0\");\n    }\n\n    const conditions = values.map(\n      (value) =>\n        sql`EXISTS (SELECT 1 FROM json_each(${column}) WHERE json_each.value = ${value})`,\n    );\n    return sql`(${sql.join(conditions, sql` OR `)})`;\n  },\n\n  // ============================================================\n  // JSON Object Operations\n  // ============================================================\n\n  jsonHasPath(column, pointer) {\n    const path = toSqlitePath(pointer);\n    return sql`json_type(${column}, ${sql.raw(escapeSqliteLiteral(path))}) IS NOT NULL`;\n  },\n\n  jsonPathIsNull(column, pointer) {\n    const path = toSqlitePath(pointer);\n    const pathSql = sql.raw(escapeSqliteLiteral(path));\n    return sql`(json_extract(${column}, ${pathSql}) IS NULL OR json_type(${column}, ${pathSql}) = 'null')`;\n  },\n\n  jsonPathIsNotNull(column, pointer) {\n    const path = toSqlitePath(pointer);\n    const pathSql = sql.raw(escapeSqliteLiteral(path));\n    return sql`(json_extract(${column}, ${pathSql}) IS NOT NULL AND json_type(${column}, ${pathSql}) != 'null')`;\n  },\n\n  // ============================================================\n  // Comparison Operations\n  // ============================================================\n\n  nullSafeEquals(left, right) {\n    // SQLite's IS operator is null-safe equality (equivalent to = for\n    // non-null operands, TRUE when both sides are NULL).\n    return sql`${left} IS ${right}`;\n  },\n\n  // ============================================================\n  // String Operations\n  // ============================================================\n\n  ilike(column, pattern) {\n    // SQLite LIKE is case-insensitive for ASCII by default, but we use\n    // LOWER() for consistency with non-ASCII characters\n    return sql`LOWER(${column}) LIKE LOWER(${pattern})`;\n  },\n\n  // ============================================================\n  // Set Operations\n  // ============================================================\n\n  wrapSetOperationOperand(inner) {\n    // SQLite forbids parenthesized compound operands, but a FROM-subquery may\n    // carry its own WITH clause, so wrap each operand as a subquery.\n    return sql`SELECT * FROM (${inner})`;\n  },\n\n  // ============================================================\n  // Recursive CTE Path Operations\n  // ============================================================\n\n  initializePath(nodeId) {\n    // SQLite uses string-based paths with delimiters: '|id|'\n    return sql`'|' || ${nodeId} || '|'`;\n  },\n\n  extendPath(currentPath, nodeId) {\n    // Append: path || id || '|'\n    return sql`${currentPath} || ${nodeId} || '|'`;\n  },\n\n  cycleCheck(nodeId, path) {\n    // Check that id is NOT in path using INSTR\n    // Returns TRUE if no cycle (id not found in path)\n    return sql`INSTR(${path}, '|' || ${nodeId} || '|') = 0`;\n  },\n\n  // ============================================================\n  // Type Utilities\n  // ============================================================\n\n  currentTimestamp() {\n    // Keep ISO-8601 format aligned with stored timestamps from Date.toISOString()\n    // so string-based temporal comparisons remain correct in SQLite TEXT columns.\n    return sql`strftime('%Y-%m-%dT%H:%M:%fZ', 'now')`;\n  },\n\n  // ============================================================\n  // Value Binding & Literals\n  // ============================================================\n\n  bindValue(value) {\n    // SQLite doesn't support native booleans, convert to 0/1\n    if (typeof value === \"boolean\") {\n      return value ? 1 : 0;\n    }\n    return value;\n  },\n\n  booleanLiteral(value) {\n    return sql.raw(this.booleanLiteralString(value));\n  },\n\n  booleanLiteralString(value) {\n    return value ? \"1\" : \"0\";\n  },\n\n  quoteIdentifier(name) {\n    // SQLite uses double quotes (or backticks), escape embedded quotes by doubling\n    return `\"${name.replaceAll('\"', '\"\"')}\"`;\n  },\n\n  // ============================================================\n  // Vector Operations\n  // ============================================================\n\n  // Compile-time gate for `field.similarTo(...)`; the active\n  // `VectorStrategy` (sqlite-vec / libSQL-native) owns the distance SQL.\n  supportsVectors: true,\n\n  // ============================================================\n  // Fulltext Operations\n  // ============================================================\n\n  fulltext: fts5Strategy,\n};\n","/**\n * SQL Dialect Module\n *\n * Provides dialect adapters for different SQL databases.\n * Use `getDialect()` to get the appropriate adapter for a dialect name.\n */\n\nexport type { FulltextStrategy } from \"./fulltext-strategy\";\nexport {\n  ALL_FULLTEXT_MODES,\n  buildFulltextCapabilities,\n  fts5Strategy,\n  tsvectorStrategy,\n} from \"./fulltext-strategy\";\nexport { postgresDialect } from \"./postgres\";\nexport { sqliteDialect } from \"./sqlite\";\nexport type {\n  DialectAdapter,\n  DialectCapabilities,\n  DialectRecursiveQueryStrategy,\n  DialectStandardQueryStrategy,\n  DialectVectorPredicateStrategy,\n  SqlDialect,\n} from \"./types\";\nexport {\n  buildVectorCapabilities,\n  type VectorSlot,\n  type VectorStrategy,\n} from \"./vector-strategy\";\n\nimport { postgresDialect } from \"./postgres\";\nimport { sqliteDialect } from \"./sqlite\";\nimport { type DialectAdapter, type SqlDialect } from \"./types\";\n\n/**\n * Map of dialect names to their adapters.\n */\nconst DIALECT_ADAPTERS: Record<SqlDialect, DialectAdapter> = {\n  sqlite: sqliteDialect,\n  postgres: postgresDialect,\n};\n\n/**\n * Gets the dialect adapter for a given dialect name.\n *\n * @param dialect - The dialect name (\"sqlite\" or \"postgres\")\n * @returns The dialect adapter\n *\n * @example\n * ```typescript\n * const adapter = getDialect(\"postgres\");\n * const sql = adapter.jsonExtract(column, \"/name\");\n * ```\n */\nexport function getDialect(dialect: SqlDialect): DialectAdapter {\n  return DIALECT_ADAPTERS[dialect];\n}\n\n/**\n * Default dialect used when none is specified.\n */\nexport const DEFAULT_DIALECT: SqlDialect = \"sqlite\";\n","import { type SQL, sql } from \"drizzle-orm\";\n\nimport { type ValueType } from \"../query/ast\";\nimport { getDialect } from \"../query/dialect\";\nimport { type SqlDialect } from \"../query/dialect/types\";\nimport { type JsonPointer, jsonPointer } from \"../query/json-pointer\";\nimport {\n  type EdgeIndexDeclaration,\n  type IndexWhereExpression,\n  type IndexWhereLiteral,\n  type IndexWhereOp,\n  type IndexWhereOperand,\n  type NodeIndexDeclaration,\n  type SystemColumnName,\n} from \"./types\";\n\n// ============================================================\n// Public Types\n// ============================================================\n\nexport type IndexCompilationContext = Readonly<{\n  dialect: SqlDialect;\n  propsColumn: SQL;\n  systemColumn: (column: SystemColumnName) => SQL;\n}>;\n\ntype CompiledIndexKeys = Readonly<{\n  /** SQL expressions in index key order */\n  keys: readonly SQL[];\n}>;\n\n// ============================================================\n// Index Key Compilation\n// ============================================================\n\nexport function compileNodeIndexKeys(\n  index: NodeIndexDeclaration,\n  dialect: SqlDialect,\n  propsColumn: SQL,\n  systemColumn: (column: SystemColumnName) => SQL,\n): CompiledIndexKeys {\n  const adapter = getDialect(dialect);\n  const keys: SQL[] = [];\n\n  for (const column of getNodeScopeColumns(index.scope)) {\n    keys.push(systemColumn(column));\n  }\n\n  const allPointers = [...index.fields, ...index.coveringFields];\n  const allValueTypes = [\n    ...index.fieldValueTypes,\n    ...index.coveringFieldValueTypes,\n  ];\n\n  for (const [pointerIndex, pointer] of allPointers.entries()) {\n    const valueType = allValueTypes[pointerIndex];\n    const extracted = compileIndexKeyValue(\n      adapter,\n      propsColumn,\n      pointer,\n      valueType,\n    );\n    keys.push(sql`(${extracted})`);\n  }\n\n  return { keys };\n}\n\nexport function compileEdgeIndexKeys(\n  index: EdgeIndexDeclaration,\n  dialect: SqlDialect,\n  propsColumn: SQL,\n  systemColumn: (column: SystemColumnName) => SQL,\n): CompiledIndexKeys {\n  const adapter = getDialect(dialect);\n  const keys: SQL[] = [];\n\n  for (const column of getEdgeScopeColumns(index.scope, index.direction)) {\n    keys.push(systemColumn(column));\n  }\n\n  const allPointers = [...index.fields, ...index.coveringFields];\n  const allValueTypes = [\n    ...index.fieldValueTypes,\n    ...index.coveringFieldValueTypes,\n  ];\n\n  for (const [pointerIndex, pointer] of allPointers.entries()) {\n    const valueType = allValueTypes[pointerIndex];\n    const extracted = compileIndexKeyValue(\n      adapter,\n      propsColumn,\n      pointer,\n      valueType,\n    );\n    keys.push(sql`(${extracted})`);\n  }\n\n  return { keys };\n}\n\n/**\n * Compiles the per-field key-extraction expressions for a node index's\n * **lookup keys** — `index.fields` only, excluding scope columns and\n * `coveringFields` (which are index payload, not part of the lookup key).\n *\n * Each expression is the exact extraction the index DDL builds for that\n * field (via the shared {@link compileIndexKeyValue}), so a runtime lookup\n * predicate stays byte-identical to the materialized index expression —\n * the single source of truth that lets the planner use the physical index.\n */\nexport function compileNodeIndexFieldKeys(\n  index: NodeIndexDeclaration,\n  ctx: IndexCompilationContext,\n): readonly SQL[] {\n  const adapter = getDialect(ctx.dialect);\n  const keys: SQL[] = [];\n  for (const [position, pointer] of index.fields.entries()) {\n    const extracted = compileIndexKeyValue(\n      adapter,\n      ctx.propsColumn,\n      pointer,\n      index.fieldValueTypes[position],\n    );\n    keys.push(sql`(${extracted})`);\n  }\n  return keys;\n}\n\nfunction compileIndexKeyValue(\n  dialect: ReturnType<typeof getDialect>,\n  propsColumn: SQL,\n  pointer: JsonPointer,\n  valueType: ValueType | undefined,\n): SQL {\n  switch (valueType) {\n    case \"number\": {\n      return dialect.jsonExtractNumber(propsColumn, pointer);\n    }\n    case \"boolean\": {\n      return dialect.jsonExtractBoolean(propsColumn, pointer);\n    }\n    case \"date\": {\n      return dialect.jsonExtractDate(propsColumn, pointer);\n    }\n    case \"string\":\n    case \"unknown\":\n    case undefined: {\n      return dialect.jsonExtractText(propsColumn, pointer);\n    }\n    case \"array\":\n    case \"object\":\n    case \"embedding\": {\n      // For advanced index types (GIN/json), callers should use dialect.jsonExtract\n      // or index the props column directly. We keep this as a conservative fallback.\n      return dialect.jsonExtract(propsColumn, pointer);\n    }\n  }\n}\n\nfunction getNodeScopeColumns(\n  scope: NodeIndexDeclaration[\"scope\"],\n): readonly SystemColumnName[] {\n  switch (scope) {\n    case \"graphAndKind\": {\n      return [\"graph_id\", \"kind\"];\n    }\n    case \"graph\": {\n      return [\"graph_id\"];\n    }\n    case \"none\": {\n      return [];\n    }\n  }\n}\n\nfunction getEdgeScopeColumns(\n  scope: EdgeIndexDeclaration[\"scope\"],\n  direction: EdgeIndexDeclaration[\"direction\"],\n): readonly SystemColumnName[] {\n  const base =\n    scope === \"graphAndKind\" ? ([\"graph_id\", \"kind\"] as const)\n    : scope === \"graph\" ? ([\"graph_id\"] as const)\n    : ([] as const);\n\n  if (direction === \"out\") {\n    return [...base, \"from_id\"];\n  }\n  if (direction === \"in\") {\n    return [...base, \"to_id\"];\n  }\n  return [...base];\n}\n\n// ============================================================\n// WHERE Clause Compilation\n// ============================================================\n\nfunction isIndexWhereLiteralList(\n  value: IndexWhereLiteral | readonly IndexWhereLiteral[],\n): value is readonly IndexWhereLiteral[] {\n  return Array.isArray(value);\n}\n\nexport function compileIndexWhere(\n  ctx: IndexCompilationContext,\n  expression: IndexWhereExpression,\n): SQL {\n  switch (expression.__type) {\n    case \"index_where_and\": {\n      return sql`(${sql.join(\n        expression.predicates.map((p) => compileIndexWhere(ctx, p)),\n        sql` AND `,\n      )})`;\n    }\n    case \"index_where_or\": {\n      return sql`(${sql.join(\n        expression.predicates.map((p) => compileIndexWhere(ctx, p)),\n        sql` OR `,\n      )})`;\n    }\n    case \"index_where_not\": {\n      return sql`(NOT ${compileIndexWhere(ctx, expression.predicate)})`;\n    }\n    case \"index_where_null_check\": {\n      const operand = compileIndexWhereOperand(ctx, expression.operand);\n      return expression.op === \"isNull\" ?\n          sql`${operand} IS NULL`\n        : sql`${operand} IS NOT NULL`;\n    }\n    case \"index_where_comparison\": {\n      const left = compileIndexWhereOperand(ctx, expression.left);\n\n      const right = expression.right;\n      if (isIndexWhereLiteralList(right)) {\n        if (expression.op !== \"in\" && expression.op !== \"notIn\") {\n          throw new Error(\n            `Operator \"${expression.op}\" does not support list comparison in index WHERE clause`,\n          );\n        }\n        const values = right.map((literal) =>\n          compileIndexWhereLiteral(ctx.dialect, literal),\n        );\n        const operator = expression.op === \"in\" ? sql`IN` : sql`NOT IN`;\n        return sql`${left} ${operator} (${sql.join(values, sql`, `)})`;\n      }\n\n      if (expression.op === \"in\" || expression.op === \"notIn\") {\n        throw new Error(\n          `Operator \"${expression.op}\" requires a list of values in index WHERE clause`,\n        );\n      }\n\n      const rightLiteral = compileIndexWhereLiteral(ctx.dialect, right);\n      const opSql = compileComparisonOperator(expression.op);\n      return sql`${left} ${opSql} ${rightLiteral}`;\n    }\n  }\n}\n\nfunction compileIndexWhereOperand(\n  ctx: IndexCompilationContext,\n  operand: IndexWhereOperand,\n): SQL {\n  if (operand.__type === \"index_operand_system\") {\n    return ctx.systemColumn(operand.column);\n  }\n\n  const adapter = getDialect(ctx.dialect);\n  const pointer = jsonPointer([operand.field]);\n\n  switch (operand.valueType) {\n    case \"number\": {\n      return adapter.jsonExtractNumber(ctx.propsColumn, pointer);\n    }\n    case \"boolean\": {\n      return adapter.jsonExtractBoolean(ctx.propsColumn, pointer);\n    }\n    case \"date\": {\n      return adapter.jsonExtractDate(ctx.propsColumn, pointer);\n    }\n    case \"array\":\n    case \"object\":\n    case \"embedding\": {\n      return adapter.jsonExtract(ctx.propsColumn, pointer);\n    }\n    case \"string\":\n    case \"unknown\":\n    case undefined: {\n      return adapter.jsonExtractText(ctx.propsColumn, pointer);\n    }\n  }\n}\n\nfunction compileIndexWhereLiteral(\n  dialect: SqlDialect,\n  literal: IndexWhereLiteral,\n): SQL {\n  switch (literal.valueType) {\n    case \"string\":\n    case \"date\": {\n      return sql.raw(escapeStringLiteral(literal.value.toString()));\n    }\n    case \"number\": {\n      return sql.raw(literal.value.toString());\n    }\n    case \"boolean\": {\n      return getDialect(dialect).booleanLiteral(literal.value as boolean);\n    }\n    case \"array\":\n    case \"object\":\n    case \"embedding\":\n    case \"unknown\": {\n      return sql.raw(escapeStringLiteral(literal.value.toString()));\n    }\n  }\n}\n\ntype ComparisonIndexWhereOp = Exclude<IndexWhereOp, \"in\" | \"notIn\">;\n\nfunction compileComparisonOperator(op: ComparisonIndexWhereOp): SQL {\n  switch (op) {\n    case \"eq\": {\n      return sql`=`;\n    }\n    case \"neq\": {\n      return sql`<>`;\n    }\n    case \"gt\": {\n      return sql`>`;\n    }\n    case \"gte\": {\n      return sql`>=`;\n    }\n    case \"lt\": {\n      return sql`<`;\n    }\n    case \"lte\": {\n      return sql`<=`;\n    }\n  }\n}\n\nfunction escapeStringLiteral(value: string): string {\n  return `'${value.replaceAll(\"'\", \"''\")}'`;\n}\n"]}

package/dist/{chunk-O4VUR6SI.js → chunk-CEF2QOTO.js}

@@ -1,4 +1,4 @@
-import { quoteIdentifier, quotedTableName, vectorScoreExpression, vectorMinScoreCondition, VECTOR_CONTRIBUTION_PREFIX, vectorPhysicalName, assertFiniteEmbedding } from './chunk-2HZGWCB4.js';
+import { quoteIdentifier, quotedTableName, vectorScoreExpression, vectorMinScoreCondition, VECTOR_CONTRIBUTION_PREFIX, vectorPhysicalName, assertFiniteEmbedding } from './chunk-C4C4Q7A6.js';
 import { sql } from 'drizzle-orm';
 
 var TABLE_PREFIX = "tg_vec";
@@ -202,5 +202,5 @@ function libsqlVectorIndexDdl(table, slot) {
 }
 
 export { libsqlVectorStrategy };
-//# sourceMappingURL=chunk-O4VUR6SI.js.map
-//# sourceMappingURL=chunk-O4VUR6SI.js.map
+//# sourceMappingURL=chunk-CEF2QOTO.js.map
+//# sourceMappingURL=chunk-CEF2QOTO.js.map