@nicia-ai/typegraph 0.49.0 → 0.51.0

package/dist/chunk-PC5NGH5A.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/backend/table-contribution.ts","../src/query/dialect/fulltext-strategy.ts","../src/query/dialect/vector-strategy.ts"],"names":["quoteIdentifier"],"mappings":"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","file":"chunk-PC5NGH5A.js","sourcesContent":["/**\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   * Idempotent (`DROP ... IF EXISTS`) statements that tear this\n   * contribution's storage down, ordered so that running the list\n   * leaves nothing behind. Declaring it is what makes a contribution\n   * *rebuildable*: the destructive\n   * `store.rebuildContribution()` path drops through these statements\n   * before re-running {@link createDdl}, which is the only repair for a\n   * table provisioned at a shape the current `createDdl` no longer\n   * produces.\n   *\n   * Optional because it is a capability, not an invariant. A\n   * contribution whose content cannot be reconstructed from data\n   * TypeGraph already stores has no business advertising a rebuild —\n   * dropping it would destroy the only copy — and a third-party\n   * strategy that predates this field keeps compiling and is reported\n   * as not rebuildable rather than silently rebuilt through a\n   * synthesized `DROP`. Backends surface the resulting gap as\n   * `capabilities.contributions.rebuild`.\n   *\n   * The rebuild visits a strategy's `runtimeEnsure` contributions, the\n   * same set the boot ensure provisions — so a companion table a strategy\n   * declares outside that set is neither dropped nor recreated, and must\n   * not be something the recreated storage depends on.\n   */\n  dropDdl?: 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 {\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\";\nimport { sql, type SqlFragment } from \"../sql-fragment\";\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 type FulltextStrategy = Readonly<{\n  /** Human-readable identifier used in error messages and telemetry. */\n  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  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  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  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  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  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    this: void,\n    tableName: string,\n    query: string,\n    mode: FulltextQueryMode,\n    language?: string,\n  ) => SqlFragment;\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    this: void,\n    tableName: string,\n    query: string,\n    mode: FulltextQueryMode,\n    language?: string,\n  ) => SqlFragment;\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    this: void,\n    tableName: string,\n    query: string,\n    mode: FulltextQueryMode,\n    language?: string,\n  ) => SqlFragment;\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   * Declare `dropDdl` on each contribution to opt the strategy into the\n   * destructive `store.rebuildContribution(\"fulltext\")` path — the only\n   * repair for storage provisioned at a shape `createDdl` no longer\n   * produces. Fulltext content is reconstructed from the node rows, so a\n   * rebuild loses nothing; a strategy that omits `dropDdl` is reported\n   * as not rebuildable instead of being dropped through a synthesized\n   * statement.\n   */\n  ownedTables: (\n    this: void,\n    primaryTableName: string,\n  ) => 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    this: void,\n    tableName: string,\n    params: UpsertFulltextParams,\n    timestamp: string,\n  ) => readonly SqlFragment[];\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    this: void,\n    tableName: string,\n    params: UpsertFulltextBatchParams,\n    timestamp: string,\n  ) => readonly SqlFragment[];\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: (\n    this: void,\n    tableName: string,\n    params: DeleteFulltextParams,\n  ) => readonly SqlFragment[];\n\n  /**\n   * Emits the statements that delete many fulltext rows at once. Returns\n   * `[]` when `params.nodeIds` is empty.\n   */\n  buildBatchDelete: (\n    this: void,\n    tableName: string,\n    params: DeleteFulltextBatchParams,\n  ) => readonly SqlFragment[];\n}>;\n\n// ============================================================\n// Shared graph-scoped statements\n// ============================================================\n\n/**\n * Deletes every fulltext row one graph contributed.\n *\n * The fulltext table is DATABASE-global: one physical table whose rows are\n * keyed by `graph_id` and shared by every graph in the database. \"Remove this\n * graph's fulltext content\" therefore has more than one caller — `clearGraph`\n * and the destructive contribution rebuild — and it is one exported statement\n * both use rather than two spellings that would be free to drift.\n */\nexport function buildFulltextGraphDelete(\n  tableName: string,\n  graphId: string,\n): SqlFragment {\n  return sql`\n    DELETE FROM ${sql.identifier(tableName)}\n    WHERE \"graph_id\" = ${graphId}\n  `;\n}\n\n/**\n * The graph ids OTHER than `graphId` that currently have rows in the shared\n * fulltext table, capped at `limit` (the probe only needs to know whether the\n * set is empty, plus a few names for the operator-facing message).\n *\n * The predicate behind \"would tearing this table down destroy content this\n * process cannot put back?\". Fulltext content is derived from a graph's own\n * node rows through its own schema, so only the graph that owns those rows\n * can reconstruct them — another graph's rows are exactly the content a\n * `DROP TABLE` must never take with it.\n */\nexport function buildForeignFulltextGraphProbe(\n  tableName: string,\n  graphId: string,\n  limit: number,\n): SqlFragment {\n  return sql`\n    SELECT DISTINCT \"graph_id\"\n    FROM ${sql.identifier(tableName)}\n    WHERE \"graph_id\" <> ${graphId}\n    LIMIT ${limit}\n  `;\n}\n\n// ============================================================\n// Internal helpers\n// ============================================================\n\nfunction quoteIdentifier(name: string): string {\n  return `\"${name.replaceAll('\"', '\"\"')}\"`;\n}\n\nfunction tsvectorColumn(tableName: string): SqlFragment {\n  return sql`${sql.identifier(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): SqlFragment {\n  const table = sql.identifier(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): SqlFragment | undefined {\n  if (params.nodeIds.length === 0) return undefined;\n  const unique = [...new Set(params.nodeIds)];\n  const table = sql.identifier(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): SqlFragment {\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: SqlFragment =\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: SqlFragment =\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        // Both indexes belong to the table, so Postgres drops them with\n        // it; no separate DROP INDEX is needed or wanted (naming them\n        // would break the moment a future createDdl renames one).\n        dropDdl: [`DROP TABLE IF EXISTS ${name};`],\n        runtimeEnsure: true,\n      },\n    ];\n  },\n\n  buildUpsert(tableName, params, timestamp) {\n    const table = sql.identifier(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 = sql.identifier(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`${sql.identifier(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(${sql.identifier(tableName)})`;\n  },\n\n  snippetExpression(tableName, _query, _mode, _language) {\n    return sql`snippet(${sql.identifier(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        // `DROP TABLE` on an FTS5 virtual table also removes the shadow\n        // tables (`_data`, `_idx`, `_content`, …) the module created, so\n        // one statement is the whole teardown.\n        dropDdl: [`DROP TABLE IF EXISTS ${name};`],\n        runtimeEnsure: true,\n      },\n    ];\n  },\n\n  buildUpsert(tableName, params, timestamp) {\n    const table = sql.identifier(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 = sql.identifier(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 StrategyTableContribution } from \"../../backend/table-contribution\";\nimport {\n  type DeleteEmbeddingParams,\n  type UpsertEmbeddingBatchParams,\n  type UpsertEmbeddingParams,\n  type VectorCapabilities,\n  type VectorIndexType,\n  type VectorMetric,\n  type VectorSearchFrontierTuning,\n  type VectorSearchParams,\n} from \"../../backend/types\";\nimport {\n  ConfigurationError,\n  UnsupportedBackendCapabilityError,\n} from \"../../errors\";\nimport { requireDefined } from \"../../utils/presence\";\nimport { sql, type SqlFragment } from \"../sql-fragment\";\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 type VectorStrategy = Readonly<{\n  /** Human-readable identifier used in error messages and telemetry. */\n  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  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: (\n    this: void,\n    graphId: string,\n    nodeKind: string,\n    fieldPath: string,\n  ) => 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: (\n    this: void,\n    slot: VectorSlot,\n  ) => 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    this: void,\n    slot: VectorSlot,\n    params: UpsertEmbeddingParams,\n    timestamp: string,\n  ) => readonly SqlFragment[];\n\n  /**\n   * Emits the statement(s) that upsert MANY embeddings into the slot's\n   * storage in multi-row form. Optional — the backend falls back to one\n   * {@link buildUpsert} per row when unset. The backend guarantees the\n   * rows carry distinct `nodeId`s and fit the connection's bound-parameter\n   * budget (it chunks before calling).\n   */\n  buildUpsertBatch?: (\n    this: void,\n    slot: VectorSlot,\n    params: UpsertEmbeddingBatchParams,\n    timestamp: string,\n  ) => readonly SqlFragment[];\n\n  /** Emits the statement(s) that delete a single embedding from the slot. */\n  buildDelete: (\n    this: void,\n    slot: VectorSlot,\n    params: DeleteEmbeddingParams,\n  ) => readonly SqlFragment[];\n  /** Emits one set-based delete for many node ids in a vector slot. */\n  buildDeleteBatch: (\n    this: void,\n    slot: VectorSlot,\n    params: Omit<DeleteEmbeddingParams, \"nodeId\"> &\n      Readonly<{ nodeIds: readonly string[] }>,\n  ) => readonly SqlFragment[];\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: (this: void, 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   * `candidates`, when provided, is a subquery yielding the node ids\n   * eligible to appear in results (the backend passes its live-node-ids\n   * subquery so top-k is computed over live rows in SQL — see\n   * `liveNodeIdsSubquery`). Strategies whose ANN form cannot take the\n   * filter directly must over-fetch and post-filter, documenting the\n   * recall bound. A custom strategy that ignores the argument keeps the\n   * pre-pushdown behavior: tombstoned ids are dropped after top-k during\n   * hydration, so results can shrink below `limit` under index drift.\n   */\n  buildSearch: (\n    this: void,\n    slot: VectorSlot,\n    params: VectorSearchParams,\n    candidates?: SqlFragment,\n  ) => SqlFragment;\n\n  /**\n   * True when {@link buildSearch} returns EXACT rankings — a brute-force\n   * engine form, not an approximate index (sqlite-vec's vec0 KNN scans\n   * every row in C). The query compiler then routes the NON-approximate\n   * `.similarTo()` branch through `buildSearch` too: same results as the\n   * SQL distance scan, at engine speed (measured 489ms -> 113ms at 50k\n   * on the SQLite lane). Leave false/absent when the engine form is or\n   * can be approximate (pgvector planner rewrites, libSQL DiskANN):\n   * exactness of the default path is a semantic guarantee.\n   */\n  searchIsExact?: boolean;\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    this: void,\n    embeddingColumn: SqlFragment,\n    queryEmbedding: readonly number[],\n    metric: VectorMetric,\n  ) => SqlFragment;\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    this: void,\n    slot: VectorSlot,\n    options?: Readonly<{ concurrent?: boolean }>,\n  ) => SqlFragment | undefined;\n\n  /** Emits the ANN index drop statement, or `undefined` when not applicable. */\n  buildDropIndex?: (this: void, slot: VectorSlot) => SqlFragment | 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: SqlFragment,\n  metric: VectorMetric,\n): SqlFragment {\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: SqlFragment,\n  metric: VectorMetric,\n  minScore: number,\n): SqlFragment {\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 * The frontier declaration of a backend's active vector strategy, or the\n * \"there is no vector engine here\" declaration when vector support is\n * disabled. Total, so a call site never has to invent a default: a backend\n * with no strategy has nothing to apply an override to and refuses on the\n * same arm as an engine that lacks the knob.\n */\nexport function vectorSearchFrontierTuning(\n  strategy: VectorStrategy | undefined,\n): VectorSearchFrontierTuning {\n  return (\n    strategy?.capabilities.searchFrontierTuning ?? {\n      tunable: false,\n      reason: \"vector support is disabled on this backend\",\n    }\n  );\n}\n\n/** What one backend needs to decide whether it can apply an `efSearch`. */\nexport type EfSearchApplicability = Readonly<{\n  /** The caller's override; `undefined` (no override) is always accepted. */\n  efSearch: number | undefined;\n  /** Index type of the slot being searched. */\n  indexType: VectorIndexType;\n  /** The active strategy's declaration. See {@link VectorSearchFrontierTuning}. */\n  tuning: VectorSearchFrontierTuning;\n  /** Whether the backend can open the frame a scoped override needs. */\n  transactions: boolean;\n  /**\n   * Dialect name used in the refusal message (`\"PostgreSQL\"` / `\"SQLite\"`) —\n   * the only dialect-specific token in the decision, so both backends read\n   * the same predicate rather than re-spelling the arms.\n   */\n  dialect: string;\n  /** Engine identity recorded in the refusal details (`strategy.name`). */\n  engine: string;\n}>;\n\n/**\n * The single owner of \"may this backend apply a per-search `efSearch`?\" —\n * returning the engine parameter to set with it, or `undefined` when no\n * override was requested.\n *\n * An accepted option is applied or refused, never ignored: every arm below is\n * a state in which the option cannot reach the engine, and each throws naming\n * that state instead of dropping the value. Both backends call this before\n * building the search, so the SQLite and PostgreSQL behaviors are two readings\n * of one predicate — the sqlite-vec silent no-op existed precisely because the\n * decision lived only on the PostgreSQL side. Returning the parameter (rather\n * than only asserting) is what keeps it one owner: the caller that applies the\n * override never re-derives whether it may.\n *\n * Refusals:\n *\n * - engine has no per-search frontier knob at all (`tunable: false`) —\n *   `UnsupportedBackendCapabilityError` on `vector.searchFrontierTuning`,\n *   carrying the strategy's own `reason`.\n * - slot is not the tunable index type — `ConfigurationError` (the caller can\n *   fix this by declaring the index, so it is configuration, not capability).\n * - the override needs a transaction to be scoped to and the backend has none\n *   — `UnsupportedBackendCapabilityError` on `transactions`.\n *\n * Range validation (pgvector's 1..1000) stays with the engine that has the\n * range; this predicate answers only whether the knob exists here at all.\n */\nexport function resolveEfSearchOverride(\n  applicability: EfSearchApplicability,\n): string | undefined {\n  const { efSearch, indexType, tuning, transactions, dialect, engine } =\n    applicability;\n  if (efSearch === undefined) return undefined;\n  if (!tuning.tunable) {\n    throw new UnsupportedBackendCapabilityError(\n      `${dialect} efSearch override`,\n      \"vector.searchFrontierTuning\",\n      { efSearch, engine, reason: tuning.reason },\n      `Omit efSearch: ${engine} has no per-search ANN frontier parameter (${tuning.reason}). Tune recall with the search limit, or use an exact search.`,\n    );\n  }\n  if (indexType !== tuning.indexType) {\n    // \"an HNSW vector index\" — the article suits the one tunable index type\n    // any bundled engine declares.\n    throw new ConfigurationError(\n      `${dialect} efSearch requires an ${tuning.indexType.toUpperCase()} vector index.`,\n      { efSearch, indexType },\n      {\n        suggestion: `Configure the embedding with index: { type: \"${tuning.indexType}\" }, or omit efSearch.`,\n      },\n    );\n  }\n  if (tuning.requiresTransactionScope && !transactions) {\n    throw new UnsupportedBackendCapabilityError(\n      `${dialect} efSearch override`,\n      \"transactions\",\n      { efSearch, engine, parameter: tuning.parameter },\n      `Use a transactional ${dialect} driver: ${tuning.parameter} is scoped to the search's own transaction, and a session-wide setting would leak into concurrent searches.`,\n    );\n  }\n  return tuning.parameter;\n}\n\n/** What one call site needs to decide whether ANN retrieval can be honored. */\nexport type ApproximateRetrievalRequest = Readonly<{\n  /** Whether the caller STATED `approximate: true`. */\n  approximate: boolean | undefined;\n  /**\n   * The metric the caller explicitly overrode to, or `undefined` when they\n   * passed none (in which case the slot's declared metric is used and no\n   * mismatch is possible).\n   */\n  requestedMetric: VectorMetric | undefined;\n  /** The metric the slot's storage and ANN structure were built for. */\n  declaredMetric: VectorMetric;\n  /** The slot's index type; `\"none\"` means there is no ANN structure at all. */\n  indexType: VectorIndexType;\n  /** Kind and field named in the refusal, so a union says WHICH slot refused. */\n  nodeKind: string;\n  fieldPath: string;\n}>;\n\n/**\n * The single owner of \"can this slot serve APPROXIMATE retrieval under the\n * metric the caller asked for?\".\n *\n * Every engine materializes metric-specific ANN structures — vec0 bakes\n * `distance_metric` into the virtual table, libSQL's DiskANN index is built\n * with `metric=…`, pgvector's index carries a per-metric operator class — so\n * an ANN structure can only retrieve under the metric it was built for.\n * Retrieving by the declared metric and re-scoring under an overridden one\n * returns the declared metric's neighbors wearing the override's scores: the\n * wrong rows, silently.\n *\n * Stating `approximate: true` alongside a mismatched `metric` therefore states\n * two things that cannot both hold. The option is refused naming both metrics\n * rather than downgraded to an exact scan behind the caller's back — the same\n * accepted-or-refused rule {@link resolveEfSearchOverride} applies to\n * `efSearch`.\n *\n * NOT refused, deliberately:\n *\n * - `indexType: \"none\"`. There is no ANN structure to be bound to a metric, so\n *   `approximate` has nothing to opt into and compiles to the strategy's exact\n *   scan under whichever metric was asked for. That degradation is stated on\n *   the public `SimilarToOptions.approximate` option.\n * - A mismatched metric with NO `approximate`. An exact scan computes any\n *   metric over the stored vectors correctly, and nothing was stated that the\n *   engine cannot honor. (`store.search.vector` refuses that override too, on\n *   its own broader rule — see `assertVectorQueryCompatible` in\n *   `store/search.ts`. The query builder's exact path is deliberately the\n *   wider surface; only the *silent* half is closed here.)\n */\nexport function assertApproximateMetricSupported(\n  request: ApproximateRetrievalRequest,\n): void {\n  const {\n    approximate,\n    requestedMetric,\n    declaredMetric,\n    indexType,\n    nodeKind,\n    fieldPath,\n  } = request;\n  if (approximate !== true) return;\n  if (indexType === \"none\") return;\n  if (requestedMetric === undefined || requestedMetric === declaredMetric) {\n    return;\n  }\n  throw new ConfigurationError(\n    `Approximate retrieval for \"${nodeKind}.${fieldPath}\" cannot use metric \"${requestedMetric}\": its ${indexType.toUpperCase()} index is built for \"${declaredMetric}\", and an ANN structure only retrieves under the metric it was built for.`,\n    {\n      nodeKind,\n      fieldPath,\n      requestedMetric,\n      declaredMetric,\n      indexType,\n    },\n    {\n      suggestion: `Omit metric (or pass \"${declaredMetric}\") to keep approximate retrieval, or drop approximate to scan exactly under \"${requestedMetric}\".`,\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 */\nexport function 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 = requireDefined(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"]}

package/dist/{chunk-26YKDNUD.cjs → chunk-PS3TUWJM.cjs}

@@ -1,20 +1,22 @@
 'use strict';
 
-var chunkBFUOME67_cjs = require('./chunk-BFUOME67.cjs');
-var chunk6NGW27EO_cjs = require('./chunk-6NGW27EO.cjs');
+var chunk7B7I7YAW_cjs = require('./chunk-7B7I7YAW.cjs');
+var chunkCRZ56SZU_cjs = require('./chunk-CRZ56SZU.cjs');
+var chunkVLBTRXA2_cjs = require('./chunk-VLBTRXA2.cjs');
 var zod = require('zod');
 
 // src/core/node.ts
 function validateSchemaKeys(schema, name) {
-  chunk6NGW27EO_cjs.assertSchemaKeysAreFree("Node", name, schema, chunk6NGW27EO_cjs.RESERVED_NODE_KEYS);
+  chunkVLBTRXA2_cjs.assertSchemaKeysAreFree("Node", name, schema, chunkVLBTRXA2_cjs.RESERVED_NODE_KEYS);
 }
 function defineNode(name, options) {
+  chunkCRZ56SZU_cjs.assertClaimAxisSafe(name, "Node kind");
   validateSchemaKeys(options.schema, name);
   if (options.annotations !== void 0) {
-    chunk6NGW27EO_cjs.assertJsonValue(options.annotations, "annotations", `Node "${name}"`);
+    chunkVLBTRXA2_cjs.assertJsonValue(options.annotations, "annotations", `Node "${name}"`);
   }
   return Object.freeze({
-    [chunkBFUOME67_cjs.NODE_TYPE_BRAND]: true,
+    [chunk7B7I7YAW_cjs.NODE_TYPE_BRAND]: true,
     kind: name,
     schema: options.schema,
     description: options.description,
@@ -23,16 +25,16 @@ function defineNode(name, options) {
 }
 var EMPTY_SCHEMA = zod.z.object({});
 function validateSchemaKeys2(schema, name) {
-  chunk6NGW27EO_cjs.assertSchemaKeysAreFree("Edge", name, schema, chunk6NGW27EO_cjs.RESERVED_EDGE_KEYS);
+  chunkVLBTRXA2_cjs.assertSchemaKeysAreFree("Edge", name, schema, chunkVLBTRXA2_cjs.RESERVED_EDGE_KEYS);
 }
 function defineEdge(name, options) {
   const schema = options?.schema ?? EMPTY_SCHEMA;
   validateSchemaKeys2(schema, name);
   if (options?.annotations !== void 0) {
-    chunk6NGW27EO_cjs.assertJsonValue(options.annotations, "annotations", `Edge "${name}"`);
+    chunkVLBTRXA2_cjs.assertJsonValue(options.annotations, "annotations", `Edge "${name}"`);
   }
   return Object.freeze({
-    [chunkBFUOME67_cjs.EDGE_TYPE_BRAND]: true,
+    [chunk7B7I7YAW_cjs.EDGE_TYPE_BRAND]: true,
     kind: name,
     schema,
     description: options?.description,
@@ -59,5 +61,5 @@ exports.defineEdge = defineEdge;
 exports.defineNode = defineNode;
 exports.getTypeName = getTypeName;
 exports.isMetaEdge = isMetaEdge;
-//# sourceMappingURL=chunk-26YKDNUD.cjs.map
-//# sourceMappingURL=chunk-26YKDNUD.cjs.map
+//# sourceMappingURL=chunk-PS3TUWJM.cjs.map
+//# sourceMappingURL=chunk-PS3TUWJM.cjs.map

package/dist/chunk-PS3TUWJM.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/node.ts","../src/core/edge.ts","../src/ontology/types.ts"],"names":["assertSchemaKeysAreFree","RESERVED_NODE_KEYS","assertClaimAxisSafe","assertJsonValue","NODE_TYPE_BRAND","z","validateSchemaKeys","RESERVED_EDGE_KEYS","EDGE_TYPE_BRAND"],"mappings":";;;;;;;;AAoCA,SAAS,kBAAA,CACP,QACA,IAAA,EACM;AACN,EAAAA,yCAAA,CAAwB,MAAA,EAAQ,IAAA,EAAM,MAAA,EAAQC,oCAAkB,CAAA;AAClE;AAgBO,SAAS,UAAA,CAGd,MAAS,OAAA,EAA+C;AAGxD,EAAAC,qCAAA,CAAoB,MAAM,WAAW,CAAA;AACrC,EAAA,kBAAA,CAAmB,OAAA,CAAQ,QAAQ,IAAI,CAAA;AACvC,EAAA,IAAI,OAAA,CAAQ,gBAAgB,MAAA,EAAW;AACrC,IAAAC,iCAAA,CAAgB,OAAA,CAAQ,WAAA,EAAa,aAAA,EAAe,CAAA,MAAA,EAAS,IAAI,CAAA,CAAA,CAAG,CAAA;AAAA,EACtE;AAEA,EAAA,OAAO,OAAO,MAAA,CAAO;AAAA,IACnB,CAACC,iCAAe,GAAG,IAAA;AAAA,IACnB,IAAA,EAAM,IAAA;AAAA,IACN,QAAQ,OAAA,CAAQ,MAAA;AAAA,IAChB,aAAa,OAAA,CAAQ,WAAA;AAAA,IACrB,aAAa,OAAA,CAAQ;AAAA,GACtB,CAAA;AACH;AC5BA,IAAM,YAAA,GAAeC,KAAA,CAAE,MAAA,CAAO,EAAE,CAAA;AAOhC,SAASC,mBAAAA,CACP,QACA,IAAA,EACM;AACN,EAAAN,yCAAA,CAAwB,MAAA,EAAQ,IAAA,EAAM,MAAA,EAAQO,oCAAkB,CAAA;AAClE;AAgDO,SAAS,UAAA,CAMd,MACA,OAAA,EACqD;AACrD,EAAA,MAAM,MAAA,GAAS,SAAS,MAAA,IAAU,YAAA;AAClC,EAAAD,mBAAAA,CAAmB,QAAQ,IAAI,CAAA;AAC/B,EAAA,IAAI,OAAA,EAAS,gBAAgB,MAAA,EAAW;AACtC,IAAAH,iCAAA,CAAgB,OAAA,CAAQ,WAAA,EAAa,aAAA,EAAe,CAAA,MAAA,EAAS,IAAI,CAAA,CAAA,CAAG,CAAA;AAAA,EACtE;AAEA,EAAA,OAAO,OAAO,MAAA,CAAO;AAAA,IACnB,CAACK,iCAAe,GAAG,IAAA;AAAA,IACnB,IAAA,EAAM,IAAA;AAAA,IACN,MAAA;AAAA,IACA,aAAa,OAAA,EAAS,WAAA;AAAA,IACtB,aAAa,OAAA,EAAS,WAAA;AAAA,IACtB,MAAM,OAAA,EAAS,IAAA;AAAA,IACf,IAAI,OAAA,EAAS;AAAA,GACd,CAAA;AACH;;;AC7HO,IAAM,eAAA,GAAkB;AA+ExB,SAAS,WAAW,KAAA,EAAmC;AAC5D,EAAA,OACE,OAAO,UAAU,QAAA,IACjB,KAAA,KAAU,QACV,eAAA,IAAmB,KAAA,IAClB,KAAA,CAAkC,eAAe,CAAA,KAAM,IAAA;AAE5D;AAKO,SAAS,YAAY,SAAA,EAAiD;AAC3E,EAAA,IAAI,OAAO,cAAc,QAAA,EAAU;AACjC,IAAA,OAAO,SAAA;AAAA,EACT;AACA,EAAA,OAAO,SAAA,CAAU,IAAA;AACnB","file":"chunk-PS3TUWJM.cjs","sourcesContent":["import { type z } from \"zod\";\n\nimport { assertClaimAxisSafe } from \"../store/claims/axis\";\nimport {\n  assertSchemaKeysAreFree,\n  RESERVED_NODE_KEYS,\n} from \"../store/reserved-keys\";\nimport { assertJsonValue } from \"./json-value\";\nimport { type KindAnnotations, NODE_TYPE_BRAND, type NodeType } from \"./types\";\n\n// ============================================================\n// Node Factory Options\n// ============================================================\n\n/**\n * Options for defining a node type.\n */\nexport type DefineNodeOptions<S extends z.ZodObject<z.ZodRawShape>> = Readonly<{\n  /** Zod schema for node properties */\n  schema: S;\n  /** Optional description for documentation */\n  description?: string;\n  /**\n   * Consumer-owned structured annotations for the kind.\n   *\n   * Stored in the canonical schema and **participates in schema hashing** —\n   * any change bumps the schema version and shows up as a `safe`-severity\n   * diff in `getSchemaChanges`. See `KindAnnotations` for the contract.\n   */\n  annotations?: KindAnnotations;\n}>;\n\n// ============================================================\n// Node Factory\n// ============================================================\n\nfunction validateSchemaKeys(\n  schema: z.ZodObject<z.ZodRawShape>,\n  name: string,\n): void {\n  assertSchemaKeysAreFree(\"Node\", name, schema, RESERVED_NODE_KEYS);\n}\n\n/**\n * Creates a node type definition.\n *\n * @example\n * ```typescript\n * const Person = defineNode(\"Person\", {\n *   schema: z.object({\n *     fullName: z.string().min(1),\n *     email: z.string().email().optional(),\n *   }),\n *   description: \"A person in the system\",\n * });\n * ```\n */\nexport function defineNode<\n  K extends string,\n  S extends z.ZodObject<z.ZodRawShape>,\n>(name: K, options: DefineNodeOptions<S>): NodeType<K, S> {\n  // A kind name is a claim axis, so it may not contain the code point reserved\n  // for building the axes that are not kinds.\n  assertClaimAxisSafe(name, \"Node kind\");\n  validateSchemaKeys(options.schema, name);\n  if (options.annotations !== undefined) {\n    assertJsonValue(options.annotations, \"annotations\", `Node \"${name}\"`);\n  }\n\n  return Object.freeze({\n    [NODE_TYPE_BRAND]: true as const,\n    kind: name,\n    schema: options.schema,\n    description: options.description,\n    annotations: options.annotations,\n  });\n}\n","import { z } from \"zod\";\n\nimport {\n  assertSchemaKeysAreFree,\n  RESERVED_EDGE_KEYS,\n} from \"../store/reserved-keys\";\nimport { assertJsonValue } from \"./json-value\";\nimport {\n  EDGE_TYPE_BRAND,\n  type EdgeType,\n  type KindAnnotations,\n  type NodeType,\n} from \"./types\";\n\n// ============================================================\n// Edge Factory Options\n// ============================================================\n\n/**\n * Options for defining an edge type.\n */\nexport type DefineEdgeOptions<\n  S extends z.ZodObject<z.ZodRawShape>,\n  From extends readonly NodeType[] | undefined = undefined,\n  To extends readonly NodeType[] | undefined = undefined,\n> = Readonly<{\n  /** Zod schema for edge properties (defaults to empty object) */\n  schema?: S;\n  /** Optional description for documentation */\n  description?: string;\n  /**\n   * Consumer-owned structured annotations for the kind.\n   *\n   * Stored in the canonical schema and **participates in schema hashing** —\n   * any change bumps the schema version and shows up as a `safe`-severity\n   * diff in `getSchemaChanges`. See `KindAnnotations` for the contract.\n   */\n  annotations?: KindAnnotations;\n  /** Node types that can be the source of this edge (domain constraint) */\n  from?: From;\n  /** Node types that can be the target of this edge (range constraint) */\n  to?: To;\n}>;\n\n// ============================================================\n// Empty Schema\n// ============================================================\n\nconst EMPTY_SCHEMA = z.object({});\ntype EmptySchema = typeof EMPTY_SCHEMA;\n\n// ============================================================\n// Edge Factory\n// ============================================================\n\nfunction validateSchemaKeys(\n  schema: z.ZodObject<z.ZodRawShape>,\n  name: string,\n): void {\n  assertSchemaKeysAreFree(\"Edge\", name, schema, RESERVED_EDGE_KEYS);\n}\n\n/**\n * Creates an edge type definition.\n *\n * @example\n * ```typescript\n * // Edge with no properties\n * const hasEpisode = defineEdge(\"hasEpisode\");\n *\n * // Edge with properties\n * const employedAt = defineEdge(\"employedAt\", {\n *   schema: z.object({\n *     isPrimary: z.boolean().default(true),\n *     startedAt: z.date(),\n *   }),\n *   description: \"Employment relationship\",\n * });\n *\n * // Edge with domain/range constraints (can be used directly in defineGraph)\n * const worksAt = defineEdge(\"worksAt\", {\n *   schema: z.object({ role: z.string() }),\n *   from: [Person],\n *   to: [Company],\n * });\n * ```\n */\n// Overload: no options - returns edge without domain/range\nexport function defineEdge<K extends string>(name: K): EdgeType<K, EmptySchema>;\n\n// Overload: options with both from and to - returns edge with domain/range\nexport function defineEdge<\n  K extends string,\n  S extends z.ZodObject<z.ZodRawShape>,\n  From extends readonly NodeType[],\n  To extends readonly NodeType[],\n>(\n  name: K,\n  options: DefineEdgeOptions<S, From, To> & { from: From; to: To },\n): EdgeType<K, S, From, To>;\n\n// Overload: options without from/to - returns edge without domain/range\nexport function defineEdge<\n  K extends string,\n  S extends z.ZodObject<z.ZodRawShape>,\n>(name: K, options: DefineEdgeOptions<S>): EdgeType<K, S>;\n\n// Implementation\nexport function defineEdge<\n  K extends string,\n  S extends z.ZodObject<z.ZodRawShape>,\n  From extends readonly NodeType[] | undefined,\n  To extends readonly NodeType[] | undefined,\n>(\n  name: K,\n  options?: DefineEdgeOptions<S, From, To>,\n): EdgeType<K, S, From, To> | EdgeType<K, EmptySchema> {\n  const schema = options?.schema ?? EMPTY_SCHEMA;\n  validateSchemaKeys(schema, name);\n  if (options?.annotations !== undefined) {\n    assertJsonValue(options.annotations, \"annotations\", `Edge \"${name}\"`);\n  }\n\n  return Object.freeze({\n    [EDGE_TYPE_BRAND]: true as const,\n    kind: name,\n    schema,\n    description: options?.description,\n    annotations: options?.annotations,\n    from: options?.from,\n    to: options?.to,\n  }) as EdgeType<K, S, From, To> | EdgeType<K, EmptySchema>;\n}\n","import { type EdgeType, type NodeType } from \"../core/types\";\n\n// ============================================================\n// Brand Key\n// ============================================================\n\n/** Brand key for MetaEdge */\nexport const META_EDGE_BRAND = \"__metaEdge\" as const;\n\n// ============================================================\n// Inference Types\n// ============================================================\n\n/**\n * How a meta-edge affects queries and validation.\n */\nexport type InferenceType =\n  | \"subsumption\" // Query for X includes instances of subclasses\n  | \"hierarchy\" // Enables broader/narrower traversal\n  | \"substitution\" // Can substitute equivalent types\n  | \"constraint\" // Validation rules\n  | \"composition\" // Part-whole navigation\n  | \"association\" // Discovery/recommendation\n  | \"none\"; // No automatic inference\n\n// ============================================================\n// Meta-Edge Properties\n// ============================================================\n\n/**\n * Properties of a meta-edge.\n */\nexport type MetaEdgeProperties = Readonly<{\n  transitive: boolean; // A→B, B→C implies A→C\n  symmetric: boolean; // A→B implies B→A\n  reflexive: boolean; // A→A is always true\n  inverse: string | undefined; // Name of inverse meta-edge\n  inference: InferenceType; // How this affects queries\n  description: string | undefined;\n}>;\n\n// ============================================================\n// Meta-Edge Type\n// ============================================================\n\n/**\n * A meta-edge definition.\n *\n * Meta-edges represent type-level relationships (between kinds),\n * not instance-level relationships (between nodes).\n */\nexport type MetaEdge<K extends string = string> = Readonly<{\n  [META_EDGE_BRAND]: true;\n  name: K;\n  properties: MetaEdgeProperties;\n}>;\n\n// ============================================================\n// Ontology Relation\n// ============================================================\n\n/**\n * A relation in the ontology (instance of meta-edge between types).\n *\n * @example\n * ```typescript\n * // Podcast subClassOf Media\n * subClassOf(Podcast, Media)\n *\n * // Person equivalentTo schema:Person\n * equivalentTo(Person, \"https://schema.org/Person\")\n * ```\n */\nexport type OntologyRelation = Readonly<{\n  metaEdge: MetaEdge;\n  from: NodeType | EdgeType | string; // string for external IRIs\n  to: NodeType | EdgeType | string;\n}>;\n\n// ============================================================\n// Type Guards\n// ============================================================\n\n/**\n * Checks if a value is a MetaEdge.\n */\nexport function isMetaEdge(value: unknown): value is MetaEdge {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    META_EDGE_BRAND in value &&\n    (value as Record<string, unknown>)[META_EDGE_BRAND] === true\n  );\n}\n\n/**\n * Gets the type name from a NodeType, EdgeType, or IRI string.\n */\nexport function getTypeName(typeOrIri: NodeType | EdgeType | string): string {\n  if (typeof typeOrIri === \"string\") {\n    return typeOrIri;\n  }\n  return typeOrIri.kind;\n}\n"]}

package/dist/{chunk-OMZ37BM2.js → chunk-PVFFH7TL.js}

@@ -1,6 +1,6 @@
-import { SYSTEM_INDEX_DECLARATIONS, systemIndexName } from './chunk-SDBBMD4N.js';
-import { compileNodeIndexKeys, compileIndexWhere, compileEdgeIndexKeys } from './chunk-ZDKTPBGV.js';
-import { isSqlFragment, renderSql, throwUnsupportedSqlChunk, bindSqlValue, sql as sql$1 } from './chunk-3DMMGT6S.js';
+import { SYSTEM_INDEX_DECLARATIONS, systemIndexName } from './chunk-36VYWVQU.js';
+import { compileNodeIndexKeys, compileIndexWhere, compileEdgeIndexKeys } from './chunk-7G5IYROL.js';
+import { isSqlFragment, renderSql, throwUnsupportedSqlChunk, bindSqlValue, sql as sql$1 } from './chunk-7QFRK6PU.js';
 import { uniqueIndex, index } from 'drizzle-orm/pg-core';
 import { uniqueIndex as uniqueIndex$1, index as index$1 } from 'drizzle-orm/sqlite-core';
 import { sql } from 'drizzle-orm';
@@ -379,5 +379,5 @@ function assertNonEmpty(values, label) {
 }
 
 export { buildPostgresEdgeIndexBuilders, buildPostgresNodeIndexBuilders, buildPostgresSystemIndexBuilders, buildSqliteEdgeIndexBuilders, buildSqliteNodeIndexBuilders, buildSqliteSystemIndexBuilders, compileQueryWithDialect, toDrizzleSql };
-//# sourceMappingURL=chunk-OMZ37BM2.js.map
-//# sourceMappingURL=chunk-OMZ37BM2.js.map
+//# sourceMappingURL=chunk-PVFFH7TL.js.map
+//# sourceMappingURL=chunk-PVFFH7TL.js.map

package/dist/{chunk-OMZ37BM2.js.map → chunk-PVFFH7TL.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../src/backend/drizzle/execution/types.ts","../src/indexes/drizzle.ts"],"names":["drizzleSql","index","sql","pgUniqueIndex","pgIndex","sqliteUniqueIndex","sqliteIndex"],"mappings":"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","file":"chunk-OMZ37BM2.js","sourcesContent":["import { type SQL as DrizzleSql, sql as drizzleSql } from \"drizzle-orm\";\n\nimport { bindSqlValue } from \"../../../query/dialect/profile\";\nimport { type SqlDialect } from \"../../../query/dialect/types\";\nimport {\n  isSqlFragment,\n  renderSql,\n  type SqlFragment,\n  throwUnsupportedSqlChunk,\n} from \"../../../query/sql-fragment\";\n\nexport type ExecutableSql = DrizzleSql | SqlFragment;\n\nexport type CompiledSqlQuery = Readonly<{\n  params: readonly unknown[];\n  sql: string;\n}>;\n\nexport type PreparedSqlStatement = Readonly<{\n  execute: <TRow>(params: readonly unknown[]) => Promise<readonly TRow[]>;\n}>;\n\nexport type SqlExecutionAdapter = Readonly<{\n  compile: (query: ExecutableSql) => CompiledSqlQuery;\n  execute: <TRow>(query: ExecutableSql) => Promise<readonly TRow[]>;\n  executeCompiled?: <TRow>(\n    compiledQuery: CompiledSqlQuery,\n  ) => Promise<readonly TRow[]>;\n  prepare?: (sqlText: string) => PreparedSqlStatement;\n  /**\n   * Runs `critical` with exclusive use of the connection: no statement from\n   * anywhere else can interleave with the ones it issues.\n   *\n   * Statement-at-a-time serialization is not enough for a *sequence* that must\n   * be atomic. `SET LOCAL` around a query is the motivating case — snapshot,\n   * set, select, restore. Two searches whose statements merely take turns can\n   * still interleave as `A snapshot → B snapshot → A set → B set → A select`,\n   * and `A` then runs under `B`'s settings.\n   *\n   * `critical` is handed the unqueued adapter, so it must not attempt to\n   * re-enter the queue. Present only on transaction-scoped (serialized)\n   * adapters; a pooled adapter needs no exclusion because every statement gets\n   * its own connection.\n   */\n  runExclusive?: <T>(\n    critical: (connection: SqlExecutionAdapter) => Promise<T>,\n  ) => Promise<T>;\n}>;\n\ntype SqlCompiler = Readonly<{\n  sqlToQuery: (query: DrizzleSql) => CompiledSqlQuery;\n}>;\n\ntype DatabaseWithCompiler = Readonly<{\n  dialect?: SqlCompiler;\n}>;\n\ntype BackendName = \"PostgreSQL\" | \"SQLite\";\n\nconst DIALECT_BY_BACKEND_NAME = {\n  PostgreSQL: \"postgres\",\n  SQLite: \"sqlite\",\n} as const satisfies Record<BackendName, SqlDialect>;\n\nexport function compileQueryWithDialect(\n  db: unknown,\n  query: ExecutableSql,\n  backendName: BackendName,\n): CompiledSqlQuery {\n  if (isSqlFragment(query)) {\n    return renderSql(query, DIALECT_BY_BACKEND_NAME[backendName]);\n  }\n  const databaseWithCompiler = db as DatabaseWithCompiler;\n  const compiler = databaseWithCompiler.dialect;\n  if (compiler === undefined) {\n    throw new Error(`${backendName} backend is missing a SQL compiler`);\n  }\n  return compiler.sqlToQuery(query);\n}\n\n/**\n * Translates TypeGraph's fragment IR into Drizzle's adapter-native SQL object.\n *\n * Most execution paths render directly to text and parameters. Async SQLite\n * drivers expose only Drizzle's execution method, so that adapter needs this\n * lossless bridge at its final boundary.\n */\nexport function toDrizzleSql(\n  fragment: SqlFragment,\n  dialect: SqlDialect,\n): DrizzleSql {\n  const chunks = fragment.chunks.map((chunk) => {\n    switch (chunk.kind) {\n      case \"text\": {\n        return drizzleSql.raw(chunk.value);\n      }\n      case \"identifier\": {\n        // Drizzle's schema builders treat Name chunks as bare index-column\n        // references and omit dialect quoting. Preserve the portable IR's\n        // identifier semantics by handing the adapter an already-quoted,\n        // trusted SQL token instead.\n        return drizzleSql.raw(`\"${chunk.value.replaceAll('\"', '\"\"')}\"`);\n      }\n      case \"parameter\": {\n        return drizzleSql.param(bindSqlValue(chunk.value, dialect));\n      }\n      case \"placeholder\": {\n        return drizzleSql.placeholder(chunk.value.name);\n      }\n      default: {\n        return throwUnsupportedSqlChunk(chunk);\n      }\n    }\n  });\n  return drizzleSql.join(chunks);\n}\n","import { type SQLWrapper } from \"drizzle-orm\";\nimport {\n  index as pgIndex,\n  type IndexBuilder as PgIndexBuilder,\n  type PgColumn,\n  uniqueIndex as pgUniqueIndex,\n} from \"drizzle-orm/pg-core\";\nimport {\n  index as sqliteIndex,\n  type IndexBuilder as SqliteIndexBuilder,\n  type SQLiteColumn,\n  uniqueIndex as sqliteUniqueIndex,\n} from \"drizzle-orm/sqlite-core\";\n\nimport { toDrizzleSql } from \"../backend/drizzle/execution/types\";\nimport { sql as portableSql, type SqlFragment } from \"../query/sql-fragment\";\nimport {\n  compileEdgeIndexKeys,\n  compileIndexWhere,\n  compileNodeIndexKeys,\n  type IndexCompilationContext,\n} from \"./compiler\";\nimport {\n  SYSTEM_INDEX_DECLARATIONS,\n  type SystemIndexDeclaration,\n  systemIndexName,\n  type SystemIndexTable,\n} from \"./system\";\nimport {\n  type EdgeIndexDeclaration,\n  type IndexDeclaration,\n  type NodeIndexDeclaration,\n  type SystemColumnName,\n} from \"./types\";\n\n// ============================================================\n// PostgreSQL (Drizzle Schema)\n// ============================================================\n\nexport function buildPostgresNodeIndexBuilders(\n  table: NodeIndexTable,\n  indexes: readonly IndexDeclaration[],\n): readonly PgIndexBuilder[] {\n  // GIN-family declarations (method: \"gin\" / \"trigram\") are\n  // materialize-only — like pgvector ANN indexes, they are a pure\n  // materialization concern and never ride the Drizzle table extras.\n  const nodeIndexes = indexes.filter(\n    (index): index is NodeIndexDeclaration =>\n      index.entity === \"node\" && index.method === undefined,\n  );\n\n  return nodeIndexes.map((index) => {\n    const propsColumn = portableSql.identifier(table.props.name);\n    const systemColumn = (column: SystemColumnName): SqlFragment =>\n      portableSql.identifier(getPostgresNodeSystemColumn(table, column).name);\n\n    const { keys } = compileNodeIndexKeys(\n      index,\n      \"postgres\",\n      propsColumn,\n      systemColumn,\n    );\n    assertNonEmpty(keys, `node index \"${index.name}\"`);\n\n    const base = index.unique ? pgUniqueIndex(index.name) : pgIndex(index.name);\n\n    const drizzleKeys = keys.map((key) => toDrizzleSql(key, \"postgres\"));\n    assertNonEmpty(drizzleKeys, `node index \"${index.name}\"`);\n    const [firstKey, ...remainingKeys] = drizzleKeys;\n    const builder = base.on(firstKey, ...remainingKeys);\n\n    if (index.where) {\n      const ctx: IndexCompilationContext = {\n        dialect: \"postgres\",\n        propsColumn,\n        systemColumn,\n      };\n      builder.where(\n        toDrizzleSql(compileIndexWhere(ctx, index.where), \"postgres\"),\n      );\n    }\n\n    return builder;\n  });\n}\n\nexport function buildPostgresEdgeIndexBuilders(\n  table: EdgeIndexTable,\n  indexes: readonly IndexDeclaration[],\n): readonly PgIndexBuilder[] {\n  const edgeIndexes = indexes.filter(\n    (index): index is EdgeIndexDeclaration =>\n      index.entity === \"edge\" && index.method === undefined,\n  );\n\n  return edgeIndexes.map((index) => {\n    const propsColumn = portableSql.identifier(table.props.name);\n    const systemColumn = (column: SystemColumnName): SqlFragment =>\n      portableSql.identifier(getPostgresEdgeSystemColumn(table, column).name);\n\n    const { keys } = compileEdgeIndexKeys(\n      index,\n      \"postgres\",\n      propsColumn,\n      systemColumn,\n    );\n    assertNonEmpty(keys, `edge index \"${index.name}\"`);\n\n    const base = index.unique ? pgUniqueIndex(index.name) : pgIndex(index.name);\n\n    const drizzleKeys = keys.map((key) => toDrizzleSql(key, \"postgres\"));\n    assertNonEmpty(drizzleKeys, `edge index \"${index.name}\"`);\n    const [firstKey, ...remainingKeys] = drizzleKeys;\n    const builder = base.on(firstKey, ...remainingKeys);\n\n    if (index.where) {\n      const ctx: IndexCompilationContext = {\n        dialect: \"postgres\",\n        propsColumn,\n        systemColumn,\n      };\n      builder.where(\n        toDrizzleSql(compileIndexWhere(ctx, index.where), \"postgres\"),\n      );\n    }\n\n    return builder;\n  });\n}\n\nfunction getPostgresNodeSystemColumn(\n  table: NodeIndexTable,\n  column: SystemColumnName,\n): NamedSqlWrapper {\n  switch (column) {\n    case \"graph_id\": {\n      return table.graphId;\n    }\n    case \"kind\": {\n      return table.kind;\n    }\n    case \"id\": {\n      return table.id;\n    }\n    case \"from_kind\":\n    case \"from_id\":\n    case \"to_kind\":\n    case \"to_id\": {\n      throw new Error(`Unsupported node system column for indexes: ${column}`);\n    }\n    case \"deleted_at\": {\n      return table.deletedAt;\n    }\n    case \"valid_from\": {\n      return table.validFrom;\n    }\n    case \"valid_to\": {\n      return table.validTo;\n    }\n    case \"created_at\": {\n      return table.createdAt;\n    }\n    case \"updated_at\": {\n      return table.updatedAt;\n    }\n    case \"version\": {\n      return table.version;\n    }\n  }\n}\n\nfunction getPostgresEdgeSystemColumn(\n  table: EdgeIndexTable,\n  column: SystemColumnName,\n): NamedSqlWrapper {\n  switch (column) {\n    case \"graph_id\": {\n      return table.graphId;\n    }\n    case \"kind\": {\n      return table.kind;\n    }\n    case \"id\": {\n      return table.id;\n    }\n    case \"from_kind\": {\n      return table.fromKind;\n    }\n    case \"from_id\": {\n      return table.fromId;\n    }\n    case \"to_kind\": {\n      return table.toKind;\n    }\n    case \"to_id\": {\n      return table.toId;\n    }\n    case \"deleted_at\": {\n      return table.deletedAt;\n    }\n    case \"valid_from\": {\n      return table.validFrom;\n    }\n    case \"valid_to\": {\n      return table.validTo;\n    }\n    case \"created_at\": {\n      return table.createdAt;\n    }\n    case \"updated_at\": {\n      return table.updatedAt;\n    }\n    case \"version\": {\n      throw new Error(`Unsupported edge system column for indexes: ${column}`);\n    }\n  }\n}\n\n// ============================================================\n// SQLite (Drizzle Schema)\n// ============================================================\n\nexport function buildSqliteNodeIndexBuilders(\n  table: NodeIndexTable,\n  indexes: readonly IndexDeclaration[],\n): readonly SqliteIndexBuilder[] {\n  // GIN-family declarations (method: \"gin\" / \"trigram\") are\n  // materialize-only — like pgvector ANN indexes, they are a pure\n  // materialization concern and never ride the Drizzle table extras.\n  const nodeIndexes = indexes.filter(\n    (index): index is NodeIndexDeclaration =>\n      index.entity === \"node\" && index.method === undefined,\n  );\n\n  return nodeIndexes.map((index) => {\n    const propsColumn = portableSql.identifier(table.props.name);\n    const systemColumn = (column: SystemColumnName): SqlFragment =>\n      portableSql.identifier(getSqliteNodeSystemColumn(table, column).name);\n\n    const { keys } = compileNodeIndexKeys(\n      index,\n      \"sqlite\",\n      propsColumn,\n      systemColumn,\n    );\n    assertNonEmpty(keys, `node index \"${index.name}\"`);\n\n    const base =\n      index.unique ? sqliteUniqueIndex(index.name) : sqliteIndex(index.name);\n\n    const drizzleKeys = keys.map((key) => toDrizzleSql(key, \"sqlite\"));\n    assertNonEmpty(drizzleKeys, `node index \"${index.name}\"`);\n    const [firstKey, ...remainingKeys] = drizzleKeys;\n    const builder = base.on(firstKey, ...remainingKeys);\n\n    if (index.where) {\n      const ctx: IndexCompilationContext = {\n        dialect: \"sqlite\",\n        propsColumn,\n        systemColumn,\n      };\n      builder.where(\n        toDrizzleSql(compileIndexWhere(ctx, index.where), \"sqlite\"),\n      );\n    }\n\n    return builder;\n  });\n}\n\nexport function buildSqliteEdgeIndexBuilders(\n  table: EdgeIndexTable,\n  indexes: readonly IndexDeclaration[],\n): readonly SqliteIndexBuilder[] {\n  const edgeIndexes = indexes.filter(\n    (index): index is EdgeIndexDeclaration =>\n      index.entity === \"edge\" && index.method === undefined,\n  );\n\n  return edgeIndexes.map((index) => {\n    const propsColumn = portableSql.identifier(table.props.name);\n    const systemColumn = (column: SystemColumnName): SqlFragment =>\n      portableSql.identifier(getSqliteEdgeSystemColumn(table, column).name);\n\n    const { keys } = compileEdgeIndexKeys(\n      index,\n      \"sqlite\",\n      propsColumn,\n      systemColumn,\n    );\n    assertNonEmpty(keys, `edge index \"${index.name}\"`);\n\n    const base =\n      index.unique ? sqliteUniqueIndex(index.name) : sqliteIndex(index.name);\n\n    const drizzleKeys = keys.map((key) => toDrizzleSql(key, \"sqlite\"));\n    assertNonEmpty(drizzleKeys, `edge index \"${index.name}\"`);\n    const [firstKey, ...remainingKeys] = drizzleKeys;\n    const builder = base.on(firstKey, ...remainingKeys);\n\n    if (index.where) {\n      const ctx: IndexCompilationContext = {\n        dialect: \"sqlite\",\n        propsColumn,\n        systemColumn,\n      };\n      builder.where(\n        toDrizzleSql(compileIndexWhere(ctx, index.where), \"sqlite\"),\n      );\n    }\n\n    return builder;\n  });\n}\n\nfunction getSqliteNodeSystemColumn(\n  table: NodeIndexTable,\n  column: SystemColumnName,\n): NamedSqlWrapper {\n  switch (column) {\n    case \"graph_id\": {\n      return table.graphId;\n    }\n    case \"kind\": {\n      return table.kind;\n    }\n    case \"id\": {\n      return table.id;\n    }\n    case \"from_kind\":\n    case \"from_id\":\n    case \"to_kind\":\n    case \"to_id\": {\n      throw new Error(`Unsupported node system column for indexes: ${column}`);\n    }\n    case \"deleted_at\": {\n      return table.deletedAt;\n    }\n    case \"valid_from\": {\n      return table.validFrom;\n    }\n    case \"valid_to\": {\n      return table.validTo;\n    }\n    case \"created_at\": {\n      return table.createdAt;\n    }\n    case \"updated_at\": {\n      return table.updatedAt;\n    }\n    case \"version\": {\n      return table.version;\n    }\n  }\n}\n\nfunction getSqliteEdgeSystemColumn(\n  table: EdgeIndexTable,\n  column: SystemColumnName,\n): NamedSqlWrapper {\n  switch (column) {\n    case \"graph_id\": {\n      return table.graphId;\n    }\n    case \"kind\": {\n      return table.kind;\n    }\n    case \"id\": {\n      return table.id;\n    }\n    case \"from_kind\": {\n      return table.fromKind;\n    }\n    case \"from_id\": {\n      return table.fromId;\n    }\n    case \"to_kind\": {\n      return table.toKind;\n    }\n    case \"to_id\": {\n      return table.toId;\n    }\n    case \"deleted_at\": {\n      return table.deletedAt;\n    }\n    case \"valid_from\": {\n      return table.validFrom;\n    }\n    case \"valid_to\": {\n      return table.validTo;\n    }\n    case \"created_at\": {\n      return table.createdAt;\n    }\n    case \"updated_at\": {\n      return table.updatedAt;\n    }\n    case \"version\": {\n      throw new Error(`Unsupported edge system column for indexes: ${column}`);\n    }\n  }\n}\n\n// ============================================================\n// System indexes (both dialects)\n// ============================================================\n//\n// The schema factories derive their system-index Drizzle builders from\n// `SYSTEM_INDEX_DECLARATIONS` so both dialects emit the same index set by\n// construction. The builders receive the table's real column objects (not\n// SQL wrappers) so the DDL generator renders plain quoted column names —\n// byte-identical to the runtime DDL `materializeSystemIndexes` emits.\n\ntype SystemIndexColumns<C extends { name: string }> = Readonly<\n  Record<string, C>\n>;\n\n/**\n * Resolves a declaration's physical column names against the table's own\n * column objects by each column's `.name` — the SQL name Drizzle carries on\n * the column itself — so no naming convention sits between the declaration\n * and the schema. A column the table doesn't define throws at\n * table-construction time (exercised by the system-index parity tests).\n */\nfunction resolveSystemIndexColumns<C extends { name: string }>(\n  declaration: SystemIndexDeclaration,\n  columns: SystemIndexColumns<C>,\n): readonly [C, ...C[]] {\n  const byPhysicalName = new Map(\n    Object.values(columns).map((column) => [column.name, column]),\n  );\n  const resolved = declaration.columns.map((column) => {\n    const value = byPhysicalName.get(column);\n    if (value === undefined) {\n      throw new Error(\n        `System index \"${declaration.table}_${declaration.suffix}\" references ` +\n          `a column \"${column}\" the ${declaration.table} table does not define`,\n      );\n    }\n    return value;\n  });\n  // `declaration.columns` is non-empty by type, so `resolved` is too.\n  return resolved as [C, ...C[]];\n}\n\n/**\n * The two dialect variants do no dialect-specific work (no unique, no\n * where, no expression compilation — unlike the node/edge builder pairs\n * above), so they share one body parameterized by the dialect's index\n * factory.\n */\nfunction buildSystemIndexBuilders<C extends { name: string }, B>(\n  tableKey: SystemIndexTable,\n  physicalTableName: string,\n  columns: SystemIndexColumns<C>,\n  indexFactory: (name: string) => { on: (...cols: [C, ...C[]]) => B },\n): readonly B[] {\n  return SYSTEM_INDEX_DECLARATIONS.filter(\n    (declaration) => declaration.table === tableKey,\n  ).map((declaration) =>\n    indexFactory(systemIndexName(physicalTableName, declaration.suffix)).on(\n      ...resolveSystemIndexColumns(declaration, columns),\n    ),\n  );\n}\n\nexport function buildSqliteSystemIndexBuilders(\n  tableKey: SystemIndexTable,\n  physicalTableName: string,\n  columns: SystemIndexColumns<SQLiteColumn>,\n): readonly SqliteIndexBuilder[] {\n  return buildSystemIndexBuilders(\n    tableKey,\n    physicalTableName,\n    columns,\n    (name) => sqliteIndex(name),\n  );\n}\n\nexport function buildPostgresSystemIndexBuilders(\n  tableKey: SystemIndexTable,\n  physicalTableName: string,\n  columns: SystemIndexColumns<PgColumn>,\n): readonly PgIndexBuilder[] {\n  return buildSystemIndexBuilders(\n    tableKey,\n    physicalTableName,\n    columns,\n    (name) => pgIndex(name),\n  );\n}\n\n// ============================================================\n// Minimal table shapes (shared between dialect schemas)\n// ============================================================\n\ntype NamedSqlWrapper = SQLWrapper & Readonly<{ name: string }>;\n\ntype NodeIndexTable = Readonly<{\n  graphId: NamedSqlWrapper;\n  kind: NamedSqlWrapper;\n  id: NamedSqlWrapper;\n  props: NamedSqlWrapper;\n  version: NamedSqlWrapper;\n  validFrom: NamedSqlWrapper;\n  validTo: NamedSqlWrapper;\n  createdAt: NamedSqlWrapper;\n  updatedAt: NamedSqlWrapper;\n  deletedAt: NamedSqlWrapper;\n}>;\n\ntype EdgeIndexTable = Readonly<{\n  graphId: NamedSqlWrapper;\n  id: NamedSqlWrapper;\n  kind: NamedSqlWrapper;\n  fromKind: NamedSqlWrapper;\n  fromId: NamedSqlWrapper;\n  toKind: NamedSqlWrapper;\n  toId: NamedSqlWrapper;\n  props: NamedSqlWrapper;\n  validFrom: NamedSqlWrapper;\n  validTo: NamedSqlWrapper;\n  createdAt: NamedSqlWrapper;\n  updatedAt: NamedSqlWrapper;\n  deletedAt: NamedSqlWrapper;\n}>;\n\nfunction assertNonEmpty<T>(\n  values: readonly T[],\n  label: string,\n): asserts values is readonly [T, ...T[]] {\n  if (values.length === 0) {\n    throw new Error(`Index must have at least one key (${label})`);\n  }\n}\n"]}
+{"version":3,"sources":["../src/backend/drizzle/execution/types.ts","../src/indexes/drizzle.ts"],"names":["drizzleSql","index","sql","pgUniqueIndex","pgIndex","sqliteUniqueIndex","sqliteIndex"],"mappings":";;;;;;;AA2DA,IAAM,uBAAA,GAA0B;AAAA,EAC9B,UAAA,EAAY,UAAA;AAAA,EACZ,MAAA,EAAQ;AACV,CAAA;AAEO,SAAS,uBAAA,CACd,EAAA,EACA,KAAA,EACA,WAAA,EACkB;AAClB,EAAA,IAAI,aAAA,CAAc,KAAK,CAAA,EAAG;AACxB,IAAA,OAAO,SAAA,CAAU,KAAA,EAAO,uBAAA,CAAwB,WAAW,CAAC,CAAA;AAAA,EAC9D;AACA,EAAA,MAAM,oBAAA,GAAuB,EAAA;AAC7B,EAAA,MAAM,WAAW,oBAAA,CAAqB,OAAA;AACtC,EAAA,IAAI,aAAa,MAAA,EAAW;AAC1B,IAAA,MAAM,IAAI,KAAA,CAAM,CAAA,EAAG,WAAW,CAAA,kCAAA,CAAoC,CAAA;AAAA,EACpE;AACA,EAAA,OAAO,QAAA,CAAS,WAAW,KAAK,CAAA;AAClC;AASO,SAAS,YAAA,CACd,UACA,OAAA,EACY;AACZ,EAAA,MAAM,MAAA,GAAS,QAAA,CAAS,MAAA,CAAO,GAAA,CAAI,CAAC,KAAA,KAAU;AAC5C,IAAA,QAAQ,MAAM,IAAA;AAAM,MAClB,KAAK,MAAA,EAAQ;AACX,QAAA,OAAOA,GAAA,CAAW,GAAA,CAAI,KAAA,CAAM,KAAK,CAAA;AAAA,MACnC;AAAA,MACA,KAAK,YAAA,EAAc;AAKjB,QAAA,OAAOA,GAAA,CAAW,IAAI,CAAA,CAAA,EAAI,KAAA,CAAM,MAAM,UAAA,CAAW,GAAA,EAAK,IAAI,CAAC,CAAA,CAAA,CAAG,CAAA;AAAA,MAChE;AAAA,MACA,KAAK,WAAA,EAAa;AAChB,QAAA,OAAOA,IAAW,KAAA,CAAM,YAAA,CAAa,KAAA,CAAM,KAAA,EAAO,OAAO,CAAC,CAAA;AAAA,MAC5D;AAAA,MACA,KAAK,aAAA,EAAe;AAClB,QAAA,OAAOA,GAAA,CAAW,WAAA,CAAY,KAAA,CAAM,KAAA,CAAM,IAAI,CAAA;AAAA,MAChD;AAAA,MACA,SAAS;AACP,QAAA,OAAO,yBAAyB,KAAK,CAAA;AAAA,MACvC;AAAA;AACF,EACF,CAAC,CAAA;AACD,EAAA,OAAOA,GAAA,CAAW,KAAK,MAAM,CAAA;AAC/B;;;AC5EO,SAAS,8BAAA,CACd,OACA,OAAA,EAC2B;AAI3B,EAAA,MAAM,cAAc,OAAA,CAAQ,MAAA;AAAA,IAC1B,CAAC,KAAA,KACC,KAAA,CAAM,MAAA,KAAW,MAAA,IAAU,MAAM,MAAA,KAAW;AAAA,GAChD;AAEA,EAAA,OAAO,WAAA,CAAY,GAAA,CAAI,CAACC,OAAA,KAAU;AAChC,IAAA,MAAM,WAAA,GAAcC,KAAA,CAAY,UAAA,CAAW,KAAA,CAAM,MAAM,IAAI,CAAA;AAC3D,IAAA,MAAM,YAAA,GAAe,CAAC,MAAA,KACpBA,KAAA,CAAY,WAAW,2BAAA,CAA4B,KAAA,EAAO,MAAM,CAAA,CAAE,IAAI,CAAA;AAExE,IAAA,MAAM,EAAE,MAAK,GAAI,oBAAA;AAAA,MACfD,OAAA;AAAA,MACA,UAAA;AAAA,MACA,WAAA;AAAA,MACA;AAAA,KACF;AACA,IAAA,cAAA,CAAe,IAAA,EAAM,CAAA,YAAA,EAAeA,OAAA,CAAM,IAAI,CAAA,CAAA,CAAG,CAAA;AAEjD,IAAA,MAAM,IAAA,GAAOA,QAAM,MAAA,GAASE,WAAA,CAAcF,QAAM,IAAI,CAAA,GAAIG,KAAA,CAAQH,OAAA,CAAM,IAAI,CAAA;AAE1E,IAAA,MAAM,WAAA,GAAc,KAAK,GAAA,CAAI,CAAC,QAAQ,YAAA,CAAa,GAAA,EAAK,UAAU,CAAC,CAAA;AACnE,IAAA,cAAA,CAAe,WAAA,EAAa,CAAA,YAAA,EAAeA,OAAA,CAAM,IAAI,CAAA,CAAA,CAAG,CAAA;AACxD,IAAA,MAAM,CAAC,QAAA,EAAU,GAAG,aAAa,CAAA,GAAI,WAAA;AACrC,IAAA,MAAM,OAAA,GAAU,IAAA,CAAK,EAAA,CAAG,QAAA,EAAU,GAAG,aAAa,CAAA;AAElD,IAAA,IAAIA,QAAM,KAAA,EAAO;AACf,MAAA,MAAM,GAAA,GAA+B;AAAA,QACnC,OAAA,EAAS,UAAA;AAAA,QACT,WAAA;AAAA,QACA;AAAA,OACF;AACA,MAAA,OAAA,CAAQ,KAAA;AAAA,QACN,aAAa,iBAAA,CAAkB,GAAA,EAAKA,OAAA,CAAM,KAAK,GAAG,UAAU;AAAA,OAC9D;AAAA,IACF;AAEA,IAAA,OAAO,OAAA;AAAA,EACT,CAAC,CAAA;AACH;AAEO,SAAS,8BAAA,CACd,OACA,OAAA,EAC2B;AAC3B,EAAA,MAAM,cAAc,OAAA,CAAQ,MAAA;AAAA,IAC1B,CAAC,KAAA,KACC,KAAA,CAAM,MAAA,KAAW,MAAA,IAAU,MAAM,MAAA,KAAW;AAAA,GAChD;AAEA,EAAA,OAAO,WAAA,CAAY,GAAA,CAAI,CAACA,OAAA,KAAU;AAChC,IAAA,MAAM,WAAA,GAAcC,KAAA,CAAY,UAAA,CAAW,KAAA,CAAM,MAAM,IAAI,CAAA;AAC3D,IAAA,MAAM,YAAA,GAAe,CAAC,MAAA,KACpBA,KAAA,CAAY,WAAW,2BAAA,CAA4B,KAAA,EAAO,MAAM,CAAA,CAAE,IAAI,CAAA;AAExE,IAAA,MAAM,EAAE,MAAK,GAAI,oBAAA;AAAA,MACfD,OAAA;AAAA,MACA,UAAA;AAAA,MACA,WAAA;AAAA,MACA;AAAA,KACF;AACA,IAAA,cAAA,CAAe,IAAA,EAAM,CAAA,YAAA,EAAeA,OAAA,CAAM,IAAI,CAAA,CAAA,CAAG,CAAA;AAEjD,IAAA,MAAM,IAAA,GAAOA,QAAM,MAAA,GAASE,WAAA,CAAcF,QAAM,IAAI,CAAA,GAAIG,KAAA,CAAQH,OAAA,CAAM,IAAI,CAAA;AAE1E,IAAA,MAAM,WAAA,GAAc,KAAK,GAAA,CAAI,CAAC,QAAQ,YAAA,CAAa,GAAA,EAAK,UAAU,CAAC,CAAA;AACnE,IAAA,cAAA,CAAe,WAAA,EAAa,CAAA,YAAA,EAAeA,OAAA,CAAM,IAAI,CAAA,CAAA,CAAG,CAAA;AACxD,IAAA,MAAM,CAAC,QAAA,EAAU,GAAG,aAAa,CAAA,GAAI,WAAA;AACrC,IAAA,MAAM,OAAA,GAAU,IAAA,CAAK,EAAA,CAAG,QAAA,EAAU,GAAG,aAAa,CAAA;AAElD,IAAA,IAAIA,QAAM,KAAA,EAAO;AACf,MAAA,MAAM,GAAA,GAA+B;AAAA,QACnC,OAAA,EAAS,UAAA;AAAA,QACT,WAAA;AAAA,QACA;AAAA,OACF;AACA,MAAA,OAAA,CAAQ,KAAA;AAAA,QACN,aAAa,iBAAA,CAAkB,GAAA,EAAKA,OAAA,CAAM,KAAK,GAAG,UAAU;AAAA,OAC9D;AAAA,IACF;AAEA,IAAA,OAAO,OAAA;AAAA,EACT,CAAC,CAAA;AACH;AAEA,SAAS,2BAAA,CACP,OACA,MAAA,EACiB;AACjB,EAAA,QAAQ,MAAA;AAAQ,IACd,KAAK,UAAA,EAAY;AACf,MAAA,OAAO,KAAA,CAAM,OAAA;AAAA,IACf;AAAA,IACA,KAAK,MAAA,EAAQ;AACX,MAAA,OAAO,KAAA,CAAM,IAAA;AAAA,IACf;AAAA,IACA,KAAK,IAAA,EAAM;AACT,MAAA,OAAO,KAAA,CAAM,EAAA;AAAA,IACf;AAAA,IACA,KAAK,WAAA;AAAA,IACL,KAAK,SAAA;AAAA,IACL,KAAK,SAAA;AAAA,IACL,KAAK,OAAA,EAAS;AACZ,MAAA,MAAM,IAAI,KAAA,CAAM,CAAA,4CAAA,EAA+C,MAAM,CAAA,CAAE,CAAA;AAAA,IACzE;AAAA,IACA,KAAK,YAAA,EAAc;AACjB,MAAA,OAAO,KAAA,CAAM,SAAA;AAAA,IACf;AAAA,IACA,KAAK,YAAA,EAAc;AACjB,MAAA,OAAO,KAAA,CAAM,SAAA;AAAA,IACf;AAAA,IACA,KAAK,UAAA,EAAY;AACf,MAAA,OAAO,KAAA,CAAM,OAAA;AAAA,IACf;AAAA,IACA,KAAK,YAAA,EAAc;AACjB,MAAA,OAAO,KAAA,CAAM,SAAA;AAAA,IACf;AAAA,IACA,KAAK,YAAA,EAAc;AACjB,MAAA,OAAO,KAAA,CAAM,SAAA;AAAA,IACf;AAAA,IACA,KAAK,SAAA,EAAW;AACd,MAAA,OAAO,KAAA,CAAM,OAAA;AAAA,IACf;AAAA;AAEJ;AAEA,SAAS,2BAAA,CACP,OACA,MAAA,EACiB;AACjB,EAAA,QAAQ,MAAA;AAAQ,IACd,KAAK,UAAA,EAAY;AACf,MAAA,OAAO,KAAA,CAAM,OAAA;AAAA,IACf;AAAA,IACA,KAAK,MAAA,EAAQ;AACX,MAAA,OAAO,KAAA,CAAM,IAAA;AAAA,IACf;AAAA,IACA,KAAK,IAAA,EAAM;AACT,MAAA,OAAO,KAAA,CAAM,EAAA;AAAA,IACf;AAAA,IACA,KAAK,WAAA,EAAa;AAChB,MAAA,OAAO,KAAA,CAAM,QAAA;AAAA,IACf;AAAA,IACA,KAAK,SAAA,EAAW;AACd,MAAA,OAAO,KAAA,CAAM,MAAA;AAAA,IACf;AAAA,IACA,KAAK,SAAA,EAAW;AACd,MAAA,OAAO,KAAA,CAAM,MAAA;AAAA,IACf;AAAA,IACA,KAAK,OAAA,EAAS;AACZ,MAAA,OAAO,KAAA,CAAM,IAAA;AAAA,IACf;AAAA,IACA,KAAK,YAAA,EAAc;AACjB,MAAA,OAAO,KAAA,CAAM,SAAA;AAAA,IACf;AAAA,IACA,KAAK,YAAA,EAAc;AACjB,MAAA,OAAO,KAAA,CAAM,SAAA;AAAA,IACf;AAAA,IACA,KAAK,UAAA,EAAY;AACf,MAAA,OAAO,KAAA,CAAM,OAAA;AAAA,IACf;AAAA,IACA,KAAK,YAAA,EAAc;AACjB,MAAA,OAAO,KAAA,CAAM,SAAA;AAAA,IACf;AAAA,IACA,KAAK,YAAA,EAAc;AACjB,MAAA,OAAO,KAAA,CAAM,SAAA;AAAA,IACf;AAAA,IACA,KAAK,SAAA,EAAW;AACd,MAAA,MAAM,IAAI,KAAA,CAAM,CAAA,4CAAA,EAA+C,MAAM,CAAA,CAAE,CAAA;AAAA,IACzE;AAAA;AAEJ;AAMO,SAAS,4BAAA,CACd,OACA,OAAA,EAC+B;AAI/B,EAAA,MAAM,cAAc,OAAA,CAAQ,MAAA;AAAA,IAC1B,CAAC,KAAA,KACC,KAAA,CAAM,MAAA,KAAW,MAAA,IAAU,MAAM,MAAA,KAAW;AAAA,GAChD;AAEA,EAAA,OAAO,WAAA,CAAY,GAAA,CAAI,CAAC,KAAA,KAAU;AAChC,IAAA,MAAM,WAAA,GAAcC,KAAA,CAAY,UAAA,CAAW,KAAA,CAAM,MAAM,IAAI,CAAA;AAC3D,IAAA,MAAM,YAAA,GAAe,CAAC,MAAA,KACpBA,KAAA,CAAY,WAAW,yBAAA,CAA0B,KAAA,EAAO,MAAM,CAAA,CAAE,IAAI,CAAA;AAEtE,IAAA,MAAM,EAAE,MAAK,GAAI,oBAAA;AAAA,MACf,KAAA;AAAA,MACA,QAAA;AAAA,MACA,WAAA;AAAA,MACA;AAAA,KACF;AACA,IAAA,cAAA,CAAe,IAAA,EAAM,CAAA,YAAA,EAAe,KAAA,CAAM,IAAI,CAAA,CAAA,CAAG,CAAA;AAEjD,IAAA,MAAM,IAAA,GACJ,MAAM,MAAA,GAASG,aAAA,CAAkB,MAAM,IAAI,CAAA,GAAIC,OAAA,CAAY,KAAA,CAAM,IAAI,CAAA;AAEvE,IAAA,MAAM,WAAA,GAAc,KAAK,GAAA,CAAI,CAAC,QAAQ,YAAA,CAAa,GAAA,EAAK,QAAQ,CAAC,CAAA;AACjE,IAAA,cAAA,CAAe,WAAA,EAAa,CAAA,YAAA,EAAe,KAAA,CAAM,IAAI,CAAA,CAAA,CAAG,CAAA;AACxD,IAAA,MAAM,CAAC,QAAA,EAAU,GAAG,aAAa,CAAA,GAAI,WAAA;AACrC,IAAA,MAAM,OAAA,GAAU,IAAA,CAAK,EAAA,CAAG,QAAA,EAAU,GAAG,aAAa,CAAA;AAElD,IAAA,IAAI,MAAM,KAAA,EAAO;AACf,MAAA,MAAM,GAAA,GAA+B;AAAA,QACnC,OAAA,EAAS,QAAA;AAAA,QACT,WAAA;AAAA,QACA;AAAA,OACF;AACA,MAAA,OAAA,CAAQ,KAAA;AAAA,QACN,aAAa,iBAAA,CAAkB,GAAA,EAAK,KAAA,CAAM,KAAK,GAAG,QAAQ;AAAA,OAC5D;AAAA,IACF;AAEA,IAAA,OAAO,OAAA;AAAA,EACT,CAAC,CAAA;AACH;AAEO,SAAS,4BAAA,CACd,OACA,OAAA,EAC+B;AAC/B,EAAA,MAAM,cAAc,OAAA,CAAQ,MAAA;AAAA,IAC1B,CAAC,KAAA,KACC,KAAA,CAAM,MAAA,KAAW,MAAA,IAAU,MAAM,MAAA,KAAW;AAAA,GAChD;AAEA,EAAA,OAAO,WAAA,CAAY,GAAA,CAAI,CAAC,KAAA,KAAU;AAChC,IAAA,MAAM,WAAA,GAAcJ,KAAA,CAAY,UAAA,CAAW,KAAA,CAAM,MAAM,IAAI,CAAA;AAC3D,IAAA,MAAM,YAAA,GAAe,CAAC,MAAA,KACpBA,KAAA,CAAY,WAAW,yBAAA,CAA0B,KAAA,EAAO,MAAM,CAAA,CAAE,IAAI,CAAA;AAEtE,IAAA,MAAM,EAAE,MAAK,GAAI,oBAAA;AAAA,MACf,KAAA;AAAA,MACA,QAAA;AAAA,MACA,WAAA;AAAA,MACA;AAAA,KACF;AACA,IAAA,cAAA,CAAe,IAAA,EAAM,CAAA,YAAA,EAAe,KAAA,CAAM,IAAI,CAAA,CAAA,CAAG,CAAA;AAEjD,IAAA,MAAM,IAAA,GACJ,MAAM,MAAA,GAASG,aAAA,CAAkB,MAAM,IAAI,CAAA,GAAIC,OAAA,CAAY,KAAA,CAAM,IAAI,CAAA;AAEvE,IAAA,MAAM,WAAA,GAAc,KAAK,GAAA,CAAI,CAAC,QAAQ,YAAA,CAAa,GAAA,EAAK,QAAQ,CAAC,CAAA;AACjE,IAAA,cAAA,CAAe,WAAA,EAAa,CAAA,YAAA,EAAe,KAAA,CAAM,IAAI,CAAA,CAAA,CAAG,CAAA;AACxD,IAAA,MAAM,CAAC,QAAA,EAAU,GAAG,aAAa,CAAA,GAAI,WAAA;AACrC,IAAA,MAAM,OAAA,GAAU,IAAA,CAAK,EAAA,CAAG,QAAA,EAAU,GAAG,aAAa,CAAA;AAElD,IAAA,IAAI,MAAM,KAAA,EAAO;AACf,MAAA,MAAM,GAAA,GAA+B;AAAA,QACnC,OAAA,EAAS,QAAA;AAAA,QACT,WAAA;AAAA,QACA;AAAA,OACF;AACA,MAAA,OAAA,CAAQ,KAAA;AAAA,QACN,aAAa,iBAAA,CAAkB,GAAA,EAAK,KAAA,CAAM,KAAK,GAAG,QAAQ;AAAA,OAC5D;AAAA,IACF;AAEA,IAAA,OAAO,OAAA;AAAA,EACT,CAAC,CAAA;AACH;AAEA,SAAS,yBAAA,CACP,OACA,MAAA,EACiB;AACjB,EAAA,QAAQ,MAAA;AAAQ,IACd,KAAK,UAAA,EAAY;AACf,MAAA,OAAO,KAAA,CAAM,OAAA;AAAA,IACf;AAAA,IACA,KAAK,MAAA,EAAQ;AACX,MAAA,OAAO,KAAA,CAAM,IAAA;AAAA,IACf;AAAA,IACA,KAAK,IAAA,EAAM;AACT,MAAA,OAAO,KAAA,CAAM,EAAA;AAAA,IACf;AAAA,IACA,KAAK,WAAA;AAAA,IACL,KAAK,SAAA;AAAA,IACL,KAAK,SAAA;AAAA,IACL,KAAK,OAAA,EAAS;AACZ,MAAA,MAAM,IAAI,KAAA,CAAM,CAAA,4CAAA,EAA+C,MAAM,CAAA,CAAE,CAAA;AAAA,IACzE;AAAA,IACA,KAAK,YAAA,EAAc;AACjB,MAAA,OAAO,KAAA,CAAM,SAAA;AAAA,IACf;AAAA,IACA,KAAK,YAAA,EAAc;AACjB,MAAA,OAAO,KAAA,CAAM,SAAA;AAAA,IACf;AAAA,IACA,KAAK,UAAA,EAAY;AACf,MAAA,OAAO,KAAA,CAAM,OAAA;AAAA,IACf;AAAA,IACA,KAAK,YAAA,EAAc;AACjB,MAAA,OAAO,KAAA,CAAM,SAAA;AAAA,IACf;AAAA,IACA,KAAK,YAAA,EAAc;AACjB,MAAA,OAAO,KAAA,CAAM,SAAA;AAAA,IACf;AAAA,IACA,KAAK,SAAA,EAAW;AACd,MAAA,OAAO,KAAA,CAAM,OAAA;AAAA,IACf;AAAA;AAEJ;AAEA,SAAS,yBAAA,CACP,OACA,MAAA,EACiB;AACjB,EAAA,QAAQ,MAAA;AAAQ,IACd,KAAK,UAAA,EAAY;AACf,MAAA,OAAO,KAAA,CAAM,OAAA;AAAA,IACf;AAAA,IACA,KAAK,MAAA,EAAQ;AACX,MAAA,OAAO,KAAA,CAAM,IAAA;AAAA,IACf;AAAA,IACA,KAAK,IAAA,EAAM;AACT,MAAA,OAAO,KAAA,CAAM,EAAA;AAAA,IACf;AAAA,IACA,KAAK,WAAA,EAAa;AAChB,MAAA,OAAO,KAAA,CAAM,QAAA;AAAA,IACf;AAAA,IACA,KAAK,SAAA,EAAW;AACd,MAAA,OAAO,KAAA,CAAM,MAAA;AAAA,IACf;AAAA,IACA,KAAK,SAAA,EAAW;AACd,MAAA,OAAO,KAAA,CAAM,MAAA;AAAA,IACf;AAAA,IACA,KAAK,OAAA,EAAS;AACZ,MAAA,OAAO,KAAA,CAAM,IAAA;AAAA,IACf;AAAA,IACA,KAAK,YAAA,EAAc;AACjB,MAAA,OAAO,KAAA,CAAM,SAAA;AAAA,IACf;AAAA,IACA,KAAK,YAAA,EAAc;AACjB,MAAA,OAAO,KAAA,CAAM,SAAA;AAAA,IACf;AAAA,IACA,KAAK,UAAA,EAAY;AACf,MAAA,OAAO,KAAA,CAAM,OAAA;AAAA,IACf;AAAA,IACA,KAAK,YAAA,EAAc;AACjB,MAAA,OAAO,KAAA,CAAM,SAAA;AAAA,IACf;AAAA,IACA,KAAK,YAAA,EAAc;AACjB,MAAA,OAAO,KAAA,CAAM,SAAA;AAAA,IACf;AAAA,IACA,KAAK,SAAA,EAAW;AACd,MAAA,MAAM,IAAI,KAAA,CAAM,CAAA,4CAAA,EAA+C,MAAM,CAAA,CAAE,CAAA;AAAA,IACzE;AAAA;AAEJ;AAuBA,SAAS,yBAAA,CACP,aACA,OAAA,EACsB;AACtB,EAAA,MAAM,iBAAiB,IAAI,GAAA;AAAA,IACzB,MAAA,CAAO,MAAA,CAAO,OAAO,CAAA,CAAE,GAAA,CAAI,CAAC,MAAA,KAAW,CAAC,MAAA,CAAO,IAAA,EAAM,MAAM,CAAC;AAAA,GAC9D;AACA,EAAA,MAAM,QAAA,GAAW,WAAA,CAAY,OAAA,CAAQ,GAAA,CAAI,CAAC,MAAA,KAAW;AACnD,IAAA,MAAM,KAAA,GAAQ,cAAA,CAAe,GAAA,CAAI,MAAM,CAAA;AACvC,IAAA,IAAI,UAAU,MAAA,EAAW;AACvB,MAAA,MAAM,IAAI,KAAA;AAAA,QACR,CAAA,cAAA,EAAiB,WAAA,CAAY,KAAK,CAAA,CAAA,EAAI,WAAA,CAAY,MAAM,CAAA,uBAAA,EACzC,MAAM,CAAA,MAAA,EAAS,WAAA,CAAY,KAAK,CAAA,sBAAA;AAAA,OACjD;AAAA,IACF;AACA,IAAA,OAAO,KAAA;AAAA,EACT,CAAC,CAAA;AAED,EAAA,OAAO,QAAA;AACT;AAQA,SAAS,wBAAA,CACP,QAAA,EACA,iBAAA,EACA,OAAA,EACA,YAAA,EACc;AACd,EAAA,OAAO,yBAAA,CAA0B,MAAA;AAAA,IAC/B,CAAC,WAAA,KAAgB,WAAA,CAAY,KAAA,KAAU;AAAA,GACzC,CAAE,GAAA;AAAA,IAAI,CAAC,gBACL,YAAA,CAAa,eAAA,CAAgB,mBAAmB,WAAA,CAAY,MAAM,CAAC,CAAA,CAAE,EAAA;AAAA,MACnE,GAAG,yBAAA,CAA0B,WAAA,EAAa,OAAO;AAAA;AACnD,GACF;AACF;AAEO,SAAS,8BAAA,CACd,QAAA,EACA,iBAAA,EACA,OAAA,EAC+B;AAC/B,EAAA,OAAO,wBAAA;AAAA,IACL,QAAA;AAAA,IACA,iBAAA;AAAA,IACA,OAAA;AAAA,IACA,CAAC,IAAA,KAASA,OAAA,CAAY,IAAI;AAAA,GAC5B;AACF;AAEO,SAAS,gCAAA,CACd,QAAA,EACA,iBAAA,EACA,OAAA,EAC2B;AAC3B,EAAA,OAAO,wBAAA;AAAA,IACL,QAAA;AAAA,IACA,iBAAA;AAAA,IACA,OAAA;AAAA,IACA,CAAC,IAAA,KAASF,KAAA,CAAQ,IAAI;AAAA,GACxB;AACF;AAqCA,SAAS,cAAA,CACP,QACA,KAAA,EACwC;AACxC,EAAA,IAAI,MAAA,CAAO,WAAW,CAAA,EAAG;AACvB,IAAA,MAAM,IAAI,KAAA,CAAM,CAAA,kCAAA,EAAqC,KAAK,CAAA,CAAA,CAAG,CAAA;AAAA,EAC/D;AACF","file":"chunk-PVFFH7TL.js","sourcesContent":["import { type SQL as DrizzleSql, sql as drizzleSql } from \"drizzle-orm\";\n\nimport { bindSqlValue } from \"../../../query/dialect/profile\";\nimport { type SqlDialect } from \"../../../query/dialect/types\";\nimport {\n  isSqlFragment,\n  renderSql,\n  type SqlFragment,\n  throwUnsupportedSqlChunk,\n} from \"../../../query/sql-fragment\";\n\nexport type ExecutableSql = DrizzleSql | SqlFragment;\n\nexport type CompiledSqlQuery = Readonly<{\n  params: readonly unknown[];\n  sql: string;\n}>;\n\nexport type PreparedSqlStatement = Readonly<{\n  execute: <TRow>(params: readonly unknown[]) => Promise<readonly TRow[]>;\n}>;\n\nexport type SqlExecutionAdapter = Readonly<{\n  compile: (query: ExecutableSql) => CompiledSqlQuery;\n  execute: <TRow>(query: ExecutableSql) => Promise<readonly TRow[]>;\n  executeCompiled?: <TRow>(\n    compiledQuery: CompiledSqlQuery,\n  ) => Promise<readonly TRow[]>;\n  prepare?: (sqlText: string) => PreparedSqlStatement;\n  /**\n   * Runs `critical` with exclusive use of the connection: no statement from\n   * anywhere else can interleave with the ones it issues.\n   *\n   * Statement-at-a-time serialization is not enough for a *sequence* that must\n   * be atomic. `SET LOCAL` around a query is the motivating case — snapshot,\n   * set, select, restore. Two searches whose statements merely take turns can\n   * still interleave as `A snapshot → B snapshot → A set → B set → A select`,\n   * and `A` then runs under `B`'s settings.\n   *\n   * `critical` is handed the unqueued adapter, so it must not attempt to\n   * re-enter the queue. Present only on transaction-scoped (serialized)\n   * adapters; a pooled adapter needs no exclusion because every statement gets\n   * its own connection.\n   */\n  runExclusive?: <T>(\n    critical: (connection: SqlExecutionAdapter) => Promise<T>,\n  ) => Promise<T>;\n}>;\n\ntype SqlCompiler = Readonly<{\n  sqlToQuery: (query: DrizzleSql) => CompiledSqlQuery;\n}>;\n\ntype DatabaseWithCompiler = Readonly<{\n  dialect?: SqlCompiler;\n}>;\n\ntype BackendName = \"PostgreSQL\" | \"SQLite\";\n\nconst DIALECT_BY_BACKEND_NAME = {\n  PostgreSQL: \"postgres\",\n  SQLite: \"sqlite\",\n} as const satisfies Record<BackendName, SqlDialect>;\n\nexport function compileQueryWithDialect(\n  db: unknown,\n  query: ExecutableSql,\n  backendName: BackendName,\n): CompiledSqlQuery {\n  if (isSqlFragment(query)) {\n    return renderSql(query, DIALECT_BY_BACKEND_NAME[backendName]);\n  }\n  const databaseWithCompiler = db as DatabaseWithCompiler;\n  const compiler = databaseWithCompiler.dialect;\n  if (compiler === undefined) {\n    throw new Error(`${backendName} backend is missing a SQL compiler`);\n  }\n  return compiler.sqlToQuery(query);\n}\n\n/**\n * Translates TypeGraph's fragment IR into Drizzle's adapter-native SQL object.\n *\n * Most execution paths render directly to text and parameters. Async SQLite\n * drivers expose only Drizzle's execution method, so that adapter needs this\n * lossless bridge at its final boundary.\n */\nexport function toDrizzleSql(\n  fragment: SqlFragment,\n  dialect: SqlDialect,\n): DrizzleSql {\n  const chunks = fragment.chunks.map((chunk) => {\n    switch (chunk.kind) {\n      case \"text\": {\n        return drizzleSql.raw(chunk.value);\n      }\n      case \"identifier\": {\n        // Drizzle's schema builders treat Name chunks as bare index-column\n        // references and omit dialect quoting. Preserve the portable IR's\n        // identifier semantics by handing the adapter an already-quoted,\n        // trusted SQL token instead.\n        return drizzleSql.raw(`\"${chunk.value.replaceAll('\"', '\"\"')}\"`);\n      }\n      case \"parameter\": {\n        return drizzleSql.param(bindSqlValue(chunk.value, dialect));\n      }\n      case \"placeholder\": {\n        return drizzleSql.placeholder(chunk.value.name);\n      }\n      default: {\n        return throwUnsupportedSqlChunk(chunk);\n      }\n    }\n  });\n  return drizzleSql.join(chunks);\n}\n","import { type SQLWrapper } from \"drizzle-orm\";\nimport {\n  index as pgIndex,\n  type IndexBuilder as PgIndexBuilder,\n  type PgColumn,\n  uniqueIndex as pgUniqueIndex,\n} from \"drizzle-orm/pg-core\";\nimport {\n  index as sqliteIndex,\n  type IndexBuilder as SqliteIndexBuilder,\n  type SQLiteColumn,\n  uniqueIndex as sqliteUniqueIndex,\n} from \"drizzle-orm/sqlite-core\";\n\nimport { toDrizzleSql } from \"../backend/drizzle/execution/types\";\nimport { sql as portableSql, type SqlFragment } from \"../query/sql-fragment\";\nimport {\n  compileEdgeIndexKeys,\n  compileIndexWhere,\n  compileNodeIndexKeys,\n  type IndexCompilationContext,\n} from \"./compiler\";\nimport {\n  SYSTEM_INDEX_DECLARATIONS,\n  type SystemIndexDeclaration,\n  systemIndexName,\n  type SystemIndexTable,\n} from \"./system\";\nimport {\n  type EdgeIndexDeclaration,\n  type IndexDeclaration,\n  type NodeIndexDeclaration,\n  type SystemColumnName,\n} from \"./types\";\n\n// ============================================================\n// PostgreSQL (Drizzle Schema)\n// ============================================================\n\nexport function buildPostgresNodeIndexBuilders(\n  table: NodeIndexTable,\n  indexes: readonly IndexDeclaration[],\n): readonly PgIndexBuilder[] {\n  // GIN-family declarations (method: \"gin\" / \"trigram\") are\n  // materialize-only — like pgvector ANN indexes, they are a pure\n  // materialization concern and never ride the Drizzle table extras.\n  const nodeIndexes = indexes.filter(\n    (index): index is NodeIndexDeclaration =>\n      index.entity === \"node\" && index.method === undefined,\n  );\n\n  return nodeIndexes.map((index) => {\n    const propsColumn = portableSql.identifier(table.props.name);\n    const systemColumn = (column: SystemColumnName): SqlFragment =>\n      portableSql.identifier(getPostgresNodeSystemColumn(table, column).name);\n\n    const { keys } = compileNodeIndexKeys(\n      index,\n      \"postgres\",\n      propsColumn,\n      systemColumn,\n    );\n    assertNonEmpty(keys, `node index \"${index.name}\"`);\n\n    const base = index.unique ? pgUniqueIndex(index.name) : pgIndex(index.name);\n\n    const drizzleKeys = keys.map((key) => toDrizzleSql(key, \"postgres\"));\n    assertNonEmpty(drizzleKeys, `node index \"${index.name}\"`);\n    const [firstKey, ...remainingKeys] = drizzleKeys;\n    const builder = base.on(firstKey, ...remainingKeys);\n\n    if (index.where) {\n      const ctx: IndexCompilationContext = {\n        dialect: \"postgres\",\n        propsColumn,\n        systemColumn,\n      };\n      builder.where(\n        toDrizzleSql(compileIndexWhere(ctx, index.where), \"postgres\"),\n      );\n    }\n\n    return builder;\n  });\n}\n\nexport function buildPostgresEdgeIndexBuilders(\n  table: EdgeIndexTable,\n  indexes: readonly IndexDeclaration[],\n): readonly PgIndexBuilder[] {\n  const edgeIndexes = indexes.filter(\n    (index): index is EdgeIndexDeclaration =>\n      index.entity === \"edge\" && index.method === undefined,\n  );\n\n  return edgeIndexes.map((index) => {\n    const propsColumn = portableSql.identifier(table.props.name);\n    const systemColumn = (column: SystemColumnName): SqlFragment =>\n      portableSql.identifier(getPostgresEdgeSystemColumn(table, column).name);\n\n    const { keys } = compileEdgeIndexKeys(\n      index,\n      \"postgres\",\n      propsColumn,\n      systemColumn,\n    );\n    assertNonEmpty(keys, `edge index \"${index.name}\"`);\n\n    const base = index.unique ? pgUniqueIndex(index.name) : pgIndex(index.name);\n\n    const drizzleKeys = keys.map((key) => toDrizzleSql(key, \"postgres\"));\n    assertNonEmpty(drizzleKeys, `edge index \"${index.name}\"`);\n    const [firstKey, ...remainingKeys] = drizzleKeys;\n    const builder = base.on(firstKey, ...remainingKeys);\n\n    if (index.where) {\n      const ctx: IndexCompilationContext = {\n        dialect: \"postgres\",\n        propsColumn,\n        systemColumn,\n      };\n      builder.where(\n        toDrizzleSql(compileIndexWhere(ctx, index.where), \"postgres\"),\n      );\n    }\n\n    return builder;\n  });\n}\n\nfunction getPostgresNodeSystemColumn(\n  table: NodeIndexTable,\n  column: SystemColumnName,\n): NamedSqlWrapper {\n  switch (column) {\n    case \"graph_id\": {\n      return table.graphId;\n    }\n    case \"kind\": {\n      return table.kind;\n    }\n    case \"id\": {\n      return table.id;\n    }\n    case \"from_kind\":\n    case \"from_id\":\n    case \"to_kind\":\n    case \"to_id\": {\n      throw new Error(`Unsupported node system column for indexes: ${column}`);\n    }\n    case \"deleted_at\": {\n      return table.deletedAt;\n    }\n    case \"valid_from\": {\n      return table.validFrom;\n    }\n    case \"valid_to\": {\n      return table.validTo;\n    }\n    case \"created_at\": {\n      return table.createdAt;\n    }\n    case \"updated_at\": {\n      return table.updatedAt;\n    }\n    case \"version\": {\n      return table.version;\n    }\n  }\n}\n\nfunction getPostgresEdgeSystemColumn(\n  table: EdgeIndexTable,\n  column: SystemColumnName,\n): NamedSqlWrapper {\n  switch (column) {\n    case \"graph_id\": {\n      return table.graphId;\n    }\n    case \"kind\": {\n      return table.kind;\n    }\n    case \"id\": {\n      return table.id;\n    }\n    case \"from_kind\": {\n      return table.fromKind;\n    }\n    case \"from_id\": {\n      return table.fromId;\n    }\n    case \"to_kind\": {\n      return table.toKind;\n    }\n    case \"to_id\": {\n      return table.toId;\n    }\n    case \"deleted_at\": {\n      return table.deletedAt;\n    }\n    case \"valid_from\": {\n      return table.validFrom;\n    }\n    case \"valid_to\": {\n      return table.validTo;\n    }\n    case \"created_at\": {\n      return table.createdAt;\n    }\n    case \"updated_at\": {\n      return table.updatedAt;\n    }\n    case \"version\": {\n      throw new Error(`Unsupported edge system column for indexes: ${column}`);\n    }\n  }\n}\n\n// ============================================================\n// SQLite (Drizzle Schema)\n// ============================================================\n\nexport function buildSqliteNodeIndexBuilders(\n  table: NodeIndexTable,\n  indexes: readonly IndexDeclaration[],\n): readonly SqliteIndexBuilder[] {\n  // GIN-family declarations (method: \"gin\" / \"trigram\") are\n  // materialize-only — like pgvector ANN indexes, they are a pure\n  // materialization concern and never ride the Drizzle table extras.\n  const nodeIndexes = indexes.filter(\n    (index): index is NodeIndexDeclaration =>\n      index.entity === \"node\" && index.method === undefined,\n  );\n\n  return nodeIndexes.map((index) => {\n    const propsColumn = portableSql.identifier(table.props.name);\n    const systemColumn = (column: SystemColumnName): SqlFragment =>\n      portableSql.identifier(getSqliteNodeSystemColumn(table, column).name);\n\n    const { keys } = compileNodeIndexKeys(\n      index,\n      \"sqlite\",\n      propsColumn,\n      systemColumn,\n    );\n    assertNonEmpty(keys, `node index \"${index.name}\"`);\n\n    const base =\n      index.unique ? sqliteUniqueIndex(index.name) : sqliteIndex(index.name);\n\n    const drizzleKeys = keys.map((key) => toDrizzleSql(key, \"sqlite\"));\n    assertNonEmpty(drizzleKeys, `node index \"${index.name}\"`);\n    const [firstKey, ...remainingKeys] = drizzleKeys;\n    const builder = base.on(firstKey, ...remainingKeys);\n\n    if (index.where) {\n      const ctx: IndexCompilationContext = {\n        dialect: \"sqlite\",\n        propsColumn,\n        systemColumn,\n      };\n      builder.where(\n        toDrizzleSql(compileIndexWhere(ctx, index.where), \"sqlite\"),\n      );\n    }\n\n    return builder;\n  });\n}\n\nexport function buildSqliteEdgeIndexBuilders(\n  table: EdgeIndexTable,\n  indexes: readonly IndexDeclaration[],\n): readonly SqliteIndexBuilder[] {\n  const edgeIndexes = indexes.filter(\n    (index): index is EdgeIndexDeclaration =>\n      index.entity === \"edge\" && index.method === undefined,\n  );\n\n  return edgeIndexes.map((index) => {\n    const propsColumn = portableSql.identifier(table.props.name);\n    const systemColumn = (column: SystemColumnName): SqlFragment =>\n      portableSql.identifier(getSqliteEdgeSystemColumn(table, column).name);\n\n    const { keys } = compileEdgeIndexKeys(\n      index,\n      \"sqlite\",\n      propsColumn,\n      systemColumn,\n    );\n    assertNonEmpty(keys, `edge index \"${index.name}\"`);\n\n    const base =\n      index.unique ? sqliteUniqueIndex(index.name) : sqliteIndex(index.name);\n\n    const drizzleKeys = keys.map((key) => toDrizzleSql(key, \"sqlite\"));\n    assertNonEmpty(drizzleKeys, `edge index \"${index.name}\"`);\n    const [firstKey, ...remainingKeys] = drizzleKeys;\n    const builder = base.on(firstKey, ...remainingKeys);\n\n    if (index.where) {\n      const ctx: IndexCompilationContext = {\n        dialect: \"sqlite\",\n        propsColumn,\n        systemColumn,\n      };\n      builder.where(\n        toDrizzleSql(compileIndexWhere(ctx, index.where), \"sqlite\"),\n      );\n    }\n\n    return builder;\n  });\n}\n\nfunction getSqliteNodeSystemColumn(\n  table: NodeIndexTable,\n  column: SystemColumnName,\n): NamedSqlWrapper {\n  switch (column) {\n    case \"graph_id\": {\n      return table.graphId;\n    }\n    case \"kind\": {\n      return table.kind;\n    }\n    case \"id\": {\n      return table.id;\n    }\n    case \"from_kind\":\n    case \"from_id\":\n    case \"to_kind\":\n    case \"to_id\": {\n      throw new Error(`Unsupported node system column for indexes: ${column}`);\n    }\n    case \"deleted_at\": {\n      return table.deletedAt;\n    }\n    case \"valid_from\": {\n      return table.validFrom;\n    }\n    case \"valid_to\": {\n      return table.validTo;\n    }\n    case \"created_at\": {\n      return table.createdAt;\n    }\n    case \"updated_at\": {\n      return table.updatedAt;\n    }\n    case \"version\": {\n      return table.version;\n    }\n  }\n}\n\nfunction getSqliteEdgeSystemColumn(\n  table: EdgeIndexTable,\n  column: SystemColumnName,\n): NamedSqlWrapper {\n  switch (column) {\n    case \"graph_id\": {\n      return table.graphId;\n    }\n    case \"kind\": {\n      return table.kind;\n    }\n    case \"id\": {\n      return table.id;\n    }\n    case \"from_kind\": {\n      return table.fromKind;\n    }\n    case \"from_id\": {\n      return table.fromId;\n    }\n    case \"to_kind\": {\n      return table.toKind;\n    }\n    case \"to_id\": {\n      return table.toId;\n    }\n    case \"deleted_at\": {\n      return table.deletedAt;\n    }\n    case \"valid_from\": {\n      return table.validFrom;\n    }\n    case \"valid_to\": {\n      return table.validTo;\n    }\n    case \"created_at\": {\n      return table.createdAt;\n    }\n    case \"updated_at\": {\n      return table.updatedAt;\n    }\n    case \"version\": {\n      throw new Error(`Unsupported edge system column for indexes: ${column}`);\n    }\n  }\n}\n\n// ============================================================\n// System indexes (both dialects)\n// ============================================================\n//\n// The schema factories derive their system-index Drizzle builders from\n// `SYSTEM_INDEX_DECLARATIONS` so both dialects emit the same index set by\n// construction. The builders receive the table's real column objects (not\n// SQL wrappers) so the DDL generator renders plain quoted column names —\n// byte-identical to the runtime DDL `materializeSystemIndexes` emits.\n\ntype SystemIndexColumns<C extends { name: string }> = Readonly<\n  Record<string, C>\n>;\n\n/**\n * Resolves a declaration's physical column names against the table's own\n * column objects by each column's `.name` — the SQL name Drizzle carries on\n * the column itself — so no naming convention sits between the declaration\n * and the schema. A column the table doesn't define throws at\n * table-construction time (exercised by the system-index parity tests).\n */\nfunction resolveSystemIndexColumns<C extends { name: string }>(\n  declaration: SystemIndexDeclaration,\n  columns: SystemIndexColumns<C>,\n): readonly [C, ...C[]] {\n  const byPhysicalName = new Map(\n    Object.values(columns).map((column) => [column.name, column]),\n  );\n  const resolved = declaration.columns.map((column) => {\n    const value = byPhysicalName.get(column);\n    if (value === undefined) {\n      throw new Error(\n        `System index \"${declaration.table}_${declaration.suffix}\" references ` +\n          `a column \"${column}\" the ${declaration.table} table does not define`,\n      );\n    }\n    return value;\n  });\n  // `declaration.columns` is non-empty by type, so `resolved` is too.\n  return resolved as [C, ...C[]];\n}\n\n/**\n * The two dialect variants do no dialect-specific work (no unique, no\n * where, no expression compilation — unlike the node/edge builder pairs\n * above), so they share one body parameterized by the dialect's index\n * factory.\n */\nfunction buildSystemIndexBuilders<C extends { name: string }, B>(\n  tableKey: SystemIndexTable,\n  physicalTableName: string,\n  columns: SystemIndexColumns<C>,\n  indexFactory: (name: string) => { on: (...cols: [C, ...C[]]) => B },\n): readonly B[] {\n  return SYSTEM_INDEX_DECLARATIONS.filter(\n    (declaration) => declaration.table === tableKey,\n  ).map((declaration) =>\n    indexFactory(systemIndexName(physicalTableName, declaration.suffix)).on(\n      ...resolveSystemIndexColumns(declaration, columns),\n    ),\n  );\n}\n\nexport function buildSqliteSystemIndexBuilders(\n  tableKey: SystemIndexTable,\n  physicalTableName: string,\n  columns: SystemIndexColumns<SQLiteColumn>,\n): readonly SqliteIndexBuilder[] {\n  return buildSystemIndexBuilders(\n    tableKey,\n    physicalTableName,\n    columns,\n    (name) => sqliteIndex(name),\n  );\n}\n\nexport function buildPostgresSystemIndexBuilders(\n  tableKey: SystemIndexTable,\n  physicalTableName: string,\n  columns: SystemIndexColumns<PgColumn>,\n): readonly PgIndexBuilder[] {\n  return buildSystemIndexBuilders(\n    tableKey,\n    physicalTableName,\n    columns,\n    (name) => pgIndex(name),\n  );\n}\n\n// ============================================================\n// Minimal table shapes (shared between dialect schemas)\n// ============================================================\n\ntype NamedSqlWrapper = SQLWrapper & Readonly<{ name: string }>;\n\ntype NodeIndexTable = Readonly<{\n  graphId: NamedSqlWrapper;\n  kind: NamedSqlWrapper;\n  id: NamedSqlWrapper;\n  props: NamedSqlWrapper;\n  version: NamedSqlWrapper;\n  validFrom: NamedSqlWrapper;\n  validTo: NamedSqlWrapper;\n  createdAt: NamedSqlWrapper;\n  updatedAt: NamedSqlWrapper;\n  deletedAt: NamedSqlWrapper;\n}>;\n\ntype EdgeIndexTable = Readonly<{\n  graphId: NamedSqlWrapper;\n  id: NamedSqlWrapper;\n  kind: NamedSqlWrapper;\n  fromKind: NamedSqlWrapper;\n  fromId: NamedSqlWrapper;\n  toKind: NamedSqlWrapper;\n  toId: NamedSqlWrapper;\n  props: NamedSqlWrapper;\n  validFrom: NamedSqlWrapper;\n  validTo: NamedSqlWrapper;\n  createdAt: NamedSqlWrapper;\n  updatedAt: NamedSqlWrapper;\n  deletedAt: NamedSqlWrapper;\n}>;\n\nfunction assertNonEmpty<T>(\n  values: readonly T[],\n  label: string,\n): asserts values is readonly [T, ...T[]] {\n  if (values.length === 0) {\n    throw new Error(`Index must have at least one key (${label})`);\n  }\n}\n"]}

package/dist/chunk-QCD5JKU4.cjs

@@ -0,0 +1,15 @@
+'use strict';
+
+// src/backend/sqlite/local-options.ts
+var DEFAULT_LOCAL_SQLITE_PRAGMAS = {
+  journalMode: "wal",
+  synchronous: "normal",
+  busyTimeoutMs: 5e3,
+  cacheSizeKib: void 0,
+  mmapSizeBytes: void 0,
+  walAutocheckpointPages: void 0
+};
+
+exports.DEFAULT_LOCAL_SQLITE_PRAGMAS = DEFAULT_LOCAL_SQLITE_PRAGMAS;
+//# sourceMappingURL=chunk-QCD5JKU4.cjs.map
+//# sourceMappingURL=chunk-QCD5JKU4.cjs.map

package/dist/chunk-QCD5JKU4.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/backend/sqlite/local-options.ts"],"names":[],"mappings":";;;AA8BO,IAAM,4BAAA,GACX;AAAA,EACE,WAAA,EAAa,KAAA;AAAA,EACb,WAAA,EAAa,QAAA;AAAA,EACb,aAAA,EAAe,GAAA;AAAA,EACf,YAAA,EAAc,MAAA;AAAA,EACd,aAAA,EAAe,MAAA;AAAA,EACf,sBAAA,EAAwB;AAC1B","file":"chunk-QCD5JKU4.cjs","sourcesContent":["/** Journal modes accepted by local SQLite connections. */\nexport type LocalSqliteJournalMode =\n  \"wal\" | \"delete\" | \"truncate\" | \"persist\" | \"memory\" | \"off\";\n\n/** Synchronous levels accepted by local SQLite connections. */\nexport type LocalSqliteSynchronousMode = \"off\" | \"normal\" | \"full\" | \"extra\";\n\n/** Connection pragmas applied when TypeGraph opens a local SQLite database. */\nexport type LocalSqlitePragmaOptions = Readonly<{\n  /** `PRAGMA journal_mode`. Default: `\"wal\"` (no-op on `\":memory:\"`). */\n  journalMode?: LocalSqliteJournalMode;\n  /** `PRAGMA synchronous`. Default: `\"normal\"`. */\n  synchronous?: LocalSqliteSynchronousMode;\n  /** `PRAGMA busy_timeout`, in milliseconds. Default: `5000`. */\n  busyTimeoutMs?: number;\n  /**\n   * `PRAGMA cache_size`, expressed as a negative KiB value. Positive values\n   * mean pages in SQLite and are rejected to prevent accidental oversizing.\n   */\n  cacheSizeKib?: number | undefined;\n  /** `PRAGMA mmap_size`, in non-negative bytes. */\n  mmapSizeBytes?: number | undefined;\n  /**\n   * `PRAGMA wal_autocheckpoint`, in WAL pages. Use `0` to disable automatic\n   * checkpoints and run them explicitly after controlled bulk loads.\n   */\n  walAutocheckpointPages?: number | undefined;\n}>;\n\n/** Defaults for TypeGraph-owned local SQLite connections. */\nexport const DEFAULT_LOCAL_SQLITE_PRAGMAS: Required<LocalSqlitePragmaOptions> =\n  {\n    journalMode: \"wal\",\n    synchronous: \"normal\",\n    busyTimeoutMs: 5000,\n    cacheSizeKib: undefined,\n    mmapSizeBytes: undefined,\n    walAutocheckpointPages: undefined,\n  };\n"]}

package/dist/{chunk-UGHG7PGX.js → chunk-QG5VEOKX.js}

@@ -1,4 +1,6 @@
-import { ConfigurationError } from './chunk-ZLONH2UD.js';
+import { carryFirstPartyFactoryMark } from './chunk-LKZDQ2B4.js';
+import { ConfigurationError } from './chunk-YDEJQWOL.js';
+import { createDataKeyedBag } from './chunk-DYATYRY4.js';
 
 // src/backend/graph-backend-keys.ts
 var GRAPH_BACKEND_PROJECTION_KEYS = [
@@ -41,8 +43,13 @@ var GRAPH_BACKEND_PROJECTION_KEYS = [
   "insertUniqueBatch",
   "deleteUnique",
   "hardDeleteUniquesByNodeIds",
+  "hardDeleteUniquesByConcreteKind",
   "checkUnique",
   "checkUniqueBatch",
+  "claimEdgeCardinality",
+  "claimEdgeCardinalityBatch",
+  "purgeEdgeClaims",
+  "readConstraintFenceViolations",
   "getActiveSchema",
   "getSchemaVersion",
   "commitSchemaVersion",
@@ -94,6 +101,7 @@ var GRAPH_BACKEND_PROJECTION_KEYS = [
   "ensureFulltextTable",
   "ensureIdentityTables",
   "identityTableDdl",
+  "recordedTableDdl",
   "getReconciliationMarker",
   "setReconciliationMarker",
   "clearGraph",
@@ -106,6 +114,7 @@ var GRAPH_BACKEND_PROJECTION_KEYS = [
   "executeRaw",
   "compileSql",
   "executeDdl",
+  "ensureExtension",
   "transaction",
   "close"
 ];
@@ -279,6 +288,7 @@ function deriveBackend(base, overrides) {
     }
   });
   carryBackendResourceAudit(decoratedBackend, base);
+  carryFirstPartyFactoryMark(decoratedBackend, base);
   return decoratedBackend;
 }
 function projectBackend(base, keys) {
@@ -288,6 +298,7 @@ function projectBackend(base, keys) {
   });
   const projection = Object.fromEntries(entries);
   carryBackendResourceAudit(projection, base);
+  carryFirstPartyFactoryMark(projection, base);
   return projection;
 }
 function projectGraphBackend(base) {
@@ -563,6 +574,21 @@ function parseDimensionMismatch(error) {
   return void 0;
 }
 
+// src/schema/canonical.ts
+function sortedReplacer(_key, value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    const sorted = createDataKeyedBag();
+    for (const key of Object.keys(value).toSorted()) {
+      sorted[key] = value[key];
+    }
+    return sorted;
+  }
+  return value;
+}
+function canonicalEqual(a, b) {
+  return JSON.stringify(a, sortedReplacer) === JSON.stringify(b, sortedReplacer);
+}
+
 // src/utils/array.ts
 function chunk(items, size) {
   if (!Number.isSafeInteger(size) || size < 1) {
@@ -587,6 +613,6 @@ function groupBy(items, keyFor) {
   return groups;
 }
 
-export { acquireSerializedStreamLease, auditBackendResource, chunk, deriveBackend, errorChain, groupBy, isDuplicatePrimaryKeyError, isInsufficientResourcesError, isMissingTableError, isPostgresConcurrentDdlRaceError, isSqliteNotAuthorizedError, isSqliteStaleSnapshotError, parseDimensionMismatch, postgresReadWriteRefusedSqlState, postgresTemporaryTableUnavailableSqlState, projectBackend, projectGraphBackend, resolveDeclaredBackendResource, snapshotExportContention, withRecordedRelationsPrecondition, wrapWithManagedClose };
-//# sourceMappingURL=chunk-UGHG7PGX.js.map
-//# sourceMappingURL=chunk-UGHG7PGX.js.map
+export { acquireSerializedStreamLease, auditBackendResource, canonicalEqual, chunk, deriveBackend, errorChain, groupBy, isDuplicatePrimaryKeyError, isInsufficientResourcesError, isMissingTableError, isPostgresConcurrentDdlRaceError, isSqliteNotAuthorizedError, isSqliteStaleSnapshotError, parseDimensionMismatch, postgresReadWriteRefusedSqlState, postgresTemporaryTableUnavailableSqlState, projectBackend, projectGraphBackend, resolveDeclaredBackendResource, snapshotExportContention, sortedReplacer, withRecordedRelationsPrecondition, wrapWithManagedClose };
+//# sourceMappingURL=chunk-QG5VEOKX.js.map
+//# sourceMappingURL=chunk-QG5VEOKX.js.map