@nicia-ai/typegraph 0.35.0 → 0.37.0

package/dist/{chunk-EM3CWPND.cjs → chunk-DIQ3AV5W.cjs}

@@ -1,15 +1,16 @@
 'use strict';
 
-var chunkFN35DLCN_cjs = require('./chunk-FN35DLCN.cjs');
-var chunkS55OV6PW_cjs = require('./chunk-S55OV6PW.cjs');
-var chunkCTTSDJLY_cjs = require('./chunk-CTTSDJLY.cjs');
+var chunk3C2RYI6L_cjs = require('./chunk-3C2RYI6L.cjs');
+var chunkXPCZADMT_cjs = require('./chunk-XPCZADMT.cjs');
+var chunkVL2V6PEN_cjs = require('./chunk-VL2V6PEN.cjs');
 var chunkACSVZPK7_cjs = require('./chunk-ACSVZPK7.cjs');
+var chunkQARBLBXT_cjs = require('./chunk-QARBLBXT.cjs');
 var chunkTEDRJXOG_cjs = require('./chunk-TEDRJXOG.cjs');
-var chunkD7ZEOS56_cjs = require('./chunk-D7ZEOS56.cjs');
-var chunk4TOD4LBZ_cjs = require('./chunk-4TOD4LBZ.cjs');
-var chunkBLZDPRXT_cjs = require('./chunk-BLZDPRXT.cjs');
+var chunkXGU7DZDA_cjs = require('./chunk-XGU7DZDA.cjs');
+var chunkIPSVVTWT_cjs = require('./chunk-IPSVVTWT.cjs');
+var chunk3GH67G4Z_cjs = require('./chunk-3GH67G4Z.cjs');
 var chunk7YSP4V4R_cjs = require('./chunk-7YSP4V4R.cjs');
-var chunkLGEALRC6_cjs = require('./chunk-LGEALRC6.cjs');
+var chunkBVRDGYXQ_cjs = require('./chunk-BVRDGYXQ.cjs');
 var drizzleOrm = require('drizzle-orm');
 var pgCore = require('drizzle-orm/pg-core');
 var sqliteCore = require('drizzle-orm/sqlite-core');
@@ -40,6 +41,7 @@ var DEFAULT_TABLE_NAMES = {
 function createPostgresTables(names = {}, options = {}) {
   const n = { ...DEFAULT_TABLE_NAMES, ...names };
   const indexes = options.indexes ?? [];
+  chunkQARBLBXT_cjs.assertNoSystemIndexNameCollision(indexes, n);
   const nodes2 = pgCore.pgTable(
     n.nodes,
     {
@@ -56,16 +58,10 @@ function createPostgresTables(names = {}, options = {}) {
     },
     (t) => [
       pgCore.primaryKey({ columns: [t.graphId, t.kind, t.id] }),
-      pgCore.index(`${n.nodes}_kind_idx`).on(t.graphId, t.kind),
-      pgCore.index(`${n.nodes}_kind_created_idx`).on(
-        t.graphId,
-        t.kind,
-        t.deletedAt,
-        t.createdAt
-      ),
-      pgCore.index(`${n.nodes}_deleted_idx`).on(t.graphId, t.deletedAt),
-      pgCore.index(`${n.nodes}_valid_idx`).on(t.graphId, t.validFrom, t.validTo),
-      ...chunkS55OV6PW_cjs.buildPostgresNodeIndexBuilders(t, indexes)
+      // System indexes come from SYSTEM_INDEX_DECLARATIONS (single source
+      // for both dialects + the runtime materializer).
+      ...chunkXPCZADMT_cjs.buildPostgresSystemIndexBuilders("nodes", n.nodes, t),
+      ...chunkXPCZADMT_cjs.buildPostgresNodeIndexBuilders(t, indexes)
     ]
   );
   const edges2 = pgCore.pgTable(
@@ -87,56 +83,8 @@ function createPostgresTables(names = {}, options = {}) {
     },
     (t) => [
       pgCore.primaryKey({ columns: [t.graphId, t.id] }),
-      pgCore.index(`${n.edges}_kind_idx`).on(t.graphId, t.kind),
-      // Directional traversal index (outgoing): supports endpoint lookups
-      // and extra filtering by edge kind / target kind. Includes every
-      // system column the compiled query's soft-delete/temporal-validity
-      // predicate touches (deleted_at, valid_from, valid_to), trailed by
-      // to_id — the compiled traversal join reads `n.id = e.to_id` for an
-      // outgoing traversal (standard-builders.ts), so without to_id here
-      // the join still fetches the edge's heap row for that one column
-      // even with the seek/predicate columns covered.
-      pgCore.index(`${n.edges}_from_idx`).on(
-        t.graphId,
-        t.fromKind,
-        t.fromId,
-        t.kind,
-        t.toKind,
-        t.deletedAt,
-        t.validFrom,
-        t.validTo,
-        t.toId
-      ),
-      // Directional traversal index (incoming): mirrors from_idx for
-      // reverse traversals, trailed by from_id for the same reason
-      // (`n.id = e.from_id` for an incoming traversal).
-      pgCore.index(`${n.edges}_to_idx`).on(
-        t.graphId,
-        t.toKind,
-        t.toId,
-        t.kind,
-        t.fromKind,
-        t.deletedAt,
-        t.validFrom,
-        t.validTo,
-        t.fromId
-      ),
-      pgCore.index(`${n.edges}_kind_created_idx`).on(
-        t.graphId,
-        t.kind,
-        t.deletedAt,
-        t.createdAt
-      ),
-      pgCore.index(`${n.edges}_deleted_idx`).on(t.graphId, t.deletedAt),
-      pgCore.index(`${n.edges}_valid_idx`).on(t.graphId, t.validFrom, t.validTo),
-      pgCore.index(`${n.edges}_cardinality_idx`).on(
-        t.graphId,
-        t.kind,
-        t.fromKind,
-        t.fromId,
-        t.validTo
-      ),
-      ...chunkS55OV6PW_cjs.buildPostgresEdgeIndexBuilders(t, indexes)
+      ...chunkXPCZADMT_cjs.buildPostgresSystemIndexBuilders("edges", n.edges, t),
+      ...chunkXPCZADMT_cjs.buildPostgresEdgeIndexBuilders(t, indexes)
     ]
   );
   const recordedNodes2 = pgCore.pgTable(
@@ -162,19 +110,7 @@ function createPostgresTables(names = {}, options = {}) {
     },
     (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
-      )
+      ...chunkXPCZADMT_cjs.buildPostgresSystemIndexBuilders("recordedNodes", n.recordedNodes, t)
     ]
   );
   const recordedEdges2 = pgCore.pgTable(
@@ -203,37 +139,7 @@ function createPostgresTables(names = {}, options = {}) {
     },
     (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
-      )
+      ...chunkXPCZADMT_cjs.buildPostgresSystemIndexBuilders("recordedEdges", n.recordedEdges, t)
     ]
   );
   const recordedClock2 = pgCore.pgTable(
@@ -462,9 +368,9 @@ function renderIndexColumn(col) {
   if (col && typeof col === "object" && "name" in col) {
     return `"${col.name}"`;
   }
-  const sql14 = tryInlineSql(col);
-  if (sql14 !== void 0) {
-    return sql14;
+  const sql15 = tryInlineSql(col);
+  if (sql15 !== void 0) {
+    return sql15;
   }
   return "unknown";
 }
@@ -540,13 +446,13 @@ function isSqliteTable(value) {
 function runtimeStrategyContributions(fulltextStrategy, fulltextTableName) {
   return fulltextStrategy.ownedTables(fulltextTableName).filter((contribution) => contribution.runtimeEnsure);
 }
-function sqliteContributions(tables3 = chunkFN35DLCN_cjs.tables, fulltextStrategy = chunkD7ZEOS56_cjs.fts5Strategy) {
+function sqliteContributions(tables3 = chunk3C2RYI6L_cjs.tables, fulltextStrategy = chunkXGU7DZDA_cjs.fts5Strategy) {
   const contributions = [];
   for (const [key, table] of Object.entries(tables3)) {
     if (!isSqliteTable(table)) continue;
     contributions.push({
       logicalName: key,
-      owner: chunkD7ZEOS56_cjs.BASE_CONTRIBUTION_OWNER,
+      owner: chunkXGU7DZDA_cjs.BASE_CONTRIBUTION_OWNER,
       tableName: sqliteCore.getTableConfig(table).name,
       createDdl: [
         generateSqliteCreateTableSQL(table),
@@ -562,12 +468,12 @@ function sqliteContributions(tables3 = chunkFN35DLCN_cjs.tables, fulltextStrateg
   }
   return contributions;
 }
-function generateSqliteDDL(tables3 = chunkFN35DLCN_cjs.tables, fulltextStrategy = chunkD7ZEOS56_cjs.fts5Strategy) {
+function generateSqliteDDL(tables3 = chunk3C2RYI6L_cjs.tables, fulltextStrategy = chunkXGU7DZDA_cjs.fts5Strategy) {
   return sqliteContributions(tables3, fulltextStrategy).flatMap(
     (contribution) => [...contribution.createDdl]
   );
 }
-function generateSqliteMigrationSQL(tables3 = chunkFN35DLCN_cjs.tables, fulltextStrategy = chunkD7ZEOS56_cjs.fts5Strategy) {
+function generateSqliteMigrationSQL(tables3 = chunk3C2RYI6L_cjs.tables, fulltextStrategy = chunkXGU7DZDA_cjs.fts5Strategy) {
   return generateSqliteDDL(tables3, fulltextStrategy).join("\n\n");
 }
 function getPgColumnType(column) {
@@ -649,14 +555,14 @@ function generatePgCreateIndexSQL(table) {
 function isPgTable(value) {
   return drizzleOrm.is(value, pgCore.PgTable);
 }
-function postgresContributions(tables3 = tables2, fulltextStrategy = chunkD7ZEOS56_cjs.tsvectorStrategy) {
+function postgresContributions(tables3 = tables2, fulltextStrategy = chunkXGU7DZDA_cjs.tsvectorStrategy) {
   const contributions = [];
   for (const [key, table] of Object.entries(tables3)) {
     if (!isPgTable(table)) continue;
     if (table === tables3.fulltext) continue;
     contributions.push({
       logicalName: key,
-      owner: chunkD7ZEOS56_cjs.BASE_CONTRIBUTION_OWNER,
+      owner: chunkXGU7DZDA_cjs.BASE_CONTRIBUTION_OWNER,
       tableName: pgCore.getTableConfig(table).name,
       createDdl: [
         generatePgCreateTableSQL(table),
@@ -672,12 +578,12 @@ function postgresContributions(tables3 = tables2, fulltextStrategy = chunkD7ZEOS
   }
   return contributions;
 }
-function generatePostgresDDL(tables3 = tables2, fulltextStrategy = chunkD7ZEOS56_cjs.tsvectorStrategy) {
+function generatePostgresDDL(tables3 = tables2, fulltextStrategy = chunkXGU7DZDA_cjs.tsvectorStrategy) {
   return postgresContributions(tables3, fulltextStrategy).flatMap(
     (contribution) => [...contribution.createDdl]
   );
 }
-function generatePostgresMigrationSQL(tables3 = tables2, fulltextStrategy = chunkD7ZEOS56_cjs.tsvectorStrategy) {
+function generatePostgresMigrationSQL(tables3 = tables2, fulltextStrategy = chunkXGU7DZDA_cjs.tsvectorStrategy) {
   const extensionSql = "-- Enable pgvector extension for vector similarity search\nCREATE EXTENSION IF NOT EXISTS vector;";
   const ddlSql = generatePostgresDDL(tables3, fulltextStrategy).join("\n\n");
   return `${extensionSql}
@@ -686,39 +592,6 @@ ${ddlSql}`;
 }
 
 // src/backend/drizzle/vector-runtime.ts
-function vectorSlotKey(slot) {
-  return JSON.stringify([
-    slot.graphId,
-    slot.nodeKind,
-    slot.fieldPath,
-    slot.dimensions,
-    slot.metric,
-    slot.indexType
-  ]);
-}
-function createVectorSlotLatch() {
-  const inFlight = /* @__PURE__ */ new Map();
-  return {
-    ensure(strategy, slot, execDdl) {
-      const key = vectorSlotKey(slot);
-      const existing = inFlight.get(key);
-      if (existing !== void 0) return existing;
-      const run = (async () => {
-        for (const contribution of strategy.ownedTables(slot)) {
-          for (const statement of contribution.createDdl) {
-            await execDdl(statement);
-          }
-        }
-      })();
-      const cached = run.catch((error) => {
-        inFlight.delete(key);
-        throw error;
-      });
-      inFlight.set(key, cached);
-      return cached;
-    }
-  };
-}
 var VECTOR_SLOT_PLACEHOLDER_DIMENSIONS = 1;
 var EMBEDDING_UPSERT_PARAM_COUNT = 5;
 function vectorSlotFromParams(params) {
@@ -748,10 +621,10 @@ function vectorSlotFromDropIndexParams(params) {
   };
 }
 function mapVectorWriteError(error, params) {
-  const mismatch = chunkBLZDPRXT_cjs.parseDimensionMismatch(error);
+  const mismatch = chunk3GH67G4Z_cjs.parseDimensionMismatch(error);
   if (mismatch === void 0) return error;
   const attempted = mismatch.actual ?? "a different number of";
-  return new chunkLGEALRC6_cjs.EmbeddingDimensionChangedError(
+  return new chunkBVRDGYXQ_cjs.EmbeddingDimensionChangedError(
     `Embedding "${params.nodeKind}.${params.fieldPath}" was written with ${attempted} dimensions, but its per-field storage expects ${mismatch.expected}. The field's embedding dimension changed; existing vectors must be recreated and re-embedded.`,
     {
       kind: params.nodeKind,
@@ -767,7 +640,7 @@ var SQLITE_CONTRIBUTION_MAT_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS = {
-  decode: chunkCTTSDJLY_cjs.formatPostgresTimestamp,
+  decode: chunkVL2V6PEN_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapContributionMaterializationRow(row, decode) {
@@ -809,7 +682,7 @@ function buildContributionOnConflictSet(materializedAtColumn, paramsMaterialized
     lastError: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_error")}`
   };
 }
-async function computeContributionSignature(dialect, identity, createDdl) {
+function contributionSignatureInput(dialect, identity, createDdl) {
   const hashable = {
     dialect,
     owner: identity.owner,
@@ -817,7 +690,7 @@ async function computeContributionSignature(dialect, identity, createDdl) {
     tableName: identity.tableName,
     createDdl
   };
-  return chunkTEDRJXOG_cjs.sha256Hex(JSON.stringify(hashable, chunkACSVZPK7_cjs.sortedReplacer), 16);
+  return JSON.stringify(hashable, chunkACSVZPK7_cjs.sortedReplacer);
 }
 function evaluateContributionState(row, signature) {
   if (row === void 0) return "missing";
@@ -881,43 +754,82 @@ function gateFulltextMethods(source, assert) {
   return gated;
 }
 function gateFulltext(tx, assert) {
-  return chunk4TOD4LBZ_cjs.createBackendOverlay(
+  return chunkIPSVVTWT_cjs.createBackendOverlay(
     tx,
     gateFulltextMethods(tx, assert)
   );
 }
+var CONTRIBUTION_KEY_SEPARATOR = String.fromCodePoint(0);
+function contributionKey(graphId, contribution) {
+  return [
+    graphId,
+    contribution.owner,
+    contribution.logicalName,
+    contribution.tableName
+  ].join(CONTRIBUTION_KEY_SEPARATOR);
+}
 function createContributionMaterializer(deps) {
   const { dialect, fulltextStrategy, fulltextTableName } = deps;
-  const initializedGraphIds = /* @__PURE__ */ new Set();
-  function runtimeContributions() {
-    return runtimeStrategyContributions(fulltextStrategy, fulltextTableName);
-  }
-  async function materializeOne(graphId, contribution) {
-    const signature = await computeContributionSignature(
+  const initializedSignatures = /* @__PURE__ */ new Map();
+  const computedSignatures = /* @__PURE__ */ new Map();
+  async function resolveContributionSignature(key, contribution) {
+    const cached = computedSignatures.get(key);
+    const cachedCreateDdl = cached?.createDdl;
+    const cachedSignature = cached?.signature;
+    if (cachedCreateDdl?.length === contribution.createDdl.length && cachedSignature !== void 0 && contribution.createDdl.every(
+      (statement, index2) => cachedCreateDdl[index2] === statement
+    )) {
+      return cachedSignature;
+    }
+    const input = contributionSignatureInput(
       dialect,
       contribution,
       contribution.createDdl
     );
+    const entry = {
+      createDdl: [...contribution.createDdl],
+      signature: chunkTEDRJXOG_cjs.sha256Hex(input, 16)
+    };
+    computedSignatures.set(key, entry);
+    try {
+      return await entry.signature;
+    } catch (error) {
+      if (computedSignatures.get(key) === entry) {
+        computedSignatures.delete(key);
+      }
+      throw error;
+    }
+  }
+  function runtimeContributions() {
+    return runtimeStrategyContributions(fulltextStrategy, fulltextTableName);
+  }
+  async function materializeOne(graphId, contribution, signature, existing, options) {
+    const force = options?.force === true;
     const identity = identityOf(graphId, contribution);
-    const existing = await deps.getMarker(identity);
-    if (evaluateContributionState(existing, signature) === "initialized") {
-      return;
+    if (!force && evaluateContributionState(existing, signature) === "initialized") {
+      return "materialized";
     }
     const priorSuccess = existing?.materializedAt !== void 0;
-    if (priorSuccess && existing.signature !== signature) {
+    if (!force && priorSuccess && existing.signature !== signature) {
+      if (options?.onDrift === "skip") {
+        console.warn(
+          `[typegraph] contribution "${contribution.logicalName}" (table "${contribution.tableName}") is provisioned at a different shape than the current declaration \u2014 left untouched. Writes to it will fail until store.reembedVectorField(kind, fieldPath) recreates the storage at the new shape.`
+        );
+        return "drift-skipped";
+      }
       const error = new Error(
         `Contribution "${contribution.logicalName}" (owner "${contribution.owner}", table "${contribution.tableName}") was already materialized with a different signature. The recorded physical shape is stale relative to the current strategy/DDL \u2014 migrate or drop the table and retry, or restore the original strategy.`
       );
       await deps.recordMarker({
         ...identity,
         signature,
-        attemptedAt: chunkCTTSDJLY_cjs.nowIso(),
+        attemptedAt: chunkVL2V6PEN_cjs.nowIso(),
         materializedAt: void 0,
         error: error.message
       });
       throw error;
     }
-    const attemptedAt = chunkCTTSDJLY_cjs.nowIso();
+    const attemptedAt = chunkVL2V6PEN_cjs.nowIso();
     try {
       for (const statement of contribution.createDdl) {
         await deps.execDdl(statement);
@@ -939,71 +851,166 @@ function createContributionMaterializer(deps) {
       materializedAt: attemptedAt,
       error: void 0
     });
+    return "materialized";
   }
-  async function readContributionState(graphId, contribution) {
-    const signature = await computeContributionSignature(
-      dialect,
-      contribution,
-      contribution.createDdl
+  function indexMarkerRows(graphId, rows) {
+    return new Map(
+      rows.map((row) => [contributionKey(graphId, row), row])
     );
-    const identity = identityOf(graphId, contribution);
+  }
+  async function readMarkerRows(graphId) {
     try {
-      const existing = await deps.getMarker(identity);
       return {
-        kind: "state",
-        state: evaluateContributionState(existing, signature)
+        kind: "rows",
+        rows: indexMarkerRows(graphId, await deps.getMarkers(graphId))
       };
     } catch (error) {
-      if (!chunkBLZDPRXT_cjs.isMissingTableError(error)) throw error;
+      if (!chunk3GH67G4Z_cjs.isMissingTableError(error)) throw error;
       return { kind: "missing-table", error };
     }
   }
-  async function allContributionsInitialized(graphId, contributions) {
-    for (const contribution of contributions) {
-      const read = await readContributionState(graphId, contribution);
-      if (read.kind !== "state" || read.state !== "initialized") return false;
-    }
-    return true;
-  }
-  async function ensureRuntimeContributions(graphId) {
-    if (initializedGraphIds.has(graphId)) return;
-    const contributions = runtimeContributions();
-    if (await allContributionsInitialized(graphId, contributions)) {
-      initializedGraphIds.add(graphId);
+  async function ensureContributions(graphId, contributions, options) {
+    const force = options?.force === true;
+    const entries = await Promise.all(
+      contributions.map(async (contribution) => {
+        const key = contributionKey(graphId, contribution);
+        return {
+          contribution,
+          key,
+          signature: await resolveContributionSignature(key, contribution)
+        };
+      })
+    );
+    const pending = force ? entries : entries.filter(
+      (entry) => initializedSignatures.get(entry.key) !== entry.signature
+    );
+    if (pending.length === 0) return;
+    const initialRead = force ? void 0 : await readMarkerRows(graphId);
+    if (!force && initialRead?.kind === "rows" && pending.every(
+      (entry) => evaluateContributionState(
+        initialRead.rows.get(entry.key),
+        entry.signature
+      ) === "initialized"
+    )) {
+      for (const entry of pending) {
+        initializedSignatures.set(entry.key, entry.signature);
+      }
       return;
     }
     await deps.ensureMarkerTable();
-    for (const contribution of contributions) {
-      await materializeOne(graphId, contribution);
+    const existingRows = indexMarkerRows(
+      graphId,
+      await deps.getMarkers(graphId)
+    );
+    for (const entry of pending) {
+      const outcome = await materializeOne(
+        graphId,
+        entry.contribution,
+        entry.signature,
+        existingRows.get(entry.key),
+        {
+          force,
+          ...options?.onDrift === void 0 ? {} : { onDrift: options.onDrift }
+        }
+      );
+      if (outcome === "materialized") {
+        initializedSignatures.set(entry.key, entry.signature);
+      }
     }
-    initializedGraphIds.add(graphId);
   }
-  async function assertInitialized(graphId) {
-    if (initializedGraphIds.has(graphId)) return;
-    for (const contribution of runtimeContributions()) {
-      const read = await readContributionState(graphId, contribution);
-      if (read.kind === "missing-table") {
-        throw new chunkLGEALRC6_cjs.StoreNotInitializedError(graphId, "missing", {
-          cause: read.error,
-          details: { logicalName: contribution.logicalName }
-        });
-      }
-      if (read.state !== "initialized") {
-        throw new chunkLGEALRC6_cjs.StoreNotInitializedError(graphId, read.state, {
+  async function assertContributions(graphId, contributions) {
+    const entries = await Promise.all(
+      contributions.map(async (contribution) => {
+        const key = contributionKey(graphId, contribution);
+        return {
+          contribution,
+          key,
+          signature: await resolveContributionSignature(key, contribution)
+        };
+      })
+    );
+    const pending = entries.filter(
+      (entry) => initializedSignatures.get(entry.key) !== entry.signature
+    );
+    if (pending.length === 0) return;
+    const read = await readMarkerRows(graphId);
+    if (read.kind === "missing-table") {
+      const first = pending[0];
+      if (first === void 0) return;
+      throw new chunkBVRDGYXQ_cjs.StoreNotInitializedError(graphId, "missing", {
+        cause: read.error,
+        details: { logicalName: first.contribution.logicalName }
+      });
+    }
+    for (const entry of pending) {
+      const { contribution, key, signature } = entry;
+      const state = evaluateContributionState(read.rows.get(key), signature);
+      if (state !== "initialized") {
+        throw new chunkBVRDGYXQ_cjs.StoreNotInitializedError(graphId, state, {
           details: { logicalName: contribution.logicalName }
         });
       }
+      initializedSignatures.set(key, signature);
+    }
+  }
+  async function ensureRuntimeContributions(graphId) {
+    await ensureContributions(graphId, runtimeContributions());
+  }
+  async function assertInitialized(graphId) {
+    await assertContributions(graphId, runtimeContributions());
+  }
+  async function ensureVectorSlot(slot, options) {
+    await ensureVectorSlots([slot], options);
+  }
+  async function assertVectorSlot(slot) {
+    await assertVectorSlots([slot]);
+  }
+  function groupVectorContributions(slots) {
+    const grouped = /* @__PURE__ */ new Map();
+    if (deps.vectorStrategy === void 0) return grouped;
+    for (const slot of slots) {
+      grouped.set(slot.graphId, [
+        ...grouped.get(slot.graphId) ?? [],
+        ...deps.vectorStrategy.ownedTables(slot)
+      ]);
+    }
+    return grouped;
+  }
+  async function ensureVectorSlots(slots, options) {
+    for (const [graphId, contributions] of groupVectorContributions(slots)) {
+      await ensureContributions(graphId, contributions, options);
     }
-    initializedGraphIds.add(graphId);
   }
-  return { ensureRuntimeContributions, assertInitialized };
+  async function assertVectorSlots(slots) {
+    for (const [graphId, contributions] of groupVectorContributions(slots)) {
+      await assertContributions(graphId, contributions);
+    }
+  }
+  async function dropVectorSlot(slot) {
+    if (deps.vectorStrategy === void 0) return;
+    for (const contribution of deps.vectorStrategy.ownedTables(slot)) {
+      await deps.deleteMarker(identityOf(slot.graphId, contribution));
+      const key = contributionKey(slot.graphId, contribution);
+      initializedSignatures.delete(key);
+      computedSignatures.delete(key);
+    }
+  }
+  return {
+    ensureRuntimeContributions,
+    assertInitialized,
+    ensureVectorSlot,
+    ensureVectorSlots,
+    assertVectorSlot,
+    assertVectorSlots,
+    dropVectorSlot
+  };
 }
 var SQLITE_INDEX_MAT_TIMESTAMPS = {
   decode: (value) => typeof value === "string" ? value : void 0,
   encode: (value) => value
 };
 var POSTGRES_INDEX_MAT_TIMESTAMPS = {
-  decode: chunkCTTSDJLY_cjs.formatPostgresTimestamp,
+  decode: chunkVL2V6PEN_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapMaterializationRow(row, decode) {
@@ -1038,15 +1045,20 @@ function buildMaterializationInsertValues(params, encode) {
     lastError: params.error
   };
 }
-function buildMaterializationOnConflictSet(materializedAtColumn, paramsMaterializedAt) {
-  const materializedAtSet = paramsMaterializedAt === void 0 ? drizzleOrm.sql`COALESCE(excluded.${drizzleOrm.sql.identifier("materialized_at")}, ${materializedAtColumn})` : drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("materialized_at")}`;
+function buildMaterializationOnConflictSet(paramsMaterializedAt) {
+  if (paramsMaterializedAt === void 0) {
+    return {
+      lastAttemptedAt: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_attempted_at")}`,
+      lastError: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_error")}`
+    };
+  }
   return {
     graphId: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("graph_id")}`,
     entity: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("entity")}`,
     kind: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("kind")}`,
     signature: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("signature")}`,
     schemaVersion: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("schema_version")}`,
-    materializedAt: materializedAtSet,
+    materializedAt: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("materialized_at")}`,
     lastAttemptedAt: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_attempted_at")}`,
     lastError: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_error")}`
   };
@@ -1056,7 +1068,7 @@ var SQLITE_KIND_REMOVAL_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_KIND_REMOVAL_TIMESTAMPS = {
-  decode: chunkCTTSDJLY_cjs.formatPostgresTimestamp,
+  decode: chunkVL2V6PEN_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapKindRemovalRow(row, decode) {
@@ -1188,12 +1200,12 @@ function present(value) {
 function mapHybridSearchRow(row, toNodeRow) {
   return {
     node: toNodeRow(row),
-    fusedScore: chunkCTTSDJLY_cjs.coerceNumericScore(row.fused_score),
+    fusedScore: chunkVL2V6PEN_cjs.coerceNumericScore(row.fused_score),
     ...present(row.vector_rank) ? { vectorRank: Number(row.vector_rank) } : {},
-    ...present(row.vector_score) ? { vectorScore: chunkCTTSDJLY_cjs.coerceNumericScore(row.vector_score) } : {},
+    ...present(row.vector_score) ? { vectorScore: chunkVL2V6PEN_cjs.coerceNumericScore(row.vector_score) } : {},
     ...present(row.fulltext_rank) ? { fulltextRank: Number(row.fulltext_rank) } : {},
     ...present(row.fulltext_score) ? {
-      fulltextScore: chunkCTTSDJLY_cjs.coerceNumericScore(
+      fulltextScore: chunkVL2V6PEN_cjs.coerceNumericScore(
         row.fulltext_score
       )
     } : {},
@@ -1447,7 +1459,7 @@ function buildGetEdges(tables3, graphId, ids) {
   return drizzleOrm.sql`
     SELECT * FROM ${edges2}
     WHERE ${edges2.graphId} = ${graphId}
-      AND ${edges2.id} IN (${chunk4TOD4LBZ_cjs.sqlValueList(ids)})
+      AND ${edges2.id} IN (${chunkIPSVVTWT_cjs.sqlValueList(ids)})
   `;
 }
 function buildUpdateEdge(tables3, params, timestamp2) {
@@ -1498,7 +1510,7 @@ function buildDeleteEdgesBatch(tables3, params, timestamp2) {
     UPDATE ${edges2}
     SET ${chunk7YSP4V4R_cjs.quotedColumn(edges2.deletedAt)} = ${timestamp2}
     WHERE ${edges2.graphId} = ${params.graphId}
-      AND ${edges2.id} IN (${chunk4TOD4LBZ_cjs.sqlValueList(params.ids)})
+      AND ${edges2.id} IN (${chunkIPSVVTWT_cjs.sqlValueList(params.ids)})
       AND ${edges2.deletedAt} IS NULL
   `;
 }
@@ -1507,7 +1519,7 @@ function buildHardDeleteEdgesBatch(tables3, params) {
   return drizzleOrm.sql`
     DELETE FROM ${edges2}
     WHERE ${edges2.graphId} = ${params.graphId}
-      AND ${edges2.id} IN (${chunk4TOD4LBZ_cjs.sqlValueList(params.ids)})
+      AND ${edges2.id} IN (${chunkIPSVVTWT_cjs.sqlValueList(params.ids)})
   `;
 }
 function buildHardDeleteEdge(tables3, params) {
@@ -1710,7 +1722,7 @@ function buildGetNodes(tables3, graphId, kind, ids) {
     SELECT * FROM ${nodes2}
     WHERE ${nodes2.graphId} = ${graphId}
       AND ${nodes2.kind} = ${kind}
-      AND ${nodes2.id} IN (${chunk4TOD4LBZ_cjs.sqlValueList(ids)})
+      AND ${nodes2.id} IN (${chunkIPSVVTWT_cjs.sqlValueList(ids)})
   `;
 }
 function buildUpdateNode(tables3, params, timestamp2) {
@@ -2081,15 +2093,15 @@ function createCommonOperationStrategy(tables3, dialect, fulltextStrategy) {
       dialect,
       // Store-compiled candidates (predicates + subclass + currency)
       // take precedence; the live-node default covers direct backend use.
-      params.candidates ?? chunk7YSP4V4R_cjs.liveNodeIdsSubquery(tables3.nodes, params.graphId, params.nodeKind, chunkCTTSDJLY_cjs.nowIso())
+      params.candidates ?? chunk7YSP4V4R_cjs.liveNodeIdsSubquery(tables3.nodes, params.graphId, params.nodeKind, chunkVL2V6PEN_cjs.nowIso())
     ),
-    buildLiveNodeIds: (graphId, nodeKind) => chunk7YSP4V4R_cjs.liveNodeIdsSubquery(tables3.nodes, graphId, nodeKind, chunkCTTSDJLY_cjs.nowIso()),
+    buildLiveNodeIds: (graphId, nodeKind) => chunk7YSP4V4R_cjs.liveNodeIdsSubquery(tables3.nodes, graphId, nodeKind, chunkVL2V6PEN_cjs.nowIso()),
     buildHybridSearch: (params, vectorSql, vectorScoreDescending) => {
       const candidates = params.candidates ?? chunk7YSP4V4R_cjs.liveNodeIdsSubquery(
         tables3.nodes,
         params.graphId,
         params.nodeKind,
-        chunkCTTSDJLY_cjs.nowIso()
+        chunkVL2V6PEN_cjs.nowIso()
       );
       const fulltextSql = buildFulltextSearch(
         fulltextTable,
@@ -2164,7 +2176,7 @@ function createCommonOperationStrategy(tables3, dialect, fulltextStrategy) {
 }
 function tableExistsFromRow(row) {
   if (row === void 0) return false;
-  return Object.values(row).some((value) => chunk4TOD4LBZ_cjs.isPresent(value));
+  return Object.values(row).some((value) => chunkIPSVVTWT_cjs.isPresent(value));
 }
 function createCachedTableExistence(probe, options) {
   const cacheExisting = options?.cacheExisting !== false;
@@ -2193,7 +2205,7 @@ function createPostgresOperationStrategy(tables3, fulltextStrategy) {
 function assertAdoptedDialect(externalTx, brand, backend) {
   if (drizzleOrm.is(externalTx, brand)) return;
   const label = backend === "postgres" ? "Postgres" : "SQLite";
-  throw new chunkLGEALRC6_cjs.ConfigurationError(
+  throw new chunkBVRDGYXQ_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" }
   );
@@ -2201,7 +2213,7 @@ function assertAdoptedDialect(externalTx, brand, backend) {
 function verifyExpectedActiveVersion(graphId, expected, actualActiveVersion) {
   const expectedVersion = expected.kind === "active" ? expected.version : 0;
   if (actualActiveVersion !== expectedVersion) {
-    throw new chunkLGEALRC6_cjs.StaleVersionError({
+    throw new chunkBVRDGYXQ_cjs.StaleVersionError({
       graphId,
       expected: expectedVersion,
       actual: actualActiveVersion
@@ -2210,7 +2222,7 @@ function verifyExpectedActiveVersion(graphId, expected, actualActiveVersion) {
 }
 function createCommonOperationBackend(options) {
   const { batchConfig, execution, operationStrategy, rowMappers } = options;
-  const nowIso2 = options.nowIso ?? chunkCTTSDJLY_cjs.nowIso;
+  const nowIso2 = options.nowIso ?? chunkVL2V6PEN_cjs.nowIso;
   const requiredClearTableExists = createCachedTableExistence(
     (tableName) => execution.execGet(
       operationStrategy.buildTableExists(tableName)
@@ -2233,16 +2245,26 @@ function createCommonOperationBackend(options) {
     async executeStatement(query) {
       await execution.execRun(query);
     },
+    async executeTemporaryStatement(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 chunkLGEALRC6_cjs.DatabaseOperationError("Insert node failed: no row returned", { operation: "insert", entity: "node" });
+      if (!row)
+        throw new chunkBVRDGYXQ_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);
+      const query = operationStrategy.buildInsertNodeNoReturn(
+        params,
+        timestamp2
+      );
       await execution.execRun(query);
     },
     async insertNodesBatch(params) {
@@ -2250,7 +2272,7 @@ function createCommonOperationBackend(options) {
         return;
       }
       const timestamp2 = nowIso2();
-      for (const chunk2 of chunk4TOD4LBZ_cjs.chunk(params, batchConfig.nodeInsertBatchSize)) {
+      for (const chunk2 of chunkIPSVVTWT_cjs.chunk(params, batchConfig.nodeInsertBatchSize)) {
         const query = operationStrategy.buildInsertNodesBatch(chunk2, timestamp2);
         await execution.execRun(query);
       }
@@ -2261,8 +2283,11 @@ function createCommonOperationBackend(options) {
       }
       const timestamp2 = nowIso2();
       const allRows = [];
-      for (const chunk2 of chunk4TOD4LBZ_cjs.chunk(params, batchConfig.nodeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertNodesBatchReturning(chunk2, timestamp2);
+      for (const chunk2 of chunkIPSVVTWT_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)));
       }
@@ -2276,7 +2301,7 @@ function createCommonOperationBackend(options) {
     async getNodes(graphId, kind, ids) {
       if (ids.length === 0) return [];
       const allRows = [];
-      for (const chunk2 of chunk4TOD4LBZ_cjs.chunk(ids, batchConfig.getNodesChunkSize)) {
+      for (const chunk2 of chunkIPSVVTWT_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)));
@@ -2287,7 +2312,11 @@ function createCommonOperationBackend(options) {
       const timestamp2 = nowIso2();
       const query = operationStrategy.buildUpdateNode(params, timestamp2);
       const row = await execution.execGet(query);
-      if (!row) throw new chunkLGEALRC6_cjs.DatabaseOperationError("Update node failed: no row returned", { operation: "update", entity: "node" });
+      if (!row)
+        throw new chunkBVRDGYXQ_cjs.DatabaseOperationError(
+          "Update node failed: no row returned",
+          { operation: "update", entity: "node" }
+        );
       return rowMappers.toNodeRow(row);
     },
     async deleteNode(params) {
@@ -2331,12 +2360,19 @@ function createCommonOperationBackend(options) {
       const timestamp2 = nowIso2();
       const query = operationStrategy.buildInsertEdge(params, timestamp2);
       const row = await execution.execGet(query);
-      if (!row) throw new chunkLGEALRC6_cjs.DatabaseOperationError("Insert edge failed: no row returned", { operation: "insert", entity: "edge" });
+      if (!row)
+        throw new chunkBVRDGYXQ_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);
+      const query = operationStrategy.buildInsertEdgeNoReturn(
+        params,
+        timestamp2
+      );
       await execution.execRun(query);
     },
     async insertEdgesBatch(params) {
@@ -2344,7 +2380,7 @@ function createCommonOperationBackend(options) {
         return;
       }
       const timestamp2 = nowIso2();
-      for (const chunk2 of chunk4TOD4LBZ_cjs.chunk(params, batchConfig.edgeInsertBatchSize)) {
+      for (const chunk2 of chunkIPSVVTWT_cjs.chunk(params, batchConfig.edgeInsertBatchSize)) {
         const query = operationStrategy.buildInsertEdgesBatch(chunk2, timestamp2);
         await execution.execRun(query);
       }
@@ -2355,8 +2391,11 @@ function createCommonOperationBackend(options) {
       }
       const timestamp2 = nowIso2();
       const allRows = [];
-      for (const chunk2 of chunk4TOD4LBZ_cjs.chunk(params, batchConfig.edgeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertEdgesBatchReturning(chunk2, timestamp2);
+      for (const chunk2 of chunkIPSVVTWT_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)));
       }
@@ -2370,7 +2409,7 @@ function createCommonOperationBackend(options) {
     async getEdges(graphId, ids) {
       if (ids.length === 0) return [];
       const allRows = [];
-      for (const chunk2 of chunk4TOD4LBZ_cjs.chunk(ids, batchConfig.getEdgesChunkSize)) {
+      for (const chunk2 of chunkIPSVVTWT_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)));
@@ -2381,7 +2420,11 @@ function createCommonOperationBackend(options) {
       const timestamp2 = nowIso2();
       const query = operationStrategy.buildUpdateEdge(params, timestamp2);
       const row = await execution.execGet(query);
-      if (!row) throw new chunkLGEALRC6_cjs.DatabaseOperationError("Update edge failed: no row returned", { operation: "update", entity: "edge" });
+      if (!row)
+        throw new chunkBVRDGYXQ_cjs.DatabaseOperationError(
+          "Update edge failed: no row returned",
+          { operation: "update", entity: "edge" }
+        );
       return rowMappers.toEdgeRow(row);
     },
     async deleteEdge(params) {
@@ -2396,8 +2439,11 @@ function createCommonOperationBackend(options) {
     async deleteEdgesBatch(params) {
       if (params.ids.length === 0) return;
       const timestamp2 = nowIso2();
-      const softDeleteChunkSize = Math.max(1, batchConfig.getEdgesChunkSize - 1);
-      for (const chunk2 of chunk4TOD4LBZ_cjs.chunk(params.ids, softDeleteChunkSize)) {
+      const softDeleteChunkSize = Math.max(
+        1,
+        batchConfig.getEdgesChunkSize - 1
+      );
+      for (const chunk2 of chunkIPSVVTWT_cjs.chunk(params.ids, softDeleteChunkSize)) {
         const query = operationStrategy.buildDeleteEdgesBatch(
           { graphId: params.graphId, ids: chunk2 },
           timestamp2
@@ -2407,7 +2453,10 @@ function createCommonOperationBackend(options) {
     },
     async hardDeleteEdgesBatch(params) {
       if (params.ids.length === 0) return;
-      for (const chunk2 of chunk4TOD4LBZ_cjs.chunk(params.ids, batchConfig.getEdgesChunkSize)) {
+      for (const chunk2 of chunkIPSVVTWT_cjs.chunk(
+        params.ids,
+        batchConfig.getEdgesChunkSize
+      )) {
         const query = operationStrategy.buildHardDeleteEdgesBatch({
           graphId: params.graphId,
           ids: chunk2
@@ -2454,7 +2503,7 @@ function createCommonOperationBackend(options) {
       const query = operationStrategy.buildInsertUnique(params);
       const result = await execution.execGet(query);
       if (result && result.node_id !== params.nodeId) {
-        throw new chunkLGEALRC6_cjs.UniquenessError({
+        throw new chunkBVRDGYXQ_cjs.UniquenessError({
           constraintName: params.constraintName,
           kind: params.nodeKind,
           existingId: result.node_id,
@@ -2474,7 +2523,7 @@ function createCommonOperationBackend(options) {
           continue;
         }
         if (existing.nodeId !== entry.nodeId) {
-          throw new chunkLGEALRC6_cjs.UniquenessError({
+          throw new chunkBVRDGYXQ_cjs.UniquenessError({
             constraintName: entry.constraintName,
             kind: entry.nodeKind,
             existingId: existing.nodeId,
@@ -2484,7 +2533,7 @@ function createCommonOperationBackend(options) {
         }
       }
       const deduped = [...byTarget.values()];
-      for (const chunk2 of chunk4TOD4LBZ_cjs.chunk(
+      for (const chunk2 of chunkIPSVVTWT_cjs.chunk(
         deduped,
         batchConfig.uniqueInsertBatchSize
       )) {
@@ -2499,7 +2548,7 @@ function createCommonOperationBackend(options) {
         for (const entry of chunk2) {
           const owner = ownerByTarget.get(targetKey(entry));
           if (owner !== void 0 && owner !== entry.nodeId) {
-            throw new chunkLGEALRC6_cjs.UniquenessError({
+            throw new chunkBVRDGYXQ_cjs.UniquenessError({
               constraintName: entry.constraintName,
               kind: entry.nodeKind,
               existingId: owner,
@@ -2523,8 +2572,14 @@ function createCommonOperationBackend(options) {
     async checkUniqueBatch(params) {
       if (params.keys.length === 0) return [];
       const allRows = [];
-      for (const chunk2 of chunk4TOD4LBZ_cjs.chunk(params.keys, batchConfig.checkUniqueBatchChunkSize)) {
-        const query = operationStrategy.buildCheckUniqueBatch({ ...params, keys: chunk2 });
+      for (const chunk2 of chunkIPSVVTWT_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)));
       }
@@ -2542,16 +2597,13 @@ function createCommonOperationBackend(options) {
     },
     async commitSchemaVersion(params) {
       const existingRaw = await execution.execGet(
-        operationStrategy.buildGetSchemaVersion(
-          params.graphId,
-          params.version
-        )
+        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 chunkLGEALRC6_cjs.SchemaContentConflictError({
+          throw new chunkBVRDGYXQ_cjs.SchemaContentConflictError({
             graphId: params.graphId,
             version: params.version,
             existingHash: existing.schema_hash,
@@ -2599,7 +2651,7 @@ function createCommonOperationBackend(options) {
       );
       const insertedRaw = await execution.execGet(insertQuery);
       if (!insertedRaw) {
-        throw new chunkLGEALRC6_cjs.DatabaseOperationError(
+        throw new chunkBVRDGYXQ_cjs.DatabaseOperationError(
           "Insert schema failed: no row returned",
           { operation: "insert", entity: "schema" }
         );
@@ -2614,13 +2666,10 @@ function createCommonOperationBackend(options) {
         actualActiveVersion
       );
       const targetRaw = await execution.execGet(
-        operationStrategy.buildGetSchemaVersion(
-          params.graphId,
-          params.version
-        )
+        operationStrategy.buildGetSchemaVersion(params.graphId, params.version)
       );
       if (!targetRaw) {
-        throw new chunkLGEALRC6_cjs.MigrationError(
+        throw new chunkBVRDGYXQ_cjs.MigrationError(
           `Cannot activate version ${params.version}: version does not exist for graph "${params.graphId}".`,
           {
             graphId: params.graphId,
@@ -2644,6 +2693,256 @@ function createCommonOperationBackend(options) {
     }
   };
 }
+var DATABASE_NULL = null;
+function quoteSqlIdentifier(identifier) {
+  return `"${identifier.replaceAll('"', '""')}"`;
+}
+function requireRawExecution(backend) {
+  if (backend.executeRaw === void 0) {
+    throw new chunkBVRDGYXQ_cjs.TrustedImportError(
+      "This backend cannot execute the raw statements required by trusted import.",
+      "backend_unsupported"
+    );
+  }
+  return backend.executeRaw;
+}
+function requireStatementExecution(backend) {
+  if (backend.executeStatement === void 0) {
+    throw new chunkBVRDGYXQ_cjs.TrustedImportError(
+      "This backend cannot execute the index lifecycle required by trusted import.",
+      "backend_unsupported"
+    );
+  }
+  return backend.executeStatement;
+}
+function rowIndicatesExistingData(row) {
+  if (typeof row !== "object" || row === null) return false;
+  const value = row.has_rows;
+  return value === true || value === 1 || value === "1";
+}
+async function assertTrustedImportDatabaseEmpty(backend, tableNames) {
+  const executeRaw = requireRawExecution(backend);
+  const rows = await executeRaw(
+    `SELECT (
+       EXISTS (SELECT 1 FROM ${quoteSqlIdentifier(tableNames.nodes)} LIMIT 1)
+       OR EXISTS (SELECT 1 FROM ${quoteSqlIdentifier(tableNames.edges)} LIMIT 1)
+     ) AS has_rows`,
+    []
+  );
+  if (!rowIndicatesExistingData(rows[0])) return;
+  throw new chunkBVRDGYXQ_cjs.TrustedImportError(
+    "Trusted import requires globally empty TypeGraph node and edge tables.",
+    "database_not_empty",
+    { tables: [tableNames.nodes, tableNames.edges] },
+    {
+      suggestion: "Run trusted import only against a fresh, dedicated database. Use importGraph or the collection bulk APIs to add data to an existing database."
+    }
+  );
+}
+async function lockPostgresTrustedImportTables(backend, tableNames) {
+  const executeStatement = requireStatementExecution(backend);
+  await executeStatement(
+    chunkIPSVVTWT_cjs.asCompiledStatementSql(
+      drizzleOrm.sql.raw(
+        `LOCK TABLE ${quoteSqlIdentifier(tableNames.nodes)}, ${quoteSqlIdentifier(tableNames.edges)} IN ACCESS EXCLUSIVE MODE`
+      )
+    )
+  );
+}
+async function suspendSqliteSecondaryIndexes(backend, tableNames) {
+  const executeRaw = requireRawExecution(backend);
+  const executeStatement = requireStatementExecution(backend);
+  const definitions = await executeRaw(
+    `SELECT name AS index_name, sql AS index_definition
+       FROM sqlite_schema
+      WHERE type = 'index'
+        AND tbl_name IN (?, ?)
+        AND sql IS NOT NULL
+      ORDER BY name`,
+    [tableNames.nodes, tableNames.edges]
+  );
+  for (const definition of definitions) {
+    await executeStatement(
+      chunkIPSVVTWT_cjs.asCompiledStatementSql(
+        drizzleOrm.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
+      )
+    );
+  }
+  return definitions;
+}
+async function suspendPostgresSecondaryIndexes(backend, tableNames) {
+  const executeRaw = requireRawExecution(backend);
+  const executeStatement = requireStatementExecution(backend);
+  const definitions = await executeRaw(
+    `SELECT index_class.relname AS index_name,
+            pg_get_indexdef(index_class.oid) AS index_definition
+       FROM pg_class AS table_class
+       JOIN pg_namespace AS namespace
+         ON namespace.oid = table_class.relnamespace
+       JOIN pg_index AS index_metadata
+         ON index_metadata.indrelid = table_class.oid
+       JOIN pg_class AS index_class
+         ON index_class.oid = index_metadata.indexrelid
+       LEFT JOIN pg_constraint AS table_constraint
+         ON table_constraint.conindid = index_class.oid
+      WHERE namespace.nspname = current_schema()
+        AND table_class.relname IN ($1, $2)
+        AND table_constraint.oid IS NULL
+        AND NOT index_metadata.indisprimary
+      ORDER BY index_class.relname`,
+    [tableNames.nodes, tableNames.edges]
+  );
+  for (const definition of definitions) {
+    await executeStatement(
+      chunkIPSVVTWT_cjs.asCompiledStatementSql(
+        drizzleOrm.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
+      )
+    );
+  }
+  return definitions;
+}
+async function restoreSecondaryIndexes(backend, definitions) {
+  const executeStatement = requireStatementExecution(backend);
+  for (const definition of definitions) {
+    await executeStatement(
+      chunkIPSVVTWT_cjs.asCompiledStatementSql(drizzleOrm.sql.raw(definition.index_definition))
+    );
+  }
+}
+async function analyzeImportedTables(backend, tableNames) {
+  const executeStatement = requireStatementExecution(backend);
+  await executeStatement(
+    chunkIPSVVTWT_cjs.asCompiledStatementSql(
+      drizzleOrm.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.nodes)}`)
+    )
+  );
+  await executeStatement(
+    chunkIPSVVTWT_cjs.asCompiledStatementSql(
+      drizzleOrm.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.edges)}`)
+    )
+  );
+}
+function resolvedValidFrom(validFrom, timestamp2) {
+  return validFrom === void 0 ? timestamp2 : validFrom;
+}
+function postgresArray(values) {
+  return `{${values.map(
+    (value) => value === DATABASE_NULL ? "NULL" : `"${value.replaceAll("\\", "\\\\").replaceAll('"', String.raw`\"`)}"`
+  ).join(",")}}`;
+}
+function createSqliteTrustedImportSession(executionAdapter, tableNames) {
+  const executePreparedRunBatch = executionAdapter.executePreparedRunBatch;
+  if (executePreparedRunBatch === void 0) {
+    throw new chunkBVRDGYXQ_cjs.TrustedImportError(
+      "Trusted import requires a synchronous SQLite driver with prepared statement support.",
+      "backend_unsupported"
+    );
+  }
+  const nodeSql = `INSERT INTO ${quoteSqlIdentifier(tableNames.nodes)}
+    (graph_id, kind, id, props, version, valid_from, valid_to, created_at, updated_at)
+    VALUES (?, ?, ?, ?, 1, ?, ?, ?, ?)`;
+  const edgeSql = `INSERT INTO ${quoteSqlIdentifier(tableNames.edges)}
+    (graph_id, id, kind, from_kind, from_id, to_kind, to_id, props, valid_from, valid_to, created_at, updated_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`;
+  return {
+    async insertNodes(params) {
+      if (params.length === 0) return;
+      const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
+      await executePreparedRunBatch(
+        nodeSql,
+        params.map((item) => [
+          item.graphId,
+          item.kind,
+          item.id,
+          JSON.stringify(item.props),
+          resolvedValidFrom(item.validFrom, timestamp2),
+          item.validTo ?? DATABASE_NULL,
+          timestamp2,
+          timestamp2
+        ])
+      );
+    },
+    async insertEdges(params) {
+      if (params.length === 0) return;
+      const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
+      await executePreparedRunBatch(
+        edgeSql,
+        params.map((item) => [
+          item.graphId,
+          item.id,
+          item.kind,
+          item.fromKind,
+          item.fromId,
+          item.toKind,
+          item.toId,
+          JSON.stringify(item.props),
+          resolvedValidFrom(item.validFrom, timestamp2),
+          item.validTo ?? DATABASE_NULL,
+          timestamp2,
+          timestamp2
+        ])
+      );
+    }
+  };
+}
+function createPostgresTrustedImportSession(backend, tableNames) {
+  const executeRaw = requireRawExecution(backend);
+  const nodeSql = `INSERT INTO ${quoteSqlIdentifier(tableNames.nodes)}
+    (graph_id, kind, id, props, version, valid_from, valid_to, created_at, updated_at)
+    SELECT graph_id, kind, id, props::jsonb, 1, valid_from, valid_to, created_at, created_at
+      FROM UNNEST(
+        $1::text[], $2::text[], $3::text[], $4::text[],
+        $5::timestamptz[], $6::timestamptz[], $7::timestamptz[]
+      ) AS imported(graph_id, kind, id, props, valid_from, valid_to, created_at)`;
+  const edgeSql = `INSERT INTO ${quoteSqlIdentifier(tableNames.edges)}
+    (graph_id, id, kind, from_kind, from_id, to_kind, to_id, props, valid_from, valid_to, created_at, updated_at)
+    SELECT graph_id, id, kind, from_kind, from_id, to_kind, to_id, props::jsonb,
+           valid_from, valid_to, created_at, created_at
+      FROM UNNEST(
+        $1::text[], $2::text[], $3::text[], $4::text[], $5::text[],
+        $6::text[], $7::text[], $8::text[], $9::timestamptz[],
+        $10::timestamptz[], $11::timestamptz[]
+      ) AS imported(
+        graph_id, id, kind, from_kind, from_id, to_kind, to_id, props,
+        valid_from, valid_to, created_at
+      )`;
+  return {
+    async insertNodes(params) {
+      if (params.length === 0) return;
+      const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
+      await executeRaw(nodeSql, [
+        postgresArray(params.map((item) => item.graphId)),
+        postgresArray(params.map((item) => item.kind)),
+        postgresArray(params.map((item) => item.id)),
+        postgresArray(params.map((item) => JSON.stringify(item.props))),
+        postgresArray(
+          params.map((item) => resolvedValidFrom(item.validFrom, timestamp2))
+        ),
+        postgresArray(params.map((item) => item.validTo ?? DATABASE_NULL)),
+        postgresArray(params.map(() => timestamp2))
+      ]);
+    },
+    async insertEdges(params) {
+      if (params.length === 0) return;
+      const timestamp2 = (/* @__PURE__ */ new Date()).toISOString();
+      await executeRaw(edgeSql, [
+        postgresArray(params.map((item) => item.graphId)),
+        postgresArray(params.map((item) => item.id)),
+        postgresArray(params.map((item) => item.kind)),
+        postgresArray(params.map((item) => item.fromKind)),
+        postgresArray(params.map((item) => item.fromId)),
+        postgresArray(params.map((item) => item.toKind)),
+        postgresArray(params.map((item) => item.toId)),
+        postgresArray(params.map((item) => JSON.stringify(item.props))),
+        postgresArray(
+          params.map((item) => resolvedValidFrom(item.validFrom, timestamp2))
+        ),
+        postgresArray(params.map((item) => item.validTo ?? DATABASE_NULL)),
+        postgresArray(params.map(() => timestamp2))
+      ]);
+    }
+  };
+}
 
 // src/backend/drizzle/execution/lru.ts
 function getOrCreateLru(cache, key, cacheMax, create) {
@@ -2679,7 +2978,9 @@ exports.POSTGRES_KIND_REMOVAL_TIMESTAMPS = POSTGRES_KIND_REMOVAL_TIMESTAMPS;
 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.analyzeImportedTables = analyzeImportedTables;
 exports.assertAdoptedDialect = assertAdoptedDialect;
+exports.assertTrustedImportDatabaseEmpty = assertTrustedImportDatabaseEmpty;
 exports.buildContributionInsertValues = buildContributionInsertValues;
 exports.buildContributionOnConflictSet = buildContributionOnConflictSet;
 exports.buildKindRemovalInsertValues = buildKindRemovalInsertValues;
@@ -2692,8 +2993,9 @@ exports.createCommonOperationBackend = createCommonOperationBackend;
 exports.createContributionMaterializer = createContributionMaterializer;
 exports.createPostgresOperationStrategy = createPostgresOperationStrategy;
 exports.createPostgresTables = createPostgresTables;
+exports.createPostgresTrustedImportSession = createPostgresTrustedImportSession;
 exports.createSqliteOperationStrategy = createSqliteOperationStrategy;
-exports.createVectorSlotLatch = createVectorSlotLatch;
+exports.createSqliteTrustedImportSession = createSqliteTrustedImportSession;
 exports.edges = edges;
 exports.fulltext = fulltext;
 exports.gateFulltext = gateFulltext;
@@ -2706,6 +3008,7 @@ exports.generateSqliteDDL = generateSqliteDDL;
 exports.generateSqliteMigrationSQL = generateSqliteMigrationSQL;
 exports.getOrCreateLru = getOrCreateLru;
 exports.hybridCandidatesRef = hybridCandidatesRef;
+exports.lockPostgresTrustedImportTables = lockPostgresTrustedImportTables;
 exports.mapContributionMaterializationRow = mapContributionMaterializationRow;
 exports.mapHybridSearchRow = mapHybridSearchRow;
 exports.mapKindRemovalRow = mapKindRemovalRow;
@@ -2715,11 +3018,14 @@ exports.nodes = nodes;
 exports.recordedClock = recordedClock;
 exports.recordedEdges = recordedEdges;
 exports.recordedNodes = recordedNodes;
+exports.restoreSecondaryIndexes = restoreSecondaryIndexes;
 exports.schemaVersions = schemaVersions;
+exports.suspendPostgresSecondaryIndexes = suspendPostgresSecondaryIndexes;
+exports.suspendSqliteSecondaryIndexes = suspendSqliteSecondaryIndexes;
 exports.tables = tables2;
 exports.uniques = uniques;
 exports.vectorSlotFromCreateIndexParams = vectorSlotFromCreateIndexParams;
 exports.vectorSlotFromDropIndexParams = vectorSlotFromDropIndexParams;
 exports.vectorSlotFromParams = vectorSlotFromParams;
-//# sourceMappingURL=chunk-EM3CWPND.cjs.map
-//# sourceMappingURL=chunk-EM3CWPND.cjs.map
+//# sourceMappingURL=chunk-DIQ3AV5W.cjs.map
+//# sourceMappingURL=chunk-DIQ3AV5W.cjs.map