@nicia-ai/typegraph 0.44.0 → 0.46.0

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

@@ -1,42 +1,87 @@
 'use strict';
 
-var chunkHJH3RMXG_cjs = require('./chunk-HJH3RMXG.cjs');
-var chunk6JZUSDY2_cjs = require('./chunk-6JZUSDY2.cjs');
-var chunkNN3QSOVS_cjs = require('./chunk-NN3QSOVS.cjs');
-var chunkZDH3DX3C_cjs = require('./chunk-ZDH3DX3C.cjs');
-var chunk3PRKZW6D_cjs = require('./chunk-3PRKZW6D.cjs');
-var chunkACSVZPK7_cjs = require('./chunk-ACSVZPK7.cjs');
-var chunkWBUFJ7BS_cjs = require('./chunk-WBUFJ7BS.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 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
 var FIND_EDGES_ENDPOINT_FIXED_PARAM_COUNT = 6;
-function resolveEdgeEndpointIds(params) {
-  const { limitPerEndpoint } = params;
-  if (limitPerEndpoint !== void 0 && (!Number.isInteger(limitPerEndpoint) || limitPerEndpoint <= 0)) {
-    throw new chunkC4F7VJ5D_cjs.ConfigurationError(
-      `findEdgesByEndpointSet \`limitPerEndpoint\` must be a positive integer, received ${String(limitPerEndpoint)}.`,
-      {
-        code: "EDGE_ENDPOINT_SET_INVALID",
-        graphId: params.graphId,
-        kind: params.kind
-      },
-      {
-        suggestion: "Pass a positive integer to cap each endpoint's rows, or omit it for an unbounded read."
-      }
-    );
+var FIND_EDGES_HETEROGENEOUS_FIXED_PARAM_COUNT = 4;
+function assertLimitPerEndpoint(operation, graphId, limitPerEndpoint, kind) {
+  if (limitPerEndpoint === void 0 || Number.isInteger(limitPerEndpoint) && limitPerEndpoint > 0) {
+    return;
   }
+  throw new chunkNI72YOJB_cjs.ConfigurationError(
+    `${operation} \`limitPerEndpoint\` must be a positive integer, received ${String(limitPerEndpoint)}.`,
+    {
+      code: "EDGE_ENDPOINT_SET_INVALID",
+      graphId,
+      ...kind === void 0 ? {} : { kind }
+    },
+    {
+      suggestion: "Pass a positive integer to cap each endpoint's rows, or omit it for an unbounded read."
+    }
+  );
+}
+function resolveEdgeEndpointIds(params) {
+  assertLimitPerEndpoint(
+    "findEdgesByEndpointSet",
+    params.graphId,
+    params.limitPerEndpoint,
+    params.kind
+  );
   return [...new Set(params.endpointIds)];
 }
+function endpointKey(endpoint) {
+  return `${endpoint.kind}\0${endpoint.id}`;
+}
+function resolveHeterogeneousEdgeRead(params, maxBindParameters) {
+  assertLimitPerEndpoint(
+    "findEdgesByHeterogeneousEndpointSet",
+    params.graphId,
+    params.limitPerEndpoint
+  );
+  const edgeKinds = [...new Set(params.edgeKinds)];
+  const endpoints = [
+    ...new Map(
+      params.endpoints.map((endpoint) => [endpointKey(endpoint), endpoint])
+    ).values()
+  ];
+  if (edgeKinds.length === 0 || endpoints.length === 0) {
+    return { edgeKinds, endpoints, endpointChunkSize: 1 };
+  }
+  const endpointBindBudget = maxBindParameters - FIND_EDGES_HETEROGENEOUS_FIXED_PARAM_COUNT - edgeKinds.length;
+  const endpointChunkSize = Math.floor(endpointBindBudget / 2);
+  if (endpointChunkSize >= 1) {
+    return { edgeKinds, endpoints, endpointChunkSize };
+  }
+  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",
+      graphId: params.graphId,
+      edgeKindCount: edgeKinds.length,
+      maxBindParameters
+    },
+    {
+      suggestion: "Select fewer edge kinds in one call or use a backend with a larger bind-parameter budget."
+    }
+  );
+}
 
 // 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}
@@ -77,10 +122,10 @@ function vectorSlotFromDropIndexParams(params) {
   };
 }
 function mapVectorWriteError(error, params) {
-  const mismatch = chunkWBUFJ7BS_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,
@@ -96,7 +141,7 @@ var SQLITE_CONTRIBUTION_MAT_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS = {
-  decode: chunkHJH3RMXG_cjs.formatPostgresTimestamp,
+  decode: chunkYAAM3M2S_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapContributionMaterializationRow(row, decode) {
@@ -146,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";
@@ -161,6 +206,9 @@ function diagnoseContribution(row, signature, tableExists) {
     if (row.materializedAt !== void 0) return "orphaned-marker";
     return row.lastError === void 0 ? void 0 : "failed-materialization";
   }
+  if (row?.materializedAt !== void 0 && row.signature !== signature) {
+    return "stale";
+  }
   const state = evaluateContributionState(row, signature);
   switch (state) {
     case "initialized": {
@@ -178,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,
@@ -233,11 +295,18 @@ function gateFulltextMethods(source, assert) {
   return gated;
 }
 function gateFulltext(tx, assert) {
-  return chunk3PRKZW6D_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 [
@@ -281,7 +350,7 @@ function createContributionMaterializer(deps) {
     }
   }
   function runtimeContributions() {
-    return chunk6JZUSDY2_cjs.runtimeStrategyContributions(fulltextStrategy, fulltextTableName);
+    return chunkRMQLSPA2_cjs.runtimeStrategyContributions(fulltextStrategy, fulltextTableName);
   }
   function cacheInitializedSignature(key, signature) {
     if (!uncacheableKeys.has(key)) {
@@ -307,14 +376,14 @@ function createContributionMaterializer(deps) {
       );
       await deps.recordMarker({
         ...identity,
-        signature,
-        attemptedAt: chunkHJH3RMXG_cjs.nowIso(),
+        signature: existing.signature,
+        attemptedAt: chunkYAAM3M2S_cjs.nowIso(),
         materializedAt: void 0,
         error: error.message
       });
       throw error;
     }
-    const attemptedAt = chunkHJH3RMXG_cjs.nowIso();
+    const attemptedAt = chunkYAAM3M2S_cjs.nowIso();
     try {
       for (const statement of contribution.createDdl) {
         await deps.execDdl(statement);
@@ -350,12 +419,13 @@ function createContributionMaterializer(deps) {
         rows: indexMarkerRows(graphId, await deps.getMarkers(graphId))
       };
     } catch (error) {
-      if (!chunkWBUFJ7BS_cjs.isMissingTableError(error)) throw error;
+      if (!chunkBSFJMMV3_cjs.isMissingTableError(error)) throw error;
       return { kind: "missing-table", error };
     }
   }
   async function ensureContributions(graphId, contributions, options) {
     const force = options?.force === true;
+    const bypassCache = options?.bypassCache === true;
     const entries = await Promise.all(
       contributions.map(async (contribution) => {
         const key = contributionKey(graphId, contribution);
@@ -366,7 +436,13 @@ function createContributionMaterializer(deps) {
         };
       })
     );
-    const pending = force ? entries : entries.filter(
+    if (bypassCache) {
+      for (const entry of entries) {
+        uncacheableKeys.add(entry.key);
+        initializedSignatures.delete(entry.key);
+      }
+    }
+    const pending = force || bypassCache ? entries : entries.filter(
       (entry) => uncacheableKeys.has(entry.key) || initializedSignatures.get(entry.key) !== entry.signature
     );
     if (pending.length === 0) return;
@@ -422,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 }
       });
@@ -431,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 }
         });
       }
@@ -471,15 +547,15 @@ function createContributionMaterializer(deps) {
       await assertContributions(graphId, contributions);
     }
   }
-  async function verifyContributions(graphId, vectorSlots) {
-    const targetsByGraph = /* @__PURE__ */ new Map();
+  function verificationTargetsByGraph(graphId, vectorSlots) {
+    const targets = /* @__PURE__ */ new Map();
     function addTarget(id, target) {
-      const existing = targetsByGraph.get(id);
-      if (existing === void 0) targetsByGraph.set(id, [target]);
+      const existing = targets.get(id);
+      if (existing === void 0) targets.set(id, [target]);
       else existing.push(target);
     }
     for (const contribution of runtimeContributions()) {
-      addTarget(graphId, { contribution });
+      addTarget(graphId, { contribution, projection: "fulltext" });
     }
     const { vectorStrategy } = deps;
     if (vectorStrategy !== void 0) {
@@ -487,12 +563,16 @@ function createContributionMaterializer(deps) {
         for (const contribution of vectorStrategy.ownedTables(slot)) {
           addTarget(slot.graphId, {
             contribution,
+            projection: "vector",
             kind: slot.nodeKind,
             fieldPath: slot.fieldPath
           });
         }
       }
     }
+    return targets;
+  }
+  async function diagnoseTargets(targetsByGraph) {
     const probes = /* @__PURE__ */ new Map();
     function tableExists(tableName) {
       const pending = probes.get(tableName);
@@ -501,11 +581,11 @@ function createContributionMaterializer(deps) {
       probes.set(tableName, probe);
       return probe;
     }
-    const diagnostics = [];
+    const diagnosed = [];
     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(
@@ -514,22 +594,239 @@ function createContributionMaterializer(deps) {
           await tableExists(contribution.tableName)
         );
         if (state === void 0) continue;
-        diagnostics.push({
-          owner: contribution.owner,
-          logicalName: contribution.logicalName,
-          physicalName: contribution.tableName,
-          ...kind === void 0 ? {} : { kind },
-          ...fieldPath === void 0 ? {} : { fieldPath },
-          state,
-          // The recorded reason, carried through verbatim. `state` folds
-          // several marker verdicts together because they share a repair;
-          // this is what keeps the fold from also discarding the one thing
-          // the catalog can never tell the operator.
-          ...row?.lastError === void 0 ? {} : { lastError: row.lastError }
+        diagnosed.push({
+          graphId: id,
+          contribution,
+          projection,
+          diagnostic: {
+            owner: contribution.owner,
+            logicalName: contribution.logicalName,
+            physicalName: contribution.tableName,
+            ...kind === void 0 ? {} : { kind },
+            ...fieldPath === void 0 ? {} : { fieldPath },
+            state,
+            // The recorded reason, carried through verbatim. `state` folds
+            // several marker verdicts together because they share a repair;
+            // this is what keeps the fold from also discarding the one thing
+            // the catalog can never tell the operator.
+            ...row?.lastError === void 0 ? {} : { lastError: row.lastError }
+          }
+        });
+      }
+    }
+    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) {
+      if (diagnostic.state === "stale" || diagnostic.state === "orphaned-marker") {
+        results.push({ diagnostic, status: "requires-rebuild" });
+        continue;
+      }
+      try {
+        await ensureContributions(targetGraphId, [contribution], {
+          bypassCache: true
+        });
+        results.push({ diagnostic, status: "repaired" });
+      } catch (error) {
+        results.push({
+          diagnostic,
+          status: "failed",
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return {
+      results,
+      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 diagnostics;
+    return rebuilt;
   }
   function evictVectorSlot(slot) {
     if (deps.vectorStrategy === void 0) return;
@@ -559,7 +856,10 @@ function createContributionMaterializer(deps) {
     assertVectorSlots,
     dropVectorSlot,
     evictVectorSlot,
-    verifyContributions
+    verifyContributions,
+    repairContributions,
+    probeContributions,
+    rebuildContribution
   };
 }
 var SQLITE_INDEX_MAT_TIMESTAMPS = {
@@ -567,7 +867,7 @@ var SQLITE_INDEX_MAT_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_INDEX_MAT_TIMESTAMPS = {
-  decode: chunkHJH3RMXG_cjs.formatPostgresTimestamp,
+  decode: chunkYAAM3M2S_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapMaterializationRow(row, decode) {
@@ -625,7 +925,7 @@ var SQLITE_KIND_REMOVAL_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_KIND_REMOVAL_TIMESTAMPS = {
-  decode: chunkHJH3RMXG_cjs.formatPostgresTimestamp,
+  decode: chunkYAAM3M2S_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapKindRemovalRow(row, decode) {
@@ -666,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");
 }
@@ -673,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('"', '""')}"`);
 }
@@ -792,12 +1121,12 @@ function present(value) {
 function mapHybridSearchRow(row, toNodeRow) {
   return {
     node: toNodeRow(row),
-    fusedScore: chunkHJH3RMXG_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: chunkHJH3RMXG_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: chunkHJH3RMXG_cjs.coerceNumericScore(
+      fulltextScore: chunkYAAM3M2S_cjs.coerceNumericScore(
         row["fulltext_score"]
       )
     } : {},
@@ -805,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,
@@ -823,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}`
     },
@@ -1009,6 +1360,58 @@ function buildFindEdgesByEndpointSet(tables, params, endpointIds) {
     ORDER BY ${derivedOrderByClause}
   `;
 }
+function buildFindEdgesByHeterogeneousEndpointSet(tables, params, endpoints, edgeKinds) {
+  const { edges } = tables;
+  const fromSide = params.side === "from";
+  const kindColumn = fromSide ? edges.fromKind : edges.toKind;
+  const idColumn = fromSide ? edges.fromId : edges.toId;
+  const requestedKind = drizzleOrm.sql.raw(`requested_endpoints."endpoint_kind"`);
+  const requestedId = drizzleOrm.sql.raw(`requested_endpoints."endpoint_id"`);
+  const requestedRows = drizzleOrm.sql.join(
+    endpoints.map((endpoint) => drizzleOrm.sql`(${endpoint.kind}, ${endpoint.id})`),
+    drizzleOrm.sql`, `
+  );
+  const whereClause = drizzleOrm.sql.join(
+    [
+      drizzleOrm.sql`${edges.graphId} = ${params.graphId}`,
+      buildIdSetCondition(edges.kind, edgeKinds),
+      ...buildTemporalConditions(edges, params)
+    ],
+    drizzleOrm.sql` AND `
+  );
+  const joinClause = drizzleOrm.sql`
+    FROM ${edges}
+    INNER JOIN requested_endpoints
+      ON ${kindColumn} = ${requestedKind}
+     AND ${idColumn} = ${requestedId}
+    WHERE ${whereClause}
+  `;
+  const { qualified: orderByClause, bare: derivedOrderByClause } = buildEdgeOrdering(tables, void 0);
+  if (params.limitPerEndpoint === void 0) {
+    return drizzleOrm.sql`
+      WITH requested_endpoints(endpoint_kind, endpoint_id) AS (
+        VALUES ${requestedRows}
+      )
+      SELECT ${edges}.*
+      ${joinClause}
+      ORDER BY ${orderByClause}
+    `;
+  }
+  const ranked = drizzleOrm.sql`
+    SELECT ${edges}.*, ROW_NUMBER() OVER (
+      PARTITION BY ${kindColumn}, ${idColumn} ORDER BY ${orderByClause}
+    ) AS endpoint_rank
+    ${joinClause}
+  `;
+  return drizzleOrm.sql`
+    WITH requested_endpoints(endpoint_kind, endpoint_id) AS (
+      VALUES ${requestedRows}
+    )
+    SELECT * FROM (${ranked}) AS ranked_edges
+    WHERE endpoint_rank <= ${params.limitPerEndpoint}
+    ORDER BY ${derivedOrderByClause}
+  `;
+}
 function buildCountEdgesByKind(tables, params) {
   const { edges } = tables;
   const conditions = [
@@ -1107,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);
@@ -1114,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 *
     `;
   }
@@ -1134,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 *
   `;
@@ -1145,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
   `;
 }
@@ -1178,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) {
@@ -1255,11 +1679,11 @@ function buildFulltextSearch(tableName, params, strategy, dialect, candidates) {
   assertValidSearchParams(params);
   const mode = resolveMode(params.mode);
   const table = quotedTableName(tableName);
-  const matchCondition = chunkNN3QSOVS_cjs.toDrizzleSql(
+  const matchCondition = chunkU5SON7R2_cjs.toDrizzleSql(
     strategy.matchCondition(tableName, params.query, mode, params.language),
     dialect
   );
-  const rankExpression = chunkNN3QSOVS_cjs.toDrizzleSql(
+  const rankExpression = chunkU5SON7R2_cjs.toDrizzleSql(
     strategy.rankExpression(tableName, params.query, mode, params.language),
     dialect
   );
@@ -1272,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) ? chunkNN3QSOVS_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 ? chunkNN3QSOVS_cjs.toDrizzleSql(
+  const snippetExpr = params.includeSnippets === true && strategy.supportsSnippets ? chunkU5SON7R2_cjs.toDrizzleSql(
     strategy.snippetExpression(
       tableName,
       params.query,
@@ -1391,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 *
     `;
   }
@@ -1413,8 +1847,39 @@ 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 = chunk4UGOKMI5_cjs.getDialect(dialect);
+  const patchedProps = chunkU5SON7R2_cjs.toDrizzleSql(
+    adapter.jsonSetProperties(
+      chunkVCRRKBLN_cjs.sql.identifier(nodes.props.name),
+      params.patch,
+      params.unsetProperties ?? []
+    ),
+    dialect
+  );
+  const candidateIds = chunkU5SON7R2_cjs.toDrizzleSql(params.candidateIds, dialect);
+  const candidateIdColumn = chunkU5SON7R2_cjs.toDrizzleSql(
+    chunkVCRRKBLN_cjs.sql.identifier(params.candidateIdColumn),
+    dialect
+  );
+  return drizzleOrm.sql`
+    UPDATE ${nodes}
+    SET ${quotedColumn(nodes.props)} = ${patchedProps},
+        ${quotedColumn(nodes.updatedAt)} = ${timestamp},
+        ${quotedColumn(nodes.version)} = ${quotedColumn(nodes.version)} + 1
+    WHERE ${nodes.graphId} = ${params.graphId}
+      AND ${nodes.kind} = ${params.kind}
       AND ${nodes.deletedAt} IS NULL
+      AND ${nodes.id} IN (
+        SELECT ${candidateIdColumn}
+        FROM (${candidateIds}) AS tg_set_candidates
+      )
     RETURNING *
   `;
 }
@@ -1653,12 +2118,23 @@ function buildDeleteUnique(tables, params, timestamp) {
       AND ${uniques.deletedAt} IS NULL
   `;
 }
-function buildHardDeleteUniquesByNode(tables, graphId, nodeId) {
+function buildHardDeleteUniquesByNode(tables, graphId, concreteKind, nodeId) {
+  return buildHardDeleteUniquesByNodeIds(tables, {
+    graphId,
+    concreteKind,
+    nodeIds: [nodeId]
+  });
+}
+function buildHardDeleteUniquesByNodeIds(tables, params) {
   const { uniques } = tables;
   return drizzleOrm.sql`
     DELETE FROM ${uniques}
-    WHERE ${uniques.graphId} = ${graphId}
-      AND ${uniques.nodeId} = ${nodeId}
+    WHERE ${uniques.graphId} = ${params.graphId}
+      AND ${uniques.concreteKind} = ${params.concreteKind}
+      AND ${uniques.nodeId} IN (${drizzleOrm.sql.join(
+    params.nodeIds.map((nodeId) => drizzleOrm.sql`${nodeId}`),
+    drizzleOrm.sql`, `
+  )})
   `;
 }
 function buildCheckUnique(tables, params) {
@@ -1707,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) {
@@ -1747,9 +2226,11 @@ var COMMON_TABLE_OPERATION_BUILDERS = {
   buildCountNodesByKind,
   buildFindEdgesByKind,
   buildFindEdgesByEndpointSet,
+  buildFindEdgesByHeterogeneousEndpointSet,
   buildCountEdgesByKind,
   buildDeleteUnique,
   buildHardDeleteUniquesByNode,
+  buildHardDeleteUniquesByNodeIds,
   buildCheckUnique,
   buildCheckUniqueBatch,
   buildGetSchemaVersion
@@ -1762,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) => chunkNN3QSOVS_cjs.toDrizzleSql(statement, dialect)),
-    buildDeleteFulltext: (params) => fulltextStrategy.buildDelete(fulltextTable, params).map((statement) => chunkNN3QSOVS_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) => chunkNN3QSOVS_cjs.toDrizzleSql(statement, dialect)),
-    buildUpsertFulltextBatch: (params, timestamp) => fulltextStrategy.buildBatchUpsert(fulltextTable, params, timestamp).map((statement) => chunkNN3QSOVS_cjs.toDrizzleSql(statement, dialect)),
-    buildDeleteFulltextBatch: (params) => fulltextStrategy.buildBatchDelete(fulltextTable, params).map((statement) => chunkNN3QSOVS_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,
@@ -1782,7 +2263,7 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
         tables.nodes,
         params.graphId,
         params.nodeKind,
-        chunkHJH3RMXG_cjs.nowIso()
+        chunkYAAM3M2S_cjs.nowIso()
       )
     ),
     buildHybridSearch: (params, vectorSql, vectorScoreDescending) => {
@@ -1790,7 +2271,7 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
         tables.nodes,
         params.graphId,
         params.nodeKind,
-        chunkHJH3RMXG_cjs.nowIso()
+        chunkYAAM3M2S_cjs.nowIso()
       );
       const fulltextSql = buildFulltextSearch(
         fulltextTable,
@@ -1811,7 +2292,7 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
         hybridCandidatesRef()
       );
       return buildHybridSearchStatement({
-        candidatesSql: chunkU5W4LKZV_cjs.isSqlFragment(candidates) ? chunkNN3QSOVS_cjs.toDrizzleSql(candidates, dialect) : candidates,
+        candidatesSql: chunkVCRRKBLN_cjs.isSqlFragment(candidates) ? chunkU5SON7R2_cjs.toDrizzleSql(candidates, dialect) : candidates,
         vectorSql,
         vectorScoreDescending,
         fulltextSql,
@@ -1827,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}
@@ -1839,7 +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);
     },
@@ -1882,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;
@@ -1915,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
@@ -1969,8 +2496,14 @@ async function commitSchemaVersionIfKindsEmpty(backend, params, probes) {
   };
 }
 function createCommonOperationBackend(options) {
-  const { batchConfig, execution, operationStrategy, rowMappers } = options;
-  const nowIso2 = options.nowIso ?? chunkHJH3RMXG_cjs.nowIso;
+  const {
+    batchConfig,
+    execution,
+    maxBindParameters,
+    operationStrategy,
+    rowMappers
+  } = options;
+  const nowIso2 = options.nowIso ?? chunkYAAM3M2S_cjs.nowIso;
   const tableExists = createCachedTableExistence(
     (tableName) => execution.execGet(
       operationStrategy.buildTableExists(tableName)
@@ -1992,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);
@@ -2003,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);
     },
@@ -2017,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) {
@@ -2035,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;
@@ -2053,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)));
@@ -2065,12 +2624,35 @@ 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 chunkNI72YOJB_cjs.ConfigurationError(
+          "Set-based node update requires at least one property",
+          { operation: "updateNodeSet", kind: params.kind }
+        );
+      }
+      if (params.candidateIdColumn.length === 0) {
+        throw new chunkNI72YOJB_cjs.ConfigurationError(
+          "Set-based node update requires a candidate id column",
+          { operation: "updateNodeSet", kind: params.kind }
+        );
+      }
+      const timestamp = nowIso2();
+      const query = operationStrategy.buildUpdateNodeSet(params, timestamp);
+      const rows = await execution.execAll(query);
+      const updatedRows = rows.map((row) => rowMappers.toNodeRow(row));
+      return { affectedCount: updatedRows.length, rows: updatedRows };
+    },
     async deleteNode(params) {
       const timestamp = nowIso2();
       const query = operationStrategy.buildDeleteNode(params, timestamp);
@@ -2088,6 +2670,7 @@ function createCommonOperationBackend(options) {
     async hardDeleteNode(params) {
       const deleteUniquesQuery = operationStrategy.buildHardDeleteUniquesByNode(
         params.graphId,
+        params.kind,
         params.id
       );
       await execution.execRun(deleteUniquesQuery);
@@ -2111,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);
     },
@@ -2125,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) {
@@ -2143,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;
@@ -2161,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)));
@@ -2173,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);
     },
@@ -2195,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
@@ -2205,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
       )) {
@@ -2249,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
       )) {
@@ -2262,6 +2875,21 @@ function createCommonOperationBackend(options) {
       }
       return edgeRows;
     },
+    async findEdgesByHeterogeneousEndpointSet(params) {
+      const { edgeKinds, endpoints, endpointChunkSize } = resolveHeterogeneousEdgeRead(params, maxBindParameters);
+      if (edgeKinds.length === 0 || endpoints.length === 0) return [];
+      const edgeRows = [];
+      for (const endpointChunk of chunkBSFJMMV3_cjs.chunk(endpoints, endpointChunkSize)) {
+        const query = operationStrategy.buildFindEdgesByHeterogeneousEndpointSet(
+          params,
+          endpointChunk,
+          edgeKinds
+        );
+        const rows = await execution.execAll(query);
+        for (const row of rows) edgeRows.push(rowMappers.toEdgeRow(row));
+      }
+      return edgeRows;
+    },
     async countEdgesByKind(params) {
       const query = operationStrategy.buildCountEdgesByKind(params);
       const row = await execution.execGet(query);
@@ -2271,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,
@@ -2291,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,
@@ -2301,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
       )) {
@@ -2316,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,
@@ -2332,6 +2960,19 @@ function createCommonOperationBackend(options) {
       const query = operationStrategy.buildDeleteUnique(params, timestamp);
       await execution.execRun(query);
     },
+    async hardDeleteUniquesByNodeIds(params) {
+      const nodeIds = [...new Set(params.nodeIds)];
+      for (const chunk2 of chunkBSFJMMV3_cjs.chunk(
+        nodeIds,
+        batchConfig.uniqueDeleteChunkSize
+      )) {
+        const query = operationStrategy.buildHardDeleteUniquesByNodeIds({
+          ...params,
+          nodeIds: chunk2
+        });
+        await execution.execRun(query);
+      }
+    },
     async checkUnique(params) {
       const query = operationStrategy.buildCheckUnique(params);
       const row = await execution.execGet(query);
@@ -2340,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
       )) {
@@ -2371,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,
@@ -2419,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" }
         );
@@ -2437,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,
@@ -2470,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"
     );
@@ -2479,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"
     );
@@ -2501,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] },
@@ -2513,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`
       )
     )
@@ -2534,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)}`)
       )
     );
   }
@@ -2565,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)}`)
       )
     );
   }
@@ -2576,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)}`)
     )
   );
 }
@@ -2604,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"
     );
@@ -2752,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;
@@ -2775,5 +3417,5 @@ exports.tableExistsFromRow = tableExistsFromRow;
 exports.vectorSlotFromCreateIndexParams = vectorSlotFromCreateIndexParams;
 exports.vectorSlotFromDropIndexParams = vectorSlotFromDropIndexParams;
 exports.vectorSlotFromParams = vectorSlotFromParams;
-//# sourceMappingURL=chunk-ST3LPB2V.cjs.map
-//# sourceMappingURL=chunk-ST3LPB2V.cjs.map
+//# sourceMappingURL=chunk-MUK4BU7K.cjs.map
+//# sourceMappingURL=chunk-MUK4BU7K.cjs.map