@nicia-ai/typegraph 0.44.0 → 0.45.0

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

@@ -1,13 +1,14 @@
 'use strict';
 
-var chunkHJH3RMXG_cjs = require('./chunk-HJH3RMXG.cjs');
-var chunk6JZUSDY2_cjs = require('./chunk-6JZUSDY2.cjs');
-var chunkNN3QSOVS_cjs = require('./chunk-NN3QSOVS.cjs');
+var chunkF4NHQHEZ_cjs = require('./chunk-F4NHQHEZ.cjs');
+var chunkZ3WO6MND_cjs = require('./chunk-Z3WO6MND.cjs');
+var chunkOOA273IJ_cjs = require('./chunk-OOA273IJ.cjs');
 var chunkZDH3DX3C_cjs = require('./chunk-ZDH3DX3C.cjs');
-var chunk3PRKZW6D_cjs = require('./chunk-3PRKZW6D.cjs');
+var chunkEKFUG4G7_cjs = require('./chunk-EKFUG4G7.cjs');
 var chunkACSVZPK7_cjs = require('./chunk-ACSVZPK7.cjs');
-var chunkWBUFJ7BS_cjs = require('./chunk-WBUFJ7BS.cjs');
+var chunkJQXSZHF2_cjs = require('./chunk-JQXSZHF2.cjs');
 var chunkZY4GXIVN_cjs = require('./chunk-ZY4GXIVN.cjs');
+var chunkJXUTCSXX_cjs = require('./chunk-JXUTCSXX.cjs');
 var chunkU5W4LKZV_cjs = require('./chunk-U5W4LKZV.cjs');
 var chunk764JHTLT_cjs = require('./chunk-764JHTLT.cjs');
 var chunkC4F7VJ5D_cjs = require('./chunk-C4F7VJ5D.cjs');
@@ -15,23 +16,68 @@ 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 chunkC4F7VJ5D_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 chunkC4F7VJ5D_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) {
@@ -77,7 +123,7 @@ function vectorSlotFromDropIndexParams(params) {
   };
 }
 function mapVectorWriteError(error, params) {
-  const mismatch = chunkWBUFJ7BS_cjs.parseDimensionMismatch(error);
+  const mismatch = chunkJQXSZHF2_cjs.parseDimensionMismatch(error);
   if (mismatch === void 0) return error;
   const attempted = mismatch.actual ?? "a different number of";
   return new chunkC4F7VJ5D_cjs.EmbeddingDimensionChangedError(
@@ -96,7 +142,7 @@ var SQLITE_CONTRIBUTION_MAT_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS = {
-  decode: chunkHJH3RMXG_cjs.formatPostgresTimestamp,
+  decode: chunkF4NHQHEZ_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapContributionMaterializationRow(row, decode) {
@@ -161,6 +207,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": {
@@ -233,7 +282,7 @@ function gateFulltextMethods(source, assert) {
   return gated;
 }
 function gateFulltext(tx, assert) {
-  return chunk3PRKZW6D_cjs.createBackendOverlay(
+  return chunkEKFUG4G7_cjs.createBackendOverlay(
     tx,
     gateFulltextMethods(tx, assert)
   );
@@ -281,7 +330,7 @@ function createContributionMaterializer(deps) {
     }
   }
   function runtimeContributions() {
-    return chunk6JZUSDY2_cjs.runtimeStrategyContributions(fulltextStrategy, fulltextTableName);
+    return chunkZ3WO6MND_cjs.runtimeStrategyContributions(fulltextStrategy, fulltextTableName);
   }
   function cacheInitializedSignature(key, signature) {
     if (!uncacheableKeys.has(key)) {
@@ -308,13 +357,13 @@ function createContributionMaterializer(deps) {
       await deps.recordMarker({
         ...identity,
         signature,
-        attemptedAt: chunkHJH3RMXG_cjs.nowIso(),
+        attemptedAt: chunkF4NHQHEZ_cjs.nowIso(),
         materializedAt: void 0,
         error: error.message
       });
       throw error;
     }
-    const attemptedAt = chunkHJH3RMXG_cjs.nowIso();
+    const attemptedAt = chunkF4NHQHEZ_cjs.nowIso();
     try {
       for (const statement of contribution.createDdl) {
         await deps.execDdl(statement);
@@ -350,12 +399,13 @@ function createContributionMaterializer(deps) {
         rows: indexMarkerRows(graphId, await deps.getMarkers(graphId))
       };
     } catch (error) {
-      if (!chunkWBUFJ7BS_cjs.isMissingTableError(error)) throw error;
+      if (!chunkJQXSZHF2_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 +416,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;
@@ -471,11 +527,11 @@ 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()) {
@@ -493,6 +549,10 @@ function createContributionMaterializer(deps) {
         }
       }
     }
+    return targets;
+  }
+  async function diagnoseContributions(graphId, vectorSlots) {
+    const targetsByGraph = verificationTargetsByGraph(graphId, vectorSlots);
     const probes = /* @__PURE__ */ new Map();
     function tableExists(tableName) {
       const pending = probes.get(tableName);
@@ -501,7 +561,7 @@ 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();
@@ -514,22 +574,56 @@ 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,
+          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 verifyContributions(graphId, vectorSlots) {
+    const diagnosed = await diagnoseContributions(graphId, vectorSlots);
+    return diagnosed.map((entry) => entry.diagnostic);
+  }
+  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 diagnostics;
+    return {
+      results,
+      remaining: await verifyContributions(graphId, vectorSlots)
+    };
   }
   function evictVectorSlot(slot) {
     if (deps.vectorStrategy === void 0) return;
@@ -559,7 +653,8 @@ function createContributionMaterializer(deps) {
     assertVectorSlots,
     dropVectorSlot,
     evictVectorSlot,
-    verifyContributions
+    verifyContributions,
+    repairContributions
   };
 }
 var SQLITE_INDEX_MAT_TIMESTAMPS = {
@@ -567,7 +662,7 @@ var SQLITE_INDEX_MAT_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_INDEX_MAT_TIMESTAMPS = {
-  decode: chunkHJH3RMXG_cjs.formatPostgresTimestamp,
+  decode: chunkF4NHQHEZ_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapMaterializationRow(row, decode) {
@@ -625,7 +720,7 @@ var SQLITE_KIND_REMOVAL_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_KIND_REMOVAL_TIMESTAMPS = {
-  decode: chunkHJH3RMXG_cjs.formatPostgresTimestamp,
+  decode: chunkF4NHQHEZ_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapKindRemovalRow(row, decode) {
@@ -792,12 +887,12 @@ function present(value) {
 function mapHybridSearchRow(row, toNodeRow) {
   return {
     node: toNodeRow(row),
-    fusedScore: chunkHJH3RMXG_cjs.coerceNumericScore(row["fused_score"]),
+    fusedScore: chunkF4NHQHEZ_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: chunkF4NHQHEZ_cjs.coerceNumericScore(row["vector_score"]) } : {},
     ...present(row["fulltext_rank"]) ? { fulltextRank: Number(row["fulltext_rank"]) } : {},
     ...present(row["fulltext_score"]) ? {
-      fulltextScore: chunkHJH3RMXG_cjs.coerceNumericScore(
+      fulltextScore: chunkF4NHQHEZ_cjs.coerceNumericScore(
         row["fulltext_score"]
       )
     } : {},
@@ -1009,6 +1104,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 = [
@@ -1255,11 +1402,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 = chunkOOA273IJ_cjs.toDrizzleSql(
     strategy.matchCondition(tableName, params.query, mode, params.language),
     dialect
   );
-  const rankExpression = chunkNN3QSOVS_cjs.toDrizzleSql(
+  const rankExpression = chunkOOA273IJ_cjs.toDrizzleSql(
     strategy.rankExpression(tableName, params.query, mode, params.language),
     dialect
   );
@@ -1272,10 +1419,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 = chunkU5W4LKZV_cjs.isSqlFragment(candidates) ? chunkOOA273IJ_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 ? chunkOOA273IJ_cjs.toDrizzleSql(
     strategy.snippetExpression(
       tableName,
       params.query,
@@ -1418,6 +1565,37 @@ function buildUpdateNode(tables, params, timestamp) {
     RETURNING *
   `;
 }
+function buildUpdateNodeSet(tables, dialect, params, timestamp) {
+  const { nodes } = tables;
+  const adapter = chunkJXUTCSXX_cjs.getDialect(dialect);
+  const patchedProps = chunkOOA273IJ_cjs.toDrizzleSql(
+    adapter.jsonSetProperties(
+      chunkU5W4LKZV_cjs.sql.identifier(nodes.props.name),
+      params.patch,
+      params.unsetProperties ?? []
+    ),
+    dialect
+  );
+  const candidateIds = chunkOOA273IJ_cjs.toDrizzleSql(params.candidateIds, dialect);
+  const candidateIdColumn = chunkOOA273IJ_cjs.toDrizzleSql(
+    chunkU5W4LKZV_cjs.sql.identifier(params.candidateIdColumn),
+    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 *
+  `;
+}
 function buildDeleteNode(tables, params, timestamp) {
   const { nodes } = tables;
   return drizzleOrm.sql`
@@ -1653,12 +1831,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) {
@@ -1747,9 +1936,11 @@ var COMMON_TABLE_OPERATION_BUILDERS = {
   buildCountNodesByKind,
   buildFindEdgesByKind,
   buildFindEdgesByEndpointSet,
+  buildFindEdgesByHeterogeneousEndpointSet,
   buildCountEdgesByKind,
   buildDeleteUnique,
   buildHardDeleteUniquesByNode,
+  buildHardDeleteUniquesByNodeIds,
   buildCheckUnique,
   buildCheckUniqueBatch,
   buildGetSchemaVersion
@@ -1762,15 +1953,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) => chunkOOA273IJ_cjs.toDrizzleSql(statement, dialect)),
+    buildDeleteFulltext: (params) => fulltextStrategy.buildDelete(fulltextTable, params).map((statement) => chunkOOA273IJ_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) => chunkOOA273IJ_cjs.toDrizzleSql(statement, dialect)),
+    buildUpsertFulltextBatch: (params, timestamp) => fulltextStrategy.buildBatchUpsert(fulltextTable, params, timestamp).map((statement) => chunkOOA273IJ_cjs.toDrizzleSql(statement, dialect)),
+    buildDeleteFulltextBatch: (params) => fulltextStrategy.buildBatchDelete(fulltextTable, params).map((statement) => chunkOOA273IJ_cjs.toDrizzleSql(statement, dialect)),
     buildFulltextSearch: (params) => buildFulltextSearch(
       fulltextTable,
       params,
@@ -1782,7 +1973,7 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
         tables.nodes,
         params.graphId,
         params.nodeKind,
-        chunkHJH3RMXG_cjs.nowIso()
+        chunkF4NHQHEZ_cjs.nowIso()
       )
     ),
     buildHybridSearch: (params, vectorSql, vectorScoreDescending) => {
@@ -1790,7 +1981,7 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
         tables.nodes,
         params.graphId,
         params.nodeKind,
-        chunkHJH3RMXG_cjs.nowIso()
+        chunkF4NHQHEZ_cjs.nowIso()
       );
       const fulltextSql = buildFulltextSearch(
         fulltextTable,
@@ -1811,7 +2002,7 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
         hybridCandidatesRef()
       );
       return buildHybridSearchStatement({
-        candidatesSql: chunkU5W4LKZV_cjs.isSqlFragment(candidates) ? chunkNN3QSOVS_cjs.toDrizzleSql(candidates, dialect) : candidates,
+        candidatesSql: chunkU5W4LKZV_cjs.isSqlFragment(candidates) ? chunkOOA273IJ_cjs.toDrizzleSql(candidates, dialect) : candidates,
         vectorSql,
         vectorScoreDescending,
         fulltextSql,
@@ -1839,6 +2030,9 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
   return {
     ...tableOperations,
     ...fulltextBuilders,
+    buildUpdateNodeSet(params, timestamp) {
+      return buildUpdateNodeSet(tables, dialect, params, timestamp);
+    },
     buildDeleteContributionMaterialization,
     buildInsertUnique(params) {
       return buildInsertUnique(tables, dialect, params);
@@ -1969,8 +2163,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 ?? chunkF4NHQHEZ_cjs.nowIso;
   const tableExists = createCachedTableExistence(
     (tableName) => execution.execGet(
       operationStrategy.buildTableExists(tableName)
@@ -2071,6 +2271,25 @@ function createCommonOperationBackend(options) {
         );
       return rowMappers.toNodeRow(row);
     },
+    async updateNodeSet(params) {
+      if (Object.keys(params.patch).length === 0 && (params.unsetProperties?.length ?? 0) === 0) {
+        throw new chunkC4F7VJ5D_cjs.ConfigurationError(
+          "Set-based node update requires at least one property",
+          { operation: "updateNodeSet", kind: params.kind }
+        );
+      }
+      if (params.candidateIdColumn.length === 0) {
+        throw new chunkC4F7VJ5D_cjs.ConfigurationError(
+          "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 +2307,7 @@ function createCommonOperationBackend(options) {
     async hardDeleteNode(params) {
       const deleteUniquesQuery = operationStrategy.buildHardDeleteUniquesByNode(
         params.graphId,
+        params.kind,
         params.id
       );
       await execution.execRun(deleteUniquesQuery);
@@ -2262,6 +2482,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 chunkZDH3DX3C_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);
@@ -2332,6 +2567,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 chunkZDH3DX3C_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);
@@ -2775,5 +3023,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-H7VE3FL4.cjs.map
+//# sourceMappingURL=chunk-H7VE3FL4.cjs.map