@nicia-ai/typegraph 0.32.0 → 0.34.0

package/dist/{chunk-TUA3MEJJ.js → chunk-RY2VIWAM.js}

@@ -1,9 +1,13 @@
-import { tables } from './chunk-XQFAJVYW.js';
-import { buildPostgresNodeIndexBuilders, buildPostgresEdgeIndexBuilders } from './chunk-CWFPJ3RC.js';
-import { parseDimensionMismatch, isMissingTableError, sortedReplacer } from './chunk-M6OC455F.js';
-import { tsvectorStrategy, fts5Strategy, BASE_CONTRIBUTION_OWNER, quotedTableName, quotedColumn, edgeColumnList, sqlNull, nodeColumnList } from './chunk-C4C4Q7A6.js';
-import { sha256Hex } from './chunk-2YMGNYXY.js';
-import { EmbeddingDimensionChangedError, DatabaseOperationError, ConfigurationError, MigrationError, SchemaContentConflictError, UniquenessError, StoreNotInitializedError, StaleVersionError } from './chunk-TQOYM4LN.js';
+import { tables } from './chunk-CYX2JTDG.js';
+import { buildPostgresNodeIndexBuilders, buildPostgresEdgeIndexBuilders } from './chunk-6GNSY7AV.js';
+import { formatPostgresTimestamp, nowIso } from './chunk-QV245VMN.js';
+import { sortedReplacer } from './chunk-UR7W5YQK.js';
+import { tsvectorStrategy, fts5Strategy, BASE_CONTRIBUTION_OWNER } from './chunk-KUTNI6SI.js';
+import { sha256Hex } from './chunk-K34OPSJK.js';
+import { createBackendOverlay, chunk, isPresent, sqlValueList } from './chunk-V3QNTB7Z.js';
+import { parseDimensionMismatch, isMissingTableError } from './chunk-2MRAX3UE.js';
+import { quotedTableName, quotedColumn, edgeColumnList, sqlNull, nodeColumnList } from './chunk-GZCNZ7QW.js';
+import { EmbeddingDimensionChangedError, ConfigurationError, MigrationError, SchemaContentConflictError, DatabaseOperationError, UniquenessError, StoreNotInitializedError, StaleVersionError } from './chunk-TQOYM4LN.js';
 import { sql, is, getTableName } from 'drizzle-orm';
 import { customType, pgTable, timestamp, integer, jsonb, text, primaryKey, index, boolean, uniqueIndex, getTableConfig as getTableConfig$1, PgTable } from 'drizzle-orm/pg-core';
 import { getTableConfig, SQLiteTable } from 'drizzle-orm/sqlite-core';
@@ -19,6 +23,9 @@ var tsvector = customType({
 var DEFAULT_TABLE_NAMES = {
   nodes: "typegraph_nodes",
   edges: "typegraph_edges",
+  recordedNodes: "typegraph_recorded_nodes",
+  recordedEdges: "typegraph_recorded_edges",
+  recordedClock: "typegraph_recorded_clock",
   uniques: "typegraph_node_uniques",
   schemaVersions: "typegraph_schema_versions",
   fulltext: "typegraph_node_fulltext",
@@ -117,6 +124,111 @@ function createPostgresTables(names = {}, options = {}) {
       ...buildPostgresEdgeIndexBuilders(t, indexes)
     ]
   );
+  const recordedNodes2 = pgTable(
+    n.recordedNodes,
+    {
+      historyId: text("history_id").notNull(),
+      graphId: text("graph_id").notNull(),
+      kind: text("kind").notNull(),
+      id: text("id").notNull(),
+      props: jsonb("props").notNull(),
+      version: integer("version").notNull(),
+      validFrom: timestamp("valid_from", { withTimezone: true }),
+      validTo: timestamp("valid_to", { withTimezone: true }),
+      createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: timestamp("deleted_at", { withTimezone: true }),
+      recordedFrom: timestamp("recorded_from", { withTimezone: true }).notNull(),
+      recordedTo: timestamp("recorded_to", { withTimezone: true }).notNull(),
+      op: text("op").notNull(),
+      schemaVersion: integer("schema_version"),
+      txId: text("tx_id"),
+      meta: jsonb("meta")
+    },
+    (t) => [
+      primaryKey({ columns: [t.historyId] }),
+      index(`${n.recordedNodes}_entity_idx`).on(
+        t.graphId,
+        t.kind,
+        t.id,
+        t.recordedFrom,
+        t.recordedTo
+      ),
+      index(`${n.recordedNodes}_open_idx`).on(t.graphId, t.recordedTo),
+      index(`${n.recordedNodes}_valid_idx`).on(
+        t.graphId,
+        t.validFrom,
+        t.validTo
+      )
+    ]
+  );
+  const recordedEdges2 = pgTable(
+    n.recordedEdges,
+    {
+      historyId: text("history_id").notNull(),
+      graphId: text("graph_id").notNull(),
+      id: text("id").notNull(),
+      kind: text("kind").notNull(),
+      fromKind: text("from_kind").notNull(),
+      fromId: text("from_id").notNull(),
+      toKind: text("to_kind").notNull(),
+      toId: text("to_id").notNull(),
+      props: jsonb("props").notNull(),
+      validFrom: timestamp("valid_from", { withTimezone: true }),
+      validTo: timestamp("valid_to", { withTimezone: true }),
+      createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: timestamp("deleted_at", { withTimezone: true }),
+      recordedFrom: timestamp("recorded_from", { withTimezone: true }).notNull(),
+      recordedTo: timestamp("recorded_to", { withTimezone: true }).notNull(),
+      op: text("op").notNull(),
+      schemaVersion: integer("schema_version"),
+      txId: text("tx_id"),
+      meta: jsonb("meta")
+    },
+    (t) => [
+      primaryKey({ columns: [t.historyId] }),
+      index(`${n.recordedEdges}_entity_idx`).on(
+        t.graphId,
+        t.kind,
+        t.id,
+        t.recordedFrom,
+        t.recordedTo
+      ),
+      index(`${n.recordedEdges}_open_idx`).on(t.graphId, t.recordedTo),
+      index(`${n.recordedEdges}_from_idx`).on(
+        t.graphId,
+        t.fromKind,
+        t.fromId,
+        t.kind,
+        t.toKind,
+        t.recordedFrom,
+        t.recordedTo
+      ),
+      index(`${n.recordedEdges}_to_idx`).on(
+        t.graphId,
+        t.toKind,
+        t.toId,
+        t.kind,
+        t.fromKind,
+        t.recordedFrom,
+        t.recordedTo
+      ),
+      index(`${n.recordedEdges}_valid_idx`).on(
+        t.graphId,
+        t.validFrom,
+        t.validTo
+      )
+    ]
+  );
+  const recordedClock2 = pgTable(
+    n.recordedClock,
+    {
+      graphId: text("graph_id").notNull(),
+      recordedAt: timestamp("recorded_at", { withTimezone: true }).notNull()
+    },
+    (t) => [primaryKey({ columns: [t.graphId] })]
+  );
   const uniques2 = pgTable(
     n.uniques,
     {
@@ -240,6 +352,9 @@ function createPostgresTables(names = {}, options = {}) {
   return {
     nodes: nodes2,
     edges: edges2,
+    recordedNodes: recordedNodes2,
+    recordedEdges: recordedEdges2,
+    recordedClock: recordedClock2,
     uniques: uniques2,
     schemaVersions: schemaVersions2,
     indexMaterializations,
@@ -251,7 +366,16 @@ function createPostgresTables(names = {}, options = {}) {
   };
 }
 var tables2 = createPostgresTables();
-var { nodes, edges, uniques, schemaVersions, fulltext } = tables2;
+var {
+  nodes,
+  edges,
+  recordedNodes,
+  recordedEdges,
+  recordedClock,
+  uniques,
+  schemaVersions,
+  fulltext
+} = tables2;
 function getSqliteColumnType(column) {
   switch (column.columnType) {
     case "SQLiteText": {
@@ -307,9 +431,9 @@ function renderIndexColumn(col) {
   if (col && typeof col === "object" && "name" in col) {
     return `"${col.name}"`;
   }
-  const sql12 = tryInlineSql(col);
-  if (sql12 !== void 0) {
-    return sql12;
+  const sql13 = tryInlineSql(col);
+  if (sql13 !== void 0) {
+    return sql13;
   }
   return "unknown";
 }
@@ -322,16 +446,16 @@ function tryInlineSql(value) {
   }
   return inlineSql(value);
 }
-function flattenSqlChunk(chunk) {
-  if (typeof chunk === "string") {
-    return chunk;
+function flattenSqlChunk(chunk2) {
+  if (typeof chunk2 === "string") {
+    return chunk2;
   }
-  if (typeof chunk === "object" && chunk !== null) {
-    if ("name" in chunk && typeof chunk.name === "string") {
-      return `"${chunk.name}"`;
+  if (typeof chunk2 === "object" && chunk2 !== null) {
+    if ("name" in chunk2 && typeof chunk2.name === "string") {
+      return `"${chunk2.name}"`;
     }
-    if ("value" in chunk) {
-      const value = chunk.value;
+    if ("value" in chunk2) {
+      const value = chunk2.value;
       if (typeof value === "string") {
         return value;
       }
@@ -339,17 +463,17 @@ function flattenSqlChunk(chunk) {
         return value.map((part) => flattenSqlChunk(part)).join("");
       }
     }
-    if ("queryChunks" in chunk && Array.isArray(chunk.queryChunks)) {
-      return chunk.queryChunks.map((part) => flattenSqlChunk(part)).join("");
+    if ("queryChunks" in chunk2 && Array.isArray(chunk2.queryChunks)) {
+      return chunk2.queryChunks.map((part) => flattenSqlChunk(part)).join("");
     }
-    if ("getSQL" in chunk) {
-      const maybe = chunk;
+    if ("getSQL" in chunk2) {
+      const maybe = chunk2;
       if (typeof maybe.getSQL === "function") {
         return flattenSqlChunk(maybe.getSQL());
       }
     }
   }
-  throw new Error(`Unable to inline SQL chunk: ${String(chunk)}`);
+  throw new Error(`Unable to inline SQL chunk: ${String(chunk2)}`);
 }
 function inlineSql(value) {
   try {
@@ -606,146 +730,6 @@ function mapVectorWriteError(error, params) {
     { cause: error }
   );
 }
-
-// src/backend/drizzle/row-mappers.ts
-function requireTimestamp(value, field) {
-  if (value === void 0) {
-    throw new DatabaseOperationError(
-      `Expected non-null ${field} timestamp`,
-      { operation: "select", entity: "row" }
-    );
-  }
-  return value;
-}
-function asString(value, field) {
-  if (typeof value !== "string") {
-    throw new DatabaseOperationError(
-      `Expected ${field} to be string, got ${typeof value}`,
-      { operation: "select", entity: "row" }
-    );
-  }
-  return value;
-}
-function asNumber(value, field) {
-  if (typeof value !== "number") {
-    throw new DatabaseOperationError(
-      `Expected ${field} to be number, got ${typeof value}`,
-      { operation: "select", entity: "row" }
-    );
-  }
-  return value;
-}
-function nowIso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function nullToUndefined(value) {
-  return value ?? void 0;
-}
-function formatPostgresTimestamp(value) {
-  if (value === null || value === void 0) return void 0;
-  if (value instanceof Date) return value.toISOString();
-  if (typeof value === "string") {
-    if (value.includes("T")) return value;
-    const date = new Date(value);
-    if (!Number.isNaN(date.getTime())) return date.toISOString();
-    return value;
-  }
-  return void 0;
-}
-function coerceNumericScore(value) {
-  if (typeof value === "number") return value;
-  const parsed = Number.parseFloat(value);
-  if (Number.isNaN(parsed)) {
-    throw new TypeError(
-      `Backend returned non-numeric fulltext score: ${JSON.stringify(value)}`
-    );
-  }
-  return parsed;
-}
-function normalizeJsonColumn(value) {
-  return typeof value === "string" ? value : JSON.stringify(value ?? {});
-}
-var SQLITE_ROW_MAPPER_CONFIG = {
-  formatTimestamp: (value) => {
-    if (value === null || value === void 0) return;
-    if (typeof value !== "string") {
-      throw new DatabaseOperationError(
-        `Expected timestamp to be string, got ${typeof value}`,
-        { operation: "select", entity: "row" }
-      );
-    }
-    return value;
-  },
-  normalizeJson: (value) => {
-    if (typeof value !== "string") {
-      throw new DatabaseOperationError(
-        `Expected JSON column to be string, got ${typeof value}`,
-        { operation: "select", entity: "row" }
-      );
-    }
-    return value;
-  }
-};
-var POSTGRES_ROW_MAPPER_CONFIG = {
-  formatTimestamp: formatPostgresTimestamp,
-  normalizeJson: normalizeJsonColumn
-};
-function createNodeRowMapper(config) {
-  return (row) => ({
-    graph_id: asString(row.graph_id, "graph_id"),
-    kind: asString(row.kind, "kind"),
-    id: asString(row.id, "id"),
-    props: config.normalizeJson(row.props),
-    version: asNumber(row.version, "version"),
-    valid_from: nullToUndefined(config.formatTimestamp(row.valid_from)),
-    valid_to: nullToUndefined(config.formatTimestamp(row.valid_to)),
-    created_at: requireTimestamp(config.formatTimestamp(row.created_at), "created_at"),
-    updated_at: requireTimestamp(config.formatTimestamp(row.updated_at), "updated_at"),
-    deleted_at: nullToUndefined(config.formatTimestamp(row.deleted_at))
-  });
-}
-function createEdgeRowMapper(config) {
-  return (row) => ({
-    graph_id: asString(row.graph_id, "graph_id"),
-    id: asString(row.id, "id"),
-    kind: asString(row.kind, "kind"),
-    from_kind: asString(row.from_kind, "from_kind"),
-    from_id: asString(row.from_id, "from_id"),
-    to_kind: asString(row.to_kind, "to_kind"),
-    to_id: asString(row.to_id, "to_id"),
-    props: config.normalizeJson(row.props),
-    valid_from: nullToUndefined(config.formatTimestamp(row.valid_from)),
-    valid_to: nullToUndefined(config.formatTimestamp(row.valid_to)),
-    created_at: requireTimestamp(config.formatTimestamp(row.created_at), "created_at"),
-    updated_at: requireTimestamp(config.formatTimestamp(row.updated_at), "updated_at"),
-    deleted_at: nullToUndefined(config.formatTimestamp(row.deleted_at))
-  });
-}
-function createUniqueRowMapper(config) {
-  return (row) => ({
-    graph_id: asString(row.graph_id, "graph_id"),
-    node_kind: asString(row.node_kind, "node_kind"),
-    constraint_name: asString(row.constraint_name, "constraint_name"),
-    key: asString(row.key, "key"),
-    node_id: asString(row.node_id, "node_id"),
-    concrete_kind: asString(row.concrete_kind, "concrete_kind"),
-    deleted_at: nullToUndefined(config.formatTimestamp(row.deleted_at))
-  });
-}
-function createSchemaVersionRowMapper(config) {
-  return (row) => {
-    const isActiveValue = row.is_active;
-    const isActive = isActiveValue === true || isActiveValue === 1 || isActiveValue === "1";
-    return {
-      graph_id: asString(row.graph_id, "graph_id"),
-      version: asNumber(row.version, "version"),
-      schema_hash: asString(row.schema_hash, "schema_hash"),
-      schema_doc: config.normalizeJson(row.schema_doc),
-      created_at: requireTimestamp(config.formatTimestamp(row.created_at), "created_at"),
-      is_active: isActive
-    };
-  };
-}
 var SQLITE_CONTRIBUTION_MAT_TIMESTAMPS = {
   decode: (value) => typeof value === "string" ? value : void 0,
   encode: (value) => value
@@ -821,21 +805,21 @@ function identityOf(graphId, contribution) {
 function gateFulltextMethods(source, assert) {
   const gated = {};
   if (source.upsertFulltext) {
-    const raw = source.upsertFulltext;
+    const raw = source.upsertFulltext.bind(source);
     gated.upsertFulltext = async (params) => {
       await assert(params.graphId);
       await raw(params);
     };
   }
   if (source.deleteFulltext) {
-    const raw = source.deleteFulltext;
+    const raw = source.deleteFulltext.bind(source);
     gated.deleteFulltext = async (params) => {
       await assert(params.graphId);
       await raw(params);
     };
   }
   if (source.upsertFulltextBatch) {
-    const raw = source.upsertFulltextBatch;
+    const raw = source.upsertFulltextBatch.bind(source);
     gated.upsertFulltextBatch = async (params) => {
       if (params.rows.length === 0) return;
       await assert(params.graphId);
@@ -843,7 +827,7 @@ function gateFulltextMethods(source, assert) {
     };
   }
   if (source.deleteFulltextBatch) {
-    const raw = source.deleteFulltextBatch;
+    const raw = source.deleteFulltextBatch.bind(source);
     gated.deleteFulltextBatch = async (params) => {
       if (params.nodeIds.length === 0) return;
       await assert(params.graphId);
@@ -851,13 +835,13 @@ function gateFulltextMethods(source, assert) {
     };
   }
   if (source.fulltextSearch) {
-    const raw = source.fulltextSearch;
+    const raw = source.fulltextSearch.bind(source);
     gated.fulltextSearch = async (params) => {
       await assert(params.graphId);
       return raw(params);
     };
   }
-  const rawHardDelete = source.hardDeleteNode;
+  const rawHardDelete = source.hardDeleteNode.bind(source);
   gated.hardDeleteNode = async (params) => {
     await assert(params.graphId);
     await rawHardDelete(params);
@@ -865,7 +849,10 @@ function gateFulltextMethods(source, assert) {
   return gated;
 }
 function gateFulltext(tx, assert) {
-  return { ...tx, ...gateFulltextMethods(tx, assert) };
+  return createBackendOverlay(
+    tx,
+    gateFulltextMethods(tx, assert)
+  );
 }
 function createContributionMaterializer(deps) {
   const { dialect, fulltextStrategy, fulltextTableName } = deps;
@@ -1078,397 +1065,46 @@ function buildKindRemovalOnConflictSet(removedAtColumn, paramsRemovedAt) {
     lastError: sql`excluded.${sql.identifier("last_error")}`
   };
 }
-function assertAdoptedDialect(externalTx, brand, backend) {
-  if (is(externalTx, brand)) return;
-  const label = backend === "postgres" ? "Postgres" : "SQLite";
-  throw new ConfigurationError(
-    `adoptTransaction received a handle that is not a ${label} Drizzle transaction. Pass the \`tx\` from a ${label} \`db.transaction(...)\` opened on this backend's connection.`,
-    { backend, capability: "adoptTransaction" }
-  );
-}
-function chunkArray(values, size) {
-  if (values.length <= size) {
-    return [values];
-  }
-  const chunks = [];
-  for (let index2 = 0; index2 < values.length; index2 += size) {
-    chunks.push(values.slice(index2, index2 + size));
-  }
-  return chunks;
-}
-function verifyExpectedActiveVersion(graphId, expected, actualActiveVersion) {
-  const expectedVersion = expected.kind === "active" ? expected.version : 0;
-  if (actualActiveVersion !== expectedVersion) {
-    throw new StaleVersionError({
-      graphId,
-      expected: expectedVersion,
-      actual: actualActiveVersion
-    });
-  }
-}
-function createCommonOperationBackend(options) {
-  const { batchConfig, execution, operationStrategy, rowMappers } = options;
-  const nowIso2 = options.nowIso ?? nowIso;
-  async function readActiveVersion(graphId) {
-    const row = await execution.execGet(
-      operationStrategy.buildGetActiveSchema(graphId)
-    );
-    return row === void 0 ? 0 : rowMappers.toSchemaVersionRow(row).version;
-  }
-  return {
-    async insertNode(params) {
-      const timestamp2 = nowIso2();
-      const query = operationStrategy.buildInsertNode(params, timestamp2);
-      const row = await execution.execGet(query);
-      if (!row) throw new DatabaseOperationError("Insert node failed: no row returned", { operation: "insert", entity: "node" });
-      return rowMappers.toNodeRow(row);
-    },
-    async insertNodeNoReturn(params) {
-      const timestamp2 = nowIso2();
-      const query = operationStrategy.buildInsertNodeNoReturn(params, timestamp2);
-      await execution.execRun(query);
-    },
-    async insertNodesBatch(params) {
-      if (params.length === 0) {
-        return;
-      }
-      const timestamp2 = nowIso2();
-      for (const chunk of chunkArray(params, batchConfig.nodeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertNodesBatch(chunk, timestamp2);
-        await execution.execRun(query);
-      }
-    },
-    async insertNodesBatchReturning(params) {
-      if (params.length === 0) {
-        return [];
-      }
-      const timestamp2 = nowIso2();
-      const allRows = [];
-      for (const chunk of chunkArray(params, batchConfig.nodeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertNodesBatchReturning(chunk, timestamp2);
-        const rows = await execution.execAll(query);
-        allRows.push(...rows.map((row) => rowMappers.toNodeRow(row)));
-      }
-      return allRows;
-    },
-    async getNode(graphId, kind, id) {
-      const query = operationStrategy.buildGetNode(graphId, kind, id);
-      const row = await execution.execGet(query);
-      return row ? rowMappers.toNodeRow(row) : void 0;
+function buildClearGraph(tables3, graphId) {
+  const fulltext2 = quotedTableName(tables3.fulltextTableName);
+  return [
+    { query: sql`DELETE FROM ${fulltext2} WHERE "graph_id" = ${graphId}` },
+    {
+      query: sql`DELETE FROM ${tables3.recordedEdges} WHERE ${tables3.recordedEdges.graphId} = ${graphId}`,
+      ignoreMissingTable: true,
+      requiredTableName: getTableName(tables3.recordedEdges)
     },
-    async getNodes(graphId, kind, ids) {
-      if (ids.length === 0) return [];
-      const allRows = [];
-      for (const chunk of chunkArray(ids, batchConfig.getNodesChunkSize)) {
-        const query = operationStrategy.buildGetNodes(graphId, kind, chunk);
-        const rows = await execution.execAll(query);
-        allRows.push(...rows.map((row) => rowMappers.toNodeRow(row)));
-      }
-      return allRows;
+    {
+      query: sql`DELETE FROM ${tables3.recordedNodes} WHERE ${tables3.recordedNodes.graphId} = ${graphId}`,
+      ignoreMissingTable: true,
+      requiredTableName: getTableName(tables3.recordedNodes)
     },
-    async updateNode(params) {
-      const timestamp2 = nowIso2();
-      const query = operationStrategy.buildUpdateNode(params, timestamp2);
-      const row = await execution.execGet(query);
-      if (!row) throw new DatabaseOperationError("Update node failed: no row returned", { operation: "update", entity: "node" });
-      return rowMappers.toNodeRow(row);
+    {
+      query: sql`DELETE FROM ${tables3.recordedClock} WHERE ${tables3.recordedClock.graphId} = ${graphId}`,
+      ignoreMissingTable: true,
+      requiredTableName: getTableName(tables3.recordedClock)
     },
-    async deleteNode(params) {
-      const timestamp2 = nowIso2();
-      const query = operationStrategy.buildDeleteNode(params, timestamp2);
-      await execution.execRun(query);
+    {
+      query: sql`DELETE FROM ${tables3.uniques} WHERE ${tables3.uniques.graphId} = ${graphId}`
     },
-    // IMPORTANT: This cascade is not atomic. Callers must ensure this runs
-    // within a transaction to prevent partial deletion on intermediate failure.
-    //
-    // Embeddings are NOT cleaned up here: they live in per-`(nodeKind,
-    // fieldPath)` strategy-owned tables addressable only with the slot
-    // context the graph-agnostic backend lacks. The store's hard-delete
-    // path (`executeNodeHardDelete`) drives `deleteNodeEmbeddings`, which
-    // resolves each embedding field and routes a per-field
-    // `backend.deleteEmbedding` through the active vector strategy.
-    async hardDeleteNode(params) {
-      const deleteUniquesQuery = operationStrategy.buildHardDeleteUniquesByNode(
-        params.graphId,
-        params.id
-      );
-      await execution.execRun(deleteUniquesQuery);
-      const deleteFulltextStatements = operationStrategy.buildDeleteFulltextByNode(
-        params.graphId,
-        params.kind,
-        params.id
-      );
-      for (const stmt of deleteFulltextStatements) {
-        await execution.execRun(stmt);
-      }
-      const deleteEdgesQuery = operationStrategy.buildHardDeleteEdgesByNode(
-        params.graphId,
-        params.kind,
-        params.id
-      );
-      await execution.execRun(deleteEdgesQuery);
-      const query = operationStrategy.buildHardDeleteNode(params);
-      await execution.execRun(query);
+    {
+      query: sql`DELETE FROM ${tables3.edges} WHERE ${tables3.edges.graphId} = ${graphId}`
     },
-    async insertEdge(params) {
-      const timestamp2 = nowIso2();
-      const query = operationStrategy.buildInsertEdge(params, timestamp2);
-      const row = await execution.execGet(query);
-      if (!row) throw new DatabaseOperationError("Insert edge failed: no row returned", { operation: "insert", entity: "edge" });
-      return rowMappers.toEdgeRow(row);
+    {
+      query: sql`DELETE FROM ${tables3.nodes} WHERE ${tables3.nodes.graphId} = ${graphId}`
     },
-    async insertEdgeNoReturn(params) {
-      const timestamp2 = nowIso2();
-      const query = operationStrategy.buildInsertEdgeNoReturn(params, timestamp2);
-      await execution.execRun(query);
+    {
+      query: sql`DELETE FROM ${tables3.indexMaterializations} WHERE ${tables3.indexMaterializations.graphId} = ${graphId}`
     },
-    async insertEdgesBatch(params) {
-      if (params.length === 0) {
-        return;
-      }
-      const timestamp2 = nowIso2();
-      for (const chunk of chunkArray(params, batchConfig.edgeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertEdgesBatch(chunk, timestamp2);
-        await execution.execRun(query);
-      }
+    {
+      query: sql`DELETE FROM ${tables3.kindRemovals} WHERE ${tables3.kindRemovals.graphId} = ${graphId}`
     },
-    async insertEdgesBatchReturning(params) {
-      if (params.length === 0) {
-        return [];
-      }
-      const timestamp2 = nowIso2();
-      const allRows = [];
-      for (const chunk of chunkArray(params, batchConfig.edgeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertEdgesBatchReturning(chunk, timestamp2);
-        const rows = await execution.execAll(query);
-        allRows.push(...rows.map((row) => rowMappers.toEdgeRow(row)));
-      }
-      return allRows;
+    {
+      query: sql`DELETE FROM ${tables3.reconciliationMarkers} WHERE ${tables3.reconciliationMarkers.graphId} = ${graphId}`
     },
-    async getEdge(graphId, id) {
-      const query = operationStrategy.buildGetEdge(graphId, id);
-      const row = await execution.execGet(query);
-      return row ? rowMappers.toEdgeRow(row) : void 0;
-    },
-    async getEdges(graphId, ids) {
-      if (ids.length === 0) return [];
-      const allRows = [];
-      for (const chunk of chunkArray(ids, batchConfig.getEdgesChunkSize)) {
-        const query = operationStrategy.buildGetEdges(graphId, chunk);
-        const rows = await execution.execAll(query);
-        allRows.push(...rows.map((row) => rowMappers.toEdgeRow(row)));
-      }
-      return allRows;
-    },
-    async updateEdge(params) {
-      const timestamp2 = nowIso2();
-      const query = operationStrategy.buildUpdateEdge(params, timestamp2);
-      const row = await execution.execGet(query);
-      if (!row) throw new DatabaseOperationError("Update edge failed: no row returned", { operation: "update", entity: "edge" });
-      return rowMappers.toEdgeRow(row);
-    },
-    async deleteEdge(params) {
-      const timestamp2 = nowIso2();
-      const query = operationStrategy.buildDeleteEdge(params, timestamp2);
-      await execution.execRun(query);
-    },
-    async hardDeleteEdge(params) {
-      const query = operationStrategy.buildHardDeleteEdge(params);
-      await execution.execRun(query);
-    },
-    async countEdgesFrom(params) {
-      const query = operationStrategy.buildCountEdgesFrom(params);
-      const row = await execution.execGet(query);
-      return Number(row?.count ?? 0);
-    },
-    async edgeExistsBetween(params) {
-      const query = operationStrategy.buildEdgeExistsBetween(params);
-      const row = await execution.execGet(query);
-      return row !== void 0;
-    },
-    async findEdgesConnectedTo(params) {
-      const query = operationStrategy.buildFindEdgesConnectedTo(params);
-      const rows = await execution.execAll(query);
-      return rows.map((row) => rowMappers.toEdgeRow(row));
-    },
-    async findNodesByKind(params) {
-      const query = operationStrategy.buildFindNodesByKind(params);
-      const rows = await execution.execAll(query);
-      return rows.map((row) => rowMappers.toNodeRow(row));
-    },
-    async countNodesByKind(params) {
-      const query = operationStrategy.buildCountNodesByKind(params);
-      const row = await execution.execGet(query);
-      return Number(row?.count ?? 0);
-    },
-    async findEdgesByKind(params) {
-      const query = operationStrategy.buildFindEdgesByKind(params);
-      const rows = await execution.execAll(query);
-      return rows.map((row) => rowMappers.toEdgeRow(row));
-    },
-    async countEdgesByKind(params) {
-      const query = operationStrategy.buildCountEdgesByKind(params);
-      const row = await execution.execGet(query);
-      return Number(row?.count ?? 0);
-    },
-    async insertUnique(params) {
-      const query = operationStrategy.buildInsertUnique(params);
-      const result = await execution.execGet(query);
-      if (result && result.node_id !== params.nodeId) {
-        throw new UniquenessError({
-          constraintName: params.constraintName,
-          kind: params.nodeKind,
-          existingId: result.node_id,
-          newId: params.nodeId,
-          fields: []
-        });
-      }
-    },
-    async deleteUnique(params) {
-      const timestamp2 = nowIso2();
-      const query = operationStrategy.buildDeleteUnique(params, timestamp2);
-      await execution.execRun(query);
-    },
-    async checkUnique(params) {
-      const query = operationStrategy.buildCheckUnique(params);
-      const row = await execution.execGet(query);
-      return row ? rowMappers.toUniqueRow(row) : void 0;
-    },
-    async checkUniqueBatch(params) {
-      if (params.keys.length === 0) return [];
-      const allRows = [];
-      for (const chunk of chunkArray(params.keys, batchConfig.checkUniqueBatchChunkSize)) {
-        const query = operationStrategy.buildCheckUniqueBatch({ ...params, keys: chunk });
-        const rows = await execution.execAll(query);
-        allRows.push(...rows.map((row) => rowMappers.toUniqueRow(row)));
-      }
-      return allRows;
-    },
-    async getActiveSchema(graphId) {
-      const query = operationStrategy.buildGetActiveSchema(graphId);
-      const row = await execution.execGet(query);
-      return row ? rowMappers.toSchemaVersionRow(row) : void 0;
-    },
-    async getSchemaVersion(graphId, version) {
-      const query = operationStrategy.buildGetSchemaVersion(graphId, version);
-      const row = await execution.execGet(query);
-      return row ? rowMappers.toSchemaVersionRow(row) : void 0;
-    },
-    async commitSchemaVersion(params) {
-      const existingRaw = await execution.execGet(
-        operationStrategy.buildGetSchemaVersion(
-          params.graphId,
-          params.version
-        )
-      );
-      const actualActiveVersion = await readActiveVersion(params.graphId);
-      if (existingRaw !== void 0) {
-        const existing = rowMappers.toSchemaVersionRow(existingRaw);
-        if (existing.schema_hash !== params.schemaHash) {
-          throw new SchemaContentConflictError({
-            graphId: params.graphId,
-            version: params.version,
-            existingHash: existing.schema_hash,
-            incomingHash: params.schemaHash
-          });
-        }
-        if (existing.is_active) {
-          return existing;
-        }
-        verifyExpectedActiveVersion(
-          params.graphId,
-          params.expected,
-          actualActiveVersion
-        );
-        const reactivate = operationStrategy.buildSetActiveSchema(
-          params.graphId,
-          params.version
-        );
-        await execution.execRun(reactivate.deactivateAll);
-        await execution.execRun(reactivate.activateVersion);
-        return { ...existing, is_active: true };
-      }
-      verifyExpectedActiveVersion(
-        params.graphId,
-        params.expected,
-        actualActiveVersion
-      );
-      if (params.expected.kind === "active") {
-        const flip = operationStrategy.buildSetActiveSchema(
-          params.graphId,
-          params.version
-        );
-        await execution.execRun(flip.deactivateAll);
-      }
-      const timestamp2 = nowIso2();
-      const insertQuery = operationStrategy.buildInsertSchema(
-        {
-          graphId: params.graphId,
-          version: params.version,
-          schemaHash: params.schemaHash,
-          schemaDoc: params.schemaDoc,
-          isActive: true
-        },
-        timestamp2
-      );
-      const insertedRaw = await execution.execGet(insertQuery);
-      if (!insertedRaw) {
-        throw new DatabaseOperationError(
-          "Insert schema failed: no row returned",
-          { operation: "insert", entity: "schema" }
-        );
-      }
-      return rowMappers.toSchemaVersionRow(insertedRaw);
-    },
-    async setActiveVersion(params) {
-      const actualActiveVersion = await readActiveVersion(params.graphId);
-      verifyExpectedActiveVersion(
-        params.graphId,
-        params.expected,
-        actualActiveVersion
-      );
-      const targetRaw = await execution.execGet(
-        operationStrategy.buildGetSchemaVersion(
-          params.graphId,
-          params.version
-        )
-      );
-      if (!targetRaw) {
-        throw new MigrationError(
-          `Cannot activate version ${params.version}: version does not exist for graph "${params.graphId}".`,
-          {
-            graphId: params.graphId,
-            fromVersion: actualActiveVersion,
-            toVersion: params.version
-          }
-        );
-      }
-      const queries = operationStrategy.buildSetActiveSchema(
-        params.graphId,
-        params.version
-      );
-      await execution.execRun(queries.deactivateAll);
-      await execution.execRun(queries.activateVersion);
-    },
-    async clearGraph(graphId) {
-      const statements = operationStrategy.buildClearGraph(graphId);
-      for (const statement of statements) {
-        await execution.execRun(statement);
-      }
+    {
+      query: sql`DELETE FROM ${tables3.schemaVersions} WHERE ${tables3.schemaVersions.graphId} = ${graphId}`
     }
-  };
-}
-function buildClearGraph(tables3, graphId) {
-  const fulltext2 = quotedTableName(tables3.fulltextTableName);
-  return [
-    sql`DELETE FROM ${fulltext2} WHERE "graph_id" = ${graphId}`,
-    sql`DELETE FROM ${tables3.uniques} WHERE ${tables3.uniques.graphId} = ${graphId}`,
-    sql`DELETE FROM ${tables3.edges} WHERE ${tables3.edges.graphId} = ${graphId}`,
-    sql`DELETE FROM ${tables3.nodes} WHERE ${tables3.nodes.graphId} = ${graphId}`,
-    sql`DELETE FROM ${tables3.indexMaterializations} WHERE ${tables3.indexMaterializations.graphId} = ${graphId}`,
-    sql`DELETE FROM ${tables3.kindRemovals} WHERE ${tables3.kindRemovals.graphId} = ${graphId}`,
-    sql`DELETE FROM ${tables3.reconciliationMarkers} WHERE ${tables3.reconciliationMarkers.graphId} = ${graphId}`,
-    sql`DELETE FROM ${tables3.schemaVersions} WHERE ${tables3.schemaVersions.graphId} = ${graphId}`
   ];
 }
 function buildTemporalConditions(table, params) {
@@ -1673,14 +1309,10 @@ function buildGetEdge(tables3, graphId, id) {
 }
 function buildGetEdges(tables3, graphId, ids) {
   const { edges: edges2 } = tables3;
-  const idPlaceholders = sql.join(
-    ids.map((edgeId) => sql`${edgeId}`),
-    sql`, `
-  );
   return sql`
     SELECT * FROM ${edges2}
     WHERE ${edges2.graphId} = ${graphId}
-      AND ${edges2.id} IN (${idPlaceholders})
+      AND ${edges2.id} IN (${sqlValueList(ids)})
   `;
 }
 function buildUpdateEdge(tables3, params, timestamp2) {
@@ -1917,15 +1549,11 @@ function buildGetNode(tables3, graphId, kind, id) {
 }
 function buildGetNodes(tables3, graphId, kind, ids) {
   const { nodes: nodes2 } = tables3;
-  const idPlaceholders = sql.join(
-    ids.map((nodeId) => sql`${nodeId}`),
-    sql`, `
-  );
   return sql`
     SELECT * FROM ${nodes2}
     WHERE ${nodes2.graphId} = ${graphId}
       AND ${nodes2.kind} = ${kind}
-      AND ${nodes2.id} IN (${idPlaceholders})
+      AND ${nodes2.id} IN (${sqlValueList(ids)})
   `;
 }
 function buildUpdateNode(tables3, params, timestamp2) {
@@ -2260,17 +1888,437 @@ function createCommonOperationStrategy(tables3, dialect, fulltextStrategy) {
     buildSetActiveSchema(graphId, version) {
       return buildSetActiveSchema(tables3, graphId, version, dialect);
     },
+    buildTableExists(tableName) {
+      if (dialect === "postgres") {
+        return sql`
+          SELECT c.relname AS table_name
+          FROM pg_catalog.pg_class AS c
+          WHERE c.relname = ${tableName}
+            AND c.relkind IN ('r', 'p', 'v', 'm', 'f')
+            AND pg_catalog.pg_table_is_visible(c.oid)
+          LIMIT 1
+        `;
+      }
+      return sql`SELECT name AS table_name FROM sqlite_master WHERE type IN ('table', 'view') AND name = ${tableName}`;
+    },
     buildClearGraph(graphId) {
       return buildClearGraph(tables3, graphId);
     }
   };
 }
+function tableExistsFromRow(row) {
+  if (row === void 0) return false;
+  return Object.values(row).some((value) => isPresent(value));
+}
+function createCachedTableExistence(probe, options) {
+  const cacheExisting = options?.cacheExisting !== false;
+  const cacheMissing = options?.cacheMissing === true;
+  const confirmedExisting = /* @__PURE__ */ new Set();
+  const confirmedMissing = /* @__PURE__ */ new Set();
+  return async function tableExists(tableName) {
+    if (confirmedExisting.has(tableName)) return true;
+    if (confirmedMissing.has(tableName)) return false;
+    const exists = tableExistsFromRow(await probe(tableName));
+    if (exists && cacheExisting) {
+      confirmedExisting.add(tableName);
+    }
+    if (!exists && cacheMissing) {
+      confirmedMissing.add(tableName);
+    }
+    return exists;
+  };
+}
 function createSqliteOperationStrategy(tables3, fulltextStrategy) {
   return createCommonOperationStrategy(tables3, "sqlite", fulltextStrategy);
 }
 function createPostgresOperationStrategy(tables3, fulltextStrategy) {
   return createCommonOperationStrategy(tables3, "postgres", fulltextStrategy);
 }
+function assertAdoptedDialect(externalTx, brand, backend) {
+  if (is(externalTx, brand)) return;
+  const label = backend === "postgres" ? "Postgres" : "SQLite";
+  throw new ConfigurationError(
+    `adoptTransaction received a handle that is not a ${label} Drizzle transaction. Pass the \`tx\` from a ${label} \`db.transaction(...)\` opened on this backend's connection.`,
+    { backend, capability: "adoptTransaction" }
+  );
+}
+function verifyExpectedActiveVersion(graphId, expected, actualActiveVersion) {
+  const expectedVersion = expected.kind === "active" ? expected.version : 0;
+  if (actualActiveVersion !== expectedVersion) {
+    throw new StaleVersionError({
+      graphId,
+      expected: expectedVersion,
+      actual: actualActiveVersion
+    });
+  }
+}
+function createCommonOperationBackend(options) {
+  const { batchConfig, execution, operationStrategy, rowMappers } = options;
+  const nowIso2 = options.nowIso ?? nowIso;
+  const requiredClearTableExists = createCachedTableExistence(
+    (tableName) => execution.execGet(
+      operationStrategy.buildTableExists(tableName)
+    ),
+    options.tableExistenceCache
+  );
+  async function runIgnorableClearStatement(statement) {
+    if (statement.ignoreMissingTable === true && statement.requiredTableName !== void 0 && !await requiredClearTableExists(statement.requiredTableName)) {
+      return;
+    }
+    await execution.execRun(statement.query);
+  }
+  async function readActiveVersion(graphId) {
+    const row = await execution.execGet(
+      operationStrategy.buildGetActiveSchema(graphId)
+    );
+    return row === void 0 ? 0 : rowMappers.toSchemaVersionRow(row).version;
+  }
+  return {
+    async executeStatement(query) {
+      await execution.execRun(query);
+    },
+    async insertNode(params) {
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildInsertNode(params, timestamp2);
+      const row = await execution.execGet(query);
+      if (!row) throw new DatabaseOperationError("Insert node failed: no row returned", { operation: "insert", entity: "node" });
+      return rowMappers.toNodeRow(row);
+    },
+    async insertNodeNoReturn(params) {
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildInsertNodeNoReturn(params, timestamp2);
+      await execution.execRun(query);
+    },
+    async insertNodesBatch(params) {
+      if (params.length === 0) {
+        return;
+      }
+      const timestamp2 = nowIso2();
+      for (const chunk2 of chunk(params, batchConfig.nodeInsertBatchSize)) {
+        const query = operationStrategy.buildInsertNodesBatch(chunk2, timestamp2);
+        await execution.execRun(query);
+      }
+    },
+    async insertNodesBatchReturning(params) {
+      if (params.length === 0) {
+        return [];
+      }
+      const timestamp2 = nowIso2();
+      const allRows = [];
+      for (const chunk2 of chunk(params, batchConfig.nodeInsertBatchSize)) {
+        const query = operationStrategy.buildInsertNodesBatchReturning(chunk2, timestamp2);
+        const rows = await execution.execAll(query);
+        allRows.push(...rows.map((row) => rowMappers.toNodeRow(row)));
+      }
+      return allRows;
+    },
+    async getNode(graphId, kind, id) {
+      const query = operationStrategy.buildGetNode(graphId, kind, id);
+      const row = await execution.execGet(query);
+      return row ? rowMappers.toNodeRow(row) : void 0;
+    },
+    async getNodes(graphId, kind, ids) {
+      if (ids.length === 0) return [];
+      const allRows = [];
+      for (const chunk2 of chunk(ids, batchConfig.getNodesChunkSize)) {
+        const query = operationStrategy.buildGetNodes(graphId, kind, chunk2);
+        const rows = await execution.execAll(query);
+        allRows.push(...rows.map((row) => rowMappers.toNodeRow(row)));
+      }
+      return allRows;
+    },
+    async updateNode(params) {
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildUpdateNode(params, timestamp2);
+      const row = await execution.execGet(query);
+      if (!row) throw new DatabaseOperationError("Update node failed: no row returned", { operation: "update", entity: "node" });
+      return rowMappers.toNodeRow(row);
+    },
+    async deleteNode(params) {
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildDeleteNode(params, timestamp2);
+      await execution.execRun(query);
+    },
+    // IMPORTANT: This cascade is not atomic. Callers must ensure this runs
+    // within a transaction to prevent partial deletion on intermediate failure.
+    //
+    // Embeddings are NOT cleaned up here: they live in per-`(nodeKind,
+    // fieldPath)` strategy-owned tables addressable only with the slot
+    // context the graph-agnostic backend lacks. The store's hard-delete
+    // path (`executeNodeHardDelete`) drives `deleteNodeEmbeddings`, which
+    // resolves each embedding field and routes a per-field
+    // `backend.deleteEmbedding` through the active vector strategy.
+    async hardDeleteNode(params) {
+      const deleteUniquesQuery = operationStrategy.buildHardDeleteUniquesByNode(
+        params.graphId,
+        params.id
+      );
+      await execution.execRun(deleteUniquesQuery);
+      const deleteFulltextStatements = operationStrategy.buildDeleteFulltextByNode(
+        params.graphId,
+        params.kind,
+        params.id
+      );
+      for (const stmt of deleteFulltextStatements) {
+        await execution.execRun(stmt);
+      }
+      const deleteEdgesQuery = operationStrategy.buildHardDeleteEdgesByNode(
+        params.graphId,
+        params.kind,
+        params.id
+      );
+      await execution.execRun(deleteEdgesQuery);
+      const query = operationStrategy.buildHardDeleteNode(params);
+      await execution.execRun(query);
+    },
+    async insertEdge(params) {
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildInsertEdge(params, timestamp2);
+      const row = await execution.execGet(query);
+      if (!row) throw new DatabaseOperationError("Insert edge failed: no row returned", { operation: "insert", entity: "edge" });
+      return rowMappers.toEdgeRow(row);
+    },
+    async insertEdgeNoReturn(params) {
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildInsertEdgeNoReturn(params, timestamp2);
+      await execution.execRun(query);
+    },
+    async insertEdgesBatch(params) {
+      if (params.length === 0) {
+        return;
+      }
+      const timestamp2 = nowIso2();
+      for (const chunk2 of chunk(params, batchConfig.edgeInsertBatchSize)) {
+        const query = operationStrategy.buildInsertEdgesBatch(chunk2, timestamp2);
+        await execution.execRun(query);
+      }
+    },
+    async insertEdgesBatchReturning(params) {
+      if (params.length === 0) {
+        return [];
+      }
+      const timestamp2 = nowIso2();
+      const allRows = [];
+      for (const chunk2 of chunk(params, batchConfig.edgeInsertBatchSize)) {
+        const query = operationStrategy.buildInsertEdgesBatchReturning(chunk2, timestamp2);
+        const rows = await execution.execAll(query);
+        allRows.push(...rows.map((row) => rowMappers.toEdgeRow(row)));
+      }
+      return allRows;
+    },
+    async getEdge(graphId, id) {
+      const query = operationStrategy.buildGetEdge(graphId, id);
+      const row = await execution.execGet(query);
+      return row ? rowMappers.toEdgeRow(row) : void 0;
+    },
+    async getEdges(graphId, ids) {
+      if (ids.length === 0) return [];
+      const allRows = [];
+      for (const chunk2 of chunk(ids, batchConfig.getEdgesChunkSize)) {
+        const query = operationStrategy.buildGetEdges(graphId, chunk2);
+        const rows = await execution.execAll(query);
+        allRows.push(...rows.map((row) => rowMappers.toEdgeRow(row)));
+      }
+      return allRows;
+    },
+    async updateEdge(params) {
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildUpdateEdge(params, timestamp2);
+      const row = await execution.execGet(query);
+      if (!row) throw new DatabaseOperationError("Update edge failed: no row returned", { operation: "update", entity: "edge" });
+      return rowMappers.toEdgeRow(row);
+    },
+    async deleteEdge(params) {
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildDeleteEdge(params, timestamp2);
+      await execution.execRun(query);
+    },
+    async hardDeleteEdge(params) {
+      const query = operationStrategy.buildHardDeleteEdge(params);
+      await execution.execRun(query);
+    },
+    async countEdgesFrom(params) {
+      const query = operationStrategy.buildCountEdgesFrom(params);
+      const row = await execution.execGet(query);
+      return Number(row?.count ?? 0);
+    },
+    async edgeExistsBetween(params) {
+      const query = operationStrategy.buildEdgeExistsBetween(params);
+      const row = await execution.execGet(query);
+      return row !== void 0;
+    },
+    async findEdgesConnectedTo(params) {
+      const query = operationStrategy.buildFindEdgesConnectedTo(params);
+      const rows = await execution.execAll(query);
+      return rows.map((row) => rowMappers.toEdgeRow(row));
+    },
+    async findNodesByKind(params) {
+      const query = operationStrategy.buildFindNodesByKind(params);
+      const rows = await execution.execAll(query);
+      return rows.map((row) => rowMappers.toNodeRow(row));
+    },
+    async countNodesByKind(params) {
+      const query = operationStrategy.buildCountNodesByKind(params);
+      const row = await execution.execGet(query);
+      return Number(row?.count ?? 0);
+    },
+    async findEdgesByKind(params) {
+      const query = operationStrategy.buildFindEdgesByKind(params);
+      const rows = await execution.execAll(query);
+      return rows.map((row) => rowMappers.toEdgeRow(row));
+    },
+    async countEdgesByKind(params) {
+      const query = operationStrategy.buildCountEdgesByKind(params);
+      const row = await execution.execGet(query);
+      return Number(row?.count ?? 0);
+    },
+    async insertUnique(params) {
+      const query = operationStrategy.buildInsertUnique(params);
+      const result = await execution.execGet(query);
+      if (result && result.node_id !== params.nodeId) {
+        throw new UniquenessError({
+          constraintName: params.constraintName,
+          kind: params.nodeKind,
+          existingId: result.node_id,
+          newId: params.nodeId,
+          fields: []
+        });
+      }
+    },
+    async deleteUnique(params) {
+      const timestamp2 = nowIso2();
+      const query = operationStrategy.buildDeleteUnique(params, timestamp2);
+      await execution.execRun(query);
+    },
+    async checkUnique(params) {
+      const query = operationStrategy.buildCheckUnique(params);
+      const row = await execution.execGet(query);
+      return row ? rowMappers.toUniqueRow(row) : void 0;
+    },
+    async checkUniqueBatch(params) {
+      if (params.keys.length === 0) return [];
+      const allRows = [];
+      for (const chunk2 of chunk(params.keys, batchConfig.checkUniqueBatchChunkSize)) {
+        const query = operationStrategy.buildCheckUniqueBatch({ ...params, keys: chunk2 });
+        const rows = await execution.execAll(query);
+        allRows.push(...rows.map((row) => rowMappers.toUniqueRow(row)));
+      }
+      return allRows;
+    },
+    async getActiveSchema(graphId) {
+      const query = operationStrategy.buildGetActiveSchema(graphId);
+      const row = await execution.execGet(query);
+      return row ? rowMappers.toSchemaVersionRow(row) : void 0;
+    },
+    async getSchemaVersion(graphId, version) {
+      const query = operationStrategy.buildGetSchemaVersion(graphId, version);
+      const row = await execution.execGet(query);
+      return row ? rowMappers.toSchemaVersionRow(row) : void 0;
+    },
+    async commitSchemaVersion(params) {
+      const existingRaw = await execution.execGet(
+        operationStrategy.buildGetSchemaVersion(
+          params.graphId,
+          params.version
+        )
+      );
+      const actualActiveVersion = await readActiveVersion(params.graphId);
+      if (existingRaw !== void 0) {
+        const existing = rowMappers.toSchemaVersionRow(existingRaw);
+        if (existing.schema_hash !== params.schemaHash) {
+          throw new SchemaContentConflictError({
+            graphId: params.graphId,
+            version: params.version,
+            existingHash: existing.schema_hash,
+            incomingHash: params.schemaHash
+          });
+        }
+        if (existing.is_active) {
+          return existing;
+        }
+        verifyExpectedActiveVersion(
+          params.graphId,
+          params.expected,
+          actualActiveVersion
+        );
+        const reactivate = operationStrategy.buildSetActiveSchema(
+          params.graphId,
+          params.version
+        );
+        await execution.execRun(reactivate.deactivateAll);
+        await execution.execRun(reactivate.activateVersion);
+        return { ...existing, is_active: true };
+      }
+      verifyExpectedActiveVersion(
+        params.graphId,
+        params.expected,
+        actualActiveVersion
+      );
+      if (params.expected.kind === "active") {
+        const flip = operationStrategy.buildSetActiveSchema(
+          params.graphId,
+          params.version
+        );
+        await execution.execRun(flip.deactivateAll);
+      }
+      const timestamp2 = nowIso2();
+      const insertQuery = operationStrategy.buildInsertSchema(
+        {
+          graphId: params.graphId,
+          version: params.version,
+          schemaHash: params.schemaHash,
+          schemaDoc: params.schemaDoc,
+          isActive: true
+        },
+        timestamp2
+      );
+      const insertedRaw = await execution.execGet(insertQuery);
+      if (!insertedRaw) {
+        throw new DatabaseOperationError(
+          "Insert schema failed: no row returned",
+          { operation: "insert", entity: "schema" }
+        );
+      }
+      return rowMappers.toSchemaVersionRow(insertedRaw);
+    },
+    async setActiveVersion(params) {
+      const actualActiveVersion = await readActiveVersion(params.graphId);
+      verifyExpectedActiveVersion(
+        params.graphId,
+        params.expected,
+        actualActiveVersion
+      );
+      const targetRaw = await execution.execGet(
+        operationStrategy.buildGetSchemaVersion(
+          params.graphId,
+          params.version
+        )
+      );
+      if (!targetRaw) {
+        throw new MigrationError(
+          `Cannot activate version ${params.version}: version does not exist for graph "${params.graphId}".`,
+          {
+            graphId: params.graphId,
+            fromVersion: actualActiveVersion,
+            toVersion: params.version
+          }
+        );
+      }
+      const queries = operationStrategy.buildSetActiveSchema(
+        params.graphId,
+        params.version
+      );
+      await execution.execRun(queries.deactivateAll);
+      await execution.execRun(queries.activateVersion);
+    },
+    async clearGraph(graphId) {
+      const statements = operationStrategy.buildClearGraph(graphId);
+      for (const statement of statements) {
+        await runIgnorableClearStatement(statement);
+      }
+    }
+  };
+}
 
 // src/backend/drizzle/execution/lru.ts
 function getOrCreateLru(cache, key, cacheMax, create) {
@@ -2299,6 +2347,6 @@ function compileQueryWithDialect(db, query, backendName) {
   return compiler.sqlToQuery(query);
 }
 
-export { POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, POSTGRES_INDEX_MAT_TIMESTAMPS, POSTGRES_KIND_REMOVAL_TIMESTAMPS, POSTGRES_ROW_MAPPER_CONFIG, SQLITE_CONTRIBUTION_MAT_TIMESTAMPS, SQLITE_INDEX_MAT_TIMESTAMPS, SQLITE_KIND_REMOVAL_TIMESTAMPS, SQLITE_ROW_MAPPER_CONFIG, assertAdoptedDialect, buildContributionInsertValues, buildContributionOnConflictSet, buildKindRemovalInsertValues, buildKindRemovalOnConflictSet, buildMaterializationInsertValues, buildMaterializationOnConflictSet, coerceNumericScore, compileQueryWithDialect, createCommonOperationBackend, createContributionMaterializer, createEdgeRowMapper, createNodeRowMapper, createPostgresOperationStrategy, createPostgresTables, createSchemaVersionRowMapper, createSqliteOperationStrategy, createUniqueRowMapper, createVectorSlotLatch, edges, fulltext, gateFulltext, gateFulltextMethods, generatePgCreateTableSQL, generatePostgresDDL, generatePostgresMigrationSQL, generateSqliteCreateTableSQL, generateSqliteDDL, generateSqliteMigrationSQL, getOrCreateLru, mapContributionMaterializationRow, mapKindRemovalRow, mapMaterializationRow, mapVectorWriteError, nodes, nowIso, schemaVersions, tables2 as tables, uniques, vectorSlotFromCreateIndexParams, vectorSlotFromDropIndexParams, vectorSlotFromParams };
-//# sourceMappingURL=chunk-TUA3MEJJ.js.map
-//# sourceMappingURL=chunk-TUA3MEJJ.js.map
+export { POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, POSTGRES_INDEX_MAT_TIMESTAMPS, POSTGRES_KIND_REMOVAL_TIMESTAMPS, SQLITE_CONTRIBUTION_MAT_TIMESTAMPS, SQLITE_INDEX_MAT_TIMESTAMPS, SQLITE_KIND_REMOVAL_TIMESTAMPS, assertAdoptedDialect, buildContributionInsertValues, buildContributionOnConflictSet, buildKindRemovalInsertValues, buildKindRemovalOnConflictSet, buildMaterializationInsertValues, buildMaterializationOnConflictSet, compileQueryWithDialect, createCachedTableExistence, createCommonOperationBackend, createContributionMaterializer, createPostgresOperationStrategy, createPostgresTables, createSqliteOperationStrategy, createVectorSlotLatch, edges, fulltext, gateFulltext, gateFulltextMethods, generatePgCreateTableSQL, generatePostgresDDL, generatePostgresMigrationSQL, generateSqliteCreateTableSQL, generateSqliteDDL, generateSqliteMigrationSQL, getOrCreateLru, mapContributionMaterializationRow, mapKindRemovalRow, mapMaterializationRow, mapVectorWriteError, nodes, recordedClock, recordedEdges, recordedNodes, schemaVersions, tables2 as tables, uniques, vectorSlotFromCreateIndexParams, vectorSlotFromDropIndexParams, vectorSlotFromParams };
+//# sourceMappingURL=chunk-RY2VIWAM.js.map
+//# sourceMappingURL=chunk-RY2VIWAM.js.map