@nicia-ai/typegraph 0.35.0 → 0.37.0

package/dist/{chunk-WDBCBWC4.js → chunk-K3Q3LJY3.js}

@@ -1,13 +1,14 @@
-import { tables } from './chunk-VHMPG6UL.js';
-import { buildPostgresNodeIndexBuilders, buildPostgresEdgeIndexBuilders } from './chunk-6FR2MMS6.js';
-import { formatPostgresTimestamp, coerceNumericScore, nowIso } from './chunk-55MZDDZV.js';
+import { tables } from './chunk-UXLSNRYL.js';
+import { buildPostgresSystemIndexBuilders, buildPostgresNodeIndexBuilders, buildPostgresEdgeIndexBuilders } from './chunk-QERAIDRJ.js';
+import { formatPostgresTimestamp, coerceNumericScore, nowIso } from './chunk-M6VES7V6.js';
 import { sortedReplacer } from './chunk-UR7W5YQK.js';
+import { assertNoSystemIndexNameCollision } from './chunk-YTSN73ND.js';
 import { sha256Hex } from './chunk-W63OVYY4.js';
-import { tsvectorStrategy, fts5Strategy, BASE_CONTRIBUTION_OWNER } from './chunk-FPIZFYHE.js';
-import { createBackendOverlay, chunk, isPresent, sqlValueList } from './chunk-JBTOYDMN.js';
-import { parseDimensionMismatch, isMissingTableError } from './chunk-I7ZUZKFD.js';
+import { tsvectorStrategy, fts5Strategy, BASE_CONTRIBUTION_OWNER } from './chunk-EXU3RASM.js';
+import { createBackendOverlay, chunk, asCompiledStatementSql, isPresent, sqlValueList } from './chunk-44TA22QT.js';
+import { parseDimensionMismatch, isMissingTableError } from './chunk-XGPUQ56G.js';
 import { liveNodeIdsSubquery, quotedTableName, quotedColumn, codePointOrderKey, edgeColumnList, sqlNull, resolveValidFrom, nodeColumnList } from './chunk-OHMP6N2J.js';
-import { EmbeddingDimensionChangedError, ConfigurationError, MigrationError, SchemaContentConflictError, DatabaseOperationError, UniquenessError, StoreNotInitializedError, StaleVersionError } from './chunk-MP2JQKSG.js';
+import { EmbeddingDimensionChangedError, ConfigurationError, MigrationError, SchemaContentConflictError, DatabaseOperationError, UniquenessError, TrustedImportError, StaleVersionError, StoreNotInitializedError } from './chunk-5PNMDJ7J.js';
 import { sql, is, getTableName } from 'drizzle-orm';
 import { customType, pgTable, timestamp, integer, jsonb, text, primaryKey, index, boolean, uniqueIndex, getTableConfig as getTableConfig$1, PgTable } from 'drizzle-orm/pg-core';
 import { getTableConfig, SQLiteTable } from 'drizzle-orm/sqlite-core';
@@ -38,6 +39,7 @@ var DEFAULT_TABLE_NAMES = {
 function createPostgresTables(names = {}, options = {}) {
   const n = { ...DEFAULT_TABLE_NAMES, ...names };
   const indexes = options.indexes ?? [];
+  assertNoSystemIndexNameCollision(indexes, n);
   const nodes2 = pgTable(
     n.nodes,
     {
@@ -54,15 +56,9 @@ function createPostgresTables(names = {}, options = {}) {
     },
     (t) => [
       primaryKey({ columns: [t.graphId, t.kind, t.id] }),
-      index(`${n.nodes}_kind_idx`).on(t.graphId, t.kind),
-      index(`${n.nodes}_kind_created_idx`).on(
-        t.graphId,
-        t.kind,
-        t.deletedAt,
-        t.createdAt
-      ),
-      index(`${n.nodes}_deleted_idx`).on(t.graphId, t.deletedAt),
-      index(`${n.nodes}_valid_idx`).on(t.graphId, t.validFrom, t.validTo),
+      // System indexes come from SYSTEM_INDEX_DECLARATIONS (single source
+      // for both dialects + the runtime materializer).
+      ...buildPostgresSystemIndexBuilders("nodes", n.nodes, t),
       ...buildPostgresNodeIndexBuilders(t, indexes)
     ]
   );
@@ -85,55 +81,7 @@ function createPostgresTables(names = {}, options = {}) {
     },
     (t) => [
       primaryKey({ columns: [t.graphId, t.id] }),
-      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.
-      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).
-      index(`${n.edges}_to_idx`).on(
-        t.graphId,
-        t.toKind,
-        t.toId,
-        t.kind,
-        t.fromKind,
-        t.deletedAt,
-        t.validFrom,
-        t.validTo,
-        t.fromId
-      ),
-      index(`${n.edges}_kind_created_idx`).on(
-        t.graphId,
-        t.kind,
-        t.deletedAt,
-        t.createdAt
-      ),
-      index(`${n.edges}_deleted_idx`).on(t.graphId, t.deletedAt),
-      index(`${n.edges}_valid_idx`).on(t.graphId, t.validFrom, t.validTo),
-      index(`${n.edges}_cardinality_idx`).on(
-        t.graphId,
-        t.kind,
-        t.fromKind,
-        t.fromId,
-        t.validTo
-      ),
+      ...buildPostgresSystemIndexBuilders("edges", n.edges, t),
       ...buildPostgresEdgeIndexBuilders(t, indexes)
     ]
   );
@@ -160,19 +108,7 @@ function createPostgresTables(names = {}, options = {}) {
     },
     (t) => [
       primaryKey({ columns: [t.historyId] }),
-      index(`${n.recordedNodes}_entity_idx`).on(
-        t.graphId,
-        t.kind,
-        t.id,
-        t.recordedFrom,
-        t.recordedTo
-      ),
-      index(`${n.recordedNodes}_open_idx`).on(t.graphId, t.recordedTo),
-      index(`${n.recordedNodes}_valid_idx`).on(
-        t.graphId,
-        t.validFrom,
-        t.validTo
-      )
+      ...buildPostgresSystemIndexBuilders("recordedNodes", n.recordedNodes, t)
     ]
   );
   const recordedEdges2 = pgTable(
@@ -201,37 +137,7 @@ function createPostgresTables(names = {}, options = {}) {
     },
     (t) => [
       primaryKey({ columns: [t.historyId] }),
-      index(`${n.recordedEdges}_entity_idx`).on(
-        t.graphId,
-        t.kind,
-        t.id,
-        t.recordedFrom,
-        t.recordedTo
-      ),
-      index(`${n.recordedEdges}_open_idx`).on(t.graphId, t.recordedTo),
-      index(`${n.recordedEdges}_from_idx`).on(
-        t.graphId,
-        t.fromKind,
-        t.fromId,
-        t.kind,
-        t.toKind,
-        t.recordedFrom,
-        t.recordedTo
-      ),
-      index(`${n.recordedEdges}_to_idx`).on(
-        t.graphId,
-        t.toKind,
-        t.toId,
-        t.kind,
-        t.fromKind,
-        t.recordedFrom,
-        t.recordedTo
-      ),
-      index(`${n.recordedEdges}_valid_idx`).on(
-        t.graphId,
-        t.validFrom,
-        t.validTo
-      )
+      ...buildPostgresSystemIndexBuilders("recordedEdges", n.recordedEdges, t)
     ]
   );
   const recordedClock2 = pgTable(
@@ -460,9 +366,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";
 }
@@ -684,39 +590,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) {
@@ -807,7 +680,7 @@ function buildContributionOnConflictSet(materializedAtColumn, paramsMaterialized
     lastError: sql`excluded.${sql.identifier("last_error")}`
   };
 }
-async function computeContributionSignature(dialect, identity, createDdl) {
+function contributionSignatureInput(dialect, identity, createDdl) {
   const hashable = {
     dialect,
     owner: identity.owner,
@@ -815,7 +688,7 @@ async function computeContributionSignature(dialect, identity, createDdl) {
     tableName: identity.tableName,
     createDdl
   };
-  return sha256Hex(JSON.stringify(hashable, sortedReplacer), 16);
+  return JSON.stringify(hashable, sortedReplacer);
 }
 function evaluateContributionState(row, signature) {
   if (row === void 0) return "missing";
@@ -884,25 +757,64 @@ function gateFulltext(tx, assert) {
     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: 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.`
       );
@@ -937,64 +849,159 @@ 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 (!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 StoreNotInitializedError(graphId, "missing", {
-          cause: read.error,
-          details: { logicalName: contribution.logicalName }
-        });
-      }
-      if (read.state !== "initialized") {
-        throw new 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 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 StoreNotInitializedError(graphId, state, {
           details: { logicalName: contribution.logicalName }
         });
       }
+      initializedSignatures.set(key, signature);
     }
-    initializedGraphIds.add(graphId);
   }
-  return { ensureRuntimeContributions, assertInitialized };
+  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);
+    }
+  }
+  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,
@@ -1036,15 +1043,20 @@ function buildMaterializationInsertValues(params, encode) {
     lastError: params.error
   };
 }
-function buildMaterializationOnConflictSet(materializedAtColumn, paramsMaterializedAt) {
-  const materializedAtSet = paramsMaterializedAt === void 0 ? sql`COALESCE(excluded.${sql.identifier("materialized_at")}, ${materializedAtColumn})` : sql`excluded.${sql.identifier("materialized_at")}`;
+function buildMaterializationOnConflictSet(paramsMaterializedAt) {
+  if (paramsMaterializedAt === void 0) {
+    return {
+      lastAttemptedAt: sql`excluded.${sql.identifier("last_attempted_at")}`,
+      lastError: sql`excluded.${sql.identifier("last_error")}`
+    };
+  }
   return {
     graphId: sql`excluded.${sql.identifier("graph_id")}`,
     entity: sql`excluded.${sql.identifier("entity")}`,
     kind: sql`excluded.${sql.identifier("kind")}`,
     signature: sql`excluded.${sql.identifier("signature")}`,
     schemaVersion: sql`excluded.${sql.identifier("schema_version")}`,
-    materializedAt: materializedAtSet,
+    materializedAt: sql`excluded.${sql.identifier("materialized_at")}`,
     lastAttemptedAt: sql`excluded.${sql.identifier("last_attempted_at")}`,
     lastError: sql`excluded.${sql.identifier("last_error")}`
   };
@@ -2231,16 +2243,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 DatabaseOperationError("Insert node failed: no row returned", { operation: "insert", entity: "node" });
+      if (!row)
+        throw new DatabaseOperationError(
+          "Insert node failed: no row returned",
+          { operation: "insert", entity: "node" }
+        );
       return rowMappers.toNodeRow(row);
     },
     async insertNodeNoReturn(params) {
       const timestamp2 = nowIso2();
-      const query = operationStrategy.buildInsertNodeNoReturn(params, timestamp2);
+      const query = operationStrategy.buildInsertNodeNoReturn(
+        params,
+        timestamp2
+      );
       await execution.execRun(query);
     },
     async insertNodesBatch(params) {
@@ -2260,7 +2282,10 @@ function createCommonOperationBackend(options) {
       const timestamp2 = nowIso2();
       const allRows = [];
       for (const chunk2 of chunk(params, batchConfig.nodeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertNodesBatchReturning(chunk2, timestamp2);
+        const query = operationStrategy.buildInsertNodesBatchReturning(
+          chunk2,
+          timestamp2
+        );
         const rows = await execution.execAll(query);
         allRows.push(...rows.map((row) => rowMappers.toNodeRow(row)));
       }
@@ -2285,7 +2310,11 @@ function createCommonOperationBackend(options) {
       const timestamp2 = nowIso2();
       const query = operationStrategy.buildUpdateNode(params, timestamp2);
       const row = await execution.execGet(query);
-      if (!row) throw new DatabaseOperationError("Update node failed: no row returned", { operation: "update", entity: "node" });
+      if (!row)
+        throw new DatabaseOperationError(
+          "Update node failed: no row returned",
+          { operation: "update", entity: "node" }
+        );
       return rowMappers.toNodeRow(row);
     },
     async deleteNode(params) {
@@ -2329,12 +2358,19 @@ function createCommonOperationBackend(options) {
       const timestamp2 = nowIso2();
       const query = operationStrategy.buildInsertEdge(params, timestamp2);
       const row = await execution.execGet(query);
-      if (!row) throw new DatabaseOperationError("Insert edge failed: no row returned", { operation: "insert", entity: "edge" });
+      if (!row)
+        throw new DatabaseOperationError(
+          "Insert edge failed: no row returned",
+          { operation: "insert", entity: "edge" }
+        );
       return rowMappers.toEdgeRow(row);
     },
     async insertEdgeNoReturn(params) {
       const timestamp2 = nowIso2();
-      const query = operationStrategy.buildInsertEdgeNoReturn(params, timestamp2);
+      const query = operationStrategy.buildInsertEdgeNoReturn(
+        params,
+        timestamp2
+      );
       await execution.execRun(query);
     },
     async insertEdgesBatch(params) {
@@ -2354,7 +2390,10 @@ function createCommonOperationBackend(options) {
       const timestamp2 = nowIso2();
       const allRows = [];
       for (const chunk2 of chunk(params, batchConfig.edgeInsertBatchSize)) {
-        const query = operationStrategy.buildInsertEdgesBatchReturning(chunk2, timestamp2);
+        const query = operationStrategy.buildInsertEdgesBatchReturning(
+          chunk2,
+          timestamp2
+        );
         const rows = await execution.execAll(query);
         allRows.push(...rows.map((row) => rowMappers.toEdgeRow(row)));
       }
@@ -2379,7 +2418,11 @@ function createCommonOperationBackend(options) {
       const timestamp2 = nowIso2();
       const query = operationStrategy.buildUpdateEdge(params, timestamp2);
       const row = await execution.execGet(query);
-      if (!row) throw new DatabaseOperationError("Update edge failed: no row returned", { operation: "update", entity: "edge" });
+      if (!row)
+        throw new DatabaseOperationError(
+          "Update edge failed: no row returned",
+          { operation: "update", entity: "edge" }
+        );
       return rowMappers.toEdgeRow(row);
     },
     async deleteEdge(params) {
@@ -2394,7 +2437,10 @@ function createCommonOperationBackend(options) {
     async deleteEdgesBatch(params) {
       if (params.ids.length === 0) return;
       const timestamp2 = nowIso2();
-      const softDeleteChunkSize = Math.max(1, batchConfig.getEdgesChunkSize - 1);
+      const softDeleteChunkSize = Math.max(
+        1,
+        batchConfig.getEdgesChunkSize - 1
+      );
       for (const chunk2 of chunk(params.ids, softDeleteChunkSize)) {
         const query = operationStrategy.buildDeleteEdgesBatch(
           { graphId: params.graphId, ids: chunk2 },
@@ -2405,7 +2451,10 @@ function createCommonOperationBackend(options) {
     },
     async hardDeleteEdgesBatch(params) {
       if (params.ids.length === 0) return;
-      for (const chunk2 of chunk(params.ids, batchConfig.getEdgesChunkSize)) {
+      for (const chunk2 of chunk(
+        params.ids,
+        batchConfig.getEdgesChunkSize
+      )) {
         const query = operationStrategy.buildHardDeleteEdgesBatch({
           graphId: params.graphId,
           ids: chunk2
@@ -2521,8 +2570,14 @@ function createCommonOperationBackend(options) {
     async checkUniqueBatch(params) {
       if (params.keys.length === 0) return [];
       const allRows = [];
-      for (const chunk2 of chunk(params.keys, batchConfig.checkUniqueBatchChunkSize)) {
-        const query = operationStrategy.buildCheckUniqueBatch({ ...params, keys: chunk2 });
+      for (const chunk2 of chunk(
+        params.keys,
+        batchConfig.checkUniqueBatchChunkSize
+      )) {
+        const query = operationStrategy.buildCheckUniqueBatch({
+          ...params,
+          keys: chunk2
+        });
         const rows = await execution.execAll(query);
         allRows.push(...rows.map((row) => rowMappers.toUniqueRow(row)));
       }
@@ -2540,10 +2595,7 @@ 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) {
@@ -2612,10 +2664,7 @@ 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 MigrationError(
@@ -2642,6 +2691,256 @@ function createCommonOperationBackend(options) {
     }
   };
 }
+var DATABASE_NULL = null;
+function quoteSqlIdentifier(identifier) {
+  return `"${identifier.replaceAll('"', '""')}"`;
+}
+function requireRawExecution(backend) {
+  if (backend.executeRaw === void 0) {
+    throw new 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 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 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(
+    asCompiledStatementSql(
+      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(
+      asCompiledStatementSql(
+        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(
+      asCompiledStatementSql(
+        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(
+      asCompiledStatementSql(sql.raw(definition.index_definition))
+    );
+  }
+}
+async function analyzeImportedTables(backend, tableNames) {
+  const executeStatement = requireStatementExecution(backend);
+  await executeStatement(
+    asCompiledStatementSql(
+      sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.nodes)}`)
+    )
+  );
+  await executeStatement(
+    asCompiledStatementSql(
+      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 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) {
@@ -2670,6 +2969,6 @@ function compileQueryWithDialect(db, query, backendName) {
   return compiler.sqlToQuery(query);
 }
 
-export { EMBEDDING_UPSERT_PARAM_COUNT, POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, POSTGRES_INDEX_MAT_TIMESTAMPS, POSTGRES_KIND_REMOVAL_TIMESTAMPS, SQLITE_CONTRIBUTION_MAT_TIMESTAMPS, SQLITE_INDEX_MAT_TIMESTAMPS, SQLITE_KIND_REMOVAL_TIMESTAMPS, assertAdoptedDialect, buildContributionInsertValues, buildContributionOnConflictSet, buildKindRemovalInsertValues, buildKindRemovalOnConflictSet, buildMaterializationInsertValues, buildMaterializationOnConflictSet, compileQueryWithDialect, createCachedTableExistence, createCommonOperationBackend, createContributionMaterializer, createPostgresOperationStrategy, createPostgresTables, createSqliteOperationStrategy, createVectorSlotLatch, edges, fulltext, gateFulltext, gateFulltextMethods, generatePgCreateTableSQL, generatePostgresDDL, generatePostgresMigrationSQL, generateSqliteCreateTableSQL, generateSqliteDDL, generateSqliteMigrationSQL, getOrCreateLru, hybridCandidatesRef, mapContributionMaterializationRow, mapHybridSearchRow, mapKindRemovalRow, mapMaterializationRow, mapVectorWriteError, nodes, recordedClock, recordedEdges, recordedNodes, schemaVersions, tables2 as tables, uniques, vectorSlotFromCreateIndexParams, vectorSlotFromDropIndexParams, vectorSlotFromParams };
-//# sourceMappingURL=chunk-WDBCBWC4.js.map
-//# sourceMappingURL=chunk-WDBCBWC4.js.map
+export { EMBEDDING_UPSERT_PARAM_COUNT, POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, POSTGRES_INDEX_MAT_TIMESTAMPS, POSTGRES_KIND_REMOVAL_TIMESTAMPS, SQLITE_CONTRIBUTION_MAT_TIMESTAMPS, SQLITE_INDEX_MAT_TIMESTAMPS, SQLITE_KIND_REMOVAL_TIMESTAMPS, analyzeImportedTables, assertAdoptedDialect, assertTrustedImportDatabaseEmpty, buildContributionInsertValues, buildContributionOnConflictSet, buildKindRemovalInsertValues, buildKindRemovalOnConflictSet, buildMaterializationInsertValues, buildMaterializationOnConflictSet, compileQueryWithDialect, createCachedTableExistence, createCommonOperationBackend, createContributionMaterializer, createPostgresOperationStrategy, createPostgresTables, createPostgresTrustedImportSession, createSqliteOperationStrategy, createSqliteTrustedImportSession, edges, fulltext, gateFulltext, gateFulltextMethods, generatePgCreateTableSQL, generatePostgresDDL, generatePostgresMigrationSQL, generateSqliteCreateTableSQL, generateSqliteDDL, generateSqliteMigrationSQL, getOrCreateLru, hybridCandidatesRef, lockPostgresTrustedImportTables, mapContributionMaterializationRow, mapHybridSearchRow, mapKindRemovalRow, mapMaterializationRow, mapVectorWriteError, nodes, recordedClock, recordedEdges, recordedNodes, restoreSecondaryIndexes, schemaVersions, suspendPostgresSecondaryIndexes, suspendSqliteSecondaryIndexes, tables2 as tables, uniques, vectorSlotFromCreateIndexParams, vectorSlotFromDropIndexParams, vectorSlotFromParams };
+//# sourceMappingURL=chunk-K3Q3LJY3.js.map
+//# sourceMappingURL=chunk-K3Q3LJY3.js.map