@nicia-ai/typegraph 0.32.0 → 0.33.0

package/dist/{chunk-3HQDMOBK.cjs → chunk-KY5SDVA7.cjs}

@@ -1,8 +1,9 @@
 'use strict';
 
-var chunkJKRKIEVA_cjs = require('./chunk-JKRKIEVA.cjs');
+var chunk4RBAJVEC_cjs = require('./chunk-4RBAJVEC.cjs');
 var chunkWWVV44DY_cjs = require('./chunk-WWVV44DY.cjs');
-var chunkRP7YITHX_cjs = require('./chunk-RP7YITHX.cjs');
+var chunkI4W7MKVG_cjs = require('./chunk-I4W7MKVG.cjs');
+var chunkOIE2UPVG_cjs = require('./chunk-OIE2UPVG.cjs');
 var chunkCFNT3ITG_cjs = require('./chunk-CFNT3ITG.cjs');
 var chunk73KASJGO_cjs = require('./chunk-73KASJGO.cjs');
 var chunkJIEJCTDS_cjs = require('./chunk-JIEJCTDS.cjs');
@@ -21,6 +22,9 @@ var tsvector = pgCore.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",
@@ -119,6 +123,111 @@ function createPostgresTables(names = {}, options = {}) {
       ...chunkWWVV44DY_cjs.buildPostgresEdgeIndexBuilders(t, indexes)
     ]
   );
+  const recordedNodes2 = pgCore.pgTable(
+    n.recordedNodes,
+    {
+      historyId: pgCore.text("history_id").notNull(),
+      graphId: pgCore.text("graph_id").notNull(),
+      kind: pgCore.text("kind").notNull(),
+      id: pgCore.text("id").notNull(),
+      props: pgCore.jsonb("props").notNull(),
+      version: pgCore.integer("version").notNull(),
+      validFrom: pgCore.timestamp("valid_from", { withTimezone: true }),
+      validTo: pgCore.timestamp("valid_to", { withTimezone: true }),
+      createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: pgCore.timestamp("deleted_at", { withTimezone: true }),
+      recordedFrom: pgCore.timestamp("recorded_from", { withTimezone: true }).notNull(),
+      recordedTo: pgCore.timestamp("recorded_to", { withTimezone: true }).notNull(),
+      op: pgCore.text("op").notNull(),
+      schemaVersion: pgCore.integer("schema_version"),
+      txId: pgCore.text("tx_id"),
+      meta: pgCore.jsonb("meta")
+    },
+    (t) => [
+      pgCore.primaryKey({ columns: [t.historyId] }),
+      pgCore.index(`${n.recordedNodes}_entity_idx`).on(
+        t.graphId,
+        t.kind,
+        t.id,
+        t.recordedFrom,
+        t.recordedTo
+      ),
+      pgCore.index(`${n.recordedNodes}_open_idx`).on(t.graphId, t.recordedTo),
+      pgCore.index(`${n.recordedNodes}_valid_idx`).on(
+        t.graphId,
+        t.validFrom,
+        t.validTo
+      )
+    ]
+  );
+  const recordedEdges2 = pgCore.pgTable(
+    n.recordedEdges,
+    {
+      historyId: pgCore.text("history_id").notNull(),
+      graphId: pgCore.text("graph_id").notNull(),
+      id: pgCore.text("id").notNull(),
+      kind: pgCore.text("kind").notNull(),
+      fromKind: pgCore.text("from_kind").notNull(),
+      fromId: pgCore.text("from_id").notNull(),
+      toKind: pgCore.text("to_kind").notNull(),
+      toId: pgCore.text("to_id").notNull(),
+      props: pgCore.jsonb("props").notNull(),
+      validFrom: pgCore.timestamp("valid_from", { withTimezone: true }),
+      validTo: pgCore.timestamp("valid_to", { withTimezone: true }),
+      createdAt: pgCore.timestamp("created_at", { withTimezone: true }).notNull(),
+      updatedAt: pgCore.timestamp("updated_at", { withTimezone: true }).notNull(),
+      deletedAt: pgCore.timestamp("deleted_at", { withTimezone: true }),
+      recordedFrom: pgCore.timestamp("recorded_from", { withTimezone: true }).notNull(),
+      recordedTo: pgCore.timestamp("recorded_to", { withTimezone: true }).notNull(),
+      op: pgCore.text("op").notNull(),
+      schemaVersion: pgCore.integer("schema_version"),
+      txId: pgCore.text("tx_id"),
+      meta: pgCore.jsonb("meta")
+    },
+    (t) => [
+      pgCore.primaryKey({ columns: [t.historyId] }),
+      pgCore.index(`${n.recordedEdges}_entity_idx`).on(
+        t.graphId,
+        t.kind,
+        t.id,
+        t.recordedFrom,
+        t.recordedTo
+      ),
+      pgCore.index(`${n.recordedEdges}_open_idx`).on(t.graphId, t.recordedTo),
+      pgCore.index(`${n.recordedEdges}_from_idx`).on(
+        t.graphId,
+        t.fromKind,
+        t.fromId,
+        t.kind,
+        t.toKind,
+        t.recordedFrom,
+        t.recordedTo
+      ),
+      pgCore.index(`${n.recordedEdges}_to_idx`).on(
+        t.graphId,
+        t.toKind,
+        t.toId,
+        t.kind,
+        t.fromKind,
+        t.recordedFrom,
+        t.recordedTo
+      ),
+      pgCore.index(`${n.recordedEdges}_valid_idx`).on(
+        t.graphId,
+        t.validFrom,
+        t.validTo
+      )
+    ]
+  );
+  const recordedClock2 = pgCore.pgTable(
+    n.recordedClock,
+    {
+      graphId: pgCore.text("graph_id").notNull(),
+      recordedAt: pgCore.timestamp("recorded_at", { withTimezone: true }).notNull()
+    },
+    (t) => [pgCore.primaryKey({ columns: [t.graphId] })]
+  );
   const uniques2 = pgCore.pgTable(
     n.uniques,
     {
@@ -242,6 +351,9 @@ function createPostgresTables(names = {}, options = {}) {
   return {
     nodes: nodes2,
     edges: edges2,
+    recordedNodes: recordedNodes2,
+    recordedEdges: recordedEdges2,
+    recordedClock: recordedClock2,
     uniques: uniques2,
     schemaVersions: schemaVersions2,
     indexMaterializations,
@@ -253,7 +365,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": {
@@ -309,9 +430,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";
 }
@@ -324,16 +445,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;
       }
@@ -341,17 +462,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 {
@@ -387,7 +508,7 @@ function isSqliteTable(value) {
 function runtimeStrategyContributions(fulltextStrategy, fulltextTableName) {
   return fulltextStrategy.ownedTables(fulltextTableName).filter((contribution) => contribution.runtimeEnsure);
 }
-function sqliteContributions(tables3 = chunkJKRKIEVA_cjs.tables, fulltextStrategy = chunkCFNT3ITG_cjs.fts5Strategy) {
+function sqliteContributions(tables3 = chunk4RBAJVEC_cjs.tables, fulltextStrategy = chunkCFNT3ITG_cjs.fts5Strategy) {
   const contributions = [];
   for (const [key, table] of Object.entries(tables3)) {
     if (!isSqliteTable(table)) continue;
@@ -409,12 +530,12 @@ function sqliteContributions(tables3 = chunkJKRKIEVA_cjs.tables, fulltextStrateg
   }
   return contributions;
 }
-function generateSqliteDDL(tables3 = chunkJKRKIEVA_cjs.tables, fulltextStrategy = chunkCFNT3ITG_cjs.fts5Strategy) {
+function generateSqliteDDL(tables3 = chunk4RBAJVEC_cjs.tables, fulltextStrategy = chunkCFNT3ITG_cjs.fts5Strategy) {
   return sqliteContributions(tables3, fulltextStrategy).flatMap(
     (contribution) => [...contribution.createDdl]
   );
 }
-function generateSqliteMigrationSQL(tables3 = chunkJKRKIEVA_cjs.tables, fulltextStrategy = chunkCFNT3ITG_cjs.fts5Strategy) {
+function generateSqliteMigrationSQL(tables3 = chunk4RBAJVEC_cjs.tables, fulltextStrategy = chunkCFNT3ITG_cjs.fts5Strategy) {
   return generateSqliteDDL(tables3, fulltextStrategy).join("\n\n");
 }
 function getPgColumnType(column) {
@@ -594,7 +715,7 @@ function vectorSlotFromDropIndexParams(params) {
   };
 }
 function mapVectorWriteError(error, params) {
-  const mismatch = chunkRP7YITHX_cjs.parseDimensionMismatch(error);
+  const mismatch = chunkOIE2UPVG_cjs.parseDimensionMismatch(error);
   if (mismatch === void 0) return error;
   const attempted = mismatch.actual ?? "a different number of";
   return new chunkJIEJCTDS_cjs.EmbeddingDimensionChangedError(
@@ -608,152 +729,12 @@ function mapVectorWriteError(error, params) {
     { cause: error }
   );
 }
-
-// src/backend/drizzle/row-mappers.ts
-function requireTimestamp(value, field) {
-  if (value === void 0) {
-    throw new chunkJIEJCTDS_cjs.DatabaseOperationError(
-      `Expected non-null ${field} timestamp`,
-      { operation: "select", entity: "row" }
-    );
-  }
-  return value;
-}
-function asString(value, field) {
-  if (typeof value !== "string") {
-    throw new chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.DatabaseOperationError(
-        `Expected timestamp to be string, got ${typeof value}`,
-        { operation: "select", entity: "row" }
-      );
-    }
-    return value;
-  },
-  normalizeJson: (value) => {
-    if (typeof value !== "string") {
-      throw new chunkJIEJCTDS_cjs.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
 };
 var POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS = {
-  decode: formatPostgresTimestamp,
+  decode: chunkI4W7MKVG_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapContributionMaterializationRow(row, decode) {
@@ -803,7 +784,7 @@ async function computeContributionSignature(dialect, identity, createDdl) {
     tableName: identity.tableName,
     createDdl
   };
-  return chunk73KASJGO_cjs.sha256Hex(JSON.stringify(hashable, chunkRP7YITHX_cjs.sortedReplacer), 16);
+  return chunk73KASJGO_cjs.sha256Hex(JSON.stringify(hashable, chunkOIE2UPVG_cjs.sortedReplacer), 16);
 }
 function evaluateContributionState(row, signature) {
   if (row === void 0) return "missing";
@@ -823,21 +804,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);
@@ -845,7 +826,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);
@@ -853,13 +834,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);
@@ -867,7 +848,10 @@ function gateFulltextMethods(source, assert) {
   return gated;
 }
 function gateFulltext(tx, assert) {
-  return { ...tx, ...gateFulltextMethods(tx, assert) };
+  return chunkI4W7MKVG_cjs.createBackendOverlay(
+    tx,
+    gateFulltextMethods(tx, assert)
+  );
 }
 function createContributionMaterializer(deps) {
   const { dialect, fulltextStrategy, fulltextTableName } = deps;
@@ -894,13 +878,13 @@ function createContributionMaterializer(deps) {
       await deps.recordMarker({
         ...identity,
         signature,
-        attemptedAt: nowIso(),
+        attemptedAt: chunkI4W7MKVG_cjs.nowIso(),
         materializedAt: void 0,
         error: error.message
       });
       throw error;
     }
-    const attemptedAt = nowIso();
+    const attemptedAt = chunkI4W7MKVG_cjs.nowIso();
     try {
       for (const statement of contribution.createDdl) {
         await deps.execDdl(statement);
@@ -937,7 +921,7 @@ function createContributionMaterializer(deps) {
         state: evaluateContributionState(existing, signature)
       };
     } catch (error) {
-      if (!chunkRP7YITHX_cjs.isMissingTableError(error)) throw error;
+      if (!chunkOIE2UPVG_cjs.isMissingTableError(error)) throw error;
       return { kind: "missing-table", error };
     }
   }
@@ -986,7 +970,7 @@ var SQLITE_INDEX_MAT_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_INDEX_MAT_TIMESTAMPS = {
-  decode: formatPostgresTimestamp,
+  decode: chunkI4W7MKVG_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapMaterializationRow(row, decode) {
@@ -1039,7 +1023,7 @@ var SQLITE_KIND_REMOVAL_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_KIND_REMOVAL_TIMESTAMPS = {
-  decode: formatPostgresTimestamp,
+  decode: chunkI4W7MKVG_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapKindRemovalRow(row, decode) {
@@ -1080,397 +1064,46 @@ function buildKindRemovalOnConflictSet(removedAtColumn, paramsRemovedAt) {
     lastError: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_error")}`
   };
 }
-function assertAdoptedDialect(externalTx, brand, backend) {
-  if (drizzleOrm.is(externalTx, brand)) return;
-  const label = backend === "postgres" ? "Postgres" : "SQLite";
-  throw new chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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;
-    },
-    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;
+function buildClearGraph(tables3, graphId) {
+  const fulltext2 = chunkCFNT3ITG_cjs.quotedTableName(tables3.fulltextTableName);
+  return [
+    { query: drizzleOrm.sql`DELETE FROM ${fulltext2} WHERE "graph_id" = ${graphId}` },
+    {
+      query: drizzleOrm.sql`DELETE FROM ${tables3.recordedEdges} WHERE ${tables3.recordedEdges.graphId} = ${graphId}`,
+      ignoreMissingTable: true,
+      requiredTableName: drizzleOrm.getTableName(tables3.recordedEdges)
     },
-    async updateNode(params) {
-      const timestamp2 = nowIso2();
-      const query = operationStrategy.buildUpdateNode(params, timestamp2);
-      const row = await execution.execGet(query);
-      if (!row) throw new chunkJIEJCTDS_cjs.DatabaseOperationError("Update node failed: no row returned", { operation: "update", entity: "node" });
-      return rowMappers.toNodeRow(row);
+    {
+      query: drizzleOrm.sql`DELETE FROM ${tables3.recordedNodes} WHERE ${tables3.recordedNodes.graphId} = ${graphId}`,
+      ignoreMissingTable: true,
+      requiredTableName: drizzleOrm.getTableName(tables3.recordedNodes)
     },
-    async deleteNode(params) {
-      const timestamp2 = nowIso2();
-      const query = operationStrategy.buildDeleteNode(params, timestamp2);
-      await execution.execRun(query);
+    {
+      query: drizzleOrm.sql`DELETE FROM ${tables3.recordedClock} WHERE ${tables3.recordedClock.graphId} = ${graphId}`,
+      ignoreMissingTable: true,
+      requiredTableName: drizzleOrm.getTableName(tables3.recordedClock)
     },
-    // 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: drizzleOrm.sql`DELETE FROM ${tables3.uniques} WHERE ${tables3.uniques.graphId} = ${graphId}`
     },
-    async insertEdge(params) {
-      const timestamp2 = nowIso2();
-      const query = operationStrategy.buildInsertEdge(params, timestamp2);
-      const row = await execution.execGet(query);
-      if (!row) throw new chunkJIEJCTDS_cjs.DatabaseOperationError("Insert edge failed: no row returned", { operation: "insert", entity: "edge" });
-      return rowMappers.toEdgeRow(row);
+    {
+      query: drizzleOrm.sql`DELETE FROM ${tables3.edges} WHERE ${tables3.edges.graphId} = ${graphId}`
     },
-    async insertEdgeNoReturn(params) {
-      const timestamp2 = nowIso2();
-      const query = operationStrategy.buildInsertEdgeNoReturn(params, timestamp2);
-      await execution.execRun(query);
+    {
+      query: drizzleOrm.sql`DELETE FROM ${tables3.nodes} WHERE ${tables3.nodes.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: drizzleOrm.sql`DELETE FROM ${tables3.indexMaterializations} WHERE ${tables3.indexMaterializations.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: drizzleOrm.sql`DELETE FROM ${tables3.kindRemovals} WHERE ${tables3.kindRemovals.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;
+    {
+      query: drizzleOrm.sql`DELETE FROM ${tables3.reconciliationMarkers} WHERE ${tables3.reconciliationMarkers.graphId} = ${graphId}`
     },
-    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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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: drizzleOrm.sql`DELETE FROM ${tables3.schemaVersions} WHERE ${tables3.schemaVersions.graphId} = ${graphId}`
     }
-  };
-}
-function buildClearGraph(tables3, graphId) {
-  const fulltext2 = chunkCFNT3ITG_cjs.quotedTableName(tables3.fulltextTableName);
-  return [
-    drizzleOrm.sql`DELETE FROM ${fulltext2} WHERE "graph_id" = ${graphId}`,
-    drizzleOrm.sql`DELETE FROM ${tables3.uniques} WHERE ${tables3.uniques.graphId} = ${graphId}`,
-    drizzleOrm.sql`DELETE FROM ${tables3.edges} WHERE ${tables3.edges.graphId} = ${graphId}`,
-    drizzleOrm.sql`DELETE FROM ${tables3.nodes} WHERE ${tables3.nodes.graphId} = ${graphId}`,
-    drizzleOrm.sql`DELETE FROM ${tables3.indexMaterializations} WHERE ${tables3.indexMaterializations.graphId} = ${graphId}`,
-    drizzleOrm.sql`DELETE FROM ${tables3.kindRemovals} WHERE ${tables3.kindRemovals.graphId} = ${graphId}`,
-    drizzleOrm.sql`DELETE FROM ${tables3.reconciliationMarkers} WHERE ${tables3.reconciliationMarkers.graphId} = ${graphId}`,
-    drizzleOrm.sql`DELETE FROM ${tables3.schemaVersions} WHERE ${tables3.schemaVersions.graphId} = ${graphId}`
   ];
 }
 function buildTemporalConditions(table, params) {
@@ -1675,14 +1308,10 @@ function buildGetEdge(tables3, graphId, id) {
 }
 function buildGetEdges(tables3, graphId, ids) {
   const { edges: edges2 } = tables3;
-  const idPlaceholders = drizzleOrm.sql.join(
-    ids.map((edgeId) => drizzleOrm.sql`${edgeId}`),
-    drizzleOrm.sql`, `
-  );
   return drizzleOrm.sql`
     SELECT * FROM ${edges2}
     WHERE ${edges2.graphId} = ${graphId}
-      AND ${edges2.id} IN (${idPlaceholders})
+      AND ${edges2.id} IN (${chunkI4W7MKVG_cjs.sqlValueList(ids)})
   `;
 }
 function buildUpdateEdge(tables3, params, timestamp2) {
@@ -1919,15 +1548,11 @@ function buildGetNode(tables3, graphId, kind, id) {
 }
 function buildGetNodes(tables3, graphId, kind, ids) {
   const { nodes: nodes2 } = tables3;
-  const idPlaceholders = drizzleOrm.sql.join(
-    ids.map((nodeId) => drizzleOrm.sql`${nodeId}`),
-    drizzleOrm.sql`, `
-  );
   return drizzleOrm.sql`
     SELECT * FROM ${nodes2}
     WHERE ${nodes2.graphId} = ${graphId}
       AND ${nodes2.kind} = ${kind}
-      AND ${nodes2.id} IN (${idPlaceholders})
+      AND ${nodes2.id} IN (${chunkI4W7MKVG_cjs.sqlValueList(ids)})
   `;
 }
 function buildUpdateNode(tables3, params, timestamp2) {
@@ -2262,17 +1887,437 @@ function createCommonOperationStrategy(tables3, dialect, fulltextStrategy) {
     buildSetActiveSchema(graphId, version) {
       return buildSetActiveSchema(tables3, graphId, version, dialect);
     },
+    buildTableExists(tableName) {
+      if (dialect === "postgres") {
+        return drizzleOrm.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 drizzleOrm.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) => chunkI4W7MKVG_cjs.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 (drizzleOrm.is(externalTx, brand)) return;
+  const label = backend === "postgres" ? "Postgres" : "SQLite";
+  throw new chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.StaleVersionError({
+      graphId,
+      expected: expectedVersion,
+      actual: actualActiveVersion
+    });
+  }
+}
+function createCommonOperationBackend(options) {
+  const { batchConfig, execution, operationStrategy, rowMappers } = options;
+  const nowIso2 = options.nowIso ?? chunkI4W7MKVG_cjs.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 chunkJIEJCTDS_cjs.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 chunkI4W7MKVG_cjs.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 chunkI4W7MKVG_cjs.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 chunkI4W7MKVG_cjs.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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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 chunkI4W7MKVG_cjs.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 chunkI4W7MKVG_cjs.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 chunkI4W7MKVG_cjs.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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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 chunkI4W7MKVG_cjs.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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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 chunkJIEJCTDS_cjs.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) {
@@ -2304,11 +2349,9 @@ function compileQueryWithDialect(db, query, backendName) {
 exports.POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS = POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS;
 exports.POSTGRES_INDEX_MAT_TIMESTAMPS = POSTGRES_INDEX_MAT_TIMESTAMPS;
 exports.POSTGRES_KIND_REMOVAL_TIMESTAMPS = POSTGRES_KIND_REMOVAL_TIMESTAMPS;
-exports.POSTGRES_ROW_MAPPER_CONFIG = POSTGRES_ROW_MAPPER_CONFIG;
 exports.SQLITE_CONTRIBUTION_MAT_TIMESTAMPS = SQLITE_CONTRIBUTION_MAT_TIMESTAMPS;
 exports.SQLITE_INDEX_MAT_TIMESTAMPS = SQLITE_INDEX_MAT_TIMESTAMPS;
 exports.SQLITE_KIND_REMOVAL_TIMESTAMPS = SQLITE_KIND_REMOVAL_TIMESTAMPS;
-exports.SQLITE_ROW_MAPPER_CONFIG = SQLITE_ROW_MAPPER_CONFIG;
 exports.assertAdoptedDialect = assertAdoptedDialect;
 exports.buildContributionInsertValues = buildContributionInsertValues;
 exports.buildContributionOnConflictSet = buildContributionOnConflictSet;
@@ -2316,17 +2359,13 @@ exports.buildKindRemovalInsertValues = buildKindRemovalInsertValues;
 exports.buildKindRemovalOnConflictSet = buildKindRemovalOnConflictSet;
 exports.buildMaterializationInsertValues = buildMaterializationInsertValues;
 exports.buildMaterializationOnConflictSet = buildMaterializationOnConflictSet;
-exports.coerceNumericScore = coerceNumericScore;
 exports.compileQueryWithDialect = compileQueryWithDialect;
+exports.createCachedTableExistence = createCachedTableExistence;
 exports.createCommonOperationBackend = createCommonOperationBackend;
 exports.createContributionMaterializer = createContributionMaterializer;
-exports.createEdgeRowMapper = createEdgeRowMapper;
-exports.createNodeRowMapper = createNodeRowMapper;
 exports.createPostgresOperationStrategy = createPostgresOperationStrategy;
 exports.createPostgresTables = createPostgresTables;
-exports.createSchemaVersionRowMapper = createSchemaVersionRowMapper;
 exports.createSqliteOperationStrategy = createSqliteOperationStrategy;
-exports.createUniqueRowMapper = createUniqueRowMapper;
 exports.createVectorSlotLatch = createVectorSlotLatch;
 exports.edges = edges;
 exports.fulltext = fulltext;
@@ -2344,12 +2383,14 @@ exports.mapKindRemovalRow = mapKindRemovalRow;
 exports.mapMaterializationRow = mapMaterializationRow;
 exports.mapVectorWriteError = mapVectorWriteError;
 exports.nodes = nodes;
-exports.nowIso = nowIso;
+exports.recordedClock = recordedClock;
+exports.recordedEdges = recordedEdges;
+exports.recordedNodes = recordedNodes;
 exports.schemaVersions = schemaVersions;
 exports.tables = tables2;
 exports.uniques = uniques;
 exports.vectorSlotFromCreateIndexParams = vectorSlotFromCreateIndexParams;
 exports.vectorSlotFromDropIndexParams = vectorSlotFromDropIndexParams;
 exports.vectorSlotFromParams = vectorSlotFromParams;
-//# sourceMappingURL=chunk-3HQDMOBK.cjs.map
-//# sourceMappingURL=chunk-3HQDMOBK.cjs.map
+//# sourceMappingURL=chunk-KY5SDVA7.cjs.map
+//# sourceMappingURL=chunk-KY5SDVA7.cjs.map