@nicia-ai/typegraph 0.44.0 → 0.46.0

package/dist/{chunk-SQRD2CYF.js → chunk-7VQXLT5O.js}

@@ -1,35 +1,80 @@
-import { formatPostgresTimestamp, coerceNumericScore, nowIso } from './chunk-PHXITZE4.js';
-import { runtimeStrategyContributions } from './chunk-7G32LIQM.js';
-import { toDrizzleSql } from './chunk-GWEDD3DH.js';
-import { chunk } from './chunk-35S6P5ZU.js';
-import { createBackendOverlay } from './chunk-FMMIX6N4.js';
-import { sortedReplacer } from './chunk-UR7W5YQK.js';
-import { parseDimensionMismatch, isMissingTableError } from './chunk-B75XRV3O.js';
+import { formatPostgresTimestamp, coerceNumericScore, nowIso } from './chunk-NMWDXFPH.js';
+import { runtimeStrategyContributions } from './chunk-5UVRGXD3.js';
+import { toDrizzleSql } from './chunk-UV3SN74I.js';
+import { sortedReplacer } from './chunk-JBQQ7THH.js';
+import { parseDimensionMismatch, chunk, isDuplicatePrimaryKeyError, isMissingTableError } from './chunk-JZUR7ZWE.js';
+import { createBackendOverlay } from './chunk-AKLS3BYZ.js';
 import { sha256Hex } from './chunk-K34OPSJK.js';
-import { sql as sql$1, asCompiledStatementSql, isSqlFragment } from './chunk-6DCB664D.js';
-import { isPresent } from './chunk-QMQLUA66.js';
-import { EmbeddingDimensionChangedError, ConfigurationError, StaleVersionError, MigrationError, SchemaContentConflictError, DatabaseOperationError, UniquenessError, TrustedImportError, StoreNotInitializedError } from './chunk-4MB3AQAQ.js';
+import { buildFulltextGraphDelete, buildForeignFulltextGraphProbe, getDialect } from './chunk-YDFDBE6D.js';
+import { sql as sql$1, asCompiledStatementSql, asCompiledRowsSql, isSqlFragment } from './chunk-PQBQG7IM.js';
+import { EmbeddingDimensionChangedError, ConfigurationError, StaleVersionError, MigrationError, SchemaContentConflictError, DatabaseOperationError, UniquenessError, TrustedImportError, ContributionRebuildUnsupportedError, StoreNotInitializedError } from './chunk-J3WZ3FA2.js';
+import { isPresent } from './chunk-DYATYRY4.js';
 import { sql, is, getTableName } from '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 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 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 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) {
@@ -159,6 +204,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": {
@@ -176,6 +224,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,
@@ -236,6 +298,13 @@ function gateFulltext(tx, assert) {
     gateFulltextMethods(tx, assert)
   );
 }
+function contributionRebuildSupported(fulltextStrategy, fulltextTableName, transactional) {
+  return transactional && 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 [
@@ -305,7 +374,7 @@ function createContributionMaterializer(deps) {
       );
       await deps.recordMarker({
         ...identity,
-        signature,
+        signature: existing.signature,
         attemptedAt: nowIso(),
         materializedAt: void 0,
         error: error.message
@@ -354,6 +423,7 @@ function createContributionMaterializer(deps) {
   }
   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);
@@ -364,7 +434,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;
@@ -469,15 +545,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) {
@@ -485,12 +561,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);
@@ -499,11 +579,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(
@@ -512,22 +592,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(
+      asCompiledRowsSql(
+        sql$1`SELECT pg_advisory_xact_lock(hashtext(${CONTRIBUTION_DDL_LOCK_KEY}), 0)`
+      )
+    );
+  }
+  async function lockSharedFulltextTable(tx, tableName) {
+    if (dialect !== "postgres") return;
+    await tx.executeStatement(
+      asCompiledStatementSql(
+        sql$1`LOCK TABLE ${sql$1.identifier(tableName)} IN ACCESS EXCLUSIVE MODE`
+      )
+    );
+  }
+  async function readForeignGraphIds(tx, tableName, graphId) {
+    const rows = await tx.execute(
+      asCompiledRowsSql(
+        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 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 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 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 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 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(
+          asCompiledStatementSql(
+            buildFulltextGraphDelete(sharedTable, graphId)
+          )
+        );
+      }
+      const stats = await repopulate(tx);
+      const now = 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;
@@ -557,7 +854,10 @@ function createContributionMaterializer(deps) {
     assertVectorSlots,
     dropVectorSlot,
     evictVectorSlot,
-    verifyContributions
+    verifyContributions,
+    repairContributions,
+    probeContributions,
+    rebuildContribution
   };
 }
 var SQLITE_INDEX_MAT_TIMESTAMPS = {
@@ -664,6 +964,30 @@ function buildKindRemovalOnConflictSet(removedAtColumn, paramsRemovedAt) {
     lastError: sql`excluded.${sql.identifier("last_error")}`
   };
 }
+function primaryKeyConstraintNames(relation, keyColumns) {
+  return [`${relation}_pkey`, `${relation}_${keyColumns.join("_")}_pk`];
+}
+function nodePrimaryKeyConstraint(nodes) {
+  const relation = getTableName(nodes);
+  return {
+    table: relation,
+    constraintNames: primaryKeyConstraintNames(relation, [
+      nodes.graphId.name,
+      nodes.kind.name,
+      nodes.id.name
+    ])
+  };
+}
+function edgePrimaryKeyConstraint(edges) {
+  const relation = getTableName(edges);
+  return {
+    table: relation,
+    constraintNames: primaryKeyConstraintNames(relation, [
+      edges.graphId.name,
+      edges.id.name
+    ])
+  };
+}
 function sqlNull(value) {
   return value ?? sql.raw("NULL");
 }
@@ -671,6 +995,11 @@ function resolveValidFrom(validFrom, timestamp) {
   if (validFrom === null) return void 0;
   return validFrom ?? timestamp;
 }
+function expectedValidFromPredicate(column, expected) {
+  if (expected === void 0) return sql.empty();
+  if (expected === null) return sql` AND ${column} IS NULL`;
+  return sql` AND ${column} = ${expected}`;
+}
 function quotedColumn(column) {
   return sql.raw(`"${column.name.replaceAll('"', '""')}"`);
 }
@@ -803,9 +1132,16 @@ function mapHybridSearchRow(row, toNodeRow) {
   };
 }
 function buildClearGraph(tables, graphId) {
-  const fulltext = quotedTableName(tables.fulltextTableName);
   return [
-    { query: 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: buildFulltextGraphDelete(tables.fulltextTableName, graphId) },
+    {
+      query: sql`DELETE FROM ${tables.recordedIdentityAssertions} WHERE ${tables.recordedIdentityAssertions.graphId} = ${graphId}`,
+      ignoreMissingTable: true,
+      requiredTableName: getTableName(tables.recordedIdentityAssertions)
+    },
     {
       query: sql`DELETE FROM ${tables.recordedEdges} WHERE ${tables.recordedEdges.graphId} = ${graphId}`,
       ignoreMissingTable: true,
@@ -821,6 +1157,21 @@ function buildClearGraph(tables, graphId) {
       ignoreMissingTable: true,
       requiredTableName: getTableName(tables.recordedClock)
     },
+    {
+      query: sql`DELETE FROM ${tables.identitySeparation} WHERE ${tables.identitySeparation.graphId} = ${graphId}`,
+      ignoreMissingTable: true,
+      requiredTableName: getTableName(tables.identitySeparation)
+    },
+    {
+      query: sql`DELETE FROM ${tables.identityClosure} WHERE ${tables.identityClosure.graphId} = ${graphId}`,
+      ignoreMissingTable: true,
+      requiredTableName: getTableName(tables.identityClosure)
+    },
+    {
+      query: sql`DELETE FROM ${tables.identityAssertions} WHERE ${tables.identityAssertions.graphId} = ${graphId}`,
+      ignoreMissingTable: true,
+      requiredTableName: getTableName(tables.identityAssertions)
+    },
     {
       query: sql`DELETE FROM ${tables.uniques} WHERE ${tables.uniques.graphId} = ${graphId}`
     },
@@ -1007,6 +1358,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 = sql.raw(`requested_endpoints."endpoint_kind"`);
+  const requestedId = sql.raw(`requested_endpoints."endpoint_id"`);
+  const requestedRows = sql.join(
+    endpoints.map((endpoint) => sql`(${endpoint.kind}, ${endpoint.id})`),
+    sql`, `
+  );
+  const whereClause = sql.join(
+    [
+      sql`${edges.graphId} = ${params.graphId}`,
+      buildIdSetCondition(edges.kind, edgeKinds),
+      ...buildTemporalConditions(edges, params)
+    ],
+    sql` AND `
+  );
+  const joinClause = 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 sql`
+      WITH requested_endpoints(endpoint_kind, endpoint_id) AS (
+        VALUES ${requestedRows}
+      )
+      SELECT ${edges}.*
+      ${joinClause}
+      ORDER BY ${orderByClause}
+    `;
+  }
+  const ranked = sql`
+    SELECT ${edges}.*, ROW_NUMBER() OVER (
+      PARTITION BY ${kindColumn}, ${idColumn} ORDER BY ${orderByClause}
+    ) AS endpoint_rank
+    ${joinClause}
+  `;
+  return 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 = [
@@ -1105,6 +1508,17 @@ function buildGetEdges(tables, graphId, ids) {
   )})
   `;
 }
+function expectedIdentityPredicate(tables, expected) {
+  const { edges } = tables;
+  const parts = [
+    expected.kind === void 0 ? void 0 : sql` AND ${edges.kind} = ${expected.kind}`,
+    expected.fromKind === void 0 ? void 0 : sql` AND ${edges.fromKind} = ${expected.fromKind}`,
+    expected.fromId === void 0 ? void 0 : sql` AND ${edges.fromId} = ${expected.fromId}`,
+    expected.toKind === void 0 ? void 0 : sql` AND ${edges.toKind} = ${expected.toKind}`,
+    expected.toId === void 0 ? void 0 : sql` AND ${edges.toId} = ${expected.toId}`
+  ].filter((part) => part !== void 0);
+  return parts.length === 0 ? sql.empty() : sql.join(parts, sql``);
+}
 function buildUpdateEdge(tables, params, timestamp) {
   const { edges } = tables;
   const propsJson = JSON.stringify(params.props);
@@ -1112,19 +1526,29 @@ function buildUpdateEdge(tables, params, timestamp) {
     sql`${quotedColumn(edges.props)} = ${propsJson}`,
     sql`${quotedColumn(edges.updatedAt)} = ${timestamp}`
   ];
-  if (params.validTo !== void 0) {
+  if (params.clearDeleted && params.validFrom !== void 0) {
+    setParts.push(
+      sql`${quotedColumn(edges.validFrom)} = ${sqlNull(resolveValidFrom(params.validFrom, timestamp))}`,
+      sql`${quotedColumn(edges.validTo)} = ${sqlNull(params.validTo)}`
+    );
+  } else if (params.validTo !== void 0) {
     setParts.push(sql`${quotedColumn(edges.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
     setParts.push(sql`${quotedColumn(edges.deletedAt)} = NULL`);
   }
   const setClause = sql.join(setParts, sql`, `);
+  const expectedIdentity = expectedIdentityPredicate(tables, params);
+  const expectedValidFrom = expectedValidFromPredicate(
+    edges.validFrom,
+    params.expectedValidFrom
+  );
   if (params.clearDeleted) {
     return sql`
       UPDATE ${edges}
       SET ${setClause}
       WHERE ${edges.graphId} = ${params.graphId}
-        AND ${edges.id} = ${params.id}
+        AND ${edges.id} = ${params.id}${expectedIdentity}${expectedValidFrom}
       RETURNING *
     `;
   }
@@ -1132,7 +1556,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 *
   `;
@@ -1143,7 +1567,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
   `;
 }
@@ -1176,7 +1600,7 @@ function buildHardDeleteEdge(tables, params) {
   return 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) {
@@ -1389,20 +1813,30 @@ function buildUpdateNode(tables, params, timestamp) {
       sql`${quotedColumn(nodes.version)} = ${quotedColumn(nodes.version)} + 1`
     );
   }
-  if (params.validTo !== void 0) {
+  if (params.clearDeleted) {
+    setParts.push(
+      sql`${quotedColumn(nodes.validFrom)} = ${sqlNull(resolveValidFrom(params.validFrom, timestamp))}`,
+      sql`${quotedColumn(nodes.validTo)} = ${sqlNull(params.validTo)}`
+    );
+  } else if (params.validTo !== void 0) {
     setParts.push(sql`${quotedColumn(nodes.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
     setParts.push(sql`${quotedColumn(nodes.deletedAt)} = NULL`);
   }
   const setClause = sql.join(setParts, sql`, `);
+  const expectedValidFrom = expectedValidFromPredicate(
+    nodes.validFrom,
+    params.expectedValidFrom
+  );
   if (params.clearDeleted) {
     return 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 *
     `;
   }
@@ -1411,11 +1845,42 @@ 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 = getDialect(dialect);
+  const patchedProps = toDrizzleSql(
+    adapter.jsonSetProperties(
+      sql$1.identifier(nodes.props.name),
+      params.patch,
+      params.unsetProperties ?? []
+    ),
+    dialect
+  );
+  const candidateIds = toDrizzleSql(params.candidateIds, dialect);
+  const candidateIdColumn = toDrizzleSql(
+    sql$1.identifier(params.candidateIdColumn),
+    dialect
+  );
+  return 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 sql`
@@ -1651,12 +2116,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 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 (${sql.join(
+    params.nodeIds.map((nodeId) => sql`${nodeId}`),
+    sql`, `
+  )})
   `;
 }
 function buildCheckUnique(tables, params) {
@@ -1705,6 +2181,9 @@ function buildCheckUniqueBatch(tables, params) {
 }
 
 // src/backend/drizzle/operations/strategy.ts
+function nullableText(value) {
+  return value === void 0 ? sql`NULL` : sql`${value}`;
+}
 function bindTableOperationBuilders(tables, builders) {
   const boundEntries = Object.entries(builders).map(([name, builder]) => {
     function boundBuilder(...args) {
@@ -1745,9 +2224,11 @@ var COMMON_TABLE_OPERATION_BUILDERS = {
   buildCountNodesByKind,
   buildFindEdgesByKind,
   buildFindEdgesByEndpointSet,
+  buildFindEdgesByHeterogeneousEndpointSet,
   buildCountEdgesByKind,
   buildDeleteUnique,
   buildHardDeleteUniquesByNode,
+  buildHardDeleteUniquesByNodeIds,
   buildCheckUnique,
   buildCheckUniqueBatch,
   buildGetSchemaVersion
@@ -1825,6 +2306,24 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
       });
     }
   };
+  function buildInsertContributionMaterialization(params) {
+    return 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 sql`
       DELETE FROM ${contributionMaterializations}
@@ -1837,7 +2336,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);
     },
@@ -1918,6 +2425,26 @@ function assertAdoptedDialect(externalTx, brand, backend) {
     { backend, capability: "adoptTransaction" }
   );
 }
+async function withDuplicateKeyClassification(run, context) {
+  try {
+    return await run();
+  } catch (error) {
+    if (!isDuplicatePrimaryKeyError(error, context.relation)) throw error;
+    throw new 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);
@@ -1967,7 +2494,13 @@ async function commitSchemaVersionIfKindsEmpty(backend, params, probes) {
   };
 }
 function createCommonOperationBackend(options) {
-  const { batchConfig, execution, operationStrategy, rowMappers } = options;
+  const {
+    batchConfig,
+    execution,
+    maxBindParameters,
+    operationStrategy,
+    rowMappers
+  } = options;
   const nowIso2 = options.nowIso ?? nowIso;
   const tableExists = createCachedTableExistence(
     (tableName) => execution.execGet(
@@ -2001,11 +2534,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 DatabaseOperationError(
           "Insert node failed: no row returned",
-          { operation: "insert", entity: "node" }
+          {
+            operation: "insert",
+            entity: "node",
+            reason: "no_row_returned"
+          }
         );
       return rowMappers.toNodeRow(row);
     },
@@ -2015,7 +2559,11 @@ 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) {
@@ -2024,7 +2572,11 @@ function createCommonOperationBackend(options) {
       const timestamp = nowIso2();
       for (const chunk2 of 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) {
@@ -2038,7 +2590,14 @@ function createCommonOperationBackend(options) {
           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;
@@ -2065,10 +2624,33 @@ function createCommonOperationBackend(options) {
       if (!row)
         throw new 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 ConfigurationError(
+          "Set-based node update requires at least one property",
+          { operation: "updateNodeSet", kind: params.kind }
+        );
+      }
+      if (params.candidateIdColumn.length === 0) {
+        throw new 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);
@@ -2086,6 +2668,7 @@ function createCommonOperationBackend(options) {
     async hardDeleteNode(params) {
       const deleteUniquesQuery = operationStrategy.buildHardDeleteUniquesByNode(
         params.graphId,
+        params.kind,
         params.id
       );
       await execution.execRun(deleteUniquesQuery);
@@ -2109,11 +2692,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 DatabaseOperationError(
           "Insert edge failed: no row returned",
-          { operation: "insert", entity: "edge" }
+          {
+            operation: "insert",
+            entity: "edge",
+            reason: "no_row_returned"
+          }
         );
       return rowMappers.toEdgeRow(row);
     },
@@ -2123,7 +2717,11 @@ 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) {
@@ -2132,7 +2730,11 @@ function createCommonOperationBackend(options) {
       const timestamp = nowIso2();
       for (const chunk2 of 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) {
@@ -2146,7 +2748,14 @@ function createCommonOperationBackend(options) {
           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;
@@ -2173,7 +2782,11 @@ function createCommonOperationBackend(options) {
       if (!row)
         throw new DatabaseOperationError(
           "Update edge failed: no row returned",
-          { operation: "update", entity: "edge" }
+          {
+            operation: "update",
+            entity: "edge",
+            reason: "no_row_returned"
+          }
         );
       return rowMappers.toEdgeRow(row);
     },
@@ -2260,6 +2873,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 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);
@@ -2330,6 +2958,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 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);
@@ -2730,6 +3371,6 @@ function getOrCreateLru(cache, key, cacheMax, create) {
   return value;
 }
 
-export { EMBEDDING_UPSERT_PARAM_COUNT, FIND_EDGES_ENDPOINT_FIXED_PARAM_COUNT, POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, POSTGRES_INDEX_MAT_TIMESTAMPS, POSTGRES_KIND_REMOVAL_TIMESTAMPS, SQLITE_CONTRIBUTION_MAT_TIMESTAMPS, SQLITE_INDEX_MAT_TIMESTAMPS, SQLITE_KIND_REMOVAL_TIMESTAMPS, analyzeImportedTables, assertActiveSchemaVersion, assertAdoptedDialect, assertTrustedImportDatabaseEmpty, buildContributionInsertValues, buildContributionOnConflictSet, buildKindRemovalInsertValues, buildKindRemovalOnConflictSet, buildLiveNodeCandidates, buildMaterializationInsertValues, buildMaterializationOnConflictSet, commitSchemaVersionIfKindsEmpty, createCachedTableExistence, createCommonOperationBackend, createContributionMaterializer, createPostgresOperationStrategy, createPostgresTrustedImportSession, createSqliteOperationStrategy, createSqliteTrustedImportSession, gateFulltext, gateFulltextMethods, getOrCreateLru, lockPostgresTrustedImportTables, mapContributionMaterializationRow, mapHybridSearchRow, mapKindRemovalRow, mapMaterializationRow, mapVectorWriteError, restoreSecondaryIndexes, suspendPostgresSecondaryIndexes, suspendSqliteSecondaryIndexes, tableExistsFromRow, vectorSlotFromCreateIndexParams, vectorSlotFromDropIndexParams, vectorSlotFromParams };
-//# sourceMappingURL=chunk-SQRD2CYF.js.map
-//# sourceMappingURL=chunk-SQRD2CYF.js.map
+export { EMBEDDING_UPSERT_PARAM_COUNT, FIND_EDGES_ENDPOINT_FIXED_PARAM_COUNT, POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS, POSTGRES_INDEX_MAT_TIMESTAMPS, POSTGRES_KIND_REMOVAL_TIMESTAMPS, SQLITE_CONTRIBUTION_MAT_TIMESTAMPS, SQLITE_INDEX_MAT_TIMESTAMPS, SQLITE_KIND_REMOVAL_TIMESTAMPS, analyzeImportedTables, assertActiveSchemaVersion, assertAdoptedDialect, assertTrustedImportDatabaseEmpty, buildContributionInsertValues, buildContributionOnConflictSet, buildKindRemovalInsertValues, buildKindRemovalOnConflictSet, buildLiveNodeCandidates, buildMaterializationInsertValues, buildMaterializationOnConflictSet, commitSchemaVersionIfKindsEmpty, contributionRebuildSupported, createCachedTableExistence, createCommonOperationBackend, createContributionMaterializer, createPostgresOperationStrategy, createPostgresTrustedImportSession, createSqliteOperationStrategy, createSqliteTrustedImportSession, gateFulltext, gateFulltextMethods, getOrCreateLru, lockPostgresTrustedImportTables, mapContributionMaterializationRow, mapHybridSearchRow, mapKindRemovalRow, mapMaterializationRow, mapVectorWriteError, restoreSecondaryIndexes, suspendPostgresSecondaryIndexes, suspendSqliteSecondaryIndexes, tableExistsFromRow, vectorSlotFromCreateIndexParams, vectorSlotFromDropIndexParams, vectorSlotFromParams };
+//# sourceMappingURL=chunk-7VQXLT5O.js.map
+//# sourceMappingURL=chunk-7VQXLT5O.js.map