@nicia-ai/typegraph 0.42.1 → 0.44.0

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

@@ -1,22 +1,42 @@
 'use strict';
 
-var chunkAQR6BHB3_cjs = require('./chunk-AQR6BHB3.cjs');
-var chunkOMQ2NBOR_cjs = require('./chunk-OMQ2NBOR.cjs');
-var chunk6TJ6PKPS_cjs = require('./chunk-6TJ6PKPS.cjs');
+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 chunkECU53PMN_cjs = require('./chunk-ECU53PMN.cjs');
+var chunk3PRKZW6D_cjs = require('./chunk-3PRKZW6D.cjs');
 var chunkACSVZPK7_cjs = require('./chunk-ACSVZPK7.cjs');
-var chunkAO2WPYFZ_cjs = require('./chunk-AO2WPYFZ.cjs');
+var chunkWBUFJ7BS_cjs = require('./chunk-WBUFJ7BS.cjs');
 var chunkZY4GXIVN_cjs = require('./chunk-ZY4GXIVN.cjs');
-var chunkX2XOQZT3_cjs = require('./chunk-X2XOQZT3.cjs');
+var chunkU5W4LKZV_cjs = require('./chunk-U5W4LKZV.cjs');
 var chunk764JHTLT_cjs = require('./chunk-764JHTLT.cjs');
-var chunkKTBTSHU6_cjs = require('./chunk-KTBTSHU6.cjs');
+var chunkC4F7VJ5D_cjs = require('./chunk-C4F7VJ5D.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."
+      }
+    );
+  }
+  return [...new Set(params.endpointIds)];
+}
+
 // src/backend/live-node-candidates.ts
 function buildLiveNodeCandidates(nodesTableName, graphId, nodeKind, now) {
-  const nodes = chunkX2XOQZT3_cjs.sql.identifier(nodesTableName);
-  return chunkX2XOQZT3_cjs.sql`
+  const nodes = chunkU5W4LKZV_cjs.sql.identifier(nodesTableName);
+  return chunkU5W4LKZV_cjs.sql`
     SELECT "id" AS node_id
     FROM ${nodes}
     WHERE "graph_id" = ${graphId}
@@ -57,10 +77,10 @@ function vectorSlotFromDropIndexParams(params) {
   };
 }
 function mapVectorWriteError(error, params) {
-  const mismatch = chunkAO2WPYFZ_cjs.parseDimensionMismatch(error);
+  const mismatch = chunkWBUFJ7BS_cjs.parseDimensionMismatch(error);
   if (mismatch === void 0) return error;
   const attempted = mismatch.actual ?? "a different number of";
-  return new chunkKTBTSHU6_cjs.EmbeddingDimensionChangedError(
+  return new chunkC4F7VJ5D_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,
@@ -76,7 +96,7 @@ var SQLITE_CONTRIBUTION_MAT_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS = {
-  decode: chunkAQR6BHB3_cjs.formatPostgresTimestamp,
+  decode: chunkHJH3RMXG_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapContributionMaterializationRow(row, decode) {
@@ -135,6 +155,29 @@ function evaluateContributionState(row, signature) {
   if (row.materializedAt === void 0) return "missing";
   return "initialized";
 }
+function diagnoseContribution(row, signature, tableExists) {
+  if (!tableExists) {
+    if (row === void 0) return void 0;
+    if (row.materializedAt !== void 0) return "orphaned-marker";
+    return row.lastError === void 0 ? void 0 : "failed-materialization";
+  }
+  const state = evaluateContributionState(row, signature);
+  switch (state) {
+    case "initialized": {
+      return void 0;
+    }
+    case "stale": {
+      return "stale";
+    }
+    case "missing":
+    case "failed": {
+      return "missing-marker";
+    }
+    default: {
+      return state;
+    }
+  }
+}
 function identityOf(graphId, contribution) {
   return {
     graphId,
@@ -190,7 +233,7 @@ function gateFulltextMethods(source, assert) {
   return gated;
 }
 function gateFulltext(tx, assert) {
-  return chunkECU53PMN_cjs.createBackendOverlay(
+  return chunk3PRKZW6D_cjs.createBackendOverlay(
     tx,
     gateFulltextMethods(tx, assert)
   );
@@ -207,6 +250,7 @@ function contributionKey(graphId, contribution) {
 function createContributionMaterializer(deps) {
   const { dialect, fulltextStrategy, fulltextTableName } = deps;
   const initializedSignatures = /* @__PURE__ */ new Map();
+  const uncacheableKeys = /* @__PURE__ */ new Set();
   const computedSignatures = /* @__PURE__ */ new Map();
   async function resolveContributionSignature(key, contribution) {
     const cached = computedSignatures.get(key);
@@ -237,7 +281,12 @@ function createContributionMaterializer(deps) {
     }
   }
   function runtimeContributions() {
-    return chunkOMQ2NBOR_cjs.runtimeStrategyContributions(fulltextStrategy, fulltextTableName);
+    return chunk6JZUSDY2_cjs.runtimeStrategyContributions(fulltextStrategy, fulltextTableName);
+  }
+  function cacheInitializedSignature(key, signature) {
+    if (!uncacheableKeys.has(key)) {
+      initializedSignatures.set(key, signature);
+    }
   }
   async function materializeOne(graphId, contribution, signature, existing, options) {
     const force = options?.force === true;
@@ -259,13 +308,13 @@ function createContributionMaterializer(deps) {
       await deps.recordMarker({
         ...identity,
         signature,
-        attemptedAt: chunkAQR6BHB3_cjs.nowIso(),
+        attemptedAt: chunkHJH3RMXG_cjs.nowIso(),
         materializedAt: void 0,
         error: error.message
       });
       throw error;
     }
-    const attemptedAt = chunkAQR6BHB3_cjs.nowIso();
+    const attemptedAt = chunkHJH3RMXG_cjs.nowIso();
     try {
       for (const statement of contribution.createDdl) {
         await deps.execDdl(statement);
@@ -301,7 +350,7 @@ function createContributionMaterializer(deps) {
         rows: indexMarkerRows(graphId, await deps.getMarkers(graphId))
       };
     } catch (error) {
-      if (!chunkAO2WPYFZ_cjs.isMissingTableError(error)) throw error;
+      if (!chunkWBUFJ7BS_cjs.isMissingTableError(error)) throw error;
       return { kind: "missing-table", error };
     }
   }
@@ -318,7 +367,7 @@ function createContributionMaterializer(deps) {
       })
     );
     const pending = force ? entries : entries.filter(
-      (entry) => initializedSignatures.get(entry.key) !== entry.signature
+      (entry) => uncacheableKeys.has(entry.key) || initializedSignatures.get(entry.key) !== entry.signature
     );
     if (pending.length === 0) return;
     const initialRead = force ? void 0 : await readMarkerRows(graphId);
@@ -329,7 +378,7 @@ function createContributionMaterializer(deps) {
       ) === "initialized"
     )) {
       for (const entry of pending) {
-        initializedSignatures.set(entry.key, entry.signature);
+        cacheInitializedSignature(entry.key, entry.signature);
       }
       return;
     }
@@ -350,7 +399,7 @@ function createContributionMaterializer(deps) {
         }
       );
       if (outcome === "materialized") {
-        initializedSignatures.set(entry.key, entry.signature);
+        cacheInitializedSignature(entry.key, entry.signature);
       }
     }
   }
@@ -366,14 +415,14 @@ function createContributionMaterializer(deps) {
       })
     );
     const pending = entries.filter(
-      (entry) => initializedSignatures.get(entry.key) !== entry.signature
+      (entry) => uncacheableKeys.has(entry.key) || initializedSignatures.get(entry.key) !== entry.signature
     );
     if (pending.length === 0) return;
     const read = await readMarkerRows(graphId);
     if (read.kind === "missing-table") {
       const first = pending[0];
       if (first === void 0) return;
-      throw new chunkKTBTSHU6_cjs.StoreNotInitializedError(graphId, "missing", {
+      throw new chunkC4F7VJ5D_cjs.StoreNotInitializedError(graphId, "missing", {
         cause: read.error,
         details: { logicalName: first.contribution.logicalName }
       });
@@ -382,11 +431,11 @@ function createContributionMaterializer(deps) {
       const { contribution, key, signature } = entry;
       const state = evaluateContributionState(read.rows.get(key), signature);
       if (state !== "initialized") {
-        throw new chunkKTBTSHU6_cjs.StoreNotInitializedError(graphId, state, {
+        throw new chunkC4F7VJ5D_cjs.StoreNotInitializedError(graphId, state, {
           details: { logicalName: contribution.logicalName }
         });
       }
-      initializedSignatures.set(key, signature);
+      cacheInitializedSignature(key, signature);
     }
   }
   async function ensureRuntimeContributions(graphId) {
@@ -422,15 +471,85 @@ function createContributionMaterializer(deps) {
       await assertContributions(graphId, contributions);
     }
   }
-  async function dropVectorSlot(slot) {
+  async function verifyContributions(graphId, vectorSlots) {
+    const targetsByGraph = /* @__PURE__ */ new Map();
+    function addTarget(id, target) {
+      const existing = targetsByGraph.get(id);
+      if (existing === void 0) targetsByGraph.set(id, [target]);
+      else existing.push(target);
+    }
+    for (const contribution of runtimeContributions()) {
+      addTarget(graphId, { contribution });
+    }
+    const { vectorStrategy } = deps;
+    if (vectorStrategy !== void 0) {
+      for (const slot of vectorSlots) {
+        for (const contribution of vectorStrategy.ownedTables(slot)) {
+          addTarget(slot.graphId, {
+            contribution,
+            kind: slot.nodeKind,
+            fieldPath: slot.fieldPath
+          });
+        }
+      }
+    }
+    const probes = /* @__PURE__ */ new Map();
+    function tableExists(tableName) {
+      const pending = probes.get(tableName);
+      if (pending !== void 0) return pending;
+      const probe = deps.tableExists(tableName);
+      probes.set(tableName, probe);
+      return probe;
+    }
+    const diagnostics = [];
+    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) {
+        const key = contributionKey(id, contribution);
+        const row = rows.get(key);
+        const state = diagnoseContribution(
+          row,
+          await resolveContributionSignature(key, contribution),
+          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 }
+        });
+      }
+    }
+    return diagnostics;
+  }
+  function evictVectorSlot(slot) {
     if (deps.vectorStrategy === void 0) return;
     for (const contribution of deps.vectorStrategy.ownedTables(slot)) {
-      await deps.deleteMarker(identityOf(slot.graphId, contribution));
       const key = contributionKey(slot.graphId, contribution);
+      uncacheableKeys.add(key);
       initializedSignatures.delete(key);
       computedSignatures.delete(key);
     }
   }
+  async function dropVectorSlot(slot) {
+    if (deps.vectorStrategy === void 0) return;
+    try {
+      for (const contribution of deps.vectorStrategy.ownedTables(slot)) {
+        await deps.deleteMarker(identityOf(slot.graphId, contribution));
+      }
+    } finally {
+      evictVectorSlot(slot);
+    }
+  }
   return {
     ensureRuntimeContributions,
     assertInitialized,
@@ -438,7 +557,9 @@ function createContributionMaterializer(deps) {
     ensureVectorSlots,
     assertVectorSlot,
     assertVectorSlots,
-    dropVectorSlot
+    dropVectorSlot,
+    evictVectorSlot,
+    verifyContributions
   };
 }
 var SQLITE_INDEX_MAT_TIMESTAMPS = {
@@ -446,7 +567,7 @@ var SQLITE_INDEX_MAT_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_INDEX_MAT_TIMESTAMPS = {
-  decode: chunkAQR6BHB3_cjs.formatPostgresTimestamp,
+  decode: chunkHJH3RMXG_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapMaterializationRow(row, decode) {
@@ -504,7 +625,7 @@ var SQLITE_KIND_REMOVAL_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_KIND_REMOVAL_TIMESTAMPS = {
-  decode: chunkAQR6BHB3_cjs.formatPostgresTimestamp,
+  decode: chunkHJH3RMXG_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapKindRemovalRow(row, decode) {
@@ -671,12 +792,12 @@ function present(value) {
 function mapHybridSearchRow(row, toNodeRow) {
   return {
     node: toNodeRow(row),
-    fusedScore: chunkAQR6BHB3_cjs.coerceNumericScore(row["fused_score"]),
+    fusedScore: chunkHJH3RMXG_cjs.coerceNumericScore(row["fused_score"]),
     ...present(row["vector_rank"]) ? { vectorRank: Number(row["vector_rank"]) } : {},
-    ...present(row["vector_score"]) ? { vectorScore: chunkAQR6BHB3_cjs.coerceNumericScore(row["vector_score"]) } : {},
+    ...present(row["vector_score"]) ? { vectorScore: chunkHJH3RMXG_cjs.coerceNumericScore(row["vector_score"]) } : {},
     ...present(row["fulltext_rank"]) ? { fulltextRank: Number(row["fulltext_rank"]) } : {},
     ...present(row["fulltext_score"]) ? {
-      fulltextScore: chunkAQR6BHB3_cjs.coerceNumericScore(
+      fulltextScore: chunkHJH3RMXG_cjs.coerceNumericScore(
         row["fulltext_score"]
       )
     } : {},
@@ -790,6 +911,19 @@ function buildCountNodesByKind(tables, params) {
     WHERE ${whereClause}
   `;
 }
+function buildIdSetCondition(column, ids) {
+  return drizzleOrm.sql`${column} IN (${drizzleOrm.sql.join(
+    ids.map((id) => drizzleOrm.sql`${id}`),
+    drizzleOrm.sql`, `
+  )})`;
+}
+function buildEdgeOrdering(tables, orderBy) {
+  const { edges } = tables;
+  return orderBy === "id" ? { qualified: drizzleOrm.sql`${edges.id} ASC`, bare: drizzleOrm.sql.raw(`"id" ASC`) } : {
+    qualified: drizzleOrm.sql`${edges.createdAt} DESC, ${edges.id} DESC`,
+    bare: drizzleOrm.sql.raw(`"created_at" DESC, "id" DESC`)
+  };
+}
 function buildFindEdgesByKind(tables, params) {
   const { edges } = tables;
   const conditions = [
@@ -813,7 +947,10 @@ function buildFindEdgesByKind(tables, params) {
     conditions.push(drizzleOrm.sql`${edges.id} > ${params.after}`);
   }
   const whereClause = drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `);
-  const orderByClause = params.orderBy === "id" ? drizzleOrm.sql`${edges.id} ASC` : drizzleOrm.sql`${edges.createdAt} DESC, ${edges.id} DESC`;
+  const { qualified: orderByClause } = buildEdgeOrdering(
+    tables,
+    params.orderBy
+  );
   if (params.limit !== void 0 && params.offset !== void 0) {
     return drizzleOrm.sql`
       SELECT * FROM ${edges}
@@ -836,6 +973,42 @@ function buildFindEdgesByKind(tables, params) {
     ORDER BY ${orderByClause}
   `;
 }
+function buildFindEdgesByEndpointSet(tables, params, endpointIds) {
+  const { edges } = tables;
+  const fromSide = params.side === "from";
+  const kindColumn = fromSide ? edges.fromKind : edges.toKind;
+  const idColumn = fromSide ? edges.fromId : edges.toId;
+  const whereClause = drizzleOrm.sql.join(
+    [
+      drizzleOrm.sql`${edges.graphId} = ${params.graphId}`,
+      drizzleOrm.sql`${edges.kind} = ${params.kind}`,
+      ...buildTemporalConditions(edges, params),
+      drizzleOrm.sql`${kindColumn} = ${params.endpointKind}`,
+      buildIdSetCondition(idColumn, endpointIds)
+    ],
+    drizzleOrm.sql` AND `
+  );
+  const { qualified: orderByClause, bare: derivedOrderByClause } = buildEdgeOrdering(tables, void 0);
+  if (params.limitPerEndpoint === void 0) {
+    return drizzleOrm.sql`
+      SELECT * FROM ${edges}
+      WHERE ${whereClause}
+      ORDER BY ${orderByClause}
+    `;
+  }
+  const ranked = drizzleOrm.sql`
+    SELECT *, ROW_NUMBER() OVER (
+      PARTITION BY ${idColumn} ORDER BY ${orderByClause}
+    ) AS endpoint_rank
+    FROM ${edges}
+    WHERE ${whereClause}
+  `;
+  return drizzleOrm.sql`
+    SELECT * FROM (${ranked}) AS ranked_edges
+    WHERE endpoint_rank <= ${params.limitPerEndpoint}
+    ORDER BY ${derivedOrderByClause}
+  `;
+}
 function buildCountEdgesByKind(tables, params) {
   const { edges } = tables;
   const conditions = [
@@ -1082,11 +1255,11 @@ function buildFulltextSearch(tableName, params, strategy, dialect, candidates) {
   assertValidSearchParams(params);
   const mode = resolveMode(params.mode);
   const table = quotedTableName(tableName);
-  const matchCondition = chunk6TJ6PKPS_cjs.toDrizzleSql(
+  const matchCondition = chunkNN3QSOVS_cjs.toDrizzleSql(
     strategy.matchCondition(tableName, params.query, mode, params.language),
     dialect
   );
-  const rankExpression = chunk6TJ6PKPS_cjs.toDrizzleSql(
+  const rankExpression = chunkNN3QSOVS_cjs.toDrizzleSql(
     strategy.rankExpression(tableName, params.query, mode, params.language),
     dialect
   );
@@ -1099,10 +1272,10 @@ function buildFulltextSearch(tableName, params, strategy, dialect, candidates) {
     conditions.push(drizzleOrm.sql`${rankExpression} >= ${params.minScore}`);
   }
   if (candidates !== void 0) {
-    const candidateSql = chunkX2XOQZT3_cjs.isSqlFragment(candidates) ? chunk6TJ6PKPS_cjs.toDrizzleSql(candidates, dialect) : candidates;
+    const candidateSql = chunkU5W4LKZV_cjs.isSqlFragment(candidates) ? chunkNN3QSOVS_cjs.toDrizzleSql(candidates, dialect) : candidates;
     conditions.push(drizzleOrm.sql`"node_id" IN (${candidateSql})`);
   }
-  const snippetExpr = params.includeSnippets === true && strategy.supportsSnippets ? chunk6TJ6PKPS_cjs.toDrizzleSql(
+  const snippetExpr = params.includeSnippets === true && strategy.supportsSnippets ? chunkNN3QSOVS_cjs.toDrizzleSql(
     strategy.snippetExpression(
       tableName,
       params.query,
@@ -1573,6 +1746,7 @@ var COMMON_TABLE_OPERATION_BUILDERS = {
   buildFindNodesByKind,
   buildCountNodesByKind,
   buildFindEdgesByKind,
+  buildFindEdgesByEndpointSet,
   buildCountEdgesByKind,
   buildDeleteUnique,
   buildHardDeleteUniquesByNode,
@@ -1586,16 +1760,17 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
     COMMON_TABLE_OPERATION_BUILDERS
   );
   const fulltextTable = tables.fulltextTableName;
+  const contributionMaterializations = tables.contributionMaterializations;
   const fulltextBuilders = {
-    buildUpsertFulltext: (params, timestamp) => fulltextStrategy.buildUpsert(fulltextTable, params, timestamp).map((statement) => chunk6TJ6PKPS_cjs.toDrizzleSql(statement, dialect)),
-    buildDeleteFulltext: (params) => fulltextStrategy.buildDelete(fulltextTable, params).map((statement) => chunk6TJ6PKPS_cjs.toDrizzleSql(statement, dialect)),
+    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)),
     buildDeleteFulltextByNode: (graphId, nodeKind, nodeId) => fulltextStrategy.buildDelete(fulltextTable, {
       graphId,
       nodeKind,
       nodeId
-    }).map((statement) => chunk6TJ6PKPS_cjs.toDrizzleSql(statement, dialect)),
-    buildUpsertFulltextBatch: (params, timestamp) => fulltextStrategy.buildBatchUpsert(fulltextTable, params, timestamp).map((statement) => chunk6TJ6PKPS_cjs.toDrizzleSql(statement, dialect)),
-    buildDeleteFulltextBatch: (params) => fulltextStrategy.buildBatchDelete(fulltextTable, params).map((statement) => chunk6TJ6PKPS_cjs.toDrizzleSql(statement, dialect)),
+    }).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)),
     buildFulltextSearch: (params) => buildFulltextSearch(
       fulltextTable,
       params,
@@ -1607,7 +1782,7 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
         tables.nodes,
         params.graphId,
         params.nodeKind,
-        chunkAQR6BHB3_cjs.nowIso()
+        chunkHJH3RMXG_cjs.nowIso()
       )
     ),
     buildHybridSearch: (params, vectorSql, vectorScoreDescending) => {
@@ -1615,7 +1790,7 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
         tables.nodes,
         params.graphId,
         params.nodeKind,
-        chunkAQR6BHB3_cjs.nowIso()
+        chunkHJH3RMXG_cjs.nowIso()
       );
       const fulltextSql = buildFulltextSearch(
         fulltextTable,
@@ -1636,7 +1811,7 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
         hybridCandidatesRef()
       );
       return buildHybridSearchStatement({
-        candidatesSql: chunkX2XOQZT3_cjs.isSqlFragment(candidates) ? chunk6TJ6PKPS_cjs.toDrizzleSql(candidates, dialect) : candidates,
+        candidatesSql: chunkU5W4LKZV_cjs.isSqlFragment(candidates) ? chunkNN3QSOVS_cjs.toDrizzleSql(candidates, dialect) : candidates,
         vectorSql,
         vectorScoreDescending,
         fulltextSql,
@@ -1652,9 +1827,19 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
       });
     }
   };
+  function buildDeleteContributionMaterialization(identity) {
+    return drizzleOrm.sql`
+      DELETE FROM ${contributionMaterializations}
+      WHERE graph_id = ${identity.graphId}
+        AND logical_name = ${identity.logicalName}
+        AND owner = ${identity.owner}
+        AND table_name = ${identity.tableName}
+    `;
+  }
   return {
     ...tableOperations,
     ...fulltextBuilders,
+    buildDeleteContributionMaterialization,
     buildInsertUnique(params) {
       return buildInsertUnique(tables, dialect, params);
     },
@@ -1730,32 +1915,70 @@ var DRIZZLE_DIALECT_LABELS = {
 function assertAdoptedDialect(externalTx, brand, backend) {
   if (drizzleOrm.is(externalTx, brand)) return;
   const label = DRIZZLE_DIALECT_LABELS[backend];
-  throw new chunkKTBTSHU6_cjs.ConfigurationError(
+  throw new chunkC4F7VJ5D_cjs.ConfigurationError(
     `adoptTransaction received a handle that is not a ${label} Drizzle transaction. Pass the \`tx\` from a ${label} \`db.transaction(...)\` opened on this backend's connection.`,
     { backend, capability: "adoptTransaction" }
   );
 }
 function verifyExpectedActiveVersion(graphId, expected, actualActiveVersion) {
   const expectedVersion = expected.kind === "active" ? expected.version : 0;
+  assertActiveSchemaVersion(graphId, expectedVersion, actualActiveVersion);
+}
+function assertActiveSchemaVersion(graphId, expectedVersion, actualActiveVersion) {
   if (actualActiveVersion !== expectedVersion) {
-    throw new chunkKTBTSHU6_cjs.StaleVersionError({
+    throw new chunkC4F7VJ5D_cjs.StaleVersionError({
       graphId,
       expected: expectedVersion,
       actual: actualActiveVersion
     });
   }
 }
+async function commitSchemaVersionIfKindsEmpty(backend, params, probes) {
+  const [existing, active] = await Promise.all([
+    backend.getSchemaVersion(params.graphId, params.version),
+    backend.getActiveSchema(params.graphId)
+  ]);
+  if (existing !== void 0 && (existing.is_active || existing.schema_hash !== params.schemaHash)) {
+    return {
+      status: "committed",
+      row: await backend.commitSchemaVersion(params)
+    };
+  }
+  verifyExpectedActiveVersion(
+    params.graphId,
+    params.expected,
+    active?.version ?? 0
+  );
+  const populated = [];
+  for (const probe of probes) {
+    const count = probe.entity === "node" ? await backend.countNodesByKind({
+      graphId: params.graphId,
+      kind: probe.kind
+    }) : await backend.countEdgesByKind({
+      graphId: params.graphId,
+      kind: probe.kind
+    });
+    if (count > 0) populated.push({ ...probe, count });
+  }
+  if (populated.length > 0) {
+    return { status: "populated", kinds: populated };
+  }
+  return {
+    status: "committed",
+    row: await backend.commitSchemaVersion(params)
+  };
+}
 function createCommonOperationBackend(options) {
   const { batchConfig, execution, operationStrategy, rowMappers } = options;
-  const nowIso2 = options.nowIso ?? chunkAQR6BHB3_cjs.nowIso;
-  const requiredClearTableExists = createCachedTableExistence(
+  const nowIso2 = options.nowIso ?? chunkHJH3RMXG_cjs.nowIso;
+  const tableExists = createCachedTableExistence(
     (tableName) => execution.execGet(
       operationStrategy.buildTableExists(tableName)
     ),
     options.tableExistenceCache
   );
   async function runIgnorableClearStatement(statement) {
-    if (statement.ignoreMissingTable === true && statement.requiredTableName !== void 0 && !await requiredClearTableExists(statement.requiredTableName)) {
+    if (statement.ignoreMissingTable === true && statement.requiredTableName !== void 0 && !await tableExists(statement.requiredTableName)) {
       return;
     }
     await execution.execRun(statement.query);
@@ -1767,6 +1990,10 @@ function createCommonOperationBackend(options) {
     return row === void 0 ? 0 : rowMappers.toSchemaVersionRow(row).version;
   }
   return {
+    tableExists,
+    async executeSchemaDdl(ddl) {
+      await execution.execRun(chunkU5W4LKZV_cjs.asCompiledStatementSql(chunkU5W4LKZV_cjs.sql.raw(ddl)));
+    },
     async executeStatement(query) {
       await execution.execRun(query);
     },
@@ -1778,7 +2005,7 @@ function createCommonOperationBackend(options) {
       const query = operationStrategy.buildInsertNode(params, timestamp);
       const row = await execution.execGet(query);
       if (!row)
-        throw new chunkKTBTSHU6_cjs.DatabaseOperationError(
+        throw new chunkC4F7VJ5D_cjs.DatabaseOperationError(
           "Insert node failed: no row returned",
           { operation: "insert", entity: "node" }
         );
@@ -1838,7 +2065,7 @@ function createCommonOperationBackend(options) {
       const query = operationStrategy.buildUpdateNode(params, timestamp);
       const row = await execution.execGet(query);
       if (!row)
-        throw new chunkKTBTSHU6_cjs.DatabaseOperationError(
+        throw new chunkC4F7VJ5D_cjs.DatabaseOperationError(
           "Update node failed: no row returned",
           { operation: "update", entity: "node" }
         );
@@ -1886,7 +2113,7 @@ function createCommonOperationBackend(options) {
       const query = operationStrategy.buildInsertEdge(params, timestamp);
       const row = await execution.execGet(query);
       if (!row)
-        throw new chunkKTBTSHU6_cjs.DatabaseOperationError(
+        throw new chunkC4F7VJ5D_cjs.DatabaseOperationError(
           "Insert edge failed: no row returned",
           { operation: "insert", entity: "edge" }
         );
@@ -1946,7 +2173,7 @@ function createCommonOperationBackend(options) {
       const query = operationStrategy.buildUpdateEdge(params, timestamp);
       const row = await execution.execGet(query);
       if (!row)
-        throw new chunkKTBTSHU6_cjs.DatabaseOperationError(
+        throw new chunkC4F7VJ5D_cjs.DatabaseOperationError(
           "Update edge failed: no row returned",
           { operation: "update", entity: "edge" }
         );
@@ -2019,6 +2246,22 @@ function createCommonOperationBackend(options) {
       const rows = await execution.execAll(query);
       return rows.map((row) => rowMappers.toEdgeRow(row));
     },
+    async findEdgesByEndpointSet(params) {
+      const ids = resolveEdgeEndpointIds(params);
+      const edgeRows = [];
+      for (const idChunk of chunkZDH3DX3C_cjs.chunk(
+        ids,
+        batchConfig.findEdgesEndpointChunkSize
+      )) {
+        const query = operationStrategy.buildFindEdgesByEndpointSet(
+          params,
+          idChunk
+        );
+        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);
@@ -2028,7 +2271,7 @@ function createCommonOperationBackend(options) {
       const query = operationStrategy.buildInsertUnique(params);
       const result = await execution.execGet(query);
       if (result && result.node_id !== params.nodeId) {
-        throw new chunkKTBTSHU6_cjs.UniquenessError({
+        throw new chunkC4F7VJ5D_cjs.UniquenessError({
           constraintName: params.constraintName,
           kind: params.nodeKind,
           existingId: result.node_id,
@@ -2048,7 +2291,7 @@ function createCommonOperationBackend(options) {
           continue;
         }
         if (existing.nodeId !== entry.nodeId) {
-          throw new chunkKTBTSHU6_cjs.UniquenessError({
+          throw new chunkC4F7VJ5D_cjs.UniquenessError({
             constraintName: entry.constraintName,
             kind: entry.nodeKind,
             existingId: existing.nodeId,
@@ -2073,7 +2316,7 @@ function createCommonOperationBackend(options) {
         for (const entry of chunk2) {
           const owner = ownerByTarget.get(targetKey(entry));
           if (owner !== void 0 && owner !== entry.nodeId) {
-            throw new chunkKTBTSHU6_cjs.UniquenessError({
+            throw new chunkC4F7VJ5D_cjs.UniquenessError({
               constraintName: entry.constraintName,
               kind: entry.nodeKind,
               existingId: owner,
@@ -2128,7 +2371,7 @@ function createCommonOperationBackend(options) {
       if (existingRaw !== void 0) {
         const existing = rowMappers.toSchemaVersionRow(existingRaw);
         if (existing.schema_hash !== params.schemaHash) {
-          throw new chunkKTBTSHU6_cjs.SchemaContentConflictError({
+          throw new chunkC4F7VJ5D_cjs.SchemaContentConflictError({
             graphId: params.graphId,
             version: params.version,
             existingHash: existing.schema_hash,
@@ -2176,7 +2419,7 @@ function createCommonOperationBackend(options) {
       );
       const insertedRaw = await execution.execGet(insertQuery);
       if (!insertedRaw) {
-        throw new chunkKTBTSHU6_cjs.DatabaseOperationError(
+        throw new chunkC4F7VJ5D_cjs.DatabaseOperationError(
           "Insert schema failed: no row returned",
           { operation: "insert", entity: "schema" }
         );
@@ -2194,7 +2437,7 @@ function createCommonOperationBackend(options) {
         operationStrategy.buildGetSchemaVersion(params.graphId, params.version)
       );
       if (!targetRaw) {
-        throw new chunkKTBTSHU6_cjs.MigrationError(
+        throw new chunkC4F7VJ5D_cjs.MigrationError(
           `Cannot activate version ${params.version}: version does not exist for graph "${params.graphId}".`,
           {
             graphId: params.graphId,
@@ -2227,7 +2470,7 @@ function quoteSqlIdentifier(identifier) {
 }
 function requireRawExecution(backend) {
   if (backend.executeRaw === void 0) {
-    throw new chunkKTBTSHU6_cjs.TrustedImportError(
+    throw new chunkC4F7VJ5D_cjs.TrustedImportError(
       "This backend cannot execute the raw statements required by trusted import.",
       "backend_unsupported"
     );
@@ -2236,7 +2479,7 @@ function requireRawExecution(backend) {
 }
 function requireStatementExecution(backend) {
   if (backend.executeStatement === void 0) {
-    throw new chunkKTBTSHU6_cjs.TrustedImportError(
+    throw new chunkC4F7VJ5D_cjs.TrustedImportError(
       "This backend cannot execute the index lifecycle required by trusted import.",
       "backend_unsupported"
     );
@@ -2258,7 +2501,7 @@ async function assertTrustedImportDatabaseEmpty(backend, tableNames) {
     []
   );
   if (!rowIndicatesExistingData(rows[0])) return;
-  throw new chunkKTBTSHU6_cjs.TrustedImportError(
+  throw new chunkC4F7VJ5D_cjs.TrustedImportError(
     "Trusted import requires globally empty TypeGraph node and edge tables.",
     "database_not_empty",
     { tables: [tableNames.nodes, tableNames.edges] },
@@ -2270,8 +2513,8 @@ async function assertTrustedImportDatabaseEmpty(backend, tableNames) {
 async function lockPostgresTrustedImportTables(backend, tableNames) {
   const executeStatement = requireStatementExecution(backend);
   await executeStatement(
-    chunkX2XOQZT3_cjs.asCompiledStatementSql(
-      chunkX2XOQZT3_cjs.sql.raw(
+    chunkU5W4LKZV_cjs.asCompiledStatementSql(
+      chunkU5W4LKZV_cjs.sql.raw(
         `LOCK TABLE ${quoteSqlIdentifier(tableNames.nodes)}, ${quoteSqlIdentifier(tableNames.edges)} IN ACCESS EXCLUSIVE MODE`
       )
     )
@@ -2291,8 +2534,8 @@ async function suspendSqliteSecondaryIndexes(backend, tableNames) {
   );
   for (const definition of definitions) {
     await executeStatement(
-      chunkX2XOQZT3_cjs.asCompiledStatementSql(
-        chunkX2XOQZT3_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
+      chunkU5W4LKZV_cjs.asCompiledStatementSql(
+        chunkU5W4LKZV_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
       )
     );
   }
@@ -2322,8 +2565,8 @@ async function suspendPostgresSecondaryIndexes(backend, tableNames) {
   );
   for (const definition of definitions) {
     await executeStatement(
-      chunkX2XOQZT3_cjs.asCompiledStatementSql(
-        chunkX2XOQZT3_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
+      chunkU5W4LKZV_cjs.asCompiledStatementSql(
+        chunkU5W4LKZV_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
       )
     );
   }
@@ -2333,20 +2576,20 @@ async function restoreSecondaryIndexes(backend, definitions) {
   const executeStatement = requireStatementExecution(backend);
   for (const definition of definitions) {
     await executeStatement(
-      chunkX2XOQZT3_cjs.asCompiledStatementSql(chunkX2XOQZT3_cjs.sql.raw(definition.index_definition))
+      chunkU5W4LKZV_cjs.asCompiledStatementSql(chunkU5W4LKZV_cjs.sql.raw(definition.index_definition))
     );
   }
 }
 async function analyzeImportedTables(backend, tableNames) {
   const executeStatement = requireStatementExecution(backend);
   await executeStatement(
-    chunkX2XOQZT3_cjs.asCompiledStatementSql(
-      chunkX2XOQZT3_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.nodes)}`)
+    chunkU5W4LKZV_cjs.asCompiledStatementSql(
+      chunkU5W4LKZV_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.nodes)}`)
     )
   );
   await executeStatement(
-    chunkX2XOQZT3_cjs.asCompiledStatementSql(
-      chunkX2XOQZT3_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.edges)}`)
+    chunkU5W4LKZV_cjs.asCompiledStatementSql(
+      chunkU5W4LKZV_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.edges)}`)
     )
   );
 }
@@ -2361,7 +2604,7 @@ function postgresArray(values) {
 function createSqliteTrustedImportSession(executionAdapter, tableNames) {
   const executePreparedRunBatch = executionAdapter.executePreparedRunBatch;
   if (executePreparedRunBatch === void 0) {
-    throw new chunkKTBTSHU6_cjs.TrustedImportError(
+    throw new chunkC4F7VJ5D_cjs.TrustedImportError(
       "Trusted import requires a synchronous SQLite driver with prepared statement support.",
       "backend_unsupported"
     );
@@ -2490,6 +2733,7 @@ function getOrCreateLru(cache, key, cacheMax, create) {
 }
 
 exports.EMBEDDING_UPSERT_PARAM_COUNT = EMBEDDING_UPSERT_PARAM_COUNT;
+exports.FIND_EDGES_ENDPOINT_FIXED_PARAM_COUNT = FIND_EDGES_ENDPOINT_FIXED_PARAM_COUNT;
 exports.POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS = POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS;
 exports.POSTGRES_INDEX_MAT_TIMESTAMPS = POSTGRES_INDEX_MAT_TIMESTAMPS;
 exports.POSTGRES_KIND_REMOVAL_TIMESTAMPS = POSTGRES_KIND_REMOVAL_TIMESTAMPS;
@@ -2497,6 +2741,7 @@ exports.SQLITE_CONTRIBUTION_MAT_TIMESTAMPS = SQLITE_CONTRIBUTION_MAT_TIMESTAMPS;
 exports.SQLITE_INDEX_MAT_TIMESTAMPS = SQLITE_INDEX_MAT_TIMESTAMPS;
 exports.SQLITE_KIND_REMOVAL_TIMESTAMPS = SQLITE_KIND_REMOVAL_TIMESTAMPS;
 exports.analyzeImportedTables = analyzeImportedTables;
+exports.assertActiveSchemaVersion = assertActiveSchemaVersion;
 exports.assertAdoptedDialect = assertAdoptedDialect;
 exports.assertTrustedImportDatabaseEmpty = assertTrustedImportDatabaseEmpty;
 exports.buildContributionInsertValues = buildContributionInsertValues;
@@ -2506,6 +2751,7 @@ exports.buildKindRemovalOnConflictSet = buildKindRemovalOnConflictSet;
 exports.buildLiveNodeCandidates = buildLiveNodeCandidates;
 exports.buildMaterializationInsertValues = buildMaterializationInsertValues;
 exports.buildMaterializationOnConflictSet = buildMaterializationOnConflictSet;
+exports.commitSchemaVersionIfKindsEmpty = commitSchemaVersionIfKindsEmpty;
 exports.createCachedTableExistence = createCachedTableExistence;
 exports.createCommonOperationBackend = createCommonOperationBackend;
 exports.createContributionMaterializer = createContributionMaterializer;
@@ -2525,8 +2771,9 @@ exports.mapVectorWriteError = mapVectorWriteError;
 exports.restoreSecondaryIndexes = restoreSecondaryIndexes;
 exports.suspendPostgresSecondaryIndexes = suspendPostgresSecondaryIndexes;
 exports.suspendSqliteSecondaryIndexes = suspendSqliteSecondaryIndexes;
+exports.tableExistsFromRow = tableExistsFromRow;
 exports.vectorSlotFromCreateIndexParams = vectorSlotFromCreateIndexParams;
 exports.vectorSlotFromDropIndexParams = vectorSlotFromDropIndexParams;
 exports.vectorSlotFromParams = vectorSlotFromParams;
-//# sourceMappingURL=chunk-O7XVCLXW.cjs.map
-//# sourceMappingURL=chunk-O7XVCLXW.cjs.map
+//# sourceMappingURL=chunk-ST3LPB2V.cjs.map
+//# sourceMappingURL=chunk-ST3LPB2V.cjs.map