@nicia-ai/typegraph 0.45.0 → 0.46.1

package/dist/{chunk-H7VE3FL4.cjs → chunk-MUK4BU7K.cjs}

@@ -1,17 +1,16 @@
 'use strict';
 
-var chunkF4NHQHEZ_cjs = require('./chunk-F4NHQHEZ.cjs');
-var chunkZ3WO6MND_cjs = require('./chunk-Z3WO6MND.cjs');
-var chunkOOA273IJ_cjs = require('./chunk-OOA273IJ.cjs');
-var chunkZDH3DX3C_cjs = require('./chunk-ZDH3DX3C.cjs');
-var chunkEKFUG4G7_cjs = require('./chunk-EKFUG4G7.cjs');
-var chunkACSVZPK7_cjs = require('./chunk-ACSVZPK7.cjs');
-var chunkJQXSZHF2_cjs = require('./chunk-JQXSZHF2.cjs');
+var chunkYAAM3M2S_cjs = require('./chunk-YAAM3M2S.cjs');
+var chunkRMQLSPA2_cjs = require('./chunk-RMQLSPA2.cjs');
+var chunkU5SON7R2_cjs = require('./chunk-U5SON7R2.cjs');
+var chunkPWLJ77UV_cjs = require('./chunk-PWLJ77UV.cjs');
+var chunkBSFJMMV3_cjs = require('./chunk-BSFJMMV3.cjs');
+var chunkXBYVV3MP_cjs = require('./chunk-XBYVV3MP.cjs');
 var chunkZY4GXIVN_cjs = require('./chunk-ZY4GXIVN.cjs');
-var chunkJXUTCSXX_cjs = require('./chunk-JXUTCSXX.cjs');
-var chunkU5W4LKZV_cjs = require('./chunk-U5W4LKZV.cjs');
-var chunk764JHTLT_cjs = require('./chunk-764JHTLT.cjs');
-var chunkC4F7VJ5D_cjs = require('./chunk-C4F7VJ5D.cjs');
+var chunk4UGOKMI5_cjs = require('./chunk-4UGOKMI5.cjs');
+var chunkVCRRKBLN_cjs = require('./chunk-VCRRKBLN.cjs');
+var chunkNI72YOJB_cjs = require('./chunk-NI72YOJB.cjs');
+var chunkN66HCGCY_cjs = require('./chunk-N66HCGCY.cjs');
 var drizzleOrm = require('drizzle-orm');
 
 // src/backend/edge-endpoint-sets.ts
@@ -21,7 +20,7 @@ function assertLimitPerEndpoint(operation, graphId, limitPerEndpoint, kind) {
   if (limitPerEndpoint === void 0 || Number.isInteger(limitPerEndpoint) && limitPerEndpoint > 0) {
     return;
   }
-  throw new chunkC4F7VJ5D_cjs.ConfigurationError(
+  throw new chunkNI72YOJB_cjs.ConfigurationError(
     `${operation} \`limitPerEndpoint\` must be a positive integer, received ${String(limitPerEndpoint)}.`,
     {
       code: "EDGE_ENDPOINT_SET_INVALID",
@@ -65,7 +64,7 @@ function resolveHeterogeneousEdgeRead(params, maxBindParameters) {
   if (endpointChunkSize >= 1) {
     return { edgeKinds, endpoints, endpointChunkSize };
   }
-  throw new chunkC4F7VJ5D_cjs.ConfigurationError(
+  throw new chunkNI72YOJB_cjs.ConfigurationError(
     "findEdgesByHeterogeneousEndpointSet cannot fit one endpoint and the selected edge kinds within the backend bind-parameter budget.",
     {
       code: "EDGE_HETEROGENEOUS_READ_BIND_BUDGET_EXCEEDED",
@@ -81,8 +80,8 @@ function resolveHeterogeneousEdgeRead(params, maxBindParameters) {
 
 // src/backend/live-node-candidates.ts
 function buildLiveNodeCandidates(nodesTableName, graphId, nodeKind, now) {
-  const nodes = chunkU5W4LKZV_cjs.sql.identifier(nodesTableName);
-  return chunkU5W4LKZV_cjs.sql`
+  const nodes = chunkVCRRKBLN_cjs.sql.identifier(nodesTableName);
+  return chunkVCRRKBLN_cjs.sql`
     SELECT "id" AS node_id
     FROM ${nodes}
     WHERE "graph_id" = ${graphId}
@@ -123,10 +122,10 @@ function vectorSlotFromDropIndexParams(params) {
   };
 }
 function mapVectorWriteError(error, params) {
-  const mismatch = chunkJQXSZHF2_cjs.parseDimensionMismatch(error);
+  const mismatch = chunkBSFJMMV3_cjs.parseDimensionMismatch(error);
   if (mismatch === void 0) return error;
   const attempted = mismatch.actual ?? "a different number of";
-  return new chunkC4F7VJ5D_cjs.EmbeddingDimensionChangedError(
+  return new chunkNI72YOJB_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,
@@ -142,7 +141,7 @@ var SQLITE_CONTRIBUTION_MAT_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS = {
-  decode: chunkF4NHQHEZ_cjs.formatPostgresTimestamp,
+  decode: chunkYAAM3M2S_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapContributionMaterializationRow(row, decode) {
@@ -192,7 +191,7 @@ function contributionSignatureInput(dialect, identity, createDdl) {
     tableName: identity.tableName,
     createDdl
   };
-  return JSON.stringify(hashable, chunkACSVZPK7_cjs.sortedReplacer);
+  return JSON.stringify(hashable, chunkPWLJ77UV_cjs.sortedReplacer);
 }
 function evaluateContributionState(row, signature) {
   if (row === void 0) return "missing";
@@ -227,6 +226,20 @@ function diagnoseContribution(row, signature, tableExists) {
     }
   }
 }
+var PROBE_PROJECTION_ORDER = [
+  "fulltext",
+  "vector"
+];
+var PROBE_DETAIL_PHRASE = {
+  "orphaned-marker": "storage is missing",
+  "missing-marker": "storage is not attested by a durable marker",
+  "failed-materialization": "provisioning failed and produced no storage",
+  stale: "storage exists at a different shape than the current declaration"
+};
+function describeProbeDiagnostic(diagnostic) {
+  const subject = diagnostic.kind === void 0 || diagnostic.fieldPath === void 0 ? `table "${diagnostic.physicalName}"` : `${diagnostic.kind}.${diagnostic.fieldPath}`;
+  return `${subject}: ${PROBE_DETAIL_PHRASE[diagnostic.state]} (${diagnostic.state})`;
+}
 function identityOf(graphId, contribution) {
   return {
     graphId,
@@ -282,11 +295,18 @@ function gateFulltextMethods(source, assert) {
   return gated;
 }
 function gateFulltext(tx, assert) {
-  return chunkEKFUG4G7_cjs.createBackendOverlay(
+  return chunkXBYVV3MP_cjs.createBackendOverlay(
     tx,
     gateFulltextMethods(tx, assert)
   );
 }
+function contributionRebuildSupported(fulltextStrategy, fulltextTableName, transactional) {
+  return transactional && chunkRMQLSPA2_cjs.runtimeStrategyContributions(fulltextStrategy, fulltextTableName).every(
+    (contribution) => contribution.dropDdl !== void 0
+  );
+}
+var CONTRIBUTION_DDL_LOCK_KEY = "typegraph:contribution-ddl";
+var FOREIGN_GRAPH_REPORT_LIMIT = 5;
 var CONTRIBUTION_KEY_SEPARATOR = String.fromCodePoint(0);
 function contributionKey(graphId, contribution) {
   return [
@@ -330,7 +350,7 @@ function createContributionMaterializer(deps) {
     }
   }
   function runtimeContributions() {
-    return chunkZ3WO6MND_cjs.runtimeStrategyContributions(fulltextStrategy, fulltextTableName);
+    return chunkRMQLSPA2_cjs.runtimeStrategyContributions(fulltextStrategy, fulltextTableName);
   }
   function cacheInitializedSignature(key, signature) {
     if (!uncacheableKeys.has(key)) {
@@ -356,14 +376,14 @@ function createContributionMaterializer(deps) {
       );
       await deps.recordMarker({
         ...identity,
-        signature,
-        attemptedAt: chunkF4NHQHEZ_cjs.nowIso(),
+        signature: existing.signature,
+        attemptedAt: chunkYAAM3M2S_cjs.nowIso(),
         materializedAt: void 0,
         error: error.message
       });
       throw error;
     }
-    const attemptedAt = chunkF4NHQHEZ_cjs.nowIso();
+    const attemptedAt = chunkYAAM3M2S_cjs.nowIso();
     try {
       for (const statement of contribution.createDdl) {
         await deps.execDdl(statement);
@@ -399,7 +419,7 @@ function createContributionMaterializer(deps) {
         rows: indexMarkerRows(graphId, await deps.getMarkers(graphId))
       };
     } catch (error) {
-      if (!chunkJQXSZHF2_cjs.isMissingTableError(error)) throw error;
+      if (!chunkBSFJMMV3_cjs.isMissingTableError(error)) throw error;
       return { kind: "missing-table", error };
     }
   }
@@ -478,7 +498,7 @@ function createContributionMaterializer(deps) {
     if (read.kind === "missing-table") {
       const first = pending[0];
       if (first === void 0) return;
-      throw new chunkC4F7VJ5D_cjs.StoreNotInitializedError(graphId, "missing", {
+      throw new chunkNI72YOJB_cjs.StoreNotInitializedError(graphId, "missing", {
         cause: read.error,
         details: { logicalName: first.contribution.logicalName }
       });
@@ -487,7 +507,7 @@ function createContributionMaterializer(deps) {
       const { contribution, key, signature } = entry;
       const state = evaluateContributionState(read.rows.get(key), signature);
       if (state !== "initialized") {
-        throw new chunkC4F7VJ5D_cjs.StoreNotInitializedError(graphId, state, {
+        throw new chunkNI72YOJB_cjs.StoreNotInitializedError(graphId, state, {
           details: { logicalName: contribution.logicalName }
         });
       }
@@ -535,7 +555,7 @@ function createContributionMaterializer(deps) {
       else existing.push(target);
     }
     for (const contribution of runtimeContributions()) {
-      addTarget(graphId, { contribution });
+      addTarget(graphId, { contribution, projection: "fulltext" });
     }
     const { vectorStrategy } = deps;
     if (vectorStrategy !== void 0) {
@@ -543,6 +563,7 @@ function createContributionMaterializer(deps) {
         for (const contribution of vectorStrategy.ownedTables(slot)) {
           addTarget(slot.graphId, {
             contribution,
+            projection: "vector",
             kind: slot.nodeKind,
             fieldPath: slot.fieldPath
           });
@@ -551,8 +572,7 @@ function createContributionMaterializer(deps) {
     }
     return targets;
   }
-  async function diagnoseContributions(graphId, vectorSlots) {
-    const targetsByGraph = verificationTargetsByGraph(graphId, vectorSlots);
+  async function diagnoseTargets(targetsByGraph) {
     const probes = /* @__PURE__ */ new Map();
     function tableExists(tableName) {
       const pending = probes.get(tableName);
@@ -565,7 +585,7 @@ function createContributionMaterializer(deps) {
     for (const [id, targets] of targetsByGraph) {
       const read = await readMarkerRows(id);
       const rows = read.kind === "rows" ? read.rows : /* @__PURE__ */ new Map();
-      for (const { contribution, kind, fieldPath } of targets) {
+      for (const { contribution, projection, kind, fieldPath } of targets) {
         const key = contributionKey(id, contribution);
         const row = rows.get(key);
         const state = diagnoseContribution(
@@ -577,6 +597,7 @@ function createContributionMaterializer(deps) {
         diagnosed.push({
           graphId: id,
           contribution,
+          projection,
           diagnostic: {
             owner: contribution.owner,
             logicalName: contribution.logicalName,
@@ -595,14 +616,46 @@ function createContributionMaterializer(deps) {
     }
     return diagnosed;
   }
+  async function diagnoseContributions(graphId, vectorSlots) {
+    return diagnoseTargets(verificationTargetsByGraph(graphId, vectorSlots));
+  }
   async function verifyContributions(graphId, vectorSlots) {
     const diagnosed = await diagnoseContributions(graphId, vectorSlots);
     return diagnosed.map((entry) => entry.diagnostic);
   }
+  async function probeContributions(graphId, vectorSlots) {
+    const targetsByGraph = verificationTargetsByGraph(graphId, vectorSlots);
+    const declared = /* @__PURE__ */ new Set();
+    for (const targets of targetsByGraph.values()) {
+      for (const target of targets) declared.add(target.projection);
+    }
+    const diagnosed = await diagnoseTargets(targetsByGraph);
+    const entries = [];
+    for (const projection of PROBE_PROJECTION_ORDER) {
+      if (!declared.has(projection)) continue;
+      const problems = diagnosed.filter(
+        (entry) => entry.projection === projection
+      );
+      if (problems.length === 0) {
+        entries.push({ contribution: projection, state: "ready" });
+        continue;
+      }
+      entries.push({
+        contribution: projection,
+        state: "degraded",
+        detail: problems.map((entry) => describeProbeDiagnostic(entry.diagnostic)).join("; ")
+      });
+    }
+    return entries;
+  }
   async function repairContributions(graphId, vectorSlots) {
     const diagnosed = await diagnoseContributions(graphId, vectorSlots);
     const results = [];
-    for (const { graphId: targetGraphId, contribution, diagnostic } of diagnosed) {
+    for (const {
+      graphId: targetGraphId,
+      contribution,
+      diagnostic
+    } of diagnosed) {
       if (diagnostic.state === "stale" || diagnostic.state === "orphaned-marker") {
         results.push({ diagnostic, status: "requires-rebuild" });
         continue;
@@ -625,6 +678,156 @@ function createContributionMaterializer(deps) {
       remaining: await verifyContributions(graphId, vectorSlots)
     };
   }
+  async function lockContributionDdl(tx) {
+    if (dialect !== "postgres") return;
+    await tx.execute(
+      chunkVCRRKBLN_cjs.asCompiledRowsSql(
+        chunkVCRRKBLN_cjs.sql`SELECT pg_advisory_xact_lock(hashtext(${CONTRIBUTION_DDL_LOCK_KEY}), 0)`
+      )
+    );
+  }
+  async function lockSharedFulltextTable(tx, tableName) {
+    if (dialect !== "postgres") return;
+    await tx.executeStatement(
+      chunkVCRRKBLN_cjs.asCompiledStatementSql(
+        chunkVCRRKBLN_cjs.sql`LOCK TABLE ${chunkVCRRKBLN_cjs.sql.identifier(tableName)} IN ACCESS EXCLUSIVE MODE`
+      )
+    );
+  }
+  async function readForeignGraphIds(tx, tableName, graphId) {
+    const rows = await tx.execute(
+      chunkVCRRKBLN_cjs.asCompiledRowsSql(
+        chunk4UGOKMI5_cjs.buildForeignFulltextGraphProbe(
+          tableName,
+          graphId,
+          FOREIGN_GRAPH_REPORT_LIMIT
+        )
+      )
+    );
+    return rows.map((row) => String(row.graph_id));
+  }
+  async function rebuildContribution(graphId, scope, repopulate) {
+    if (scope === "vector") {
+      throw new chunkNI72YOJB_cjs.ContributionRebuildUnsupportedError(
+        "vector-source-unavailable",
+        { graphId, contribution: scope }
+      );
+    }
+    const contributions = runtimeContributions();
+    const withoutTeardown = contributions.find(
+      (contribution) => contribution.dropDdl === void 0
+    );
+    if (withoutTeardown !== void 0) {
+      throw new chunkNI72YOJB_cjs.ContributionRebuildUnsupportedError("no-drop-ddl", {
+        graphId,
+        contribution: scope,
+        owner: withoutTeardown.owner,
+        logicalName: withoutTeardown.logicalName,
+        physicalName: withoutTeardown.tableName
+      });
+    }
+    const fence = deps.schemaWriteTransaction;
+    if (fence === void 0) {
+      throw new chunkNI72YOJB_cjs.ContributionRebuildUnsupportedError("no-schema-fence", {
+        graphId,
+        contribution: scope,
+        backend: dialect
+      });
+    }
+    const stamps = await Promise.all(
+      contributions.map(async (contribution) => {
+        const key = contributionKey(graphId, contribution);
+        return {
+          contribution,
+          key,
+          signature: await resolveContributionSignature(key, contribution)
+        };
+      })
+    );
+    await deps.ensureMarkerTable();
+    const markers = indexMarkerRows(graphId, await deps.getMarkers(graphId));
+    const sharedTable = deps.fulltextTableName;
+    const sharedTableExisted = await deps.tableExists(sharedTable);
+    const rebuilt = await fence(graphId, async (tx) => {
+      const record = tx.recordContributionMaterialization;
+      if (record === void 0) {
+        throw new chunkNI72YOJB_cjs.ConfigurationError(
+          "rebuildContribution requires a transaction-scoped backend that can write contribution markers; without it the drop, recreate, and stamp could not commit together.",
+          {
+            backend: dialect,
+            capability: "contributions",
+            operation: "rebuild"
+          }
+        );
+      }
+      await lockContributionDdl(tx);
+      const unlockedForeignGraphIds = sharedTableExisted ? await readForeignGraphIds(tx, sharedTable, graphId) : [];
+      const mayRecreate = sharedTableExisted && unlockedForeignGraphIds.length === 0;
+      if (mayRecreate) await lockSharedFulltextTable(tx, sharedTable);
+      const foreignGraphIds = mayRecreate ? await readForeignGraphIds(tx, sharedTable, graphId) : unlockedForeignGraphIds;
+      const recreateStorage = mayRecreate && foreignGraphIds.length === 0;
+      if (!recreateStorage) {
+        const staleStamp = stamps.find(
+          ({ key, signature }) => diagnoseContribution(
+            markers.get(key),
+            signature,
+            sharedTableExisted
+          ) === "stale"
+        );
+        if (staleStamp !== void 0) {
+          throw new chunkNI72YOJB_cjs.ContributionRebuildUnsupportedError(
+            "shared-storage-in-use",
+            {
+              graphId,
+              contribution: scope,
+              owner: staleStamp.contribution.owner,
+              logicalName: staleStamp.contribution.logicalName,
+              physicalName: staleStamp.contribution.tableName,
+              otherGraphIds: foreignGraphIds
+            }
+          );
+        }
+      }
+      for (const { contribution } of stamps) {
+        if (recreateStorage) {
+          for (const statement of contribution.dropDdl ?? []) {
+            await tx.executeSchemaDdl(statement);
+          }
+        }
+        for (const statement of contribution.createDdl) {
+          await tx.executeSchemaDdl(statement);
+        }
+      }
+      if (!recreateStorage) {
+        await tx.executeStatement(
+          chunkVCRRKBLN_cjs.asCompiledStatementSql(
+            chunk4UGOKMI5_cjs.buildFulltextGraphDelete(sharedTable, graphId)
+          )
+        );
+      }
+      const stats = await repopulate(tx);
+      const now = chunkYAAM3M2S_cjs.nowIso();
+      for (const { contribution, signature } of stamps) {
+        await record({
+          ...identityOf(graphId, contribution),
+          signature,
+          attemptedAt: now,
+          materializedAt: now,
+          error: void 0
+        });
+      }
+      return {
+        rebuilt: stamps.map(({ contribution }) => contribution.tableName),
+        processed: stats.processed,
+        repopulated: stats.repopulated,
+        skipped: stats.skipped
+      };
+    });
+    for (const { key, signature } of stamps) {
+      cacheInitializedSignature(key, signature);
+    }
+    return rebuilt;
+  }
   function evictVectorSlot(slot) {
     if (deps.vectorStrategy === void 0) return;
     for (const contribution of deps.vectorStrategy.ownedTables(slot)) {
@@ -654,7 +857,9 @@ function createContributionMaterializer(deps) {
     dropVectorSlot,
     evictVectorSlot,
     verifyContributions,
-    repairContributions
+    repairContributions,
+    probeContributions,
+    rebuildContribution
   };
 }
 var SQLITE_INDEX_MAT_TIMESTAMPS = {
@@ -662,7 +867,7 @@ var SQLITE_INDEX_MAT_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_INDEX_MAT_TIMESTAMPS = {
-  decode: chunkF4NHQHEZ_cjs.formatPostgresTimestamp,
+  decode: chunkYAAM3M2S_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapMaterializationRow(row, decode) {
@@ -720,7 +925,7 @@ var SQLITE_KIND_REMOVAL_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_KIND_REMOVAL_TIMESTAMPS = {
-  decode: chunkF4NHQHEZ_cjs.formatPostgresTimestamp,
+  decode: chunkYAAM3M2S_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapKindRemovalRow(row, decode) {
@@ -761,6 +966,30 @@ function buildKindRemovalOnConflictSet(removedAtColumn, paramsRemovedAt) {
     lastError: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_error")}`
   };
 }
+function primaryKeyConstraintNames(relation, keyColumns) {
+  return [`${relation}_pkey`, `${relation}_${keyColumns.join("_")}_pk`];
+}
+function nodePrimaryKeyConstraint(nodes) {
+  const relation = drizzleOrm.getTableName(nodes);
+  return {
+    table: relation,
+    constraintNames: primaryKeyConstraintNames(relation, [
+      nodes.graphId.name,
+      nodes.kind.name,
+      nodes.id.name
+    ])
+  };
+}
+function edgePrimaryKeyConstraint(edges) {
+  const relation = drizzleOrm.getTableName(edges);
+  return {
+    table: relation,
+    constraintNames: primaryKeyConstraintNames(relation, [
+      edges.graphId.name,
+      edges.id.name
+    ])
+  };
+}
 function sqlNull(value) {
   return value ?? drizzleOrm.sql.raw("NULL");
 }
@@ -768,6 +997,11 @@ function resolveValidFrom(validFrom, timestamp) {
   if (validFrom === null) return void 0;
   return validFrom ?? timestamp;
 }
+function expectedValidFromPredicate(column, expected) {
+  if (expected === void 0) return drizzleOrm.sql.empty();
+  if (expected === null) return drizzleOrm.sql` AND ${column} IS NULL`;
+  return drizzleOrm.sql` AND ${column} = ${expected}`;
+}
 function quotedColumn(column) {
   return drizzleOrm.sql.raw(`"${column.name.replaceAll('"', '""')}"`);
 }
@@ -887,12 +1121,12 @@ function present(value) {
 function mapHybridSearchRow(row, toNodeRow) {
   return {
     node: toNodeRow(row),
-    fusedScore: chunkF4NHQHEZ_cjs.coerceNumericScore(row["fused_score"]),
+    fusedScore: chunkYAAM3M2S_cjs.coerceNumericScore(row["fused_score"]),
     ...present(row["vector_rank"]) ? { vectorRank: Number(row["vector_rank"]) } : {},
-    ...present(row["vector_score"]) ? { vectorScore: chunkF4NHQHEZ_cjs.coerceNumericScore(row["vector_score"]) } : {},
+    ...present(row["vector_score"]) ? { vectorScore: chunkYAAM3M2S_cjs.coerceNumericScore(row["vector_score"]) } : {},
     ...present(row["fulltext_rank"]) ? { fulltextRank: Number(row["fulltext_rank"]) } : {},
     ...present(row["fulltext_score"]) ? {
-      fulltextScore: chunkF4NHQHEZ_cjs.coerceNumericScore(
+      fulltextScore: chunkYAAM3M2S_cjs.coerceNumericScore(
         row["fulltext_score"]
       )
     } : {},
@@ -900,9 +1134,16 @@ function mapHybridSearchRow(row, toNodeRow) {
   };
 }
 function buildClearGraph(tables, graphId) {
-  const fulltext = quotedTableName(tables.fulltextTableName);
   return [
-    { query: drizzleOrm.sql`DELETE FROM ${fulltext} WHERE "graph_id" = ${graphId}` },
+    // The fulltext table is shared by every graph in the database, so its
+    // graph-scoped delete is owned by one builder the destructive
+    // contribution rebuild calls too — see `buildFulltextGraphDelete`.
+    { query: chunk4UGOKMI5_cjs.buildFulltextGraphDelete(tables.fulltextTableName, graphId) },
+    {
+      query: drizzleOrm.sql`DELETE FROM ${tables.recordedIdentityAssertions} WHERE ${tables.recordedIdentityAssertions.graphId} = ${graphId}`,
+      ignoreMissingTable: true,
+      requiredTableName: drizzleOrm.getTableName(tables.recordedIdentityAssertions)
+    },
     {
       query: drizzleOrm.sql`DELETE FROM ${tables.recordedEdges} WHERE ${tables.recordedEdges.graphId} = ${graphId}`,
       ignoreMissingTable: true,
@@ -918,6 +1159,21 @@ function buildClearGraph(tables, graphId) {
       ignoreMissingTable: true,
       requiredTableName: drizzleOrm.getTableName(tables.recordedClock)
     },
+    {
+      query: drizzleOrm.sql`DELETE FROM ${tables.identitySeparation} WHERE ${tables.identitySeparation.graphId} = ${graphId}`,
+      ignoreMissingTable: true,
+      requiredTableName: drizzleOrm.getTableName(tables.identitySeparation)
+    },
+    {
+      query: drizzleOrm.sql`DELETE FROM ${tables.identityClosure} WHERE ${tables.identityClosure.graphId} = ${graphId}`,
+      ignoreMissingTable: true,
+      requiredTableName: drizzleOrm.getTableName(tables.identityClosure)
+    },
+    {
+      query: drizzleOrm.sql`DELETE FROM ${tables.identityAssertions} WHERE ${tables.identityAssertions.graphId} = ${graphId}`,
+      ignoreMissingTable: true,
+      requiredTableName: drizzleOrm.getTableName(tables.identityAssertions)
+    },
     {
       query: drizzleOrm.sql`DELETE FROM ${tables.uniques} WHERE ${tables.uniques.graphId} = ${graphId}`
     },
@@ -1254,6 +1510,17 @@ function buildGetEdges(tables, graphId, ids) {
   )})
   `;
 }
+function expectedIdentityPredicate(tables, expected) {
+  const { edges } = tables;
+  const parts = [
+    expected.kind === void 0 ? void 0 : drizzleOrm.sql` AND ${edges.kind} = ${expected.kind}`,
+    expected.fromKind === void 0 ? void 0 : drizzleOrm.sql` AND ${edges.fromKind} = ${expected.fromKind}`,
+    expected.fromId === void 0 ? void 0 : drizzleOrm.sql` AND ${edges.fromId} = ${expected.fromId}`,
+    expected.toKind === void 0 ? void 0 : drizzleOrm.sql` AND ${edges.toKind} = ${expected.toKind}`,
+    expected.toId === void 0 ? void 0 : drizzleOrm.sql` AND ${edges.toId} = ${expected.toId}`
+  ].filter((part) => part !== void 0);
+  return parts.length === 0 ? drizzleOrm.sql.empty() : drizzleOrm.sql.join(parts, drizzleOrm.sql``);
+}
 function buildUpdateEdge(tables, params, timestamp) {
   const { edges } = tables;
   const propsJson = JSON.stringify(params.props);
@@ -1261,19 +1528,29 @@ function buildUpdateEdge(tables, params, timestamp) {
     drizzleOrm.sql`${quotedColumn(edges.props)} = ${propsJson}`,
     drizzleOrm.sql`${quotedColumn(edges.updatedAt)} = ${timestamp}`
   ];
-  if (params.validTo !== void 0) {
+  if (params.clearDeleted && params.validFrom !== void 0) {
+    setParts.push(
+      drizzleOrm.sql`${quotedColumn(edges.validFrom)} = ${sqlNull(resolveValidFrom(params.validFrom, timestamp))}`,
+      drizzleOrm.sql`${quotedColumn(edges.validTo)} = ${sqlNull(params.validTo)}`
+    );
+  } else if (params.validTo !== void 0) {
     setParts.push(drizzleOrm.sql`${quotedColumn(edges.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
     setParts.push(drizzleOrm.sql`${quotedColumn(edges.deletedAt)} = NULL`);
   }
   const setClause = drizzleOrm.sql.join(setParts, drizzleOrm.sql`, `);
+  const expectedIdentity = expectedIdentityPredicate(tables, params);
+  const expectedValidFrom = expectedValidFromPredicate(
+    edges.validFrom,
+    params.expectedValidFrom
+  );
   if (params.clearDeleted) {
     return drizzleOrm.sql`
       UPDATE ${edges}
       SET ${setClause}
       WHERE ${edges.graphId} = ${params.graphId}
-        AND ${edges.id} = ${params.id}
+        AND ${edges.id} = ${params.id}${expectedIdentity}${expectedValidFrom}
       RETURNING *
     `;
   }
@@ -1281,7 +1558,7 @@ function buildUpdateEdge(tables, params, timestamp) {
     UPDATE ${edges}
     SET ${setClause}
     WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.id} = ${params.id}
+      AND ${edges.id} = ${params.id}${expectedIdentity}${expectedValidFrom}
       AND ${edges.deletedAt} IS NULL
     RETURNING *
   `;
@@ -1292,7 +1569,7 @@ function buildDeleteEdge(tables, params, timestamp) {
     UPDATE ${edges}
     SET ${quotedColumn(edges.deletedAt)} = ${timestamp}
     WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.id} = ${params.id}
+      AND ${edges.id} = ${params.id}${expectedIdentityPredicate(tables, params.kind === void 0 ? {} : { kind: params.kind })}
       AND ${edges.deletedAt} IS NULL
   `;
 }
@@ -1325,7 +1602,7 @@ function buildHardDeleteEdge(tables, params) {
   return drizzleOrm.sql`
     DELETE FROM ${edges}
     WHERE ${edges.graphId} = ${params.graphId}
-      AND ${edges.id} = ${params.id}
+      AND ${edges.id} = ${params.id}${expectedIdentityPredicate(tables, params.kind === void 0 ? {} : { kind: params.kind })}
   `;
 }
 function buildHardDeleteEdgesByNode(tables, graphId, nodeKind, nodeId) {
@@ -1402,11 +1679,11 @@ function buildFulltextSearch(tableName, params, strategy, dialect, candidates) {
   assertValidSearchParams(params);
   const mode = resolveMode(params.mode);
   const table = quotedTableName(tableName);
-  const matchCondition = chunkOOA273IJ_cjs.toDrizzleSql(
+  const matchCondition = chunkU5SON7R2_cjs.toDrizzleSql(
     strategy.matchCondition(tableName, params.query, mode, params.language),
     dialect
   );
-  const rankExpression = chunkOOA273IJ_cjs.toDrizzleSql(
+  const rankExpression = chunkU5SON7R2_cjs.toDrizzleSql(
     strategy.rankExpression(tableName, params.query, mode, params.language),
     dialect
   );
@@ -1419,10 +1696,10 @@ function buildFulltextSearch(tableName, params, strategy, dialect, candidates) {
     conditions.push(drizzleOrm.sql`${rankExpression} >= ${params.minScore}`);
   }
   if (candidates !== void 0) {
-    const candidateSql = chunkU5W4LKZV_cjs.isSqlFragment(candidates) ? chunkOOA273IJ_cjs.toDrizzleSql(candidates, dialect) : candidates;
+    const candidateSql = chunkVCRRKBLN_cjs.isSqlFragment(candidates) ? chunkU5SON7R2_cjs.toDrizzleSql(candidates, dialect) : candidates;
     conditions.push(drizzleOrm.sql`"node_id" IN (${candidateSql})`);
   }
-  const snippetExpr = params.includeSnippets === true && strategy.supportsSnippets ? chunkOOA273IJ_cjs.toDrizzleSql(
+  const snippetExpr = params.includeSnippets === true && strategy.supportsSnippets ? chunkU5SON7R2_cjs.toDrizzleSql(
     strategy.snippetExpression(
       tableName,
       params.query,
@@ -1538,20 +1815,30 @@ function buildUpdateNode(tables, params, timestamp) {
       drizzleOrm.sql`${quotedColumn(nodes.version)} = ${quotedColumn(nodes.version)} + 1`
     );
   }
-  if (params.validTo !== void 0) {
+  if (params.clearDeleted) {
+    setParts.push(
+      drizzleOrm.sql`${quotedColumn(nodes.validFrom)} = ${sqlNull(resolveValidFrom(params.validFrom, timestamp))}`,
+      drizzleOrm.sql`${quotedColumn(nodes.validTo)} = ${sqlNull(params.validTo)}`
+    );
+  } else if (params.validTo !== void 0) {
     setParts.push(drizzleOrm.sql`${quotedColumn(nodes.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
     setParts.push(drizzleOrm.sql`${quotedColumn(nodes.deletedAt)} = NULL`);
   }
   const setClause = drizzleOrm.sql.join(setParts, drizzleOrm.sql`, `);
+  const expectedValidFrom = expectedValidFromPredicate(
+    nodes.validFrom,
+    params.expectedValidFrom
+  );
   if (params.clearDeleted) {
     return drizzleOrm.sql`
       UPDATE ${nodes}
       SET ${setClause}
       WHERE ${nodes.graphId} = ${params.graphId}
         AND ${nodes.kind} = ${params.kind}
-        AND ${nodes.id} = ${params.id}
+        AND ${nodes.id} = ${params.id}${expectedValidFrom}
+        AND ${nodes.deletedAt} IS NOT NULL
       RETURNING *
     `;
   }
@@ -1560,25 +1847,25 @@ function buildUpdateNode(tables, params, timestamp) {
     SET ${setClause}
     WHERE ${nodes.graphId} = ${params.graphId}
       AND ${nodes.kind} = ${params.kind}
-      AND ${nodes.id} = ${params.id}
+      AND ${nodes.id} = ${params.id}${expectedValidFrom}
       AND ${nodes.deletedAt} IS NULL
     RETURNING *
   `;
 }
 function buildUpdateNodeSet(tables, dialect, params, timestamp) {
   const { nodes } = tables;
-  const adapter = chunkJXUTCSXX_cjs.getDialect(dialect);
-  const patchedProps = chunkOOA273IJ_cjs.toDrizzleSql(
+  const adapter = chunk4UGOKMI5_cjs.getDialect(dialect);
+  const patchedProps = chunkU5SON7R2_cjs.toDrizzleSql(
     adapter.jsonSetProperties(
-      chunkU5W4LKZV_cjs.sql.identifier(nodes.props.name),
+      chunkVCRRKBLN_cjs.sql.identifier(nodes.props.name),
       params.patch,
       params.unsetProperties ?? []
     ),
     dialect
   );
-  const candidateIds = chunkOOA273IJ_cjs.toDrizzleSql(params.candidateIds, dialect);
-  const candidateIdColumn = chunkOOA273IJ_cjs.toDrizzleSql(
-    chunkU5W4LKZV_cjs.sql.identifier(params.candidateIdColumn),
+  const candidateIds = chunkU5SON7R2_cjs.toDrizzleSql(params.candidateIds, dialect);
+  const candidateIdColumn = chunkU5SON7R2_cjs.toDrizzleSql(
+    chunkVCRRKBLN_cjs.sql.identifier(params.candidateIdColumn),
     dialect
   );
   return drizzleOrm.sql`
@@ -1896,6 +2183,9 @@ function buildCheckUniqueBatch(tables, params) {
 }
 
 // src/backend/drizzle/operations/strategy.ts
+function nullableText(value) {
+  return value === void 0 ? drizzleOrm.sql`NULL` : drizzleOrm.sql`${value}`;
+}
 function bindTableOperationBuilders(tables, builders) {
   const boundEntries = Object.entries(builders).map(([name, builder]) => {
     function boundBuilder(...args) {
@@ -1953,15 +2243,15 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
   const fulltextTable = tables.fulltextTableName;
   const contributionMaterializations = tables.contributionMaterializations;
   const fulltextBuilders = {
-    buildUpsertFulltext: (params, timestamp) => fulltextStrategy.buildUpsert(fulltextTable, params, timestamp).map((statement) => chunkOOA273IJ_cjs.toDrizzleSql(statement, dialect)),
-    buildDeleteFulltext: (params) => fulltextStrategy.buildDelete(fulltextTable, params).map((statement) => chunkOOA273IJ_cjs.toDrizzleSql(statement, dialect)),
+    buildUpsertFulltext: (params, timestamp) => fulltextStrategy.buildUpsert(fulltextTable, params, timestamp).map((statement) => chunkU5SON7R2_cjs.toDrizzleSql(statement, dialect)),
+    buildDeleteFulltext: (params) => fulltextStrategy.buildDelete(fulltextTable, params).map((statement) => chunkU5SON7R2_cjs.toDrizzleSql(statement, dialect)),
     buildDeleteFulltextByNode: (graphId, nodeKind, nodeId) => fulltextStrategy.buildDelete(fulltextTable, {
       graphId,
       nodeKind,
       nodeId
-    }).map((statement) => chunkOOA273IJ_cjs.toDrizzleSql(statement, dialect)),
-    buildUpsertFulltextBatch: (params, timestamp) => fulltextStrategy.buildBatchUpsert(fulltextTable, params, timestamp).map((statement) => chunkOOA273IJ_cjs.toDrizzleSql(statement, dialect)),
-    buildDeleteFulltextBatch: (params) => fulltextStrategy.buildBatchDelete(fulltextTable, params).map((statement) => chunkOOA273IJ_cjs.toDrizzleSql(statement, dialect)),
+    }).map((statement) => chunkU5SON7R2_cjs.toDrizzleSql(statement, dialect)),
+    buildUpsertFulltextBatch: (params, timestamp) => fulltextStrategy.buildBatchUpsert(fulltextTable, params, timestamp).map((statement) => chunkU5SON7R2_cjs.toDrizzleSql(statement, dialect)),
+    buildDeleteFulltextBatch: (params) => fulltextStrategy.buildBatchDelete(fulltextTable, params).map((statement) => chunkU5SON7R2_cjs.toDrizzleSql(statement, dialect)),
     buildFulltextSearch: (params) => buildFulltextSearch(
       fulltextTable,
       params,
@@ -1973,7 +2263,7 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
         tables.nodes,
         params.graphId,
         params.nodeKind,
-        chunkF4NHQHEZ_cjs.nowIso()
+        chunkYAAM3M2S_cjs.nowIso()
       )
     ),
     buildHybridSearch: (params, vectorSql, vectorScoreDescending) => {
@@ -1981,7 +2271,7 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
         tables.nodes,
         params.graphId,
         params.nodeKind,
-        chunkF4NHQHEZ_cjs.nowIso()
+        chunkYAAM3M2S_cjs.nowIso()
       );
       const fulltextSql = buildFulltextSearch(
         fulltextTable,
@@ -2002,7 +2292,7 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
         hybridCandidatesRef()
       );
       return buildHybridSearchStatement({
-        candidatesSql: chunkU5W4LKZV_cjs.isSqlFragment(candidates) ? chunkOOA273IJ_cjs.toDrizzleSql(candidates, dialect) : candidates,
+        candidatesSql: chunkVCRRKBLN_cjs.isSqlFragment(candidates) ? chunkU5SON7R2_cjs.toDrizzleSql(candidates, dialect) : candidates,
         vectorSql,
         vectorScoreDescending,
         fulltextSql,
@@ -2018,6 +2308,24 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
       });
     }
   };
+  function buildInsertContributionMaterialization(params) {
+    return drizzleOrm.sql`
+      INSERT INTO ${contributionMaterializations}
+        (graph_id, logical_name, owner, table_name, signature,
+         materialized_at, last_attempted_at, last_error)
+      VALUES (
+        ${params.graphId}, ${params.logicalName}, ${params.owner},
+        ${params.tableName}, ${params.signature},
+        ${nullableText(params.materializedAt)}, ${params.attemptedAt},
+        ${nullableText(params.error)}
+      )
+      ON CONFLICT (graph_id, logical_name, owner, table_name) DO UPDATE SET
+        signature = excluded.signature,
+        materialized_at = excluded.materialized_at,
+        last_attempted_at = excluded.last_attempted_at,
+        last_error = excluded.last_error
+    `;
+  }
   function buildDeleteContributionMaterialization(identity) {
     return drizzleOrm.sql`
       DELETE FROM ${contributionMaterializations}
@@ -2030,10 +2338,15 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
   return {
     ...tableOperations,
     ...fulltextBuilders,
+    primaryKeyConstraints: {
+      nodes: nodePrimaryKeyConstraint(tables.nodes),
+      edges: edgePrimaryKeyConstraint(tables.edges)
+    },
     buildUpdateNodeSet(params, timestamp) {
       return buildUpdateNodeSet(tables, dialect, params, timestamp);
     },
     buildDeleteContributionMaterialization,
+    buildInsertContributionMaterialization,
     buildInsertUnique(params) {
       return buildInsertUnique(tables, dialect, params);
     },
@@ -2076,7 +2389,7 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
 }
 function tableExistsFromRow(row) {
   if (row === void 0) return false;
-  return Object.values(row).some((value) => chunk764JHTLT_cjs.isPresent(value));
+  return Object.values(row).some((value) => chunkN66HCGCY_cjs.isPresent(value));
 }
 function createCachedTableExistence(probe, options) {
   const cacheExisting = options?.cacheExisting !== false;
@@ -2109,18 +2422,38 @@ var DRIZZLE_DIALECT_LABELS = {
 function assertAdoptedDialect(externalTx, brand, backend) {
   if (drizzleOrm.is(externalTx, brand)) return;
   const label = DRIZZLE_DIALECT_LABELS[backend];
-  throw new chunkC4F7VJ5D_cjs.ConfigurationError(
+  throw new chunkNI72YOJB_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" }
   );
 }
+async function withDuplicateKeyClassification(run, context) {
+  try {
+    return await run();
+  } catch (error) {
+    if (!chunkBSFJMMV3_cjs.isDuplicatePrimaryKeyError(error, context.relation)) throw error;
+    throw new chunkNI72YOJB_cjs.DatabaseOperationError(
+      `Insert ${context.entity} failed: a row with this identity already exists`,
+      {
+        operation: "insert",
+        entity: context.entity,
+        reason: "duplicate_key",
+        attempted: context.attempted
+      },
+      { cause: error }
+    );
+  }
+}
+function attemptedInserts(params) {
+  return params.map((item) => ({ kind: item.kind, id: item.id }));
+}
 function verifyExpectedActiveVersion(graphId, expected, actualActiveVersion) {
   const expectedVersion = expected.kind === "active" ? expected.version : 0;
   assertActiveSchemaVersion(graphId, expectedVersion, actualActiveVersion);
 }
 function assertActiveSchemaVersion(graphId, expectedVersion, actualActiveVersion) {
   if (actualActiveVersion !== expectedVersion) {
-    throw new chunkC4F7VJ5D_cjs.StaleVersionError({
+    throw new chunkNI72YOJB_cjs.StaleVersionError({
       graphId,
       expected: expectedVersion,
       actual: actualActiveVersion
@@ -2170,7 +2503,7 @@ function createCommonOperationBackend(options) {
     operationStrategy,
     rowMappers
   } = options;
-  const nowIso2 = options.nowIso ?? chunkF4NHQHEZ_cjs.nowIso;
+  const nowIso2 = options.nowIso ?? chunkYAAM3M2S_cjs.nowIso;
   const tableExists = createCachedTableExistence(
     (tableName) => execution.execGet(
       operationStrategy.buildTableExists(tableName)
@@ -2192,7 +2525,7 @@ function createCommonOperationBackend(options) {
   return {
     tableExists,
     async executeSchemaDdl(ddl) {
-      await execution.execRun(chunkU5W4LKZV_cjs.asCompiledStatementSql(chunkU5W4LKZV_cjs.sql.raw(ddl)));
+      await execution.execRun(chunkVCRRKBLN_cjs.asCompiledStatementSql(chunkVCRRKBLN_cjs.sql.raw(ddl)));
     },
     async executeStatement(query) {
       await execution.execRun(query);
@@ -2203,11 +2536,22 @@ function createCommonOperationBackend(options) {
     async insertNode(params) {
       const timestamp = nowIso2();
       const query = operationStrategy.buildInsertNode(params, timestamp);
-      const row = await execution.execGet(query);
+      const row = await withDuplicateKeyClassification(
+        () => execution.execGet(query),
+        {
+          entity: "node",
+          relation: operationStrategy.primaryKeyConstraints.nodes,
+          attempted: attemptedInserts([params])
+        }
+      );
       if (!row)
-        throw new chunkC4F7VJ5D_cjs.DatabaseOperationError(
+        throw new chunkNI72YOJB_cjs.DatabaseOperationError(
           "Insert node failed: no row returned",
-          { operation: "insert", entity: "node" }
+          {
+            operation: "insert",
+            entity: "node",
+            reason: "no_row_returned"
+          }
         );
       return rowMappers.toNodeRow(row);
     },
@@ -2217,16 +2561,24 @@ function createCommonOperationBackend(options) {
         params,
         timestamp
       );
-      await execution.execRun(query);
+      await withDuplicateKeyClassification(() => execution.execRun(query), {
+        entity: "node",
+        relation: operationStrategy.primaryKeyConstraints.nodes,
+        attempted: attemptedInserts([params])
+      });
     },
     async insertNodesBatch(params) {
       if (params.length === 0) {
         return;
       }
       const timestamp = nowIso2();
-      for (const chunk2 of chunkZDH3DX3C_cjs.chunk(params, batchConfig.nodeInsertBatchSize)) {
+      for (const chunk2 of chunkBSFJMMV3_cjs.chunk(params, batchConfig.nodeInsertBatchSize)) {
         const query = operationStrategy.buildInsertNodesBatch(chunk2, timestamp);
-        await execution.execRun(query);
+        await withDuplicateKeyClassification(() => execution.execRun(query), {
+          entity: "node",
+          relation: operationStrategy.primaryKeyConstraints.nodes,
+          attempted: attemptedInserts(chunk2)
+        });
       }
     },
     async insertNodesBatchReturning(params) {
@@ -2235,12 +2587,19 @@ function createCommonOperationBackend(options) {
       }
       const timestamp = nowIso2();
       const allRows = [];
-      for (const chunk2 of chunkZDH3DX3C_cjs.chunk(params, batchConfig.nodeInsertBatchSize)) {
+      for (const chunk2 of chunkBSFJMMV3_cjs.chunk(params, batchConfig.nodeInsertBatchSize)) {
         const query = operationStrategy.buildInsertNodesBatchReturning(
           chunk2,
           timestamp
         );
-        const rows = await execution.execAll(query);
+        const rows = await withDuplicateKeyClassification(
+          () => execution.execAll(query),
+          {
+            entity: "node",
+            relation: operationStrategy.primaryKeyConstraints.nodes,
+            attempted: attemptedInserts(chunk2)
+          }
+        );
         allRows.push(...rows.map((row) => rowMappers.toNodeRow(row)));
       }
       return allRows;
@@ -2253,7 +2612,7 @@ function createCommonOperationBackend(options) {
     async getNodes(graphId, kind, ids) {
       if (ids.length === 0) return [];
       const allRows = [];
-      for (const chunk2 of chunkZDH3DX3C_cjs.chunk(ids, batchConfig.getNodesChunkSize)) {
+      for (const chunk2 of chunkBSFJMMV3_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)));
@@ -2265,21 +2624,25 @@ function createCommonOperationBackend(options) {
       const query = operationStrategy.buildUpdateNode(params, timestamp);
       const row = await execution.execGet(query);
       if (!row)
-        throw new chunkC4F7VJ5D_cjs.DatabaseOperationError(
+        throw new chunkNI72YOJB_cjs.DatabaseOperationError(
           "Update node failed: no row returned",
-          { operation: "update", entity: "node" }
+          {
+            operation: "update",
+            entity: "node",
+            reason: "no_row_returned"
+          }
         );
       return rowMappers.toNodeRow(row);
     },
     async updateNodeSet(params) {
       if (Object.keys(params.patch).length === 0 && (params.unsetProperties?.length ?? 0) === 0) {
-        throw new chunkC4F7VJ5D_cjs.ConfigurationError(
+        throw new chunkNI72YOJB_cjs.ConfigurationError(
           "Set-based node update requires at least one property",
           { operation: "updateNodeSet", kind: params.kind }
         );
       }
       if (params.candidateIdColumn.length === 0) {
-        throw new chunkC4F7VJ5D_cjs.ConfigurationError(
+        throw new chunkNI72YOJB_cjs.ConfigurationError(
           "Set-based node update requires a candidate id column",
           { operation: "updateNodeSet", kind: params.kind }
         );
@@ -2331,11 +2694,22 @@ function createCommonOperationBackend(options) {
     async insertEdge(params) {
       const timestamp = nowIso2();
       const query = operationStrategy.buildInsertEdge(params, timestamp);
-      const row = await execution.execGet(query);
+      const row = await withDuplicateKeyClassification(
+        () => execution.execGet(query),
+        {
+          entity: "edge",
+          relation: operationStrategy.primaryKeyConstraints.edges,
+          attempted: attemptedInserts([params])
+        }
+      );
       if (!row)
-        throw new chunkC4F7VJ5D_cjs.DatabaseOperationError(
+        throw new chunkNI72YOJB_cjs.DatabaseOperationError(
           "Insert edge failed: no row returned",
-          { operation: "insert", entity: "edge" }
+          {
+            operation: "insert",
+            entity: "edge",
+            reason: "no_row_returned"
+          }
         );
       return rowMappers.toEdgeRow(row);
     },
@@ -2345,16 +2719,24 @@ function createCommonOperationBackend(options) {
         params,
         timestamp
       );
-      await execution.execRun(query);
+      await withDuplicateKeyClassification(() => execution.execRun(query), {
+        entity: "edge",
+        relation: operationStrategy.primaryKeyConstraints.edges,
+        attempted: attemptedInserts([params])
+      });
     },
     async insertEdgesBatch(params) {
       if (params.length === 0) {
         return;
       }
       const timestamp = nowIso2();
-      for (const chunk2 of chunkZDH3DX3C_cjs.chunk(params, batchConfig.edgeInsertBatchSize)) {
+      for (const chunk2 of chunkBSFJMMV3_cjs.chunk(params, batchConfig.edgeInsertBatchSize)) {
         const query = operationStrategy.buildInsertEdgesBatch(chunk2, timestamp);
-        await execution.execRun(query);
+        await withDuplicateKeyClassification(() => execution.execRun(query), {
+          entity: "edge",
+          relation: operationStrategy.primaryKeyConstraints.edges,
+          attempted: attemptedInserts(chunk2)
+        });
       }
     },
     async insertEdgesBatchReturning(params) {
@@ -2363,12 +2745,19 @@ function createCommonOperationBackend(options) {
       }
       const timestamp = nowIso2();
       const allRows = [];
-      for (const chunk2 of chunkZDH3DX3C_cjs.chunk(params, batchConfig.edgeInsertBatchSize)) {
+      for (const chunk2 of chunkBSFJMMV3_cjs.chunk(params, batchConfig.edgeInsertBatchSize)) {
         const query = operationStrategy.buildInsertEdgesBatchReturning(
           chunk2,
           timestamp
         );
-        const rows = await execution.execAll(query);
+        const rows = await withDuplicateKeyClassification(
+          () => execution.execAll(query),
+          {
+            entity: "edge",
+            relation: operationStrategy.primaryKeyConstraints.edges,
+            attempted: attemptedInserts(chunk2)
+          }
+        );
         allRows.push(...rows.map((row) => rowMappers.toEdgeRow(row)));
       }
       return allRows;
@@ -2381,7 +2770,7 @@ function createCommonOperationBackend(options) {
     async getEdges(graphId, ids) {
       if (ids.length === 0) return [];
       const allRows = [];
-      for (const chunk2 of chunkZDH3DX3C_cjs.chunk(ids, batchConfig.getEdgesChunkSize)) {
+      for (const chunk2 of chunkBSFJMMV3_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)));
@@ -2393,9 +2782,13 @@ function createCommonOperationBackend(options) {
       const query = operationStrategy.buildUpdateEdge(params, timestamp);
       const row = await execution.execGet(query);
       if (!row)
-        throw new chunkC4F7VJ5D_cjs.DatabaseOperationError(
+        throw new chunkNI72YOJB_cjs.DatabaseOperationError(
           "Update edge failed: no row returned",
-          { operation: "update", entity: "edge" }
+          {
+            operation: "update",
+            entity: "edge",
+            reason: "no_row_returned"
+          }
         );
       return rowMappers.toEdgeRow(row);
     },
@@ -2415,7 +2808,7 @@ function createCommonOperationBackend(options) {
         1,
         batchConfig.getEdgesChunkSize - 1
       );
-      for (const chunk2 of chunkZDH3DX3C_cjs.chunk(params.ids, softDeleteChunkSize)) {
+      for (const chunk2 of chunkBSFJMMV3_cjs.chunk(params.ids, softDeleteChunkSize)) {
         const query = operationStrategy.buildDeleteEdgesBatch(
           { graphId: params.graphId, ids: chunk2 },
           timestamp
@@ -2425,7 +2818,7 @@ function createCommonOperationBackend(options) {
     },
     async hardDeleteEdgesBatch(params) {
       if (params.ids.length === 0) return;
-      for (const chunk2 of chunkZDH3DX3C_cjs.chunk(
+      for (const chunk2 of chunkBSFJMMV3_cjs.chunk(
         params.ids,
         batchConfig.getEdgesChunkSize
       )) {
@@ -2469,7 +2862,7 @@ function createCommonOperationBackend(options) {
     async findEdgesByEndpointSet(params) {
       const ids = resolveEdgeEndpointIds(params);
       const edgeRows = [];
-      for (const idChunk of chunkZDH3DX3C_cjs.chunk(
+      for (const idChunk of chunkBSFJMMV3_cjs.chunk(
         ids,
         batchConfig.findEdgesEndpointChunkSize
       )) {
@@ -2486,7 +2879,7 @@ function createCommonOperationBackend(options) {
       const { edgeKinds, endpoints, endpointChunkSize } = resolveHeterogeneousEdgeRead(params, maxBindParameters);
       if (edgeKinds.length === 0 || endpoints.length === 0) return [];
       const edgeRows = [];
-      for (const endpointChunk of chunkZDH3DX3C_cjs.chunk(endpoints, endpointChunkSize)) {
+      for (const endpointChunk of chunkBSFJMMV3_cjs.chunk(endpoints, endpointChunkSize)) {
         const query = operationStrategy.buildFindEdgesByHeterogeneousEndpointSet(
           params,
           endpointChunk,
@@ -2506,7 +2899,7 @@ function createCommonOperationBackend(options) {
       const query = operationStrategy.buildInsertUnique(params);
       const result = await execution.execGet(query);
       if (result && result.node_id !== params.nodeId) {
-        throw new chunkC4F7VJ5D_cjs.UniquenessError({
+        throw new chunkNI72YOJB_cjs.UniquenessError({
           constraintName: params.constraintName,
           kind: params.nodeKind,
           existingId: result.node_id,
@@ -2526,7 +2919,7 @@ function createCommonOperationBackend(options) {
           continue;
         }
         if (existing.nodeId !== entry.nodeId) {
-          throw new chunkC4F7VJ5D_cjs.UniquenessError({
+          throw new chunkNI72YOJB_cjs.UniquenessError({
             constraintName: entry.constraintName,
             kind: entry.nodeKind,
             existingId: existing.nodeId,
@@ -2536,7 +2929,7 @@ function createCommonOperationBackend(options) {
         }
       }
       const deduped = [...byTarget.values()];
-      for (const chunk2 of chunkZDH3DX3C_cjs.chunk(
+      for (const chunk2 of chunkBSFJMMV3_cjs.chunk(
         deduped,
         batchConfig.uniqueInsertBatchSize
       )) {
@@ -2551,7 +2944,7 @@ function createCommonOperationBackend(options) {
         for (const entry of chunk2) {
           const owner = ownerByTarget.get(targetKey(entry));
           if (owner !== void 0 && owner !== entry.nodeId) {
-            throw new chunkC4F7VJ5D_cjs.UniquenessError({
+            throw new chunkNI72YOJB_cjs.UniquenessError({
               constraintName: entry.constraintName,
               kind: entry.nodeKind,
               existingId: owner,
@@ -2569,7 +2962,7 @@ function createCommonOperationBackend(options) {
     },
     async hardDeleteUniquesByNodeIds(params) {
       const nodeIds = [...new Set(params.nodeIds)];
-      for (const chunk2 of chunkZDH3DX3C_cjs.chunk(
+      for (const chunk2 of chunkBSFJMMV3_cjs.chunk(
         nodeIds,
         batchConfig.uniqueDeleteChunkSize
       )) {
@@ -2588,7 +2981,7 @@ function createCommonOperationBackend(options) {
     async checkUniqueBatch(params) {
       if (params.keys.length === 0) return [];
       const allRows = [];
-      for (const chunk2 of chunkZDH3DX3C_cjs.chunk(
+      for (const chunk2 of chunkBSFJMMV3_cjs.chunk(
         params.keys,
         batchConfig.checkUniqueBatchChunkSize
       )) {
@@ -2619,7 +3012,7 @@ function createCommonOperationBackend(options) {
       if (existingRaw !== void 0) {
         const existing = rowMappers.toSchemaVersionRow(existingRaw);
         if (existing.schema_hash !== params.schemaHash) {
-          throw new chunkC4F7VJ5D_cjs.SchemaContentConflictError({
+          throw new chunkNI72YOJB_cjs.SchemaContentConflictError({
             graphId: params.graphId,
             version: params.version,
             existingHash: existing.schema_hash,
@@ -2667,7 +3060,7 @@ function createCommonOperationBackend(options) {
       );
       const insertedRaw = await execution.execGet(insertQuery);
       if (!insertedRaw) {
-        throw new chunkC4F7VJ5D_cjs.DatabaseOperationError(
+        throw new chunkNI72YOJB_cjs.DatabaseOperationError(
           "Insert schema failed: no row returned",
           { operation: "insert", entity: "schema" }
         );
@@ -2685,7 +3078,7 @@ function createCommonOperationBackend(options) {
         operationStrategy.buildGetSchemaVersion(params.graphId, params.version)
       );
       if (!targetRaw) {
-        throw new chunkC4F7VJ5D_cjs.MigrationError(
+        throw new chunkNI72YOJB_cjs.MigrationError(
           `Cannot activate version ${params.version}: version does not exist for graph "${params.graphId}".`,
           {
             graphId: params.graphId,
@@ -2718,7 +3111,7 @@ function quoteSqlIdentifier(identifier) {
 }
 function requireRawExecution(backend) {
   if (backend.executeRaw === void 0) {
-    throw new chunkC4F7VJ5D_cjs.TrustedImportError(
+    throw new chunkNI72YOJB_cjs.TrustedImportError(
       "This backend cannot execute the raw statements required by trusted import.",
       "backend_unsupported"
     );
@@ -2727,7 +3120,7 @@ function requireRawExecution(backend) {
 }
 function requireStatementExecution(backend) {
   if (backend.executeStatement === void 0) {
-    throw new chunkC4F7VJ5D_cjs.TrustedImportError(
+    throw new chunkNI72YOJB_cjs.TrustedImportError(
       "This backend cannot execute the index lifecycle required by trusted import.",
       "backend_unsupported"
     );
@@ -2749,7 +3142,7 @@ async function assertTrustedImportDatabaseEmpty(backend, tableNames) {
     []
   );
   if (!rowIndicatesExistingData(rows[0])) return;
-  throw new chunkC4F7VJ5D_cjs.TrustedImportError(
+  throw new chunkNI72YOJB_cjs.TrustedImportError(
     "Trusted import requires globally empty TypeGraph node and edge tables.",
     "database_not_empty",
     { tables: [tableNames.nodes, tableNames.edges] },
@@ -2761,8 +3154,8 @@ async function assertTrustedImportDatabaseEmpty(backend, tableNames) {
 async function lockPostgresTrustedImportTables(backend, tableNames) {
   const executeStatement = requireStatementExecution(backend);
   await executeStatement(
-    chunkU5W4LKZV_cjs.asCompiledStatementSql(
-      chunkU5W4LKZV_cjs.sql.raw(
+    chunkVCRRKBLN_cjs.asCompiledStatementSql(
+      chunkVCRRKBLN_cjs.sql.raw(
         `LOCK TABLE ${quoteSqlIdentifier(tableNames.nodes)}, ${quoteSqlIdentifier(tableNames.edges)} IN ACCESS EXCLUSIVE MODE`
       )
     )
@@ -2782,8 +3175,8 @@ async function suspendSqliteSecondaryIndexes(backend, tableNames) {
   );
   for (const definition of definitions) {
     await executeStatement(
-      chunkU5W4LKZV_cjs.asCompiledStatementSql(
-        chunkU5W4LKZV_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
+      chunkVCRRKBLN_cjs.asCompiledStatementSql(
+        chunkVCRRKBLN_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
       )
     );
   }
@@ -2813,8 +3206,8 @@ async function suspendPostgresSecondaryIndexes(backend, tableNames) {
   );
   for (const definition of definitions) {
     await executeStatement(
-      chunkU5W4LKZV_cjs.asCompiledStatementSql(
-        chunkU5W4LKZV_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
+      chunkVCRRKBLN_cjs.asCompiledStatementSql(
+        chunkVCRRKBLN_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
       )
     );
   }
@@ -2824,20 +3217,20 @@ async function restoreSecondaryIndexes(backend, definitions) {
   const executeStatement = requireStatementExecution(backend);
   for (const definition of definitions) {
     await executeStatement(
-      chunkU5W4LKZV_cjs.asCompiledStatementSql(chunkU5W4LKZV_cjs.sql.raw(definition.index_definition))
+      chunkVCRRKBLN_cjs.asCompiledStatementSql(chunkVCRRKBLN_cjs.sql.raw(definition.index_definition))
     );
   }
 }
 async function analyzeImportedTables(backend, tableNames) {
   const executeStatement = requireStatementExecution(backend);
   await executeStatement(
-    chunkU5W4LKZV_cjs.asCompiledStatementSql(
-      chunkU5W4LKZV_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.nodes)}`)
+    chunkVCRRKBLN_cjs.asCompiledStatementSql(
+      chunkVCRRKBLN_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.nodes)}`)
     )
   );
   await executeStatement(
-    chunkU5W4LKZV_cjs.asCompiledStatementSql(
-      chunkU5W4LKZV_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.edges)}`)
+    chunkVCRRKBLN_cjs.asCompiledStatementSql(
+      chunkVCRRKBLN_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.edges)}`)
     )
   );
 }
@@ -2852,7 +3245,7 @@ function postgresArray(values) {
 function createSqliteTrustedImportSession(executionAdapter, tableNames) {
   const executePreparedRunBatch = executionAdapter.executePreparedRunBatch;
   if (executePreparedRunBatch === void 0) {
-    throw new chunkC4F7VJ5D_cjs.TrustedImportError(
+    throw new chunkNI72YOJB_cjs.TrustedImportError(
       "Trusted import requires a synchronous SQLite driver with prepared statement support.",
       "backend_unsupported"
     );
@@ -3000,6 +3393,7 @@ exports.buildLiveNodeCandidates = buildLiveNodeCandidates;
 exports.buildMaterializationInsertValues = buildMaterializationInsertValues;
 exports.buildMaterializationOnConflictSet = buildMaterializationOnConflictSet;
 exports.commitSchemaVersionIfKindsEmpty = commitSchemaVersionIfKindsEmpty;
+exports.contributionRebuildSupported = contributionRebuildSupported;
 exports.createCachedTableExistence = createCachedTableExistence;
 exports.createCommonOperationBackend = createCommonOperationBackend;
 exports.createContributionMaterializer = createContributionMaterializer;
@@ -3023,5 +3417,5 @@ exports.tableExistsFromRow = tableExistsFromRow;
 exports.vectorSlotFromCreateIndexParams = vectorSlotFromCreateIndexParams;
 exports.vectorSlotFromDropIndexParams = vectorSlotFromDropIndexParams;
 exports.vectorSlotFromParams = vectorSlotFromParams;
-//# sourceMappingURL=chunk-H7VE3FL4.cjs.map
-//# sourceMappingURL=chunk-H7VE3FL4.cjs.map
+//# sourceMappingURL=chunk-MUK4BU7K.cjs.map
+//# sourceMappingURL=chunk-MUK4BU7K.cjs.map