@nicia-ai/typegraph 0.27.0 → 0.28.1

package/dist/chunk-FFHW2JEK.cjs

@@ -0,0 +1,55 @@
+'use strict';
+
+// src/schema/canonical.ts
+function sortedReplacer(_key, value) {
+  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+    const sorted = {};
+    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/sql-errors.ts
+var MISSING_TABLE_PATTERNS = [
+  "no such table",
+  // SQLite
+  "does not exist",
+  // PostgreSQL ("relation ... does not exist")
+  "SQLITE_ERROR"
+  // D1 / Durable Objects error code
+];
+var POSTGRES_UNDEFINED_TABLE_CODE = "42P01";
+function* errorChain(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  while (current !== void 0 && current !== null && !seen.has(current)) {
+    seen.add(current);
+    yield current;
+    current = current instanceof Error ? current.cause : void 0;
+  }
+}
+function isPostgresUndefinedTable(link) {
+  return typeof link === "object" && link !== null && "code" in link && link.code === POSTGRES_UNDEFINED_TABLE_CODE;
+}
+function isMissingTableError(error) {
+  for (const link of errorChain(error)) {
+    if (isPostgresUndefinedTable(link)) return true;
+    const message = link instanceof Error ? link.message : String(link);
+    if (MISSING_TABLE_PATTERNS.some((pattern) => message.includes(pattern))) {
+      return true;
+    }
+  }
+  return false;
+}
+
+exports.canonicalEqual = canonicalEqual;
+exports.isMissingTableError = isMissingTableError;
+exports.sortedReplacer = sortedReplacer;
+//# sourceMappingURL=chunk-FFHW2JEK.cjs.map
+//# sourceMappingURL=chunk-FFHW2JEK.cjs.map

package/dist/chunk-FFHW2JEK.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/schema/canonical.ts","../src/utils/sql-errors.ts"],"names":[],"mappings":";;;AAiBO,SAAS,cAAA,CAAe,MAAc,KAAA,EAAyB;AACpE,EAAA,IAAI,KAAA,KAAU,QAAQ,OAAO,KAAA,KAAU,YAAY,CAAC,KAAA,CAAM,OAAA,CAAQ,KAAK,CAAA,EAAG;AACxE,IAAA,MAAM,SAAkC,EAAC;AACzC,IAAA,KAAA,MAAW,OAAO,MAAA,CAAO,IAAA,CAAK,KAAK,CAAA,CAAE,UAAS,EAAG;AAC/C,MAAA,MAAA,CAAO,GAAG,CAAA,GAAK,KAAA,CAAkC,GAAG,CAAA;AAAA,IACtD;AACA,IAAA,OAAO,MAAA;AAAA,EACT;AACA,EAAA,OAAO,KAAA;AACT;AAaO,SAAS,cAAA,CAAe,GAAY,CAAA,EAAqB;AAC9D,EAAA,OACE,IAAA,CAAK,UAAU,CAAA,EAAG,cAAc,MAAM,IAAA,CAAK,SAAA,CAAU,GAAG,cAAc,CAAA;AAE1E;;;ACtBA,IAAM,sBAAA,GAAyB;AAAA,EAC7B,eAAA;AAAA;AAAA,EACA,gBAAA;AAAA;AAAA,EACA;AAAA;AACF,CAAA;AASA,IAAM,6BAAA,GAAgC,OAAA;AAOtC,UAAU,WAAW,KAAA,EAAgD;AACnE,EAAA,MAAM,IAAA,uBAAW,GAAA,EAAa;AAC9B,EAAA,IAAI,OAAA,GAAmB,KAAA;AACvB,EAAA,OAAO,OAAA,KAAY,UAAa,OAAA,KAAY,IAAA,IAAQ,CAAC,IAAA,CAAK,GAAA,CAAI,OAAO,CAAA,EAAG;AACtE,IAAA,IAAA,CAAK,IAAI,OAAO,CAAA;AAChB,IAAA,MAAM,OAAA;AACN,IAAA,OAAA,GAAU,OAAA,YAAmB,KAAA,GAAQ,OAAA,CAAQ,KAAA,GAAQ,MAAA;AAAA,EACvD;AACF;AAMA,SAAS,yBAAyB,IAAA,EAAwB;AACxD,EAAA,OACE,OAAO,SAAS,QAAA,IAChB,IAAA,KAAS,QACT,MAAA,IAAU,IAAA,IACT,KAAsC,IAAA,KACrC,6BAAA;AAEN;AAEO,SAAS,oBAAoB,KAAA,EAAyB;AAC3D,EAAA,KAAA,MAAW,IAAA,IAAQ,UAAA,CAAW,KAAK,CAAA,EAAG;AACpC,IAAA,IAAI,wBAAA,CAAyB,IAAI,CAAA,EAAG,OAAO,IAAA;AAC3C,IAAA,MAAM,UAAU,IAAA,YAAgB,KAAA,GAAQ,IAAA,CAAK,OAAA,GAAU,OAAO,IAAI,CAAA;AAClE,IAAA,IAAI,sBAAA,CAAuB,KAAK,CAAC,OAAA,KAAY,QAAQ,QAAA,CAAS,OAAO,CAAC,CAAA,EAAG;AACvE,MAAA,OAAO,IAAA;AAAA,IACT;AAAA,EACF;AACA,EAAA,OAAO,KAAA;AACT","file":"chunk-FFHW2JEK.cjs","sourcesContent":["/**\n * Canonical-form helpers for deterministic schema serialization.\n *\n * Used by both content-hashing (`computeSchemaHash`) and structural diffing\n * (`computeSchemaDiff`) to ensure that semantically-equivalent objects with\n * differently-ordered keys produce identical canonical strings.\n */\n\n/**\n * `JSON.stringify` replacer that sorts object keys recursively.\n *\n * Apply via `JSON.stringify(value, sortedReplacer)` to obtain output in\n * which sibling keys at every depth appear in lexicographic order.\n *\n * Arrays are passed through unchanged — array order is semantically\n * meaningful and must not be normalized.\n */\nexport function sortedReplacer(_key: string, value: unknown): unknown {\n  if (value !== null && typeof value === \"object\" && !Array.isArray(value)) {\n    const sorted: Record<string, unknown> = {};\n    for (const key of Object.keys(value).toSorted()) {\n      sorted[key] = (value as Record<string, unknown>)[key];\n    }\n    return sorted;\n  }\n  return value;\n}\n\n/**\n * Compare two values for canonical-form equality.\n *\n * Returns `true` when both values produce identical JSON under `sortedReplacer`\n * — i.e., they have the same JSON structure regardless of object key order.\n * Used by diff machinery to detect semantic changes in JSON-shaped fields.\n *\n * Note: callers must handle `undefined` themselves — `JSON.stringify(undefined)`\n * returns `undefined`, so two `undefined` inputs would compare equal here, which\n * may or may not be the desired semantics depending on context.\n */\nexport function canonicalEqual(a: unknown, b: unknown): boolean {\n  return (\n    JSON.stringify(a, sortedReplacer) === JSON.stringify(b, sortedReplacer)\n  );\n}\n","/**\n * Cross-dialect detection of \"this relation does not exist yet\" errors.\n *\n * Shared so the schema bootstrap (`loadActiveSchemaWithBootstrap`) and\n * the durable contribution-materialization gate (#135) agree on what a\n * missing-table failure looks like, and — critically — so neither one\n * swallows a genuine system fault (connection/permission/driver error)\n * as a benign \"not bootstrapped yet\".\n *\n * Detection walks the error's `cause` chain because Drizzle (>= the\n * `DrizzleQueryError` era, drizzle-orm ≥ 0.36) wraps every failure from a\n * query-builder call (`db.select()`, `db.insert()`, …): the wrapper's\n * `.message` becomes the failed query text and the real driver error —\n * which carries both the missing-relation text and the SQLSTATE — is\n * preserved on `.cause`. node-postgres / postgres-js nest the pg error\n * one link deep; better-sqlite3 throws it unwrapped; raw `client.query()`\n * fast paths surface it directly. Walking the chain makes the check\n * wrapper- and driver-agnostic instead of only matching the outermost\n * `.message`, which on Postgres is just the SQL string.\n */\n\nconst MISSING_TABLE_PATTERNS = [\n  \"no such table\", // SQLite\n  \"does not exist\", // PostgreSQL (\"relation ... does not exist\")\n  \"SQLITE_ERROR\", // D1 / Durable Objects error code\n] as const;\n\n/**\n * SQLSTATE for PostgreSQL `undefined_table`. Preferred over the\n * human-readable message: it is locale-independent (the \"... does not\n * exist\" text is translated under a non-English `lc_messages`) and is\n * preserved on the underlying driver error even when Drizzle overwrites\n * `.message` with the query text.\n */\nconst POSTGRES_UNDEFINED_TABLE_CODE = \"42P01\";\n\n/**\n * Yields an error and each error reachable by following `.cause`,\n * outermost first. `seen` guards the pathological cyclic-cause case so a\n * self-referential chain can't spin forever.\n */\nfunction* errorChain(error: unknown): Generator<unknown, void, void> {\n  const seen = new Set<unknown>();\n  let current: unknown = error;\n  while (current !== undefined && current !== null && !seen.has(current)) {\n    seen.add(current);\n    yield current;\n    current = current instanceof Error ? current.cause : undefined;\n  }\n}\n\n/**\n * Whether a single chain link is a PostgreSQL `undefined_table` failure,\n * identified by its SQLSTATE rather than a message substring.\n */\nfunction isPostgresUndefinedTable(link: unknown): boolean {\n  return (\n    typeof link === \"object\" &&\n    link !== null &&\n    \"code\" in link &&\n    (link as Readonly<{ code?: unknown }>).code ===\n      POSTGRES_UNDEFINED_TABLE_CODE\n  );\n}\n\nexport function isMissingTableError(error: unknown): boolean {\n  for (const link of errorChain(error)) {\n    if (isPostgresUndefinedTable(link)) return true;\n    const message = link instanceof Error ? link.message : String(link);\n    if (MISSING_TABLE_PATTERNS.some((pattern) => message.includes(pattern))) {\n      return true;\n    }\n  }\n  return false;\n}\n"]}

package/dist/{chunk-DN4RUDF3.cjs → chunk-LYRUNG6E.cjs}

@@ -48,5 +48,5 @@ exports.POSTGRES_CAPABILITIES = POSTGRES_CAPABILITIES;
 exports.SQLITE_CAPABILITIES = SQLITE_CAPABILITIES;
 exports.runOptionallyInTransaction = runOptionallyInTransaction;
 exports.wrapWithManagedClose = wrapWithManagedClose;
-//# sourceMappingURL=chunk-DN4RUDF3.cjs.map
-//# sourceMappingURL=chunk-DN4RUDF3.cjs.map
+//# sourceMappingURL=chunk-LYRUNG6E.cjs.map
+//# sourceMappingURL=chunk-LYRUNG6E.cjs.map

package/dist/chunk-LYRUNG6E.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/backend/types.ts"],"names":[],"mappings":";;;AAgqCO,SAAS,oBAAA,CACd,SACA,QAAA,EACc;AACd,EAAA,IAAI,QAAA,GAAW,KAAA;AACf,EAAA,OAAO;AAAA,IACL,GAAG,OAAA;AAAA,IACH,MAAM,KAAA,GAAuB;AAC3B,MAAA,IAAI,QAAA,EAAU;AACd,MAAA,QAAA,GAAW,IAAA;AACX,MAAA,MAAM,QAAQ,KAAA,EAAM;AACpB,MAAA,MAAM,QAAA,EAAS;AAAA,IACjB;AAAA,GACF;AACF;AAeA,eAAsB,0BAAA,CACpB,OAAA,EACA,EAAA,EACA,QAAA,EACY;AACZ,EAAA,IAAI,CAAC,OAAA,CAAQ,YAAA,CAAa,YAAA,EAAc;AACtC,IAAA,OAAO,EAAA,CAAG,YAAY,OAAO,CAAA;AAAA,EAC/B;AACA,EAAA,OAAO,QAAQ,WAAA,CAAY,CAAC,EAAA,KAAO,EAAA,CAAG,EAAE,CAAC,CAAA;AAC3C;AA4OO,IAAM,mBAAA,GAA2C;AAAA,EACtD,KAAA,EAAO,KAAA;AAAA;AAAA,EACP,cAAA,EAAgB,IAAA;AAAA;AAAA,EAChB,UAAA,EAAY,KAAA;AAAA;AAAA,EACZ,GAAA,EAAK,IAAA;AAAA;AAAA,EACL,SAAA,EAAW,IAAA;AAAA;AAAA,EACX,YAAA,EAAc;AAAA;AAChB;AAKO,IAAM,qBAAA,GAA6C;AAAA,EACxD,KAAA,EAAO,IAAA;AAAA;AAAA,EACP,cAAA,EAAgB,IAAA;AAAA,EAChB,UAAA,EAAY,IAAA;AAAA,EACZ,GAAA,EAAK,IAAA;AAAA,EACL,SAAA,EAAW,IAAA;AAAA,EACX,YAAA,EAAc;AAAA;AAChB","file":"chunk-LYRUNG6E.cjs","sourcesContent":["/**\n * Backend interface types for TypeGraph storage.\n *\n * The backend abstracts database operations, allowing different\n * SQL implementations (SQLite, PostgreSQL) behind a common interface.\n */\nimport { type SQL } from \"drizzle-orm\";\n\nimport {\n  type IndexEntity,\n  type KindEntity,\n  type TemporalMode,\n} from \"../core/types\";\nimport { type SqlTableNames } from \"../query/compiler/schema\";\nimport { type FulltextStrategy } from \"../query/dialect/fulltext-strategy\";\nimport { type SerializedSchema } from \"../schema/types\";\nimport {\n  type AnyPgDatabase,\n  type AnySqliteDatabase,\n} from \"./drizzle/execution\";\n\n// ============================================================\n// Vector Search Types\n// ============================================================\n\n/**\n * Supported vector similarity metrics.\n */\nexport type VectorMetric = \"cosine\" | \"l2\" | \"inner_product\";\n\n/**\n * Supported vector index types.\n */\nexport type VectorIndexType = \"hnsw\" | \"ivfflat\" | \"none\";\n\n/**\n * Vector search capabilities.\n */\nexport type VectorCapabilities = Readonly<{\n  /** Whether the backend supports vector operations */\n  supported: boolean;\n  /** Supported similarity metrics */\n  metrics: readonly VectorMetric[];\n  /** Supported index types */\n  indexTypes: readonly VectorIndexType[];\n  /** Maximum dimensions supported */\n  maxDimensions: number;\n}>;\n\n// ============================================================\n// Fulltext Search Types\n// ============================================================\n\n/**\n * Query modes for fulltext search.\n *\n * - \"websearch\": Google-style syntax (quoted phrases, +required, -excluded).\n *    Postgres: `websearch_to_tsquery`. SQLite: translated to FTS5 MATCH.\n * - \"phrase\": treats the whole query as a phrase.\n *    Postgres: `phraseto_tsquery`. SQLite: FTS5 `\"...\"` phrase.\n * - \"plain\": splits on whitespace and ANDs terms.\n *    Postgres: `plainto_tsquery`. SQLite: default FTS5 AND.\n * - \"raw\": dialect-native syntax passed through unchanged.\n */\nexport type FulltextQueryMode = \"websearch\" | \"phrase\" | \"plain\" | \"raw\";\n\n/**\n * Fulltext search capabilities declared by a backend.\n */\nexport type FulltextCapabilities = Readonly<{\n  /** Whether the backend supports fulltext operations */\n  supported: boolean;\n  /**\n   * Language / tokenizer names understood by this backend.\n   * Postgres: installed regconfigs (english, simple, ...).\n   * SQLite FTS5: tokenizer names (unicode61, porter, trigram).\n   */\n  languages: readonly string[];\n  /** Whether phrase queries are supported. */\n  phraseQueries: boolean;\n  /** Whether prefix (`foo*`) queries are supported. */\n  prefixQueries: boolean;\n  /** Whether highlighting / snippets are supported. */\n  highlighting: boolean;\n}>;\n\n// ============================================================\n// SQL Dialect & Capabilities\n// ============================================================\n\nimport { type SqlDialect } from \"../query/dialect/types\";\n\nexport type { SqlDialect } from \"../query/dialect/types\";\n\n/**\n * Backend capabilities that vary by dialect.\n */\nexport type BackendCapabilities = Readonly<{\n  /** Whether the backend supports JSONB type (vs TEXT for JSON) */\n  jsonb: boolean;\n  /** Whether the backend supports partial indexes */\n  partialIndexes: boolean;\n  /** Whether the backend supports GIN indexes for JSON */\n  ginIndexes: boolean;\n  /** Whether the backend supports CTE (WITH) queries */\n  cte: boolean;\n  /** Whether the backend supports RETURNING clause */\n  returning: boolean;\n  /** Whether the backend supports atomic transactions (D1 does not) */\n  transactions: boolean;\n  /** Vector search capabilities (undefined if not configured) */\n  vector?: VectorCapabilities | undefined;\n  /** Fulltext search capabilities (undefined if not configured) */\n  fulltext?: FulltextCapabilities | undefined;\n}>;\n\n// ============================================================\n// Row Types (Database Records)\n// ============================================================\n\n/**\n * A row from the typegraph_nodes table.\n */\nexport type NodeRow = Readonly<{\n  graph_id: string;\n  kind: string;\n  id: string;\n  props: string; // JSON string\n  version: number;\n  valid_from: string | undefined;\n  valid_to: string | undefined;\n  created_at: string;\n  updated_at: string;\n  deleted_at: string | undefined;\n}>;\n\n/**\n * A row from the typegraph_edges table.\n */\nexport type EdgeRow = Readonly<{\n  graph_id: string;\n  id: string;\n  kind: string;\n  from_kind: string;\n  from_id: string;\n  to_kind: string;\n  to_id: string;\n  props: string; // JSON string\n  valid_from: string | undefined;\n  valid_to: string | undefined;\n  created_at: string;\n  updated_at: string;\n  deleted_at: string | undefined;\n}>;\n\n/**\n * A row from the typegraph_node_uniques table.\n */\nexport type UniqueRow = Readonly<{\n  graph_id: string;\n  node_kind: string;\n  constraint_name: string;\n  key: string;\n  node_id: string;\n  concrete_kind: string;\n  deleted_at: string | undefined;\n}>;\n\n/**\n * A row from the typegraph_schema_versions table.\n */\nexport type SchemaVersionRow = Readonly<{\n  graph_id: string;\n  version: number;\n  schema_hash: string;\n  schema_doc: string; // JSON string\n  created_at: string;\n  is_active: boolean;\n}>;\n\n/**\n * A row from the typegraph_node_embeddings table.\n */\nexport type EmbeddingRow = Readonly<{\n  graph_id: string;\n  node_kind: string;\n  node_id: string;\n  field_path: string;\n  embedding: readonly number[];\n  dimensions: number;\n  created_at: string;\n  updated_at: string;\n}>;\n\n// ============================================================\n// Insert Parameters\n// ============================================================\n\n/**\n * Parameters for inserting a node.\n */\nexport type InsertNodeParams = Readonly<{\n  graphId: string;\n  kind: string;\n  id: string;\n  props: Readonly<Record<string, unknown>>;\n  validFrom?: string;\n  validTo?: string;\n}>;\n\n/**\n * Parameters for updating a node.\n */\nexport type UpdateNodeParams = Readonly<{\n  graphId: string;\n  kind: string;\n  id: string;\n  props: Readonly<Record<string, unknown>>;\n  validTo?: string;\n  incrementVersion?: boolean;\n  /** If true, clears deleted_at (un-deletes the node). Used by upsert. */\n  clearDeleted?: boolean;\n}>;\n\n/**\n * Parameters for deleting a node (soft delete).\n */\nexport type DeleteNodeParams = Readonly<{\n  graphId: string;\n  kind: string;\n  id: string;\n}>;\n\n/**\n * Parameters for inserting an edge.\n */\nexport type InsertEdgeParams = Readonly<{\n  graphId: string;\n  id: string;\n  kind: string;\n  fromKind: string;\n  fromId: string;\n  toKind: string;\n  toId: string;\n  props: Readonly<Record<string, unknown>>;\n  validFrom?: string;\n  validTo?: string;\n}>;\n\n/**\n * Parameters for updating an edge.\n */\nexport type UpdateEdgeParams = Readonly<{\n  graphId: string;\n  id: string;\n  props: Readonly<Record<string, unknown>>;\n  validTo?: string;\n  clearDeleted?: boolean;\n}>;\n\n/**\n * Parameters for deleting an edge (soft delete).\n */\nexport type DeleteEdgeParams = Readonly<{\n  graphId: string;\n  id: string;\n}>;\n\n/**\n * Parameters for hard deleting a node (permanent removal).\n */\nexport type HardDeleteNodeParams = Readonly<{\n  graphId: string;\n  kind: string;\n  id: string;\n}>;\n\n/**\n * Parameters for hard deleting an edge (permanent removal).\n */\nexport type HardDeleteEdgeParams = Readonly<{\n  graphId: string;\n  id: string;\n}>;\n\n// ============================================================\n// Embedding Parameters\n// ============================================================\n\n/**\n * Parameters for inserting or updating an embedding.\n */\nexport type UpsertEmbeddingParams = Readonly<{\n  graphId: string;\n  nodeKind: string;\n  nodeId: string;\n  fieldPath: string;\n  embedding: readonly number[];\n  dimensions: number;\n}>;\n\n/**\n * Parameters for deleting an embedding.\n */\nexport type DeleteEmbeddingParams = Readonly<{\n  graphId: string;\n  nodeKind: string;\n  nodeId: string;\n  fieldPath: string;\n}>;\n\n/**\n * Parameters for vector similarity search.\n */\nexport type VectorSearchParams = Readonly<{\n  graphId: string;\n  nodeKind: string;\n  fieldPath: string;\n  queryEmbedding: readonly number[];\n  metric: VectorMetric;\n  limit: number;\n  minScore?: number;\n  /**\n   * HNSW search frontier for this query (pgvector `hnsw.ef_search`).\n   * Sizes the dynamic candidate list the index scan maintains: higher\n   * trades latency for recall. The floor for the over-fetch to fill its\n   * candidate set is `efSearch >= limit`; ~2–4× is the high-recall\n   * target. Applied transaction-locally (`SET LOCAL`) on the Postgres\n   * HNSW path only. No-op on backends without an HNSW frontier knob\n   * (sqlite-vec) and ignored — with a one-time warning — on Postgres\n   * backends without transactions (e.g. `drizzle-orm/neon-http`).\n   */\n  efSearch?: number;\n}>;\n\n/**\n * Result from a vector similarity search.\n */\nexport type VectorSearchResult = Readonly<{\n  nodeId: string;\n  /**\n   * Cosine metric returns similarity score (higher is better).\n   * L2 and inner_product return raw distance (lower is better).\n   */\n  score: number;\n}>;\n\n/**\n * Parameters for creating a vector index.\n */\nexport type CreateVectorIndexParams = Readonly<{\n  graphId: string;\n  nodeKind: string;\n  fieldPath: string;\n  dimensions: number;\n  metric: VectorMetric;\n  indexType: VectorIndexType;\n  /** Index-specific parameters */\n  indexParams?: Readonly<{\n    /** HNSW: max connections per layer */\n    m?: number;\n    /** HNSW: construction search depth */\n    efConstruction?: number;\n    /** IVFFlat: number of lists */\n    lists?: number;\n  }>;\n  /**\n   * Build the index without taking an `AccessExclusiveLock` on live\n   * tables (Postgres `CREATE INDEX CONCURRENTLY`). Mirrors the\n   * `concurrent` flag the relational DDL path uses inside\n   * `materializeIndexes()`. Cannot be set inside a transaction —\n   * callers (`materializeIndexes()`) run at top level. Backends that\n   * don't have a CONCURRENTLY equivalent (SQLite) ignore this flag.\n   */\n  concurrent?: boolean;\n}>;\n\n/**\n * Parameters for dropping a vector index.\n */\nexport type DropVectorIndexParams = Readonly<{\n  graphId: string;\n  nodeKind: string;\n  fieldPath: string;\n}>;\n\n// ============================================================\n// Fulltext Parameters\n// ============================================================\n\n/**\n * Parameters for inserting or updating a fulltext entry.\n *\n * One row per node. Callers concatenate the searchable fields into\n * `content` so a single MATCH query can find terms spread across fields.\n *\n * Note: `createFulltextIndex` / `dropFulltextIndex` were removed as\n * dead code in #PR_E. The fulltext table's canonical index (Postgres\n * GIN on `tsv`, SQLite FTS5 virtual table) is created with the table\n * itself by `bootstrapTables` per the active `FulltextStrategy`;\n * per-kind fulltext indexes are an \"advanced strategy\" surface that\n * doesn't fit the relational-style declaration model and is reserved\n * for future work.\n */\nexport type UpsertFulltextParams = Readonly<{\n  graphId: string;\n  nodeKind: string;\n  nodeId: string;\n  content: string;\n  language: string;\n}>;\n\n/**\n * Parameters for deleting a single fulltext entry.\n */\nexport type DeleteFulltextParams = Readonly<{\n  graphId: string;\n  nodeKind: string;\n  nodeId: string;\n}>;\n\n/**\n * A single row in a fulltext batch upsert.\n */\nexport type FulltextBatchRow = Readonly<{\n  nodeId: string;\n  content: string;\n  language: string;\n}>;\n\n/**\n * Parameters for a batched fulltext upsert.\n *\n * Homogeneous: one graph, one node kind, many nodes. Duplicate `nodeId`\n * values within a single batch are deduplicated last-write-wins by the\n * builders before SQL generation — Postgres `ON CONFLICT` errors on\n * repeated conflict keys in one statement, and SQLite `DELETE + INSERT`\n * would create duplicate virtual-table rows otherwise.\n */\nexport type UpsertFulltextBatchParams = Readonly<{\n  graphId: string;\n  nodeKind: string;\n  rows: readonly FulltextBatchRow[];\n}>;\n\n/**\n * Parameters for a batched fulltext delete.\n */\nexport type DeleteFulltextBatchParams = Readonly<{\n  graphId: string;\n  nodeKind: string;\n  nodeIds: readonly string[];\n}>;\n\n/**\n * Parameters for fulltext search.\n */\nexport type FulltextSearchParams = Readonly<{\n  graphId: string;\n  nodeKind: string;\n  /** The user-supplied query string. */\n  query: string;\n  /** How to parse `query`. Default: \"websearch\". */\n  mode?: FulltextQueryMode;\n  /**\n   * Language override. Default: per-row language (as stored at insert time).\n   * Postgres: passed as the regconfig to `to_tsquery` / `websearch_to_tsquery`.\n   * SQLite: informational only (FTS5 tokenizer is fixed at table-create time).\n   */\n  language?: string;\n  /** Max rows to return. */\n  limit: number;\n  /** Minimum rank to include (backend-dependent units). */\n  minScore?: number;\n  /** Whether to return a highlighted snippet per match. */\n  includeSnippets?: boolean;\n}>;\n\n/**\n * Result from a fulltext search.\n *\n * Score semantics differ by backend; prefer `rank` (1-based) when fusing\n * with another source via RRF.\n */\nexport type FulltextSearchResult = Readonly<{\n  nodeId: string;\n  /**\n   * Backend-native relevance score.\n   * Postgres: `ts_rank_cd` (higher is better).\n   * SQLite FTS5: negated `bm25()` (higher is better; FTS5 returns lower-is-better).\n   */\n  score: number;\n  /** 1-based rank within the result set, suitable for RRF. */\n  rank: number;\n  /** Highlighted snippet of the content (if `includeSnippets` was set). */\n  snippet?: string;\n}>;\n\n/**\n * Parameters for creating a fulltext index.\n *\n * The canonical index (Postgres GIN on `tsv`, SQLite FTS5 virtual table)\n * is created when the fulltext table itself is created. This is reserved\n * for advanced per-kind specializations.\n */\n\n// ============================================================\n// Index Materialization Status\n// ============================================================\n\n/**\n * Per-deployment record for a single declared index.\n *\n * Identified by `indexName` because SQL index names are physical,\n * database-global identifiers — `graphId` is provenance, not identity.\n * `materializedAt` is null until the first successful CREATE INDEX\n * completes; `lastAttemptedAt` is always set, even on failure.\n */\nexport type IndexMaterializationRow = Readonly<{\n  indexName: string;\n  graphId: string;\n  entity: IndexEntity;\n  kind: string;\n  signature: string;\n  schemaVersion: number;\n  materializedAt: string | undefined;\n  lastAttemptedAt: string;\n  lastError: string | undefined;\n}>;\n\n/**\n * Parameters for upserting a materialization attempt.\n *\n * On success: pass `materializedAt` (ISO timestamp) and undefined `error`.\n * On failure: pass undefined `materializedAt` (preserve any existing\n * timestamp from a prior success) and the error message.\n */\nexport type RecordIndexMaterializationParams = Readonly<{\n  indexName: string;\n  graphId: string;\n  entity: IndexEntity;\n  kind: string;\n  signature: string;\n  schemaVersion: number;\n  attemptedAt: string;\n  /** ISO timestamp on success; undefined on failure (preserves existing). */\n  materializedAt: string | undefined;\n  /** Error message on failure; undefined on success (clears existing). */\n  error: string | undefined;\n}>;\n\n// ============================================================\n// Contribution Materializations (#135 — durable strategy-owned\n// storage marker, sibling of index materializations)\n// ============================================================\n\n/**\n * Durable identity of a strategy-owned table contribution (#129),\n * scoped to a graph. This is the primary key of\n * `typegraph_contribution_materializations`.\n *\n * `logicalName` is the stable slot (\"fulltext\"); `owner` is the\n * producing strategy (\"tsvector\" / \"fts5\"); `tableName` is the resolved\n * physical name (custom per-deployment names must be distinguishable).\n * `graphId` is part of identity here — unlike the index status table\n * where the physical index name is database-global, two graphs can each\n * own a logically-identical fulltext contribution.\n */\nexport type ContributionMaterializationIdentity = Readonly<{\n  graphId: string;\n  logicalName: string;\n  owner: string;\n  tableName: string;\n}>;\n\n/**\n * Per-deployment record that a strategy-owned contribution has been\n * durably materialized against this database.\n *\n * `signature` is intentionally NOT part of the identity: a row with the\n * same identity but a different signature means \"materialized artifact\n * is stale/drifted\" — a loud error on the hot path, never a silent\n * re-materialize. `materializedAt` is undefined until the first\n * successful materialization; `lastAttemptedAt` is always set.\n */\nexport type ContributionMaterializationRow = Readonly<{\n  graphId: string;\n  logicalName: string;\n  owner: string;\n  tableName: string;\n  signature: string;\n  materializedAt: string | undefined;\n  lastAttemptedAt: string;\n  lastError: string | undefined;\n}>;\n\n/**\n * Parameters for upserting a contribution-materialization attempt.\n * Same success/failure contract as\n * {@link RecordIndexMaterializationParams}: on failure pass undefined\n * `materializedAt` so a prior successful timestamp is preserved via\n * COALESCE, and the error message.\n */\nexport type RecordContributionMaterializationParams = Readonly<{\n  graphId: string;\n  logicalName: string;\n  owner: string;\n  tableName: string;\n  signature: string;\n  attemptedAt: string;\n  /** ISO timestamp on success; undefined on failure (preserves existing). */\n  materializedAt: string | undefined;\n  /** Error message on failure; undefined on success (clears existing). */\n  error: string | undefined;\n}>;\n\n// ============================================================\n// Kind Removals (data-cleanup status)\n// ============================================================\n\n/**\n * One row of the per-deployment `typegraph_kind_removals` table:\n * a graph-extension kind that has been removed from the schema and whose\n * data may or may not have been cleaned up yet.\n */\nexport type KindRemovalRow = Readonly<{\n  graphId: string;\n  kindName: string;\n  entity: KindEntity;\n  schemaVersion: number;\n  /** ISO timestamp when the data-cleanup pass succeeded; undefined while pending. */\n  removedAt: string | undefined;\n  lastAttemptedAt: string;\n  lastError: string | undefined;\n}>;\n\n/**\n * Upsert payload for a kind-removal status row. On removal-commit:\n * pass `removedAt: undefined` (the pending state). On successful\n * data-cleanup: pass `removedAt` set and `error: undefined`. On\n * cleanup failure: pass `removedAt: undefined` (preserves any prior\n * timestamp from a partial success on a different replica) and the\n * error message.\n */\nexport type RecordKindRemovalParams = Readonly<{\n  graphId: string;\n  kindName: string;\n  entity: KindEntity;\n  schemaVersion: number;\n  attemptedAt: string;\n  /** ISO timestamp on success; undefined while pending or on failure. */\n  removedAt: string | undefined;\n  /** Error message on failure; undefined on success or while pending. */\n  error: string | undefined;\n}>;\n\n// ============================================================\n// Query Types\n// ============================================================\n\n/**\n * Transaction options.\n */\nexport type TransactionOptions = Readonly<{\n  /** Transaction isolation level (if supported) */\n  isolationLevel?:\n    | \"read_uncommitted\"\n    | \"read_committed\"\n    | \"repeatable_read\"\n    | \"serializable\";\n}>;\n\n/**\n * A caller-owned, already-open Drizzle transaction handle that a\n * TypeGraph store can adopt so both layers commit/rollback together.\n *\n * The literal client the caller's transaction runs on — a `PgDatabase`\n * transaction (node-postgres / `neon-serverless` Pool) or a\n * `BaseSQLiteDatabase` connection. Async drivers obtain it from\n * `db.transaction(async (tx) => …)`; synchronous `better-sqlite3` (whose\n * driver rejects an `async` transaction callback) passes the connection\n * itself under an explicit `BEGIN`/`COMMIT`/`ROLLBACK`. Passing it to\n * {@link GraphBackend.adoptTransaction} threads that *literal* client\n * through TypeGraph's SQL, so graph writes and the caller's own\n * relational writes share one Postgres/SQLite transaction (#134).\n */\nexport type AdoptedTransaction = AnyPgDatabase | AnySqliteDatabase;\n\n// ============================================================\n// Backend Interface\n// ============================================================\n\n/**\n * Transaction backend — a backend scoped to a transaction.\n *\n * `commitSchemaVersion` and `setActiveVersion` are intentionally omitted:\n * the atomicity / CAS guarantees of those primitives depend on\n * dialect-specific write-locking (BEGIN IMMEDIATE on SQLite,\n * `pg_advisory_xact_lock` on Postgres) acquired by the top-level\n * backend wrappers, not the transaction itself. Calling them from a\n * user-supplied `backend.transaction(...)` callback would bypass that\n * locking and silently weaken the orphan-row crash window the primitive\n * exists to eliminate. Schema commits go through the top-level backend\n * methods only.\n */\nexport type TransactionBackend = Omit<\n  GraphBackend,\n  | \"transaction\"\n  | \"adoptTransaction\"\n  | \"close\"\n  | \"refreshStatistics\"\n  | \"commitSchemaVersion\"\n  | \"setActiveVersion\"\n>;\n\n/**\n * The GraphBackend interface abstracts database operations.\n *\n * Implementations should provide:\n * - SQLite backend via better-sqlite3 or libsql\n * - PostgreSQL backend via pg or postgres\n */\nexport type GraphBackend = Readonly<{\n  /** The SQL dialect */\n  dialect: SqlDialect;\n  /** Backend capabilities */\n  capabilities: BackendCapabilities;\n  /** Table names used by this backend (for query schema auto-derivation) */\n  tableNames?: SqlTableNames | undefined;\n  /**\n   * Optional fulltext strategy override. When present, both the compiler\n   * (for `$fulltext.matches()` in query builder) and backend-direct\n   * search paths use this instead of the dialect's default strategy —\n   * allowing a Postgres backend to ship pg_trgm, ParadeDB, pgroonga etc.\n   * When absent, the dialect's default strategy is used.\n   */\n  fulltextStrategy?: FulltextStrategy | undefined;\n\n  // === Node Operations ===\n  insertNode: (params: InsertNodeParams) => Promise<NodeRow>;\n  insertNodeNoReturn?: (params: InsertNodeParams) => Promise<void>;\n  insertNodesBatch?: (params: readonly InsertNodeParams[]) => Promise<void>;\n  insertNodesBatchReturning?: (\n    params: readonly InsertNodeParams[],\n  ) => Promise<readonly NodeRow[]>;\n  updateNode: (params: UpdateNodeParams) => Promise<NodeRow>;\n  deleteNode: (params: DeleteNodeParams) => Promise<void>;\n  hardDeleteNode: (params: HardDeleteNodeParams) => Promise<void>;\n  getNode: (\n    graphId: string,\n    kind: string,\n    id: string,\n  ) => Promise<NodeRow | undefined>;\n  getNodes?: (\n    graphId: string,\n    kind: string,\n    ids: readonly string[],\n  ) => Promise<readonly NodeRow[]>;\n\n  // === Edge Operations ===\n  insertEdge: (params: InsertEdgeParams) => Promise<EdgeRow>;\n  insertEdgeNoReturn?: (params: InsertEdgeParams) => Promise<void>;\n  insertEdgesBatch?: (params: readonly InsertEdgeParams[]) => Promise<void>;\n  insertEdgesBatchReturning?: (\n    params: readonly InsertEdgeParams[],\n  ) => Promise<readonly EdgeRow[]>;\n  updateEdge: (params: UpdateEdgeParams) => Promise<EdgeRow>;\n  deleteEdge: (params: DeleteEdgeParams) => Promise<void>;\n  hardDeleteEdge: (params: HardDeleteEdgeParams) => Promise<void>;\n  getEdge: (graphId: string, id: string) => Promise<EdgeRow | undefined>;\n  getEdges?: (\n    graphId: string,\n    ids: readonly string[],\n  ) => Promise<readonly EdgeRow[]>;\n\n  // === Edge Cardinality Operations ===\n  countEdgesFrom: (params: CountEdgesFromParams) => Promise<number>;\n  edgeExistsBetween: (params: EdgeExistsBetweenParams) => Promise<boolean>;\n\n  // === Edge Query Operations ===\n  findEdgesConnectedTo: (\n    params: FindEdgesConnectedToParams,\n  ) => Promise<readonly EdgeRow[]>;\n\n  // === Collection Query Operations ===\n  findNodesByKind: (\n    params: FindNodesByKindParams,\n  ) => Promise<readonly NodeRow[]>;\n  countNodesByKind: (params: CountNodesByKindParams) => Promise<number>;\n  findEdgesByKind: (\n    params: FindEdgesByKindParams,\n  ) => Promise<readonly EdgeRow[]>;\n  countEdgesByKind: (params: CountEdgesByKindParams) => Promise<number>;\n\n  // === Unique Constraint Operations ===\n  insertUnique: (params: InsertUniqueParams) => Promise<void>;\n  deleteUnique: (params: DeleteUniqueParams) => Promise<void>;\n  checkUnique: (params: CheckUniqueParams) => Promise<UniqueRow | undefined>;\n  checkUniqueBatch?: (\n    params: CheckUniqueBatchParams,\n  ) => Promise<readonly UniqueRow[]>;\n\n  // === Schema Operations ===\n  getActiveSchema: (graphId: string) => Promise<SchemaVersionRow | undefined>;\n  getSchemaVersion: (\n    graphId: string,\n    version: number,\n  ) => Promise<SchemaVersionRow | undefined>;\n  /**\n   * Atomically inserts a new schema version and activates it as a single\n   * transactional unit, with optimistic compare-and-swap on the currently\n   * active version.\n   *\n   * - If `expected.kind === \"active\"` and the actual active version\n   *   differs, throws `StaleVersionError` (caller should refetch and\n   *   retry).\n   * - If a row already exists at `params.version` with the same\n   *   `schemaHash`, returns it idempotently — reactivating it if it was\n   *   left inactive by an earlier crashed commit.\n   * - If a row already exists at `params.version` with a different\n   *   `schemaHash`, throws `SchemaContentConflictError`.\n   *\n   * Requires `capabilities.transactions === true`. On non-transactional\n   * backends (e.g. Cloudflare D1, drizzle-orm/neon-http) this method\n   * throws `ConfigurationError` rather than running with degraded\n   * atomicity that would silently re-introduce the orphan-row crash\n   * window the primitive exists to eliminate.\n   */\n  commitSchemaVersion: (\n    params: CommitSchemaVersionParams,\n  ) => Promise<SchemaVersionRow>;\n  /**\n   * Atomically flips the active schema pointer to an existing version,\n   * with optimistic compare-and-swap on the currently active version.\n   * Used by `rollbackSchema` and any other \"promote/demote existing\n   * version\" workflow. Throws `StaleVersionError` on CAS mismatch and\n   * `MigrationError` if the target version row does not exist.\n   *\n   * Same transactional requirements as `commitSchemaVersion`.\n   */\n  setActiveVersion: (params: SetActiveVersionParams) => Promise<void>;\n\n  // === Embedding Operations (optional - depends on vector capabilities) ===\n  upsertEmbedding?: (params: UpsertEmbeddingParams) => Promise<void>;\n  deleteEmbedding?: (params: DeleteEmbeddingParams) => Promise<void>;\n  getEmbedding?: (\n    graphId: string,\n    nodeKind: string,\n    nodeId: string,\n    fieldPath: string,\n  ) => Promise<EmbeddingRow | undefined>;\n  vectorSearch?: (\n    params: VectorSearchParams,\n  ) => Promise<readonly VectorSearchResult[]>;\n  createVectorIndex?: (params: CreateVectorIndexParams) => Promise<void>;\n  dropVectorIndex?: (params: DropVectorIndexParams) => Promise<void>;\n\n  // === Fulltext Operations (optional - depends on fulltext capabilities) ===\n  upsertFulltext?: (params: UpsertFulltextParams) => Promise<void>;\n  deleteFulltext?: (params: DeleteFulltextParams) => Promise<void>;\n  /**\n   * Batched variant of `upsertFulltext`. Optional — callers fall back to\n   * per-row `upsertFulltext` when unset.\n   */\n  upsertFulltextBatch?: (params: UpsertFulltextBatchParams) => Promise<void>;\n  /**\n   * Batched variant of `deleteFulltext`. Optional — callers fall back to\n   * per-row `deleteFulltext` when unset.\n   */\n  deleteFulltextBatch?: (params: DeleteFulltextBatchParams) => Promise<void>;\n  fulltextSearch?: (\n    params: FulltextSearchParams,\n  ) => Promise<readonly FulltextSearchResult[]>;\n\n  // === Index Materialization (used by store.materializeIndexes) ===\n  /**\n   * Idempotently ensure ONLY the `typegraph_index_materializations`\n   * table exists — separate from `bootstrapTables` so that\n   * `materializeIndexes` doesn't pull in the full base-table DDL set\n   * just to access the status table.\n   *\n   * Why focused: `bootstrapTables` issues 20+ `CREATE TABLE / CREATE\n   * INDEX IF NOT EXISTS` statements covering every base table. Two\n   * concurrent calls (e.g. two replicas of the same `schema_doc` both\n   * starting up and calling `materializeIndexes`) race on\n   * Postgres SHARE locks and DEADLOCK. Restricting the ensure-step to\n   * the single status table eliminates the cross-table race entirely\n   * — concurrent `CREATE TABLE IF NOT EXISTS` for one specific table\n   * is well-behaved on Postgres.\n   */\n  ensureIndexMaterializationsTable?: () => Promise<void>;\n\n  /**\n   * Look up a recorded materialization for a declared index by its\n   * physical SQL index name. Returns `undefined` if no row exists.\n   */\n  getIndexMaterialization?: (\n    indexName: string,\n  ) => Promise<IndexMaterializationRow | undefined>;\n  /**\n   * Bulk variant of `getIndexMaterialization`: load every recorded\n   * materialization whose `indexName` (status key) is in `statusKeys`,\n   * in a single round-trip. Returned rows are unordered — callers index\n   * by `indexName`. Optional; consumers fall back to per-key\n   * `getIndexMaterialization` when unset.\n   */\n  getIndexMaterializations?: (\n    statusKeys: readonly string[],\n  ) => Promise<readonly IndexMaterializationRow[]>;\n  /**\n   * Upsert a materialization attempt — success or failure. Failure rows\n   * preserve any prior `materializedAt` so the historical successful\n   * timestamp survives across error windows.\n   */\n  recordIndexMaterialization?: (\n    params: RecordIndexMaterializationParams,\n  ) => Promise<void>;\n\n  // === Contribution Materialization (#135 — durable strategy-owned\n  // storage marker, sibling of the index status table) ===\n\n  /**\n   * Idempotently ensure ONLY the\n   * `typegraph_contribution_materializations` table exists. Same\n   * focused-bootstrap rationale as `ensureIndexMaterializationsTable`:\n   * a single `CREATE TABLE IF NOT EXISTS` is concurrency-safe under\n   * replica startup, where the full `bootstrapTables` set risks a\n   * Postgres SHARE-lock deadlock.\n   */\n  ensureContributionMaterializationsTable?: () => Promise<void>;\n\n  /**\n   * Look up the durable materialization marker for one strategy-owned\n   * contribution identity. Returns `undefined` when no row exists\n   * (\"never initialized\").\n   */\n  getContributionMaterialization?: (\n    identity: ContributionMaterializationIdentity,\n  ) => Promise<ContributionMaterializationRow | undefined>;\n\n  /**\n   * Upsert a contribution-materialization attempt — success or failure.\n   * Failure rows preserve any prior `materializedAt` via COALESCE so a\n   * later failed re-attempt doesn't erase the historical success.\n   */\n  recordContributionMaterialization?: (\n    params: RecordContributionMaterializationParams,\n  ) => Promise<void>;\n\n  /**\n   * Resolve (once per backend instance, cached) and assert the durable\n   * materialization markers for every `runtimeEnsure` contribution this\n   * backend's strategy declares, for `graphId`. Throws\n   * `StoreNotInitializedError` when a marker is missing, stale\n   * (signature drift), or recorded a failed last attempt.\n   *\n   * This is the single read-side gate the fulltext hot-path wrappers\n   * and `store.transaction()` consult. It performs ZERO DDL and ZERO\n   * marker writes — initialization is the exclusive job of the async\n   * boot path (`createStoreWithSchema` → `ensureRuntimeContributions`).\n   */\n  assertRuntimeContributionsInitialized?: (graphId: string) => Promise<void>;\n\n  // === Kind Removal Status ===\n\n  /**\n   * Bootstraps the per-deployment `typegraph_kind_removals` table so\n   * `store.removeKinds()` and `store.materializeRemovals()` can persist\n   * removal status. Mirrors the focused-bootstrap rationale documented\n   * on `ensureIndexMaterializationsTable` — the full `bootstrapTables`\n   * touches every base table and risks Postgres SHARE-lock deadlock\n   * under concurrent replica startup.\n   */\n  ensureKindRemovalsTable?: () => Promise<void>;\n\n  /**\n   * List graph-extension kind removals whose data-cleanup pass has not yet\n   * succeeded for this `graphId`. Returns rows with\n   * `removedAt: undefined`. Order is unspecified; callers materialize\n   * one-at-a-time and don't depend on it.\n   */\n  getPendingKindRemovals?: (\n    graphId: string,\n  ) => Promise<readonly KindRemovalRow[]>;\n\n  /**\n   * List ALL kind-removal rows for a `graphId` — pending and completed.\n   * Used by `materializeRemovals()` reconciliation to detect rows that\n   * are missing entirely (the `removeKinds()` crash window) versus\n   * already completed. Without this distinction the reconciler would\n   * have to upsert every expected historical removal on every call,\n   * churning `last_attempted_at` on rows that long since succeeded.\n   * Order is unspecified.\n   */\n  getAllKindRemovals?: (graphId: string) => Promise<readonly KindRemovalRow[]>;\n\n  /**\n   * Upsert a kind-removal status row. `removedAt: undefined` records\n   * the pending state at schema-commit time; `removedAt: <iso>`\n   * marks the data cleanup successful. The COALESCE rule on `removedAt`\n   * mirrors `recordIndexMaterialization` so a later failure doesn't\n   * clobber the historical successful timestamp from another replica.\n   */\n  recordKindRemoval?: (params: RecordKindRemovalParams) => Promise<void>;\n\n  // === Reconciliation Watermark ===\n\n  /**\n   * Bootstraps the per-deployment `typegraph_reconciliation_markers`\n   * table so `materializeRemovals()` can persist reconciliation\n   * progress. Same focused-bootstrap rationale as the other status\n   * tables — full `bootstrapTables` risks Postgres SHARE-lock\n   * deadlock under concurrent replica startup.\n   */\n  ensureReconciliationMarkersTable?: () => Promise<void>;\n\n  // === Table Contributions (#129) ===\n\n  /**\n   * Materializes every contribution flagged `runtimeEnsure` — the\n   * strategy-owned runtime tables (fulltext today) that drizzle-kit-\n   * managed setups don't create. Called once after a successful schema\n   * load. Deliberately scoped: base/drizzle-visible tables are\n   * `runtimeEnsure: false`, so this does not regress startup into\n   * broad DDL/probing across every table.\n   *\n   * The canonical durable-marker writer (#135): for each runtime\n   * contribution it short-circuits when the marker already records a\n   * matching signature, otherwise runs the idempotent `createDdl` and\n   * records the marker (success or failure) keyed by `graphId`.\n   */\n  ensureRuntimeContributions?: (graphId: string) => Promise<void>;\n\n  /**\n   * Bootstraps the fulltext storage table the active `FulltextStrategy`\n   * owns. Same focused-bootstrap rationale as the other `ensure*Table`\n   * methods: idempotent and concurrency-safe under replica startup.\n   *\n   * Superseded by `ensureRuntimeContributions()` (#129); retained as\n   * a thin back-compat wrapper for backends/callers predating #129. Not\n   * machine-`@deprecated` because the manager still calls it as the\n   * pre-#129 fallback. #135 removed the remaining hot-path callers and\n   * routed this through the durable-marker writer.\n   */\n  ensureFulltextTable?: (graphId: string) => Promise<void>;\n\n  /**\n   * Read the high-water mark schema version for which\n   * `materializeRemovals` reconciliation has already verified history\n   * for `graphId`. Returns `undefined` when no marker has been\n   * recorded yet. Used to skip already-checked transitions in the\n   * recovery walk.\n   */\n  getReconciliationMarker?: (graphId: string) => Promise<number | undefined>;\n\n  /**\n   * Persist the reconciliation high-water mark for `graphId`. Called\n   * after `materializeRemovals` completes a clean walk; subsequent\n   * calls walk only versions newer than this marker. Idempotent\n   * upsert by `graphId`.\n   */\n  setReconciliationMarker?: (graphId: string, version: number) => Promise<void>;\n\n  // === Graph Lifecycle ===\n  /**\n   * Hard-deletes all data for a graph (nodes, edges, uniques, embeddings, schema versions).\n   * Intended for import-replacement workflows. No hooks, no per-row logic.\n   */\n  clearGraph: (graphId: string) => Promise<void>;\n\n  /**\n   * Creates the base TypeGraph tables if they don't already exist.\n   *\n   * Called automatically by `createStoreWithSchema()` when a fresh database\n   * is detected. Users who manage DDL themselves via `createStore()` never\n   * hit this path.\n   */\n  bootstrapTables?: () => Promise<void>;\n\n  /**\n   * Refreshes the backend's query-planner statistics.\n   *\n   * Call this once after a large initial import or bulk backfill. Without\n   * up-to-date statistics, the planner can pick suboptimal execution plans\n   * — on PostgreSQL this is the difference between a 0.5ms and a 5ms\n   * forward traversal; on SQLite it's the difference between 0.9ms and\n   * 23ms fulltext search. Autovacuum / background statistics collection\n   * will catch up eventually, but calling this explicitly after a bulk\n   * load gives you correct latencies immediately.\n   *\n   * Implementations:\n   * - SQLite runs `ANALYZE`, which populates `sqlite_stat1`\n   * - PostgreSQL runs `ANALYZE` on the TypeGraph-managed tables\n   *\n   * Safe to call at any time; costs a few tens of milliseconds on the\n   * sizes this library is designed for.\n   */\n  refreshStatistics: () => Promise<void>;\n\n  // === Query Execution ===\n  execute: <T>(query: SQL) => Promise<readonly T[]>;\n\n  /** Execute pre-compiled SQL text with bound parameters. Available on sync SQLite and pg backends. */\n  executeRaw?: <T>(\n    sqlText: string,\n    params: readonly unknown[],\n  ) => Promise<readonly T[]>;\n\n  /** Compile a Drizzle SQL object to { sql, params } without executing. */\n  compileSql?: (\n    query: SQL,\n  ) => Readonly<{ sql: string; params: readonly unknown[] }>;\n\n  /**\n   * Execute a DDL statement that returns no rows (CREATE INDEX,\n   * CREATE TABLE, ALTER TABLE, etc.). Separate from `executeRaw`\n   * because some drivers (better-sqlite3) require `.run()` for DDL\n   * and `.all()` for queries — the ambiguity can't be resolved by\n   * inspecting the SQL string portably.\n   *\n   * Postgres path can use this for `CREATE INDEX CONCURRENTLY`, which\n   * cannot run inside a transaction. Implementations must execute the\n   * statement outside `transaction(...)`.\n   */\n  executeDdl?: (ddl: string) => Promise<void>;\n\n  // === Transaction ===\n  /**\n   * `fn` receives the tx-scoped backend and the raw Drizzle handle\n   * **bound to that same transaction** (`AdoptedTransaction`). The\n   * store surfaces the second argument as `TransactionContext.sql` so\n   * callers can write their own relational tables inside the\n   * graph-owned transaction. Implementations MUST pass the *exact*\n   * handle the tx-scoped backend writes through (the Postgres/libsql\n   * tx handle; for better-sqlite3 / do-sqlite the bound connection),\n   * never a fresh one.\n   */\n  transaction: <T>(\n    fn: (tx: TransactionBackend, sql: AdoptedTransaction) => Promise<T>,\n    options?: TransactionOptions,\n  ) => Promise<T>;\n\n  /**\n   * Adopt a caller-owned, already-open transaction (#134).\n   *\n   * Returns a transaction-scoped backend bound to the *exact*\n   * `externalTx` client, reusing this backend's already-resolved\n   * schema/strategy config — no `createStoreWithSchema` / `evolve` /\n   * `migrateSchema`, and **no DDL inside the caller's business\n   * transaction**. The caller owns `BEGIN`/`COMMIT`/`ROLLBACK`; this\n   * method neither opens nor closes a transaction. Async drivers\n   * (node-postgres, `neon-serverless` Pool, libsql) wrap with\n   * `db.transaction(async …)`; synchronous `better-sqlite3` must instead\n   * issue explicit `BEGIN`/`COMMIT`/`ROLLBACK` (its driver rejects an\n   * `async` transaction callback).\n   *\n   * Optional and presence-detected like the other capability-scoped\n   * members: only the Drizzle Postgres/SQLite backends provide it.\n   * Implementations MUST throw (not silently degrade) when\n   * `capabilities.transactions` is `false` — a non-atomic fallback is\n   * safe for graph-only writes but dangerous for cross-store flows,\n   * where the caller's relational write *would* still commit.\n   *\n   * Fulltext stays safe by construction: the returned backend's\n   * fulltext methods assert the durable materialization marker (a\n   * cached SELECT, never DDL) at point of use and throw\n   * `StoreNotInitializedError` on a missing/stale/failed marker rather\n   * than migrating mid-transaction. Prefer booting the parent store via\n   * `createStoreWithSchema` so that assertion is a warm-cache no-op.\n   */\n  adoptTransaction?: (externalTx: AdoptedTransaction) => TransactionBackend;\n\n  // === Lifecycle ===\n  close: () => Promise<void>;\n}>;\n\n// ============================================================\n// Managed Backend Helper\n// ============================================================\n\n/**\n * Wraps a GraphBackend with idempotent close that also runs a teardown\n * callback (e.g. closing the underlying database connection).\n */\nexport function wrapWithManagedClose(\n  backend: GraphBackend,\n  teardown: () => void | Promise<void>,\n): GraphBackend {\n  let isClosed = false;\n  return {\n    ...backend,\n    async close(): Promise<void> {\n      if (isClosed) return;\n      isClosed = true;\n      await backend.close();\n      await teardown();\n    },\n  };\n}\n\n/**\n * Runs `fn` inside a transaction when the backend supports one, falling\n * through to a direct invocation otherwise. Lets call sites benefit from\n * atomicity on backends that have transactions while staying functional\n * on backends that don't (Cloudflare D1, `drizzle-orm/neon-http` over\n * HTTP). The single-statement race window is already implicit on any\n * backend that reports `transactions: false`; callers that cannot\n * tolerate it must branch on the capability themselves.\n *\n * Pass `fallback` only when the toplevel backend method would recurse\n * — pass the operation-level backend so the no-tx path doesn't loop\n * back through the same toplevel method.\n */\nexport async function runOptionallyInTransaction<T>(\n  backend: GraphBackend,\n  fn: (target: GraphBackend | TransactionBackend) => Promise<T>,\n  fallback?: GraphBackend | TransactionBackend,\n): Promise<T> {\n  if (!backend.capabilities.transactions) {\n    return fn(fallback ?? backend);\n  }\n  return backend.transaction((tx) => fn(tx));\n}\n\n// ============================================================\n// Additional Parameter Types\n// ============================================================\n\n/**\n * Parameters for inserting a unique constraint entry.\n */\nexport type InsertUniqueParams = Readonly<{\n  graphId: string;\n  nodeKind: string;\n  constraintName: string;\n  key: string;\n  nodeId: string;\n  concreteKind: string;\n}>;\n\n/**\n * Parameters for deleting a unique constraint entry.\n */\nexport type DeleteUniqueParams = Readonly<{\n  graphId: string;\n  nodeKind: string;\n  constraintName: string;\n  key: string;\n}>;\n\n/**\n * Parameters for checking a unique constraint.\n */\nexport type CheckUniqueParams = Readonly<{\n  graphId: string;\n  nodeKind: string;\n  constraintName: string;\n  key: string;\n  /** If true, also returns soft-deleted entries. Used by get-or-create operations. */\n  includeDeleted?: boolean;\n}>;\n\n/**\n * Parameters for batch-checking unique constraints.\n */\nexport type CheckUniqueBatchParams = Readonly<{\n  graphId: string;\n  nodeKind: string;\n  constraintName: string;\n  keys: readonly string[];\n  /** If true, also returns soft-deleted entries. Used by get-or-create operations. */\n  includeDeleted?: boolean;\n}>;\n\n/**\n * Parameters for inserting a schema version.\n *\n * Used internally by backend implementations. Public callers go through\n * `commitSchemaVersion`, which handles the insert + activate atomically\n * with CAS guarantees.\n */\nexport type InsertSchemaParams = Readonly<{\n  graphId: string;\n  version: number;\n  schemaHash: string;\n  schemaDoc: SerializedSchema;\n  isActive: boolean;\n}>;\n\n/**\n * The caller's claim about the currently-active schema version, used as\n * the optimistic compare-and-swap guard for `commitSchemaVersion`.\n *\n * - `{ kind: \"initial\" }` — caller is committing the first-ever version\n *   for this graph and asserts no active version exists yet.\n * - `{ kind: \"active\", version: N }` — caller observed version N as\n *   active and is committing version N+1 against that baseline. The\n *   commit fails with `StaleVersionError` if some other writer has\n *   advanced or rolled back the pointer in the meantime.\n *\n * Tagged-union form (rather than a magic `version: 0` sentinel) because\n * the two cases have materially different semantics: the initial path\n * skips the \"deactivate prior\" UPDATE, and the no-active-row state is\n * a *valid* expected state, not an out-of-band signal.\n */\nexport type CommitSchemaVersionExpected =\n  | Readonly<{ kind: \"initial\" }>\n  | Readonly<{ kind: \"active\"; version: number }>;\n\n/**\n * Parameters for `commitSchemaVersion`.\n */\nexport type CommitSchemaVersionParams = Readonly<{\n  graphId: string;\n  /** CAS guard — see `CommitSchemaVersionExpected`. */\n  expected: CommitSchemaVersionExpected;\n  /** The new version to insert and activate. */\n  version: number;\n  schemaHash: string;\n  schemaDoc: SerializedSchema;\n}>;\n\n/**\n * Parameters for `setActiveVersion`.\n *\n * Flips the active pointer from `expected` to `version` for an existing\n * row. CAS prevents overwriting a concurrent rollback or commit.\n */\nexport type SetActiveVersionParams = Readonly<{\n  graphId: string;\n  /** CAS guard. Same semantics as `commitSchemaVersion.expected`. */\n  expected: CommitSchemaVersionExpected;\n  /** The version to mark active. Must already exist. */\n  version: number;\n}>;\n\n/**\n * Parameters for counting edges from a source node.\n */\nexport type CountEdgesFromParams = Readonly<{\n  graphId: string;\n  edgeKind: string;\n  fromKind: string;\n  fromId: string;\n  /** If true, only count edges where valid_to IS NULL */\n  activeOnly?: boolean;\n}>;\n\n/**\n * Parameters for checking if an edge exists between two nodes.\n */\nexport type EdgeExistsBetweenParams = Readonly<{\n  graphId: string;\n  edgeKind: string;\n  fromKind: string;\n  fromId: string;\n  toKind: string;\n  toId: string;\n}>;\n\n/**\n * Parameters for finding edges connected to a node.\n */\nexport type FindEdgesConnectedToParams = Readonly<{\n  graphId: string;\n  nodeKind: string;\n  nodeId: string;\n}>;\n\n/**\n * Parameters for finding nodes by kind.\n */\nexport type FindNodesByKindParams = Readonly<{\n  graphId: string;\n  kind: string;\n  /** Max rows to return. */\n  limit?: number;\n  /** Offset. Present for backward compat; rebuild uses `after` instead. */\n  offset?: number;\n  /** If true, exclude deleted nodes. Default true. */\n  excludeDeleted?: boolean;\n  /** Temporal mode for filtering by validity period. */\n  temporalMode?: TemporalMode;\n  /** Timestamp for \"current\" and \"asOf\" temporal modes. */\n  asOf?: string;\n  /**\n   * Stable ordering for keyset pagination. Default: \"created_at\" (existing\n   * behavior). Rebuild should use \"id\" for iteration that is stable under\n   * concurrent writes and shared timestamps.\n   */\n  orderBy?: \"id\" | \"created_at\";\n  /**\n   * Keyset cursor. Returns rows strictly greater (by `orderBy`) than this\n   * value. When `orderBy: \"id\"`, compared lexicographically. Mutually\n   * exclusive with `offset` — callers pick one.\n   */\n  after?: string;\n}>;\n\n/**\n * Parameters for counting nodes by kind.\n */\nexport type CountNodesByKindParams = Readonly<{\n  graphId: string;\n  kind: string;\n  /** If true, exclude deleted nodes. Default true. */\n  excludeDeleted?: boolean;\n  /** Temporal mode for filtering by validity period. */\n  temporalMode?: TemporalMode;\n  /** Timestamp for \"current\" and \"asOf\" temporal modes. */\n  asOf?: string;\n}>;\n\n/**\n * Parameters for finding edges by kind.\n */\nexport type FindEdgesByKindParams = Readonly<{\n  graphId: string;\n  kind: string;\n  fromKind?: string;\n  fromId?: string;\n  toKind?: string;\n  toId?: string;\n  limit?: number;\n  offset?: number;\n  /** If true, exclude deleted edges. Default true. */\n  excludeDeleted?: boolean;\n  /** Temporal mode for filtering by validity period. */\n  temporalMode?: TemporalMode;\n  /** Timestamp for \"current\" and \"asOf\" temporal modes. */\n  asOf?: string;\n}>;\n\n/**\n * Parameters for counting edges by kind.\n */\nexport type CountEdgesByKindParams = Readonly<{\n  graphId: string;\n  kind: string;\n  fromKind?: string;\n  fromId?: string;\n  toKind?: string;\n  toId?: string;\n  /** If true, exclude deleted edges. Default true. */\n  excludeDeleted?: boolean;\n  /** Temporal mode for filtering by validity period. */\n  temporalMode?: TemporalMode;\n  /** Timestamp for \"current\" and \"asOf\" temporal modes. */\n  asOf?: string;\n}>;\n\n// ============================================================\n// Default Capabilities\n// ============================================================\n\n/**\n * Default capabilities for SQLite.\n */\nexport const SQLITE_CAPABILITIES: BackendCapabilities = {\n  jsonb: false, // SQLite uses TEXT with json functions\n  partialIndexes: true, // SQLite supports WHERE in CREATE INDEX\n  ginIndexes: false, // SQLite doesn't have GIN\n  cte: true, // SQLite supports WITH\n  returning: true, // SQLite 3.35+ supports RETURNING\n  transactions: true, // SQLite supports transactions\n};\n\n/**\n * Default capabilities for PostgreSQL.\n */\nexport const POSTGRES_CAPABILITIES: BackendCapabilities = {\n  jsonb: true, // PostgreSQL has native JSONB\n  partialIndexes: true,\n  ginIndexes: true,\n  cte: true,\n  returning: true,\n  transactions: true, // PostgreSQL supports transactions\n};\n"]}

package/dist/{chunk-RVT2N4RF.cjs → chunk-NMOE2ZEU.cjs}

@@ -1,7 +1,7 @@
 'use strict';
 
-var chunkTVUARC7S_cjs = require('./chunk-TVUARC7S.cjs');
-var chunkDN4RUDF3_cjs = require('./chunk-DN4RUDF3.cjs');
+var chunkNYQFPGYP_cjs = require('./chunk-NYQFPGYP.cjs');
+var chunkLYRUNG6E_cjs = require('./chunk-LYRUNG6E.cjs');
 var chunkPN37HVAV_cjs = require('./chunk-PN37HVAV.cjs');
 var chunkYEDQLNVE_cjs = require('./chunk-YEDQLNVE.cjs');
 var drizzleOrm = require('drizzle-orm');
@@ -70,7 +70,7 @@ function resolveSqliteClient(db) {
   return sqliteClient;
 }
 function getOrCreatePreparedStatement(cache, sqliteClient, sqlText, cacheMax) {
-  return chunkTVUARC7S_cjs.getOrCreateLru(
+  return chunkNYQFPGYP_cjs.getOrCreateLru(
     cache,
     sqlText,
     cacheMax,
@@ -106,7 +106,7 @@ function createSqliteExecutionAdapter(db, statementCacheMaxOrOptions = {}) {
     supportsCompiledExecution: sqliteClient !== void 0,
     transactionMode
   };
-  const compile = (query) => chunkTVUARC7S_cjs.compileQueryWithDialect(db, query, "SQLite");
+  const compile = (query) => chunkNYQFPGYP_cjs.compileQueryWithDialect(db, query, "SQLite");
   if (sqliteClient !== void 0) {
     let executeCompiled2 = function(compiledQuery) {
       const preparedStatement = getOrCreatePreparedStatement(
@@ -177,10 +177,10 @@ var SQLITE_CHECK_UNIQUE_BATCH_CHUNK_SIZE = Math.max(
   1,
   SQLITE_MAX_BIND_PARAMETERS - CHECK_UNIQUE_BATCH_FIXED_PARAM_COUNT
 );
-var toNodeRow = chunkTVUARC7S_cjs.createNodeRowMapper(chunkTVUARC7S_cjs.SQLITE_ROW_MAPPER_CONFIG);
-var toEdgeRow = chunkTVUARC7S_cjs.createEdgeRowMapper(chunkTVUARC7S_cjs.SQLITE_ROW_MAPPER_CONFIG);
-var toUniqueRow = chunkTVUARC7S_cjs.createUniqueRowMapper(chunkTVUARC7S_cjs.SQLITE_ROW_MAPPER_CONFIG);
-var toSchemaVersionRow = chunkTVUARC7S_cjs.createSchemaVersionRowMapper(chunkTVUARC7S_cjs.SQLITE_ROW_MAPPER_CONFIG);
+var toNodeRow = chunkNYQFPGYP_cjs.createNodeRowMapper(chunkNYQFPGYP_cjs.SQLITE_ROW_MAPPER_CONFIG);
+var toEdgeRow = chunkNYQFPGYP_cjs.createEdgeRowMapper(chunkNYQFPGYP_cjs.SQLITE_ROW_MAPPER_CONFIG);
+var toUniqueRow = chunkNYQFPGYP_cjs.createUniqueRowMapper(chunkNYQFPGYP_cjs.SQLITE_ROW_MAPPER_CONFIG);
+var toSchemaVersionRow = chunkNYQFPGYP_cjs.createSchemaVersionRowMapper(chunkNYQFPGYP_cjs.SQLITE_ROW_MAPPER_CONFIG);
 var PENDING_FOREVER = new Promise(noop);
 function pendingForever() {
   return PENDING_FOREVER;
@@ -232,7 +232,7 @@ function throwSqliteTransactionsDisabled(message) {
   });
 }
 function buildSqliteCapabilities(options) {
-  const base = options.transactionMode === "none" ? { ...chunkDN4RUDF3_cjs.SQLITE_CAPABILITIES, transactions: false } : chunkDN4RUDF3_cjs.SQLITE_CAPABILITIES;
+  const base = options.transactionMode === "none" ? { ...chunkLYRUNG6E_cjs.SQLITE_CAPABILITIES, transactions: false } : chunkLYRUNG6E_cjs.SQLITE_CAPABILITIES;
   return {
     ...base,
     fulltext: chunkPN37HVAV_cjs.buildFulltextCapabilities(options.fulltextStrategy),
@@ -272,7 +272,7 @@ function createSqliteOperationBackend(options) {
       await db.run(query);
     });
   }
-  const commonBackend = chunkTVUARC7S_cjs.createCommonOperationBackend({
+  const commonBackend = chunkNYQFPGYP_cjs.createCommonOperationBackend({
     batchConfig: {
       checkUniqueBatchChunkSize: SQLITE_CHECK_UNIQUE_BATCH_CHUNK_SIZE,
       edgeInsertBatchSize: SQLITE_EDGE_INSERT_BATCH_SIZE,
@@ -285,7 +285,7 @@ function createSqliteOperationBackend(options) {
       execGet,
       execRun
     },
-    nowIso: chunkTVUARC7S_cjs.nowIso,
+    nowIso: chunkNYQFPGYP_cjs.nowIso,
     operationStrategy,
     rowMappers: {
       toEdgeRow,
@@ -307,7 +307,7 @@ function createSqliteOperationBackend(options) {
     async upsertEmbedding(params) {
       const query = operationStrategy.buildUpsertEmbedding(
         params,
-        chunkTVUARC7S_cjs.nowIso()
+        chunkNYQFPGYP_cjs.nowIso()
       );
       await execRun(query);
     },
@@ -346,14 +346,14 @@ function createSqliteOperationBackend(options) {
         ...params.indexParams?.efConstruction === void 0 ? {} : { hnswEfConstruction: params.indexParams.efConstruction },
         ...params.indexParams?.lists === void 0 ? {} : { ivfflatLists: params.indexParams.lists }
       };
-      const result = chunkTVUARC7S_cjs.createSqliteVectorIndex(indexOptions);
+      const result = chunkNYQFPGYP_cjs.createSqliteVectorIndex(indexOptions);
       if (!result.success) {
         throw new Error(result.message ?? "Failed to create SQLite vector index");
       }
       return Promise.resolve();
     },
     dropVectorIndex(params) {
-      const result = chunkTVUARC7S_cjs.dropSqliteVectorIndex(
+      const result = chunkNYQFPGYP_cjs.dropSqliteVectorIndex(
         params.graphId,
         params.nodeKind,
         params.fieldPath
@@ -365,7 +365,7 @@ function createSqliteOperationBackend(options) {
     },
     // === Fulltext Operations ===
     async upsertFulltext(params) {
-      const timestamp = chunkTVUARC7S_cjs.nowIso();
+      const timestamp = chunkNYQFPGYP_cjs.nowIso();
       const statements = operationStrategy.buildUpsertFulltext(
         params,
         timestamp
@@ -382,7 +382,7 @@ function createSqliteOperationBackend(options) {
     },
     async upsertFulltextBatch(params) {
       if (params.rows.length === 0) return;
-      const timestamp = chunkTVUARC7S_cjs.nowIso();
+      const timestamp = chunkNYQFPGYP_cjs.nowIso();
       const statements = operationStrategy.buildUpsertFulltextBatch(
         params,
         timestamp
@@ -403,7 +403,7 @@ function createSqliteOperationBackend(options) {
       const rows = await execAll(query);
       return rows.map((row, index) => ({
         nodeId: row.node_id,
-        score: chunkTVUARC7S_cjs.coerceNumericScore(row.score),
+        score: chunkNYQFPGYP_cjs.coerceNumericScore(row.score),
         rank: index + 1,
         ...row.snippet === null ? {} : { snippet: row.snippet }
       }));
@@ -422,7 +422,7 @@ function createSqliteOperationBackend(options) {
   return operationBackend;
 }
 function createSqliteBackend(db, options = {}) {
-  const tables2 = options.tables ?? chunkTVUARC7S_cjs.tables2;
+  const tables2 = options.tables ?? chunkNYQFPGYP_cjs.tables2;
   const fulltextStrategy = options.fulltext ?? chunkPN37HVAV_cjs.fts5Strategy;
   const profileHints = options.executionProfile ?? {};
   const executionAdapter = createSqliteExecutionAdapter(db, { profileHints });
@@ -440,7 +440,7 @@ function createSqliteBackend(db, options = {}) {
     fulltext: tables2.fulltextTableName,
     uniques: drizzleOrm.getTableName(tables2.uniques)
   };
-  const operationStrategy = chunkTVUARC7S_cjs.createSqliteOperationStrategy(
+  const operationStrategy = chunkNYQFPGYP_cjs.createSqliteOperationStrategy(
     tables2,
     fulltextStrategy
   );
@@ -529,7 +529,7 @@ function createSqliteBackend(db, options = {}) {
   }
   const matTable = tables2.contributionMaterializations;
   async function ensureContributionMaterializationsTableImpl() {
-    await db.run(drizzleOrm.sql.raw(chunkTVUARC7S_cjs.generateSqliteCreateTableSQL(matTable)));
+    await db.run(drizzleOrm.sql.raw(chunkNYQFPGYP_cjs.generateSqliteCreateTableSQL(matTable)));
   }
   async function getContributionMaterializationRow(identity) {
     const rows = await db.select().from(matTable).where(
@@ -542,16 +542,16 @@ function createSqliteBackend(db, options = {}) {
     );
     const row = rows[0];
     if (row === void 0) return void 0;
-    return chunkTVUARC7S_cjs.mapContributionMaterializationRow(
+    return chunkNYQFPGYP_cjs.mapContributionMaterializationRow(
       row,
-      chunkTVUARC7S_cjs.SQLITE_CONTRIBUTION_MAT_TIMESTAMPS.decode
+      chunkNYQFPGYP_cjs.SQLITE_CONTRIBUTION_MAT_TIMESTAMPS.decode
     );
   }
   async function recordContributionMaterializationRow(params) {
     await db.insert(matTable).values(
-      chunkTVUARC7S_cjs.buildContributionInsertValues(
+      chunkNYQFPGYP_cjs.buildContributionInsertValues(
         params,
-        chunkTVUARC7S_cjs.SQLITE_CONTRIBUTION_MAT_TIMESTAMPS.encode
+        chunkNYQFPGYP_cjs.SQLITE_CONTRIBUTION_MAT_TIMESTAMPS.encode
       )
     ).onConflictDoUpdate({
       target: [
@@ -560,13 +560,13 @@ function createSqliteBackend(db, options = {}) {
         matTable.owner,
         matTable.tableName
       ],
-      set: chunkTVUARC7S_cjs.buildContributionOnConflictSet(
+      set: chunkNYQFPGYP_cjs.buildContributionOnConflictSet(
         matTable.materializedAt,
         params.materializedAt
       )
     });
   }
-  const contributionMaterializer = chunkTVUARC7S_cjs.createContributionMaterializer({
+  const contributionMaterializer = chunkNYQFPGYP_cjs.createContributionMaterializer({
     dialect: "sqlite",
     fulltextStrategy,
     fulltextTableName: tables2.fulltextTableName,
@@ -587,12 +587,12 @@ function createSqliteBackend(db, options = {}) {
       fulltextStrategy,
       hasVectorEmbeddings
     });
-    return chunkTVUARC7S_cjs.gateFulltext(txBackend, contributionMaterializer.assertInitialized);
+    return chunkNYQFPGYP_cjs.gateFulltext(txBackend, contributionMaterializer.assertInitialized);
   }
   const backend = {
     ...operations,
     async bootstrapTables() {
-      const statements = chunkTVUARC7S_cjs.generateSqliteDDL(tables2, fulltextStrategy);
+      const statements = chunkNYQFPGYP_cjs.generateSqliteDDL(tables2, fulltextStrategy);
       for (const statement of statements) {
         await db.run(drizzleOrm.sql.raw(statement));
       }
@@ -602,7 +602,7 @@ function createSqliteBackend(db, options = {}) {
     // uninitialized database throws `StoreNotInitializedError` rather
     // than self-healing (#135). Shared verbatim with the tx-scoped gate
     // via `gateFulltextMethods`.
-    ...chunkTVUARC7S_cjs.gateFulltextMethods(
+    ...chunkNYQFPGYP_cjs.gateFulltextMethods(
       operations,
       contributionMaterializer.assertInitialized
     ),
@@ -611,7 +611,7 @@ function createSqliteBackend(db, options = {}) {
     },
     async ensureIndexMaterializationsTable() {
       await db.run(
-        drizzleOrm.sql.raw(chunkTVUARC7S_cjs.generateSqliteCreateTableSQL(tables2.indexMaterializations))
+        drizzleOrm.sql.raw(chunkNYQFPGYP_cjs.generateSqliteCreateTableSQL(tables2.indexMaterializations))
       );
     },
     async getIndexMaterialization(indexName) {
@@ -619,26 +619,26 @@ function createSqliteBackend(db, options = {}) {
       const rows = await db.select().from(t).where(drizzleOrm.eq(t.indexName, indexName));
       const row = rows[0];
       if (row === void 0) return void 0;
-      return chunkTVUARC7S_cjs.mapMaterializationRow(row, chunkTVUARC7S_cjs.SQLITE_INDEX_MAT_TIMESTAMPS.decode);
+      return chunkNYQFPGYP_cjs.mapMaterializationRow(row, chunkNYQFPGYP_cjs.SQLITE_INDEX_MAT_TIMESTAMPS.decode);
     },
     async getIndexMaterializations(statusKeys) {
       if (statusKeys.length === 0) return [];
       const t = tables2.indexMaterializations;
       const rows = await db.select().from(t).where(drizzleOrm.inArray(t.indexName, [...statusKeys]));
       return rows.map(
-        (row) => chunkTVUARC7S_cjs.mapMaterializationRow(row, chunkTVUARC7S_cjs.SQLITE_INDEX_MAT_TIMESTAMPS.decode)
+        (row) => chunkNYQFPGYP_cjs.mapMaterializationRow(row, chunkNYQFPGYP_cjs.SQLITE_INDEX_MAT_TIMESTAMPS.decode)
       );
     },
     async recordIndexMaterialization(params) {
       const t = tables2.indexMaterializations;
       await db.insert(t).values(
-        chunkTVUARC7S_cjs.buildMaterializationInsertValues(
+        chunkNYQFPGYP_cjs.buildMaterializationInsertValues(
           params,
-          chunkTVUARC7S_cjs.SQLITE_INDEX_MAT_TIMESTAMPS.encode
+          chunkNYQFPGYP_cjs.SQLITE_INDEX_MAT_TIMESTAMPS.encode
         )
       ).onConflictDoUpdate({
         target: t.indexName,
-        set: chunkTVUARC7S_cjs.buildMaterializationOnConflictSet(
+        set: chunkNYQFPGYP_cjs.buildMaterializationOnConflictSet(
           t.materializedAt,
           params.materializedAt
         )
@@ -657,37 +657,37 @@ function createSqliteBackend(db, options = {}) {
       await contributionMaterializer.assertInitialized(graphId);
     },
     async ensureKindRemovalsTable() {
-      await db.run(drizzleOrm.sql.raw(chunkTVUARC7S_cjs.generateSqliteCreateTableSQL(tables2.kindRemovals)));
+      await db.run(drizzleOrm.sql.raw(chunkNYQFPGYP_cjs.generateSqliteCreateTableSQL(tables2.kindRemovals)));
     },
     async getPendingKindRemovals(graphId) {
       const t = tables2.kindRemovals;
       const rows = await db.select().from(t).where(drizzleOrm.and(drizzleOrm.eq(t.graphId, graphId), drizzleOrm.isNull(t.removedAt)));
       return rows.map(
-        (row) => chunkTVUARC7S_cjs.mapKindRemovalRow(row, chunkTVUARC7S_cjs.SQLITE_KIND_REMOVAL_TIMESTAMPS.decode)
+        (row) => chunkNYQFPGYP_cjs.mapKindRemovalRow(row, chunkNYQFPGYP_cjs.SQLITE_KIND_REMOVAL_TIMESTAMPS.decode)
       );
     },
     async getAllKindRemovals(graphId) {
       const t = tables2.kindRemovals;
       const rows = await db.select().from(t).where(drizzleOrm.eq(t.graphId, graphId));
       return rows.map(
-        (row) => chunkTVUARC7S_cjs.mapKindRemovalRow(row, chunkTVUARC7S_cjs.SQLITE_KIND_REMOVAL_TIMESTAMPS.decode)
+        (row) => chunkNYQFPGYP_cjs.mapKindRemovalRow(row, chunkNYQFPGYP_cjs.SQLITE_KIND_REMOVAL_TIMESTAMPS.decode)
       );
     },
     async recordKindRemoval(params) {
       const t = tables2.kindRemovals;
       await db.insert(t).values(
-        chunkTVUARC7S_cjs.buildKindRemovalInsertValues(
+        chunkNYQFPGYP_cjs.buildKindRemovalInsertValues(
           params,
-          chunkTVUARC7S_cjs.SQLITE_KIND_REMOVAL_TIMESTAMPS.encode
+          chunkNYQFPGYP_cjs.SQLITE_KIND_REMOVAL_TIMESTAMPS.encode
         )
       ).onConflictDoUpdate({
         target: [t.graphId, t.kindName, t.entity, t.schemaVersion],
-        set: chunkTVUARC7S_cjs.buildKindRemovalOnConflictSet(t.removedAt, params.removedAt)
+        set: chunkNYQFPGYP_cjs.buildKindRemovalOnConflictSet(t.removedAt, params.removedAt)
       });
     },
     async ensureReconciliationMarkersTable() {
       await db.run(
-        drizzleOrm.sql.raw(chunkTVUARC7S_cjs.generateSqliteCreateTableSQL(tables2.reconciliationMarkers))
+        drizzleOrm.sql.raw(chunkNYQFPGYP_cjs.generateSqliteCreateTableSQL(tables2.reconciliationMarkers))
       );
     },
     async ensureRuntimeContributions(graphId) {
@@ -747,7 +747,7 @@ function createSqliteBackend(db, options = {}) {
           db.run(drizzleOrm.sql`BEGIN`);
           try {
             const result = await fn(
-              chunkTVUARC7S_cjs.gateFulltext(
+              chunkNYQFPGYP_cjs.gateFulltext(
                 txBackend,
                 contributionMaterializer.assertInitialized
               ),
@@ -779,7 +779,7 @@ function createSqliteBackend(db, options = {}) {
           "Cross-store atomicity is unavailable on this SQLite backend: transactions are disabled (transactionMode: 'none'). Adopting an external transaction here would let the caller's relational write commit with no way to roll back the graph write. Configure a driver that supports transactions (better-sqlite3, libsql, bun:sqlite)."
         );
       }
-      chunkTVUARC7S_cjs.assertAdoptedDialect(
+      chunkNYQFPGYP_cjs.assertAdoptedDialect(
         externalTx,
         sqliteCore.BaseSQLiteDatabase,
         "sqlite"
@@ -809,5 +809,5 @@ function createTransactionBackend(options) {
 }
 
 exports.createSqliteBackend = createSqliteBackend;
-//# sourceMappingURL=chunk-RVT2N4RF.cjs.map
-//# sourceMappingURL=chunk-RVT2N4RF.cjs.map
+//# sourceMappingURL=chunk-NMOE2ZEU.cjs.map
+//# sourceMappingURL=chunk-NMOE2ZEU.cjs.map