@nicia-ai/typegraph 0.48.0 → 0.50.0

package/dist/{chunk-WCCATHMB.cjs → chunk-XMY2SXOH.cjs}

@@ -1,15 +1,16 @@
 'use strict';
 
-var chunkFA2AFWLP_cjs = require('./chunk-FA2AFWLP.cjs');
-var chunkHDL2ARHX_cjs = require('./chunk-HDL2ARHX.cjs');
-var chunkWODMN3Q2_cjs = require('./chunk-WODMN3Q2.cjs');
-var chunkPWLJ77UV_cjs = require('./chunk-PWLJ77UV.cjs');
-var chunkSIT26LAZ_cjs = require('./chunk-SIT26LAZ.cjs');
-var chunkTQHGE7UC_cjs = require('./chunk-TQHGE7UC.cjs');
+var chunkEH3JZJUM_cjs = require('./chunk-EH3JZJUM.cjs');
+var chunkTP4NJTI3_cjs = require('./chunk-TP4NJTI3.cjs');
+var chunk45YZXI6X_cjs = require('./chunk-45YZXI6X.cjs');
+var chunk7PRMDZIA_cjs = require('./chunk-7PRMDZIA.cjs');
+var chunkZBFZGLZE_cjs = require('./chunk-ZBFZGLZE.cjs');
+var chunkLLVOQOWE_cjs = require('./chunk-LLVOQOWE.cjs');
+var chunkM5MSP3BI_cjs = require('./chunk-M5MSP3BI.cjs');
 var chunkZY4GXIVN_cjs = require('./chunk-ZY4GXIVN.cjs');
-var chunkL3LQNR34_cjs = require('./chunk-L3LQNR34.cjs');
-var chunkEDN4Y4ZG_cjs = require('./chunk-EDN4Y4ZG.cjs');
-var chunkMRDBBHIZ_cjs = require('./chunk-MRDBBHIZ.cjs');
+var chunkTEC24ZDA_cjs = require('./chunk-TEC24ZDA.cjs');
+var chunkOJHD3LXJ_cjs = require('./chunk-OJHD3LXJ.cjs');
+var chunkX4GDXBOP_cjs = require('./chunk-X4GDXBOP.cjs');
 var chunkN66HCGCY_cjs = require('./chunk-N66HCGCY.cjs');
 var drizzleOrm = require('drizzle-orm');
 
@@ -20,7 +21,7 @@ function assertLimitPerEndpoint(operation, graphId, limitPerEndpoint, kind) {
   if (limitPerEndpoint === void 0 || Number.isInteger(limitPerEndpoint) && limitPerEndpoint > 0) {
     return;
   }
-  throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+  throw new chunkX4GDXBOP_cjs.ConfigurationError(
     `${operation} \`limitPerEndpoint\` must be a positive integer, received ${String(limitPerEndpoint)}.`,
     {
       code: "EDGE_ENDPOINT_SET_INVALID",
@@ -64,7 +65,7 @@ function resolveHeterogeneousEdgeRead(params, maxBindParameters) {
   if (endpointChunkSize >= 1) {
     return { edgeKinds, endpoints, endpointChunkSize };
   }
-  throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+  throw new chunkX4GDXBOP_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",
@@ -80,8 +81,8 @@ function resolveHeterogeneousEdgeRead(params, maxBindParameters) {
 
 // src/backend/live-node-candidates.ts
 function buildLiveNodeCandidates(nodesTableName, graphId, nodeKind, now) {
-  const nodes = chunkEDN4Y4ZG_cjs.sql.identifier(nodesTableName);
-  return chunkEDN4Y4ZG_cjs.sql`
+  const nodes = chunkOJHD3LXJ_cjs.sql.identifier(nodesTableName);
+  return chunkOJHD3LXJ_cjs.sql`
     SELECT "id" AS node_id
     FROM ${nodes}
     WHERE "graph_id" = ${graphId}
@@ -122,10 +123,10 @@ function vectorSlotFromDropIndexParams(params) {
   };
 }
 function mapVectorWriteError(error, params) {
-  const mismatch = chunkSIT26LAZ_cjs.parseDimensionMismatch(error);
+  const mismatch = chunkZBFZGLZE_cjs.parseDimensionMismatch(error);
   if (mismatch === void 0) return error;
   const attempted = mismatch.actual ?? "a different number of";
-  return new chunkMRDBBHIZ_cjs.EmbeddingDimensionChangedError(
+  return new chunkX4GDXBOP_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,
@@ -141,7 +142,7 @@ var SQLITE_CONTRIBUTION_MAT_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_CONTRIBUTION_MAT_TIMESTAMPS = {
-  decode: chunkFA2AFWLP_cjs.formatPostgresTimestamp,
+  decode: chunkEH3JZJUM_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapContributionMaterializationRow(row, decode) {
@@ -191,7 +192,7 @@ function contributionSignatureInput(dialect, identity, createDdl) {
     tableName: identity.tableName,
     createDdl
   };
-  return JSON.stringify(hashable, chunkPWLJ77UV_cjs.sortedReplacer);
+  return JSON.stringify(hashable, chunkZBFZGLZE_cjs.sortedReplacer);
 }
 function evaluateContributionState(row, signature) {
   if (row === void 0) return "missing";
@@ -250,10 +251,10 @@ function identityOf(graphId, contribution) {
 }
 function missingTableErrorNames(error, tableName) {
   const quotedTableName2 = `"${tableName.replaceAll('"', '""')}"`;
-  for (const link of chunkSIT26LAZ_cjs.errorChain(error)) {
+  for (const link of chunkZBFZGLZE_cjs.errorChain(error)) {
     const message = errorMessage(link);
     if (typeof message !== "string") continue;
-    const sqliteMatch = /\bno such table:\s*([^\s;]+)/i.exec(message);
+    const sqliteMatch = /\bno such table:\s*([^\s;:]+)/i.exec(message);
     const sqliteName = unquoteSqliteIdentifier(sqliteMatch?.[1]);
     if (sqliteName === tableName) return true;
     const namesPostgresTable = message.includes(`relation ${quotedTableName2} does not exist`) || message.includes(`table ${quotedTableName2} does not exist`);
@@ -355,13 +356,13 @@ function gateFulltextMethods(source, assert, refuseUnavailable) {
   return gated;
 }
 function gateFulltext(tx, assert, refuseUnavailable) {
-  return chunkSIT26LAZ_cjs.deriveBackend(
+  return chunkZBFZGLZE_cjs.deriveBackend(
     tx,
     gateFulltextMethods(tx, assert, refuseUnavailable)
   );
 }
 function contributionRebuildSupported(fulltextStrategy, fulltextTableName, transactional) {
-  return transactional && chunkHDL2ARHX_cjs.runtimeStrategyContributions(fulltextStrategy, fulltextTableName).every(
+  return transactional && chunkTP4NJTI3_cjs.runtimeStrategyContributions(fulltextStrategy, fulltextTableName).every(
     (contribution) => contribution.dropDdl !== void 0
   );
 }
@@ -410,7 +411,7 @@ function createContributionMaterializer(deps) {
     }
   }
   function runtimeContributions() {
-    return chunkHDL2ARHX_cjs.runtimeStrategyContributions(fulltextStrategy, fulltextTableName);
+    return chunkTP4NJTI3_cjs.runtimeStrategyContributions(fulltextStrategy, fulltextTableName);
   }
   function cacheInitializedSignature(key, signature) {
     if (!uncacheableKeys.has(key)) {
@@ -437,13 +438,13 @@ function createContributionMaterializer(deps) {
       await deps.recordMarker({
         ...identity,
         signature: existing.signature,
-        attemptedAt: chunkFA2AFWLP_cjs.nowIso(),
+        attemptedAt: chunkEH3JZJUM_cjs.nowIso(),
         materializedAt: void 0,
         error: error.message
       });
       throw error;
     }
-    const attemptedAt = chunkFA2AFWLP_cjs.nowIso();
+    const attemptedAt = chunkEH3JZJUM_cjs.nowIso();
     try {
       for (const statement of contribution.createDdl) {
         await deps.execDdl(statement);
@@ -479,7 +480,7 @@ function createContributionMaterializer(deps) {
         rows: indexMarkerRows(graphId, await deps.getMarkers(graphId))
       };
     } catch (error) {
-      if (!chunkSIT26LAZ_cjs.isMissingTableError(error)) throw error;
+      if (!chunkZBFZGLZE_cjs.isMissingTableError(error)) throw error;
       return { kind: "missing-table", error };
     }
   }
@@ -558,7 +559,7 @@ function createContributionMaterializer(deps) {
     if (read.kind === "missing-table") {
       const first = pending[0];
       if (first === void 0) return;
-      throw new chunkMRDBBHIZ_cjs.StoreNotInitializedError(graphId, "missing", {
+      throw new chunkX4GDXBOP_cjs.StoreNotInitializedError(graphId, "missing", {
         cause: read.error,
         details: { logicalName: first.contribution.logicalName }
       });
@@ -567,7 +568,7 @@ function createContributionMaterializer(deps) {
       const { contribution, key, signature } = entry;
       const state = evaluateContributionState(read.rows.get(key), signature);
       if (state !== "initialized") {
-        throw new chunkMRDBBHIZ_cjs.StoreNotInitializedError(graphId, state, {
+        throw new chunkX4GDXBOP_cjs.StoreNotInitializedError(graphId, state, {
           details: { logicalName: contribution.logicalName }
         });
       }
@@ -582,12 +583,12 @@ function createContributionMaterializer(deps) {
   }
   async function refuseUnavailableFulltext(graphId, error) {
     await Promise.resolve();
-    if (!chunkSIT26LAZ_cjs.isMissingTableError(error)) throw error;
+    if (!chunkZBFZGLZE_cjs.isMissingTableError(error)) throw error;
     const missingContribution = runtimeContributions().find(
       (contribution) => contribution.logicalName === "fulltext" && missingTableErrorNames(error, contribution.tableName)
     );
     if (missingContribution !== void 0) {
-      throw new chunkMRDBBHIZ_cjs.ContributionUnavailableError(
+      throw new chunkX4GDXBOP_cjs.ContributionUnavailableError(
         graphId,
         missingContribution.tableName,
         { cause: error }
@@ -756,23 +757,23 @@ function createContributionMaterializer(deps) {
   async function lockContributionDdl(tx) {
     if (dialect !== "postgres") return;
     await tx.execute(
-      chunkEDN4Y4ZG_cjs.asCompiledRowsSql(
-        chunkEDN4Y4ZG_cjs.sql`SELECT pg_advisory_xact_lock(hashtext(${CONTRIBUTION_DDL_LOCK_KEY}), 0)`
+      chunkOJHD3LXJ_cjs.asCompiledRowsSql(
+        chunkOJHD3LXJ_cjs.sql`SELECT pg_advisory_xact_lock(hashtext(${CONTRIBUTION_DDL_LOCK_KEY}), 0)`
       )
     );
   }
   async function lockSharedFulltextTable(tx, tableName) {
     if (dialect !== "postgres") return;
     await tx.executeStatement(
-      chunkEDN4Y4ZG_cjs.asCompiledStatementSql(
-        chunkEDN4Y4ZG_cjs.sql`LOCK TABLE ${chunkEDN4Y4ZG_cjs.sql.identifier(tableName)} IN ACCESS EXCLUSIVE MODE`
+      chunkOJHD3LXJ_cjs.asCompiledStatementSql(
+        chunkOJHD3LXJ_cjs.sql`LOCK TABLE ${chunkOJHD3LXJ_cjs.sql.identifier(tableName)} IN ACCESS EXCLUSIVE MODE`
       )
     );
   }
   async function readForeignGraphIds(tx, tableName, graphId) {
     const rows = await tx.execute(
-      chunkEDN4Y4ZG_cjs.asCompiledRowsSql(
-        chunkL3LQNR34_cjs.buildForeignFulltextGraphProbe(
+      chunkOJHD3LXJ_cjs.asCompiledRowsSql(
+        chunkTEC24ZDA_cjs.buildForeignFulltextGraphProbe(
           tableName,
           graphId,
           FOREIGN_GRAPH_REPORT_LIMIT
@@ -783,7 +784,7 @@ function createContributionMaterializer(deps) {
   }
   async function rebuildContribution(graphId, scope, repopulate) {
     if (scope === "vector") {
-      throw new chunkMRDBBHIZ_cjs.ContributionRebuildUnsupportedError(
+      throw new chunkX4GDXBOP_cjs.ContributionRebuildUnsupportedError(
         "vector-source-unavailable",
         { graphId, contribution: scope }
       );
@@ -793,7 +794,7 @@ function createContributionMaterializer(deps) {
       (contribution) => contribution.dropDdl === void 0
     );
     if (withoutTeardown !== void 0) {
-      throw new chunkMRDBBHIZ_cjs.ContributionRebuildUnsupportedError("no-drop-ddl", {
+      throw new chunkX4GDXBOP_cjs.ContributionRebuildUnsupportedError("no-drop-ddl", {
         graphId,
         contribution: scope,
         owner: withoutTeardown.owner,
@@ -803,7 +804,7 @@ function createContributionMaterializer(deps) {
     }
     const fence = deps.schemaWriteTransaction;
     if (fence === void 0) {
-      throw new chunkMRDBBHIZ_cjs.ContributionRebuildUnsupportedError("no-schema-fence", {
+      throw new chunkX4GDXBOP_cjs.ContributionRebuildUnsupportedError("no-schema-fence", {
         graphId,
         contribution: scope,
         backend: dialect
@@ -826,7 +827,7 @@ function createContributionMaterializer(deps) {
     const rebuilt = await fence(graphId, async (tx) => {
       const record = tx.recordContributionMaterialization;
       if (record === void 0) {
-        throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+        throw new chunkX4GDXBOP_cjs.ConfigurationError(
           "rebuildContribution requires a transaction-scoped backend that can write contribution markers; without it the drop, recreate, and stamp could not commit together.",
           {
             backend: dialect,
@@ -850,7 +851,7 @@ function createContributionMaterializer(deps) {
           ) === "stale"
         );
         if (staleStamp !== void 0) {
-          throw new chunkMRDBBHIZ_cjs.ContributionRebuildUnsupportedError(
+          throw new chunkX4GDXBOP_cjs.ContributionRebuildUnsupportedError(
             "shared-storage-in-use",
             {
               graphId,
@@ -875,13 +876,13 @@ function createContributionMaterializer(deps) {
       }
       if (!recreateStorage) {
         await tx.executeStatement(
-          chunkEDN4Y4ZG_cjs.asCompiledStatementSql(
-            chunkL3LQNR34_cjs.buildFulltextGraphDelete(sharedTable, graphId)
+          chunkOJHD3LXJ_cjs.asCompiledStatementSql(
+            chunkTEC24ZDA_cjs.buildFulltextGraphDelete(sharedTable, graphId)
           )
         );
       }
       const stats = await repopulate(tx);
-      const now = chunkFA2AFWLP_cjs.nowIso();
+      const now = chunkEH3JZJUM_cjs.nowIso();
       for (const { contribution, signature } of stamps) {
         await record({
           ...identityOf(graphId, contribution),
@@ -943,7 +944,7 @@ var SQLITE_INDEX_MAT_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_INDEX_MAT_TIMESTAMPS = {
-  decode: chunkFA2AFWLP_cjs.formatPostgresTimestamp,
+  decode: chunkEH3JZJUM_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapMaterializationRow(row, decode) {
@@ -1001,7 +1002,7 @@ var SQLITE_KIND_REMOVAL_TIMESTAMPS = {
   encode: (value) => value
 };
 var POSTGRES_KIND_REMOVAL_TIMESTAMPS = {
-  decode: chunkFA2AFWLP_cjs.formatPostgresTimestamp,
+  decode: chunkEH3JZJUM_cjs.formatPostgresTimestamp,
   encode: (value) => new Date(value)
 };
 function mapKindRemovalRow(row, decode) {
@@ -1042,68 +1043,8 @@ function buildKindRemovalOnConflictSet(removedAtColumn, paramsRemovedAt) {
     lastError: drizzleOrm.sql`excluded.${drizzleOrm.sql.identifier("last_error")}`
   };
 }
-function primaryKeyConstraintNames(relation, keyColumns) {
-  return [`${relation}_pkey`, `${relation}_${keyColumns.join("_")}_pk`];
-}
-function nodePrimaryKeyConstraint(nodes) {
-  const relation = drizzleOrm.getTableName(nodes);
-  return {
-    table: relation,
-    constraintNames: primaryKeyConstraintNames(relation, [
-      nodes.graphId.name,
-      nodes.kind.name,
-      nodes.id.name
-    ])
-  };
-}
-function edgePrimaryKeyConstraint(edges) {
-  const relation = drizzleOrm.getTableName(edges);
-  return {
-    table: relation,
-    constraintNames: primaryKeyConstraintNames(relation, [
-      edges.graphId.name,
-      edges.id.name
-    ])
-  };
-}
-function sqlNull(value) {
-  return value ?? drizzleOrm.sql.raw("NULL");
-}
-function expectedValidFromPredicate(column, expected) {
-  if (expected === void 0) return drizzleOrm.sql.empty();
-  if (expected === null) return drizzleOrm.sql` AND ${column} IS NULL`;
-  return drizzleOrm.sql` AND ${column} = ${expected}`;
-}
-function quotedColumn(column) {
-  return drizzleOrm.sql.raw(`"${column.name.replaceAll('"', '""')}"`);
-}
-function quotedTableName(tableName) {
-  return drizzleOrm.sql.raw(`"${tableName.replaceAll('"', '""')}"`);
-}
-var CODE_POINT_ORDER_BUILDERS = {
-  postgres: (value) => drizzleOrm.sql`${value} COLLATE "C"`,
-  sqlite: (value) => value
-};
-function codePointOrderKey(column, dialect) {
-  return CODE_POINT_ORDER_BUILDERS[dialect](column);
-}
-function liveNodeIdsSubquery(nodes, graphId, nodeKind, nowIso2) {
-  return drizzleOrm.sql`SELECT ${nodes.id} AS node_id FROM ${nodes} WHERE ${nodes.graphId} = ${graphId} AND ${nodes.kind} = ${nodeKind} AND ${nodes.deletedAt} IS NULL AND (${nodes.validFrom} IS NULL OR ${nodes.validFrom} <= ${nowIso2}) AND (${nodes.validTo} IS NULL OR ${nodes.validTo} > ${nowIso2})`;
-}
-function nodeColumnList(nodes) {
-  return drizzleOrm.sql.raw(
-    `"${nodes.graphId.name}", "${nodes.kind.name}", "${nodes.id.name}", "${nodes.props.name}", "${nodes.version.name}", "${nodes.validFrom.name}", "${nodes.validTo.name}", "${nodes.createdAt.name}", "${nodes.updatedAt.name}"`
-  );
-}
-function edgeColumnList(edges) {
-  return drizzleOrm.sql.raw(
-    `"${edges.graphId.name}", "${edges.id.name}", "${edges.kind.name}", "${edges.fromKind.name}", "${edges.fromId.name}", "${edges.toKind.name}", "${edges.toId.name}", "${edges.props.name}", "${edges.validFrom.name}", "${edges.validTo.name}", "${edges.createdAt.name}", "${edges.updatedAt.name}"`
-  );
-}
-
-// src/backend/drizzle/operations/hybrid.ts
 function nodeIdOrderKey(dialect) {
-  return codePointOrderKey(drizzleOrm.sql.raw("node_id"), dialect);
+  return chunkEH3JZJUM_cjs.codePointOrderKey(drizzleOrm.sql.raw("node_id"), dialect);
 }
 function hybridCandidatesRef() {
   return drizzleOrm.sql`SELECT node_id FROM tg_hybrid_cand`;
@@ -1185,7 +1126,7 @@ function buildHybridSearchStatement(input) {
   `;
 }
 function qualified(nodes, member) {
-  return drizzleOrm.sql`tg_hybrid_node.${quotedColumn(nodes[member])}`;
+  return drizzleOrm.sql`tg_hybrid_node.${chunkEH3JZJUM_cjs.quotedColumn(nodes[member])}`;
 }
 function present(value) {
   return value !== null && value !== void 0;
@@ -1193,12 +1134,12 @@ function present(value) {
 function mapHybridSearchRow(row, toNodeRow) {
   return {
     node: toNodeRow(row),
-    fusedScore: chunkFA2AFWLP_cjs.coerceNumericScore(row["fused_score"]),
+    fusedScore: chunkEH3JZJUM_cjs.coerceNumericScore(row["fused_score"]),
     ...present(row["vector_rank"]) ? { vectorRank: Number(row["vector_rank"]) } : {},
-    ...present(row["vector_score"]) ? { vectorScore: chunkFA2AFWLP_cjs.coerceNumericScore(row["vector_score"]) } : {},
+    ...present(row["vector_score"]) ? { vectorScore: chunkEH3JZJUM_cjs.coerceNumericScore(row["vector_score"]) } : {},
     ...present(row["fulltext_rank"]) ? { fulltextRank: Number(row["fulltext_rank"]) } : {},
     ...present(row["fulltext_score"]) ? {
-      fulltextScore: chunkFA2AFWLP_cjs.coerceNumericScore(
+      fulltextScore: chunkEH3JZJUM_cjs.coerceNumericScore(
         row["fulltext_score"]
       )
     } : {},
@@ -1210,7 +1151,7 @@ function buildClearGraph(tables, 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: chunkL3LQNR34_cjs.buildFulltextGraphDelete(tables.fulltextTableName, graphId) },
+    { query: chunkTEC24ZDA_cjs.buildFulltextGraphDelete(tables.fulltextTableName, graphId) },
     {
       query: drizzleOrm.sql`DELETE FROM ${tables.recordedIdentityAssertions} WHERE ${tables.recordedIdentityAssertions.graphId} = ${graphId}`,
       ignoreMissingTable: true,
@@ -1249,6 +1190,17 @@ function buildClearGraph(tables, graphId) {
     {
       query: drizzleOrm.sql`DELETE FROM ${tables.uniques} WHERE ${tables.uniques.graphId} = ${graphId}`
     },
+    // Edge claims name the edges they are held by, so they are cleared
+    // BEFORE the edges — the same ordering `uniques` gets against `nodes`.
+    // Tolerates absence for the reason the recorded relations do: bootstrap DDL
+    // runs only on first boot, so a database initialized before this relation
+    // existed has no such table, and clearing a graph must not become the
+    // operation that fails on it.
+    {
+      query: drizzleOrm.sql`DELETE FROM ${tables.edgeClaims} WHERE ${tables.edgeClaims.graphId} = ${graphId}`,
+      ignoreMissingTable: true,
+      requiredTableName: drizzleOrm.getTableName(tables.edgeClaims)
+    },
     {
       query: drizzleOrm.sql`DELETE FROM ${tables.edges} WHERE ${tables.edges.graphId} = ${graphId}`
     },
@@ -1509,16 +1461,95 @@ function buildCountEdgesByKind(tables, params) {
     WHERE ${whereClause}
   `;
 }
+var PEER = "peer";
+function qualified2(relation, column) {
+  return drizzleOrm.sql.raw(`"${relation}"."${column.name}"`);
+}
+function inList(values) {
+  return drizzleOrm.sql.join(
+    values.map((value) => drizzleOrm.sql`${value}`),
+    drizzleOrm.sql`, `
+  );
+}
+function buildContendedUniqueRowAudit(tables, graphId, constraintNames) {
+  const { uniques } = tables;
+  const relation = drizzleOrm.getTableName(uniques);
+  return drizzleOrm.sql`
+    SELECT
+      ${chunkEH3JZJUM_cjs.quotedColumn(uniques.nodeKind)} as node_kind,
+      ${chunkEH3JZJUM_cjs.quotedColumn(uniques.constraintName)} as constraint_name,
+      ${chunkEH3JZJUM_cjs.quotedColumn(uniques.key)} as key,
+      ${chunkEH3JZJUM_cjs.quotedColumn(uniques.concreteKind)} as concrete_kind,
+      ${chunkEH3JZJUM_cjs.quotedColumn(uniques.nodeId)} as node_id
+    FROM ${uniques}
+    WHERE ${qualified2(relation, uniques.graphId)} = ${graphId}
+      AND ${qualified2(relation, uniques.constraintName)} IN (${inList(constraintNames)})
+      AND ${qualified2(relation, uniques.deletedAt)} IS NULL
+      AND EXISTS (
+        SELECT 1 FROM ${uniques} AS ${drizzleOrm.sql.raw(`"${PEER}"`)}
+        WHERE ${qualified2(PEER, uniques.graphId)} = ${qualified2(relation, uniques.graphId)}
+          AND ${qualified2(PEER, uniques.constraintName)} = ${qualified2(relation, uniques.constraintName)}
+          AND ${qualified2(PEER, uniques.key)} = ${qualified2(relation, uniques.key)}
+          AND ${qualified2(PEER, uniques.deletedAt)} IS NULL
+          AND ${qualified2(PEER, uniques.nodeKind)} <> ${qualified2(relation, uniques.nodeKind)}
+      )
+  `;
+}
+function buildContendedEdgeRowAudit(tables, graphId, cardinality, edgeKinds) {
+  const { edges } = tables;
+  const relation = drizzleOrm.getTableName(edges);
+  const spec = chunk7PRMDZIA_cjs.EDGE_CARDINALITY_SPECS[cardinality];
+  const activeOnly = spec.holderLiveness === "liveAndActive" ? drizzleOrm.sql` AND ${qualified2(relation, edges.validTo)} IS NULL` : drizzleOrm.sql.empty();
+  const peerActiveOnly = spec.holderLiveness === "liveAndActive" ? drizzleOrm.sql` AND ${qualified2(PEER, edges.validTo)} IS NULL` : drizzleOrm.sql.empty();
+  const peerToEndpoints = spec.keyShape === "fromAndTo" ? drizzleOrm.sql`
+        AND ${qualified2(PEER, edges.toKind)} = ${qualified2(relation, edges.toKind)}
+                  AND ${qualified2(PEER, edges.toId)} = ${qualified2(relation, edges.toId)}
+      ` : drizzleOrm.sql.empty();
+  return drizzleOrm.sql`
+    SELECT
+      ${chunkEH3JZJUM_cjs.quotedColumn(edges.id)} as edge_id,
+      ${chunkEH3JZJUM_cjs.quotedColumn(edges.kind)} as edge_kind,
+      ${chunkEH3JZJUM_cjs.quotedColumn(edges.fromKind)} as from_kind,
+      ${chunkEH3JZJUM_cjs.quotedColumn(edges.fromId)} as from_id,
+      ${chunkEH3JZJUM_cjs.quotedColumn(edges.toKind)} as to_kind,
+      ${chunkEH3JZJUM_cjs.quotedColumn(edges.toId)} as to_id
+    FROM ${edges}
+    WHERE ${qualified2(relation, edges.graphId)} = ${graphId}
+      AND ${qualified2(relation, edges.kind)} IN (${inList(edgeKinds)})
+      AND ${qualified2(relation, edges.deletedAt)} IS NULL${activeOnly}
+      AND EXISTS (
+        SELECT 1 FROM ${edges} AS ${drizzleOrm.sql.raw(`"${PEER}"`)}
+        WHERE ${qualified2(PEER, edges.graphId)} = ${qualified2(relation, edges.graphId)}
+          AND ${qualified2(PEER, edges.kind)} = ${qualified2(relation, edges.kind)}
+          AND ${qualified2(PEER, edges.fromKind)} = ${qualified2(relation, edges.fromKind)}
+          AND ${qualified2(PEER, edges.fromId)} = ${qualified2(relation, edges.fromId)}${peerToEndpoints}
+          AND ${qualified2(PEER, edges.deletedAt)} IS NULL${peerActiveOnly}
+          AND ${qualified2(PEER, edges.id)} <> ${qualified2(relation, edges.id)}
+      )
+  `;
+}
+function buildDisjointOverlapAudit(tables, graphId, kinds) {
+  const { nodes } = tables;
+  const relation = drizzleOrm.getTableName(nodes);
+  const liveIdsOfKind = (kind) => drizzleOrm.sql`
+    SELECT ${chunkEH3JZJUM_cjs.quotedColumn(nodes.id)} as node_id
+    FROM ${nodes}
+    WHERE ${qualified2(relation, nodes.graphId)} = ${graphId}
+      AND ${qualified2(relation, nodes.kind)} = ${kind}
+      AND ${qualified2(relation, nodes.deletedAt)} IS NULL
+  `;
+  return drizzleOrm.sql`${liveIdsOfKind(kinds[0])} INTERSECT ${liveIdsOfKind(kinds[1])}`;
+}
 function buildInsertEdge(tables, params, timestamp) {
   const { edges } = tables;
   const propsJson = JSON.stringify(params.props);
-  const columns = edgeColumnList(edges);
+  const columns = chunkEH3JZJUM_cjs.edgeColumnList(edges);
   return drizzleOrm.sql`
     INSERT INTO ${edges} (${columns})
     VALUES (
       ${params.graphId}, ${params.id}, ${params.kind},
       ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
-      ${propsJson}, ${sqlNull(chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}, ${sqlNull(params.validTo)},
+      ${propsJson}, ${chunkEH3JZJUM_cjs.sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}, ${chunkEH3JZJUM_cjs.sqlNull(params.validTo)},
       ${timestamp}, ${timestamp}
     )
     RETURNING *
@@ -1527,23 +1558,23 @@ function buildInsertEdge(tables, params, timestamp) {
 function buildInsertEdgeNoReturn(tables, params, timestamp) {
   const { edges } = tables;
   const propsJson = JSON.stringify(params.props);
-  const columns = edgeColumnList(edges);
+  const columns = chunkEH3JZJUM_cjs.edgeColumnList(edges);
   return drizzleOrm.sql`
     INSERT INTO ${edges} (${columns})
     VALUES (
       ${params.graphId}, ${params.id}, ${params.kind},
       ${params.fromKind}, ${params.fromId}, ${params.toKind}, ${params.toId},
-      ${propsJson}, ${sqlNull(chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}, ${sqlNull(params.validTo)},
+      ${propsJson}, ${chunkEH3JZJUM_cjs.sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}, ${chunkEH3JZJUM_cjs.sqlNull(params.validTo)},
       ${timestamp}, ${timestamp}
     )
   `;
 }
 function buildInsertEdgesBatch(tables, params, timestamp) {
   const { edges } = tables;
-  const columns = edgeColumnList(edges);
+  const columns = chunkEH3JZJUM_cjs.edgeColumnList(edges);
   const values = params.map((edgeParams) => {
     const propsJson = JSON.stringify(edgeParams.props);
-    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(edgeParams.validFrom, edgeParams.validTo, timestamp))}, ${sqlNull(edgeParams.validTo)}, ${timestamp}, ${timestamp})`;
+    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${chunkEH3JZJUM_cjs.sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(edgeParams.validFrom, edgeParams.validTo, timestamp))}, ${chunkEH3JZJUM_cjs.sqlNull(edgeParams.validTo)}, ${timestamp}, ${timestamp})`;
   });
   return drizzleOrm.sql`
     INSERT INTO ${edges} (${columns})
@@ -1552,10 +1583,10 @@ function buildInsertEdgesBatch(tables, params, timestamp) {
 }
 function buildInsertEdgesBatchReturning(tables, params, timestamp) {
   const { edges } = tables;
-  const columns = edgeColumnList(edges);
+  const columns = chunkEH3JZJUM_cjs.edgeColumnList(edges);
   const values = params.map((edgeParams) => {
     const propsJson = JSON.stringify(edgeParams.props);
-    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${sqlNull(chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(edgeParams.validFrom, edgeParams.validTo, timestamp))}, ${sqlNull(edgeParams.validTo)}, ${timestamp}, ${timestamp})`;
+    return drizzleOrm.sql`(${edgeParams.graphId}, ${edgeParams.id}, ${edgeParams.kind}, ${edgeParams.fromKind}, ${edgeParams.fromId}, ${edgeParams.toKind}, ${edgeParams.toId}, ${propsJson}, ${chunkEH3JZJUM_cjs.sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(edgeParams.validFrom, edgeParams.validTo, timestamp))}, ${chunkEH3JZJUM_cjs.sqlNull(edgeParams.validTo)}, ${timestamp}, ${timestamp})`;
   });
   return drizzleOrm.sql`
     INSERT INTO ${edges} (${columns})
@@ -1597,29 +1628,29 @@ function buildUpdateEdge(tables, params, timestamp) {
   const { edges } = tables;
   const propsJson = JSON.stringify(params.props);
   const setParts = [
-    drizzleOrm.sql`${quotedColumn(edges.props)} = ${propsJson}`,
-    drizzleOrm.sql`${quotedColumn(edges.updatedAt)} = ${timestamp}`
+    drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(edges.props)} = ${propsJson}`,
+    drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(edges.updatedAt)} = ${timestamp}`
   ];
   if (params.clearDeleted && params.validFrom !== void 0) {
     setParts.push(
-      drizzleOrm.sql`${quotedColumn(edges.validFrom)} = ${sqlNull(chunkTQHGE7UC_cjs.resolveStatedValidityLowerBound(params.validFrom))}`,
-      drizzleOrm.sql`${quotedColumn(edges.validTo)} = ${sqlNull(params.validTo)}`
+      drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(edges.validFrom)} = ${chunkEH3JZJUM_cjs.sqlNull(chunkM5MSP3BI_cjs.resolveStatedValidityLowerBound(params.validFrom))}`,
+      drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(edges.validTo)} = ${chunkEH3JZJUM_cjs.sqlNull(params.validTo)}`
     );
   } else if (params.clearValidTo === true) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(edges.validTo)} = NULL`);
+    setParts.push(drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(edges.validTo)} = NULL`);
   } else if (params.validTo !== void 0) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(edges.validTo)} = ${params.validTo}`);
+    setParts.push(drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(edges.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(edges.deletedAt)} = NULL`);
+    setParts.push(drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(edges.deletedAt)} = NULL`);
   }
   const setClause = drizzleOrm.sql.join(setParts, drizzleOrm.sql`, `);
   const expectedIdentity = expectedIdentityPredicate(tables, params);
-  const expectedValidFrom = expectedValidFromPredicate(
+  const expectedValidFrom = chunkEH3JZJUM_cjs.expectedValidFromPredicate(
     edges.validFrom,
     params.expectedValidFrom
   );
-  const expectedValidTo = expectedValidFromPredicate(
+  const expectedValidTo = chunkEH3JZJUM_cjs.expectedValidFromPredicate(
     edges.validTo,
     params.expectedValidTo
   );
@@ -1645,7 +1676,7 @@ function buildDeleteEdge(tables, params, timestamp) {
   const { edges } = tables;
   return drizzleOrm.sql`
     UPDATE ${edges}
-    SET ${quotedColumn(edges.deletedAt)} = ${timestamp}
+    SET ${chunkEH3JZJUM_cjs.quotedColumn(edges.deletedAt)} = ${timestamp}
     WHERE ${edges.graphId} = ${params.graphId}
       AND ${edges.id} = ${params.id}${expectedIdentityPredicate(tables, params.kind === void 0 ? {} : { kind: params.kind })}
       AND ${edges.deletedAt} IS NULL
@@ -1655,7 +1686,7 @@ function buildDeleteEdgesBatch(tables, params, timestamp) {
   const { edges } = tables;
   return drizzleOrm.sql`
     UPDATE ${edges}
-    SET ${quotedColumn(edges.deletedAt)} = ${timestamp}
+    SET ${chunkEH3JZJUM_cjs.quotedColumn(edges.deletedAt)} = ${timestamp}
     WHERE ${edges.graphId} = ${params.graphId}
       AND ${edges.id} IN (${drizzleOrm.sql.join(
     params.ids.map((id) => drizzleOrm.sql`${id}`),
@@ -1756,12 +1787,12 @@ function resolveMode(mode) {
 function buildFulltextSearch(tableName, params, strategy, dialect, candidates) {
   assertValidSearchParams(params);
   const mode = resolveMode(params.mode);
-  const table = quotedTableName(tableName);
-  const matchCondition = chunkWODMN3Q2_cjs.toDrizzleSql(
+  const table = chunkEH3JZJUM_cjs.quotedTableName(tableName);
+  const matchCondition = chunk45YZXI6X_cjs.toDrizzleSql(
     strategy.matchCondition(tableName, params.query, mode, params.language),
     dialect
   );
-  const rankExpression = chunkWODMN3Q2_cjs.toDrizzleSql(
+  const rankExpression = chunk45YZXI6X_cjs.toDrizzleSql(
     strategy.rankExpression(tableName, params.query, mode, params.language),
     dialect
   );
@@ -1774,10 +1805,10 @@ function buildFulltextSearch(tableName, params, strategy, dialect, candidates) {
     conditions.push(drizzleOrm.sql`${rankExpression} >= ${params.minScore}`);
   }
   if (candidates !== void 0) {
-    const candidateSql = chunkEDN4Y4ZG_cjs.isSqlFragment(candidates) ? chunkWODMN3Q2_cjs.toDrizzleSql(candidates, dialect) : candidates;
+    const candidateSql = chunkOJHD3LXJ_cjs.isSqlFragment(candidates) ? chunk45YZXI6X_cjs.toDrizzleSql(candidates, dialect) : candidates;
     conditions.push(drizzleOrm.sql`"node_id" IN (${candidateSql})`);
   }
-  const snippetExpr = params.includeSnippets === true && strategy.supportsSnippets ? chunkWODMN3Q2_cjs.toDrizzleSql(
+  const snippetExpr = params.includeSnippets === true && strategy.supportsSnippets ? chunk45YZXI6X_cjs.toDrizzleSql(
     strategy.snippetExpression(
       tableName,
       params.query,
@@ -1794,7 +1825,7 @@ function buildFulltextSearch(tableName, params, strategy, dialect, candidates) {
       ${snippetExpr} AS snippet
     FROM ${table}
     WHERE ${drizzleOrm.sql.join(conditions, drizzleOrm.sql` AND `)}
-    ORDER BY ${rankExpression} DESC, ${codePointOrderKey(drizzleOrm.sql.raw('"node_id"'), dialect)} ASC
+    ORDER BY ${rankExpression} DESC, ${chunkEH3JZJUM_cjs.codePointOrderKey(drizzleOrm.sql.raw('"node_id"'), dialect)} ASC
     ${pageClause}
   `;
 }
@@ -1811,12 +1842,12 @@ function assertValidSearchParams(params) {
 function buildInsertNode(tables, params, timestamp) {
   const { nodes } = tables;
   const propsJson = JSON.stringify(params.props);
-  const columns = nodeColumnList(nodes);
+  const columns = chunkEH3JZJUM_cjs.nodeColumnList(nodes);
   return drizzleOrm.sql`
     INSERT INTO ${nodes} (${columns})
     VALUES (
       ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${sqlNull(chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}, ${sqlNull(params.validTo)},
+      1, ${chunkEH3JZJUM_cjs.sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}, ${chunkEH3JZJUM_cjs.sqlNull(params.validTo)},
       ${timestamp}, ${timestamp}
     )
     RETURNING *
@@ -1825,22 +1856,22 @@ function buildInsertNode(tables, params, timestamp) {
 function buildInsertNodeNoReturn(tables, params, timestamp) {
   const { nodes } = tables;
   const propsJson = JSON.stringify(params.props);
-  const columns = nodeColumnList(nodes);
+  const columns = chunkEH3JZJUM_cjs.nodeColumnList(nodes);
   return drizzleOrm.sql`
     INSERT INTO ${nodes} (${columns})
     VALUES (
       ${params.graphId}, ${params.kind}, ${params.id}, ${propsJson},
-      1, ${sqlNull(chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}, ${sqlNull(params.validTo)},
+      1, ${chunkEH3JZJUM_cjs.sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}, ${chunkEH3JZJUM_cjs.sqlNull(params.validTo)},
       ${timestamp}, ${timestamp}
     )
   `;
 }
 function buildInsertNodesBatch(tables, params, timestamp) {
   const { nodes } = tables;
-  const columns = nodeColumnList(nodes);
+  const columns = chunkEH3JZJUM_cjs.nodeColumnList(nodes);
   const values = params.map((nodeParams) => {
     const propsJson = JSON.stringify(nodeParams.props);
-    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(nodeParams.validFrom, nodeParams.validTo, timestamp))}, ${sqlNull(nodeParams.validTo)}, ${timestamp}, ${timestamp})`;
+    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${chunkEH3JZJUM_cjs.sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(nodeParams.validFrom, nodeParams.validTo, timestamp))}, ${chunkEH3JZJUM_cjs.sqlNull(nodeParams.validTo)}, ${timestamp}, ${timestamp})`;
   });
   return drizzleOrm.sql`
     INSERT INTO ${nodes} (${columns})
@@ -1849,10 +1880,10 @@ function buildInsertNodesBatch(tables, params, timestamp) {
 }
 function buildInsertNodesBatchReturning(tables, params, timestamp) {
   const { nodes } = tables;
-  const columns = nodeColumnList(nodes);
+  const columns = chunkEH3JZJUM_cjs.nodeColumnList(nodes);
   const values = params.map((nodeParams) => {
     const propsJson = JSON.stringify(nodeParams.props);
-    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${sqlNull(chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(nodeParams.validFrom, nodeParams.validTo, timestamp))}, ${sqlNull(nodeParams.validTo)}, ${timestamp}, ${timestamp})`;
+    return drizzleOrm.sql`(${nodeParams.graphId}, ${nodeParams.kind}, ${nodeParams.id}, ${propsJson}, 1, ${chunkEH3JZJUM_cjs.sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(nodeParams.validFrom, nodeParams.validTo, timestamp))}, ${chunkEH3JZJUM_cjs.sqlNull(nodeParams.validTo)}, ${timestamp}, ${timestamp})`;
   });
   return drizzleOrm.sql`
     INSERT INTO ${nodes} (${columns})
@@ -1885,29 +1916,29 @@ function buildUpdateNode(tables, params, timestamp) {
   const { nodes } = tables;
   const propsJson = JSON.stringify(params.props);
   const setParts = [
-    drizzleOrm.sql`${quotedColumn(nodes.props)} = ${propsJson}`,
-    drizzleOrm.sql`${quotedColumn(nodes.updatedAt)} = ${timestamp}`
+    drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(nodes.props)} = ${propsJson}`,
+    drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(nodes.updatedAt)} = ${timestamp}`
   ];
   if (params.incrementVersion) {
     setParts.push(
-      drizzleOrm.sql`${quotedColumn(nodes.version)} = ${quotedColumn(nodes.version)} + 1`
+      drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(nodes.version)} = ${chunkEH3JZJUM_cjs.quotedColumn(nodes.version)} + 1`
     );
   }
   if (params.clearDeleted) {
     setParts.push(
-      drizzleOrm.sql`${quotedColumn(nodes.validFrom)} = ${sqlNull(chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}`,
-      drizzleOrm.sql`${quotedColumn(nodes.validTo)} = ${sqlNull(params.validTo)}`
+      drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(nodes.validFrom)} = ${chunkEH3JZJUM_cjs.sqlNull(chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(params.validFrom, params.validTo, timestamp))}`,
+      drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(nodes.validTo)} = ${chunkEH3JZJUM_cjs.sqlNull(params.validTo)}`
     );
   } else if (params.clearValidTo === true) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(nodes.validTo)} = NULL`);
+    setParts.push(drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(nodes.validTo)} = NULL`);
   } else if (params.validTo !== void 0) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(nodes.validTo)} = ${params.validTo}`);
+    setParts.push(drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(nodes.validTo)} = ${params.validTo}`);
   }
   if (params.clearDeleted) {
-    setParts.push(drizzleOrm.sql`${quotedColumn(nodes.deletedAt)} = NULL`);
+    setParts.push(drizzleOrm.sql`${chunkEH3JZJUM_cjs.quotedColumn(nodes.deletedAt)} = NULL`);
   }
   const setClause = drizzleOrm.sql.join(setParts, drizzleOrm.sql`, `);
-  const expectedValidFrom = expectedValidFromPredicate(
+  const expectedValidFrom = chunkEH3JZJUM_cjs.expectedValidFromPredicate(
     nodes.validFrom,
     params.expectedValidFrom
   );
@@ -1934,25 +1965,25 @@ function buildUpdateNode(tables, params, timestamp) {
 }
 function buildUpdateNodeSet(tables, dialect, params, timestamp) {
   const { nodes } = tables;
-  const adapter = chunkL3LQNR34_cjs.getDialect(dialect);
-  const patchedProps = chunkWODMN3Q2_cjs.toDrizzleSql(
+  const adapter = chunkTEC24ZDA_cjs.getDialect(dialect);
+  const patchedProps = chunk45YZXI6X_cjs.toDrizzleSql(
     adapter.jsonSetProperties(
-      chunkEDN4Y4ZG_cjs.sql.identifier(nodes.props.name),
+      chunkOJHD3LXJ_cjs.sql.identifier(nodes.props.name),
       params.patch,
       params.unsetProperties ?? []
     ),
     dialect
   );
-  const candidateIds = chunkWODMN3Q2_cjs.toDrizzleSql(params.candidateIds, dialect);
-  const candidateIdColumn = chunkWODMN3Q2_cjs.toDrizzleSql(
-    chunkEDN4Y4ZG_cjs.sql.identifier(params.candidateIdColumn),
+  const candidateIds = chunk45YZXI6X_cjs.toDrizzleSql(params.candidateIds, dialect);
+  const candidateIdColumn = chunk45YZXI6X_cjs.toDrizzleSql(
+    chunkOJHD3LXJ_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
+    SET ${chunkEH3JZJUM_cjs.quotedColumn(nodes.props)} = ${patchedProps},
+        ${chunkEH3JZJUM_cjs.quotedColumn(nodes.updatedAt)} = ${timestamp},
+        ${chunkEH3JZJUM_cjs.quotedColumn(nodes.version)} = ${chunkEH3JZJUM_cjs.quotedColumn(nodes.version)} + 1
     WHERE ${nodes.graphId} = ${params.graphId}
       AND ${nodes.kind} = ${params.kind}
       AND ${nodes.deletedAt} IS NULL
@@ -1967,7 +1998,7 @@ function buildDeleteNode(tables, params, timestamp) {
   const { nodes } = tables;
   return drizzleOrm.sql`
     UPDATE ${nodes}
-    SET ${quotedColumn(nodes.deletedAt)} = ${timestamp}
+    SET ${chunkEH3JZJUM_cjs.quotedColumn(nodes.deletedAt)} = ${timestamp}
     WHERE ${nodes.graphId} = ${params.graphId}
       AND ${nodes.kind} = ${params.kind}
       AND ${nodes.id} = ${params.id}
@@ -2041,226 +2072,17 @@ function buildSetActiveSchema(tables, graphId, version, dialect = "sqlite") {
   const strategy = SCHEMA_DIALECT_STRATEGIES[dialect];
   const deactivateAll = drizzleOrm.sql`
     UPDATE ${schemaVersions}
-    SET ${quotedColumn(schemaVersions.isActive)} = ${strategy.booleanLiteral(false)}
+    SET ${chunkEH3JZJUM_cjs.quotedColumn(schemaVersions.isActive)} = ${strategy.booleanLiteral(false)}
     WHERE ${schemaVersions.graphId} = ${graphId}
   `;
   const activateVersion = drizzleOrm.sql`
     UPDATE ${schemaVersions}
-    SET ${quotedColumn(schemaVersions.isActive)} = ${strategy.booleanLiteral(true)}
+    SET ${chunkEH3JZJUM_cjs.quotedColumn(schemaVersions.isActive)} = ${strategy.booleanLiteral(true)}
     WHERE ${schemaVersions.graphId} = ${graphId}
       AND ${schemaVersions.version} = ${version}
   `;
   return { deactivateAll, activateVersion };
 }
-function buildInsertUniqueSqlite(tables, params) {
-  const { uniques } = tables;
-  const columns = drizzleOrm.sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}", "${uniques.nodeId.name}", "${uniques.concreteKind.name}", "${uniques.deletedAt.name}"`
-  );
-  const conflictColumns = drizzleOrm.sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`
-  );
-  return drizzleOrm.sql`
-    INSERT INTO ${uniques} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
-      ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${drizzleOrm.sql.raw("NULL")}
-    )
-    ON CONFLICT (${conflictColumns})
-    DO UPDATE SET
-      ${quotedColumn(uniques.nodeId)} = CASE
-        WHEN ${quotedColumn(uniques.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
-        WHEN ${quotedColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.nodeId}
-        ELSE ${quotedColumn(uniques.nodeId)}
-      END,
-      ${quotedColumn(uniques.concreteKind)} = CASE
-        WHEN ${quotedColumn(uniques.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
-        WHEN ${quotedColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
-        ELSE ${quotedColumn(uniques.concreteKind)}
-      END,
-      ${quotedColumn(uniques.deletedAt)} = CASE
-        WHEN ${quotedColumn(uniques.nodeId)} = ${params.nodeId} THEN NULL
-        WHEN ${quotedColumn(uniques.deletedAt)} IS NOT NULL THEN NULL
-        ELSE ${quotedColumn(uniques.deletedAt)}
-      END
-    RETURNING ${quotedColumn(uniques.nodeId)} as node_id
-  `;
-}
-function buildInsertUniquePostgres(tables, params) {
-  const { uniques } = tables;
-  const columns = drizzleOrm.sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}", "${uniques.nodeId.name}", "${uniques.concreteKind.name}", "${uniques.deletedAt.name}"`
-  );
-  const conflictColumns = drizzleOrm.sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`
-  );
-  const tableName = drizzleOrm.getTableName(uniques);
-  const existingColumn = (column) => drizzleOrm.sql.raw(`"${tableName}"."${column.name}"`);
-  return drizzleOrm.sql`
-    INSERT INTO ${uniques} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
-      ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${drizzleOrm.sql.raw("NULL")}
-    )
-    ON CONFLICT (${conflictColumns})
-    DO UPDATE SET
-      ${quotedColumn(uniques.nodeId)} = CASE
-        WHEN ${existingColumn(uniques.nodeId)} = ${params.nodeId} THEN ${params.nodeId}
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.nodeId}
-        ELSE ${existingColumn(uniques.nodeId)}
-      END,
-      ${quotedColumn(uniques.concreteKind)} = CASE
-        WHEN ${existingColumn(uniques.nodeId)} = ${params.nodeId} THEN ${params.concreteKind}
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${params.concreteKind}
-        ELSE ${existingColumn(uniques.concreteKind)}
-      END,
-      ${quotedColumn(uniques.deletedAt)} = CASE
-        WHEN ${existingColumn(uniques.nodeId)} = ${params.nodeId} THEN NULL
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN NULL
-        ELSE ${existingColumn(uniques.deletedAt)}
-      END
-    RETURNING ${quotedColumn(uniques.nodeId)} as node_id
-  `;
-}
-var UNIQUE_INSERT_BUILDERS = {
-  postgres: buildInsertUniquePostgres,
-  sqlite: buildInsertUniqueSqlite
-};
-function buildInsertUnique(tables, dialect, params) {
-  const builder = UNIQUE_INSERT_BUILDERS[dialect];
-  return builder(tables, params);
-}
-function buildInsertUniqueBatch(tables, dialect, entries) {
-  const { uniques } = tables;
-  const columns = drizzleOrm.sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}", "${uniques.nodeId.name}", "${uniques.concreteKind.name}", "${uniques.deletedAt.name}"`
-  );
-  const conflictColumns = drizzleOrm.sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`
-  );
-  const tableName = drizzleOrm.getTableName(uniques);
-  const existingColumn = (column) => {
-    switch (dialect) {
-      case "postgres": {
-        return drizzleOrm.sql.raw(`"${tableName}"."${column.name}"`);
-      }
-      case "sqlite": {
-        return drizzleOrm.sql.raw(`"${column.name}"`);
-      }
-      default: {
-        return dialect;
-      }
-    }
-  };
-  const excludedColumn = (column) => drizzleOrm.sql.raw(`excluded."${column.name}"`);
-  const valueRows = drizzleOrm.sql.join(
-    entries.map(
-      (params) => drizzleOrm.sql`(${params.graphId}, ${params.nodeKind}, ${params.constraintName}, ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${drizzleOrm.sql.raw("NULL")})`
-    ),
-    drizzleOrm.sql`, `
-  );
-  return drizzleOrm.sql`
-    INSERT INTO ${uniques} (${columns})
-    VALUES ${valueRows}
-    ON CONFLICT (${conflictColumns})
-    DO UPDATE SET
-      ${quotedColumn(uniques.nodeId)} = CASE
-        WHEN ${existingColumn(uniques.nodeId)} = ${excludedColumn(uniques.nodeId)} THEN ${excludedColumn(uniques.nodeId)}
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${excludedColumn(uniques.nodeId)}
-        ELSE ${existingColumn(uniques.nodeId)}
-      END,
-      ${quotedColumn(uniques.concreteKind)} = CASE
-        WHEN ${existingColumn(uniques.nodeId)} = ${excludedColumn(uniques.nodeId)} THEN ${excludedColumn(uniques.concreteKind)}
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN ${excludedColumn(uniques.concreteKind)}
-        ELSE ${existingColumn(uniques.concreteKind)}
-      END,
-      ${quotedColumn(uniques.deletedAt)} = CASE
-        WHEN ${existingColumn(uniques.nodeId)} = ${excludedColumn(uniques.nodeId)} THEN NULL
-        WHEN ${existingColumn(uniques.deletedAt)} IS NOT NULL THEN NULL
-        ELSE ${existingColumn(uniques.deletedAt)}
-      END
-    RETURNING
-      ${quotedColumn(uniques.nodeKind)} as node_kind,
-      ${quotedColumn(uniques.constraintName)} as constraint_name,
-      ${quotedColumn(uniques.key)} as key,
-      ${quotedColumn(uniques.nodeId)} as node_id
-  `;
-}
-function buildDeleteUnique(tables, params, timestamp) {
-  const { uniques } = tables;
-  return drizzleOrm.sql`
-    UPDATE ${uniques}
-    SET ${quotedColumn(uniques.deletedAt)} = ${timestamp}
-    WHERE ${uniques.graphId} = ${params.graphId}
-      AND ${uniques.nodeKind} = ${params.nodeKind}
-      AND ${uniques.constraintName} = ${params.constraintName}
-      AND ${uniques.key} = ${params.key}
-      AND ${uniques.deletedAt} IS NULL
-  `;
-}
-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} = ${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) {
-  const { uniques } = tables;
-  if (params.includeDeleted) {
-    return drizzleOrm.sql`
-      SELECT * FROM ${uniques}
-      WHERE ${uniques.graphId} = ${params.graphId}
-        AND ${uniques.nodeKind} = ${params.nodeKind}
-        AND ${uniques.constraintName} = ${params.constraintName}
-        AND ${uniques.key} = ${params.key}
-    `;
-  }
-  return drizzleOrm.sql`
-    SELECT * FROM ${uniques}
-    WHERE ${uniques.graphId} = ${params.graphId}
-      AND ${uniques.nodeKind} = ${params.nodeKind}
-      AND ${uniques.constraintName} = ${params.constraintName}
-      AND ${uniques.key} = ${params.key}
-      AND ${uniques.deletedAt} IS NULL
-  `;
-}
-function buildCheckUniqueBatch(tables, params) {
-  const { uniques } = tables;
-  const keyPlaceholders = drizzleOrm.sql.join(
-    params.keys.map((key) => drizzleOrm.sql`${key}`),
-    drizzleOrm.sql`, `
-  );
-  if (params.includeDeleted) {
-    return drizzleOrm.sql`
-      SELECT * FROM ${uniques}
-      WHERE ${uniques.graphId} = ${params.graphId}
-        AND ${uniques.nodeKind} = ${params.nodeKind}
-        AND ${uniques.constraintName} = ${params.constraintName}
-        AND ${uniques.key} IN (${keyPlaceholders})
-    `;
-  }
-  return drizzleOrm.sql`
-    SELECT * FROM ${uniques}
-    WHERE ${uniques.graphId} = ${params.graphId}
-      AND ${uniques.nodeKind} = ${params.nodeKind}
-      AND ${uniques.constraintName} = ${params.constraintName}
-      AND ${uniques.key} IN (${keyPlaceholders})
-      AND ${uniques.deletedAt} IS NULL
-  `;
-}
 
 // src/backend/drizzle/operations/strategy.ts
 function nullableText(value) {
@@ -2308,11 +2130,11 @@ var COMMON_TABLE_OPERATION_BUILDERS = {
   buildFindEdgesByEndpointSet,
   buildFindEdgesByHeterogeneousEndpointSet,
   buildCountEdgesByKind,
-  buildDeleteUnique,
-  buildHardDeleteUniquesByNode,
-  buildHardDeleteUniquesByNodeIds,
-  buildCheckUnique,
-  buildCheckUniqueBatch,
+  buildDeleteUnique: chunkEH3JZJUM_cjs.buildDeleteUnique,
+  buildHardDeleteUniquesByNode: chunkEH3JZJUM_cjs.buildHardDeleteUniquesByNode,
+  buildHardDeleteUniquesByNodeIds: chunkEH3JZJUM_cjs.buildHardDeleteUniquesByNodeIds,
+  buildCheckUnique: chunkEH3JZJUM_cjs.buildCheckUnique,
+  buildCheckUniqueBatch: chunkEH3JZJUM_cjs.buildCheckUniqueBatch,
   buildGetSchemaVersion
 };
 function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
@@ -2323,15 +2145,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) => chunkWODMN3Q2_cjs.toDrizzleSql(statement, dialect)),
-    buildDeleteFulltext: (params) => fulltextStrategy.buildDelete(fulltextTable, params).map((statement) => chunkWODMN3Q2_cjs.toDrizzleSql(statement, dialect)),
+    buildUpsertFulltext: (params, timestamp) => fulltextStrategy.buildUpsert(fulltextTable, params, timestamp).map((statement) => chunk45YZXI6X_cjs.toDrizzleSql(statement, dialect)),
+    buildDeleteFulltext: (params) => fulltextStrategy.buildDelete(fulltextTable, params).map((statement) => chunk45YZXI6X_cjs.toDrizzleSql(statement, dialect)),
     buildDeleteFulltextByNode: (graphId, nodeKind, nodeId) => fulltextStrategy.buildDelete(fulltextTable, {
       graphId,
       nodeKind,
       nodeId
-    }).map((statement) => chunkWODMN3Q2_cjs.toDrizzleSql(statement, dialect)),
-    buildUpsertFulltextBatch: (params, timestamp) => fulltextStrategy.buildBatchUpsert(fulltextTable, params, timestamp).map((statement) => chunkWODMN3Q2_cjs.toDrizzleSql(statement, dialect)),
-    buildDeleteFulltextBatch: (params) => fulltextStrategy.buildBatchDelete(fulltextTable, params).map((statement) => chunkWODMN3Q2_cjs.toDrizzleSql(statement, dialect)),
+    }).map((statement) => chunk45YZXI6X_cjs.toDrizzleSql(statement, dialect)),
+    buildUpsertFulltextBatch: (params, timestamp) => fulltextStrategy.buildBatchUpsert(fulltextTable, params, timestamp).map((statement) => chunk45YZXI6X_cjs.toDrizzleSql(statement, dialect)),
+    buildDeleteFulltextBatch: (params) => fulltextStrategy.buildBatchDelete(fulltextTable, params).map((statement) => chunk45YZXI6X_cjs.toDrizzleSql(statement, dialect)),
     buildFulltextSearch: (params) => buildFulltextSearch(
       fulltextTable,
       params,
@@ -2339,19 +2161,19 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
       dialect,
       // Store-compiled candidates (predicates + subclass + currency)
       // take precedence; the live-node default covers direct backend use.
-      params.candidates ?? liveNodeIdsSubquery(
+      params.candidates ?? chunkEH3JZJUM_cjs.liveNodeIdsSubquery(
         tables.nodes,
         params.graphId,
         params.nodeKind,
-        chunkFA2AFWLP_cjs.nowIso()
+        chunkEH3JZJUM_cjs.nowIso()
       )
     ),
     buildHybridSearch: (params, vectorSql, vectorScoreDescending) => {
-      const candidates = params.candidates ?? liveNodeIdsSubquery(
+      const candidates = params.candidates ?? chunkEH3JZJUM_cjs.liveNodeIdsSubquery(
         tables.nodes,
         params.graphId,
         params.nodeKind,
-        chunkFA2AFWLP_cjs.nowIso()
+        chunkEH3JZJUM_cjs.nowIso()
       );
       const fulltextSql = buildFulltextSearch(
         fulltextTable,
@@ -2372,7 +2194,7 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
         hybridCandidatesRef()
       );
       return buildHybridSearchStatement({
-        candidatesSql: chunkEDN4Y4ZG_cjs.isSqlFragment(candidates) ? chunkWODMN3Q2_cjs.toDrizzleSql(candidates, dialect) : candidates,
+        candidatesSql: chunkOJHD3LXJ_cjs.isSqlFragment(candidates) ? chunk45YZXI6X_cjs.toDrizzleSql(candidates, dialect) : candidates,
         vectorSql,
         vectorScoreDescending,
         fulltextSql,
@@ -2419,8 +2241,8 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
     ...tableOperations,
     ...fulltextBuilders,
     primaryKeyConstraints: {
-      nodes: nodePrimaryKeyConstraint(tables.nodes),
-      edges: edgePrimaryKeyConstraint(tables.edges)
+      nodes: chunkEH3JZJUM_cjs.nodePrimaryKeyConstraint(tables.nodes),
+      edges: chunkEH3JZJUM_cjs.edgePrimaryKeyConstraint(tables.edges)
     },
     buildUpdateNodeSet(params, timestamp) {
       return buildUpdateNodeSet(tables, dialect, params, timestamp);
@@ -2428,10 +2250,39 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
     buildDeleteContributionMaterialization,
     buildInsertContributionMaterialization,
     buildInsertUnique(params) {
-      return buildInsertUnique(tables, dialect, params);
+      return chunkEH3JZJUM_cjs.buildInsertUnique(tables, dialect, params);
     },
     buildInsertUniqueBatch(entries) {
-      return buildInsertUniqueBatch(tables, dialect, entries);
+      return chunkEH3JZJUM_cjs.buildInsertUniqueBatch(tables, dialect, entries);
+    },
+    buildHardDeleteUniquesByConcreteKind(params) {
+      return chunkEH3JZJUM_cjs.buildHardDeleteUniquesByConcreteKind(
+        drizzleOrm.getTableName(tables.uniques),
+        params
+      );
+    },
+    buildLockEdgeClaims(entries, timestamp) {
+      return chunkEH3JZJUM_cjs.buildLockEdgeClaims(tables, entries, timestamp);
+    },
+    buildTakeOverEdgeClaim(params, timestamp) {
+      return chunkEH3JZJUM_cjs.buildTakeOverEdgeClaim(tables, params, timestamp);
+    },
+    buildPurgeEdgeClaims(params) {
+      return chunkEH3JZJUM_cjs.buildPurgeEdgeClaims(tables, params);
+    },
+    buildContendedUniqueRowAudit(graphId, constraintNames) {
+      return buildContendedUniqueRowAudit(tables, graphId, constraintNames);
+    },
+    buildContendedEdgeRowAudit(graphId, cardinality, edgeKinds) {
+      return buildContendedEdgeRowAudit(
+        tables,
+        graphId,
+        cardinality,
+        edgeKinds
+      );
+    },
+    buildDisjointOverlapAudit(graphId, kinds) {
+      return buildDisjointOverlapAudit(tables, graphId, kinds);
     },
     buildGetActiveSchema(graphId) {
       return buildGetActiveSchema(tables, graphId, dialect);
@@ -2495,6 +2346,9 @@ function createSqliteOperationStrategy(tables, fulltextStrategy) {
 function createPostgresOperationStrategy(tables, fulltextStrategy) {
   return createCommonOperationStrategy(tables, "postgres", fulltextStrategy);
 }
+function claimOwnerOf(params) {
+  return { concreteKind: params.concreteKind, nodeId: params.nodeId };
+}
 var DRIZZLE_DIALECT_LABELS = {
   postgres: "Postgres",
   sqlite: "SQLite"
@@ -2502,7 +2356,7 @@ var DRIZZLE_DIALECT_LABELS = {
 function assertAdoptedDialect(externalTx, brand, backend) {
   if (drizzleOrm.is(externalTx, brand)) return;
   const label = DRIZZLE_DIALECT_LABELS[backend];
-  throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+  throw new chunkX4GDXBOP_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" }
   );
@@ -2511,8 +2365,8 @@ async function withDuplicateKeyClassification(run, context) {
   try {
     return await run();
   } catch (error) {
-    if (!chunkSIT26LAZ_cjs.isDuplicatePrimaryKeyError(error, context.relation)) throw error;
-    throw new chunkMRDBBHIZ_cjs.DatabaseOperationError(
+    if (!chunkZBFZGLZE_cjs.isDuplicatePrimaryKeyError(error, context.relation)) throw error;
+    throw new chunkX4GDXBOP_cjs.DatabaseOperationError(
       `Insert ${context.entity} failed: a row with this identity already exists`,
       {
         operation: "insert",
@@ -2533,7 +2387,7 @@ function verifyExpectedActiveVersion(graphId, expected, actualActiveVersion) {
 }
 function assertActiveSchemaVersion(graphId, expectedVersion, actualActiveVersion) {
   if (actualActiveVersion !== expectedVersion) {
-    throw new chunkMRDBBHIZ_cjs.StaleVersionError({
+    throw new chunkX4GDXBOP_cjs.StaleVersionError({
       graphId,
       expected: expectedVersion,
       actual: actualActiveVersion
@@ -2583,7 +2437,7 @@ function createCommonOperationBackend(options) {
     operationStrategy,
     rowMappers
   } = options;
-  const nowIso2 = options.nowIso ?? chunkFA2AFWLP_cjs.nowIso;
+  const nowIso2 = options.nowIso ?? chunkEH3JZJUM_cjs.nowIso;
   const tableExists = createCachedTableExistence(
     (tableName) => execution.execGet(
       operationStrategy.buildTableExists(tableName)
@@ -2596,6 +2450,50 @@ function createCommonOperationBackend(options) {
     }
     await execution.execRun(statement.query);
   }
+  async function claimEdgeCardinalityEntries(entries) {
+    if (entries.length === 0) return [];
+    const targetKey = (entry) => {
+      const target = chunk7PRMDZIA_cjs.edgeCardinalityClaimTarget(entry);
+      return `${target.axis}\0${target.key}`;
+    };
+    const seen = /* @__PURE__ */ new Set();
+    for (const entry of entries) {
+      const key = targetKey(entry);
+      if (seen.has(key)) {
+        throw new chunkX4GDXBOP_cjs.DatabaseOperationError(
+          "Two edge claims in one batch name the same cardinality axis and key; a multi-row upsert cannot affect one row twice.",
+          { operation: "insert", entity: "edge" }
+        );
+      }
+      seen.add(key);
+    }
+    const outcomes = /* @__PURE__ */ new Map();
+    for (const chunk2 of chunkZBFZGLZE_cjs.chunk(entries, batchConfig.edgeInsertBatchSize)) {
+      const lockQuery = operationStrategy.buildLockEdgeClaims(chunk2, nowIso2());
+      const rows = await execution.execAll(lockQuery);
+      const holderByTarget = new Map(
+        rows.map((row) => [`${row.axis}\0${row.key}`, row.holder_edge_id])
+      );
+      for (const entry of chunk2) {
+        const key = targetKey(entry);
+        const holder = holderByTarget.get(key);
+        if (holder === void 0 || holder === entry.edgeId) {
+          outcomes.set(key, { status: "claimed" });
+          continue;
+        }
+        const takeOver = await execution.execAll(
+          operationStrategy.buildTakeOverEdgeClaim(entry, nowIso2())
+        );
+        outcomes.set(
+          key,
+          takeOver.length > 0 ? { status: "claimed" } : { status: "refused", holderEdgeId: holder }
+        );
+      }
+    }
+    return entries.map(
+      (entry) => outcomes.get(targetKey(entry)) ?? { status: "claimed" }
+    );
+  }
   async function readActiveVersion(graphId) {
     const row = await execution.execGet(
       operationStrategy.buildGetActiveSchema(graphId)
@@ -2605,7 +2503,7 @@ function createCommonOperationBackend(options) {
   return {
     tableExists,
     async executeSchemaDdl(ddl) {
-      await execution.execRun(chunkEDN4Y4ZG_cjs.asCompiledStatementSql(chunkEDN4Y4ZG_cjs.sql.raw(ddl)));
+      await execution.execRun(chunkOJHD3LXJ_cjs.asCompiledStatementSql(chunkOJHD3LXJ_cjs.sql.raw(ddl)));
     },
     async executeStatement(query) {
       await execution.execRun(query);
@@ -2625,7 +2523,7 @@ function createCommonOperationBackend(options) {
         }
       );
       if (!row)
-        throw new chunkMRDBBHIZ_cjs.DatabaseOperationError(
+        throw new chunkX4GDXBOP_cjs.DatabaseOperationError(
           "Insert node failed: no row returned",
           {
             operation: "insert",
@@ -2652,7 +2550,7 @@ function createCommonOperationBackend(options) {
         return;
       }
       const timestamp = nowIso2();
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(params, batchConfig.nodeInsertBatchSize)) {
+      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(params, batchConfig.nodeInsertBatchSize)) {
         const query = operationStrategy.buildInsertNodesBatch(chunk2, timestamp);
         await withDuplicateKeyClassification(() => execution.execRun(query), {
           entity: "node",
@@ -2667,7 +2565,7 @@ function createCommonOperationBackend(options) {
       }
       const timestamp = nowIso2();
       const allRows = [];
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(params, batchConfig.nodeInsertBatchSize)) {
+      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(params, batchConfig.nodeInsertBatchSize)) {
         const query = operationStrategy.buildInsertNodesBatchReturning(
           chunk2,
           timestamp
@@ -2692,7 +2590,7 @@ function createCommonOperationBackend(options) {
     async getNodes(graphId, kind, ids) {
       if (ids.length === 0) return [];
       const allRows = [];
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(ids, batchConfig.getNodesChunkSize)) {
+      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(ids, batchConfig.getNodesChunkSize)) {
         const query = operationStrategy.buildGetNodes(graphId, kind, chunk2);
         const rows = await execution.execAll(query);
         allRows.push(...rows.map((row) => rowMappers.toNodeRow(row)));
@@ -2704,7 +2602,7 @@ function createCommonOperationBackend(options) {
       const query = operationStrategy.buildUpdateNode(params, timestamp);
       const row = await execution.execGet(query);
       if (!row)
-        throw new chunkMRDBBHIZ_cjs.DatabaseOperationError(
+        throw new chunkX4GDXBOP_cjs.DatabaseOperationError(
           "Update node failed: no row returned",
           {
             operation: "update",
@@ -2716,13 +2614,13 @@ function createCommonOperationBackend(options) {
     },
     async updateNodeSet(params) {
       if (Object.keys(params.patch).length === 0 && (params.unsetProperties?.length ?? 0) === 0) {
-        throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+        throw new chunkX4GDXBOP_cjs.ConfigurationError(
           "Set-based node update requires at least one property",
           { operation: "updateNodeSet", kind: params.kind }
         );
       }
       if (params.candidateIdColumn.length === 0) {
-        throw new chunkMRDBBHIZ_cjs.ConfigurationError(
+        throw new chunkX4GDXBOP_cjs.ConfigurationError(
           "Set-based node update requires a candidate id column",
           { operation: "updateNodeSet", kind: params.kind }
         );
@@ -2783,7 +2681,7 @@ function createCommonOperationBackend(options) {
         }
       );
       if (!row)
-        throw new chunkMRDBBHIZ_cjs.DatabaseOperationError(
+        throw new chunkX4GDXBOP_cjs.DatabaseOperationError(
           "Insert edge failed: no row returned",
           {
             operation: "insert",
@@ -2810,7 +2708,7 @@ function createCommonOperationBackend(options) {
         return;
       }
       const timestamp = nowIso2();
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(params, batchConfig.edgeInsertBatchSize)) {
+      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(params, batchConfig.edgeInsertBatchSize)) {
         const query = operationStrategy.buildInsertEdgesBatch(chunk2, timestamp);
         await withDuplicateKeyClassification(() => execution.execRun(query), {
           entity: "edge",
@@ -2825,7 +2723,7 @@ function createCommonOperationBackend(options) {
       }
       const timestamp = nowIso2();
       const allRows = [];
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(params, batchConfig.edgeInsertBatchSize)) {
+      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(params, batchConfig.edgeInsertBatchSize)) {
         const query = operationStrategy.buildInsertEdgesBatchReturning(
           chunk2,
           timestamp
@@ -2850,7 +2748,7 @@ function createCommonOperationBackend(options) {
     async getEdges(graphId, ids) {
       if (ids.length === 0) return [];
       const allRows = [];
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(ids, batchConfig.getEdgesChunkSize)) {
+      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(ids, batchConfig.getEdgesChunkSize)) {
         const query = operationStrategy.buildGetEdges(graphId, chunk2);
         const rows = await execution.execAll(query);
         allRows.push(...rows.map((row) => rowMappers.toEdgeRow(row)));
@@ -2862,7 +2760,7 @@ function createCommonOperationBackend(options) {
       const query = operationStrategy.buildUpdateEdge(params, timestamp);
       const row = await execution.execGet(query);
       if (!row)
-        throw new chunkMRDBBHIZ_cjs.DatabaseOperationError(
+        throw new chunkX4GDXBOP_cjs.DatabaseOperationError(
           "Update edge failed: no row returned",
           {
             operation: "update",
@@ -2888,7 +2786,7 @@ function createCommonOperationBackend(options) {
         1,
         batchConfig.getEdgesChunkSize - 1
       );
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(params.ids, softDeleteChunkSize)) {
+      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(params.ids, softDeleteChunkSize)) {
         const query = operationStrategy.buildDeleteEdgesBatch(
           { graphId: params.graphId, ids: chunk2 },
           timestamp
@@ -2898,7 +2796,7 @@ function createCommonOperationBackend(options) {
     },
     async hardDeleteEdgesBatch(params) {
       if (params.ids.length === 0) return;
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(
+      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(
         params.ids,
         batchConfig.getEdgesChunkSize
       )) {
@@ -2942,7 +2840,7 @@ function createCommonOperationBackend(options) {
     async findEdgesByEndpointSet(params) {
       const ids = resolveEdgeEndpointIds(params);
       const edgeRows = [];
-      for (const idChunk of chunkSIT26LAZ_cjs.chunk(
+      for (const idChunk of chunkZBFZGLZE_cjs.chunk(
         ids,
         batchConfig.findEdgesEndpointChunkSize
       )) {
@@ -2959,7 +2857,7 @@ function createCommonOperationBackend(options) {
       const { edgeKinds, endpoints, endpointChunkSize } = resolveHeterogeneousEdgeRead(params, maxBindParameters);
       if (edgeKinds.length === 0 || endpoints.length === 0) return [];
       const edgeRows = [];
-      for (const endpointChunk of chunkSIT26LAZ_cjs.chunk(endpoints, endpointChunkSize)) {
+      for (const endpointChunk of chunkZBFZGLZE_cjs.chunk(endpoints, endpointChunkSize)) {
         const query = operationStrategy.buildFindEdgesByHeterogeneousEndpointSet(
           params,
           endpointChunk,
@@ -2978,13 +2876,23 @@ function createCommonOperationBackend(options) {
     async insertUnique(params) {
       const query = operationStrategy.buildInsertUnique(params);
       const result = await execution.execGet(query);
-      if (result && result.node_id !== params.nodeId) {
-        throw new chunkMRDBBHIZ_cjs.UniquenessError({
+      if (result && !chunkLLVOQOWE_cjs.isSameClaimOwner(
+        { concreteKind: result.concrete_kind, nodeId: result.node_id },
+        claimOwnerOf(params)
+      )) {
+        throw new chunkX4GDXBOP_cjs.UniquenessError({
           constraintName: params.constraintName,
-          kind: params.nodeKind,
+          // The holder's own kind, never `nodeKind`: that column carries the
+          // claim AXIS, which a shared scope folds across kinds, so it need not
+          // be the holder's kind and usually is not.
+          kind: result.concrete_kind,
           existingId: result.node_id,
           newId: params.nodeId,
-          fields: []
+          fields: [],
+          // The axis THIS statement attempted — `mapClaimRefusal`'s only way to
+          // tell two disjoint pairs (or two scoped constraints) sharing a key
+          // apart, since `constraintName` alone does not.
+          axis: params.nodeKind
         });
       }
     },
@@ -2998,18 +2906,19 @@ function createCommonOperationBackend(options) {
           byTarget.set(targetKey(entry), entry);
           continue;
         }
-        if (existing.nodeId !== entry.nodeId) {
-          throw new chunkMRDBBHIZ_cjs.UniquenessError({
+        if (!chunkLLVOQOWE_cjs.isSameClaimOwner(claimOwnerOf(existing), claimOwnerOf(entry))) {
+          throw new chunkX4GDXBOP_cjs.UniquenessError({
             constraintName: entry.constraintName,
-            kind: entry.nodeKind,
+            kind: existing.concreteKind,
             existingId: existing.nodeId,
             newId: entry.nodeId,
-            fields: []
+            fields: [],
+            axis: entry.nodeKind
           });
         }
       }
       const deduped = [...byTarget.values()];
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(
+      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(
         deduped,
         batchConfig.uniqueInsertBatchSize
       )) {
@@ -3018,18 +2927,19 @@ function createCommonOperationBackend(options) {
         const ownerByTarget = new Map(
           rows.map((row) => [
             `${row.node_kind}\0${row.constraint_name}\0${row.key}`,
-            row.node_id
+            { concreteKind: row.concrete_kind, nodeId: row.node_id }
           ])
         );
         for (const entry of chunk2) {
           const owner = ownerByTarget.get(targetKey(entry));
-          if (owner !== void 0 && owner !== entry.nodeId) {
-            throw new chunkMRDBBHIZ_cjs.UniquenessError({
+          if (owner !== void 0 && !chunkLLVOQOWE_cjs.isSameClaimOwner(owner, claimOwnerOf(entry))) {
+            throw new chunkX4GDXBOP_cjs.UniquenessError({
               constraintName: entry.constraintName,
-              kind: entry.nodeKind,
-              existingId: owner,
+              kind: owner.concreteKind,
+              existingId: owner.nodeId,
               newId: entry.nodeId,
-              fields: []
+              fields: [],
+              axis: entry.nodeKind
             });
           }
         }
@@ -3042,7 +2952,7 @@ function createCommonOperationBackend(options) {
     },
     async hardDeleteUniquesByNodeIds(params) {
       const nodeIds = [...new Set(params.nodeIds)];
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(
+      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(
         nodeIds,
         batchConfig.uniqueDeleteChunkSize
       )) {
@@ -3053,6 +2963,78 @@ function createCommonOperationBackend(options) {
         await execution.execRun(query);
       }
     },
+    async hardDeleteUniquesByConcreteKind(params) {
+      const query = operationStrategy.buildHardDeleteUniquesByConcreteKind(params);
+      await execution.execRun(query);
+    },
+    async claimEdgeCardinality(params) {
+      const [outcome] = await claimEdgeCardinalityEntries([params]);
+      return outcome ?? { status: "claimed" };
+    },
+    claimEdgeCardinalityBatch(entries) {
+      return claimEdgeCardinalityEntries(entries);
+    },
+    async purgeEdgeClaims(params) {
+      const edgeIds = [...new Set(params.edgeIds)];
+      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(edgeIds, batchConfig.getEdgesChunkSize)) {
+        const query = operationStrategy.buildPurgeEdgeClaims({
+          ...params,
+          edgeIds: chunk2
+        });
+        await execution.execRun(query);
+      }
+    },
+    async readConstraintFenceViolations(params) {
+      const uniqueRows = params.uniqueConstraintNames.length === 0 ? [] : await execution.execAll(
+        operationStrategy.buildContendedUniqueRowAudit(
+          params.graphId,
+          params.uniqueConstraintNames
+        )
+      );
+      const contendedUniqueRows = uniqueRows.map((row) => ({
+        nodeKind: row.node_kind,
+        constraintName: row.constraint_name,
+        key: row.key,
+        concreteKind: row.concrete_kind,
+        nodeId: row.node_id
+      }));
+      const edgeKindsByCardinality = /* @__PURE__ */ new Map();
+      for (const declaration of params.edgeCardinalities) {
+        const kinds = edgeKindsByCardinality.get(declaration.cardinality) ?? [];
+        kinds.push(declaration.edgeKind);
+        edgeKindsByCardinality.set(declaration.cardinality, kinds);
+      }
+      const contendedEdgeRows = [];
+      for (const [cardinality, edgeKinds] of edgeKindsByCardinality) {
+        const rows = await execution.execAll(
+          operationStrategy.buildContendedEdgeRowAudit(
+            params.graphId,
+            cardinality,
+            edgeKinds
+          )
+        );
+        for (const row of rows) {
+          contendedEdgeRows.push({
+            edgeKind: row.edge_kind,
+            cardinality,
+            edgeId: row.edge_id,
+            fromKind: row.from_kind,
+            fromId: row.from_id,
+            toKind: row.to_kind,
+            toId: row.to_id
+          });
+        }
+      }
+      const disjointOverlaps = [];
+      for (const kinds of params.disjointKindPairs) {
+        const rows = await execution.execAll(
+          operationStrategy.buildDisjointOverlapAudit(params.graphId, kinds)
+        );
+        for (const row of rows)
+          disjointOverlaps.push({ kinds, nodeId: row.node_id });
+      }
+      return { contendedUniqueRows, contendedEdgeRows, disjointOverlaps };
+    },
     async checkUnique(params) {
       const query = operationStrategy.buildCheckUnique(params);
       const row = await execution.execGet(query);
@@ -3061,7 +3043,7 @@ function createCommonOperationBackend(options) {
     async checkUniqueBatch(params) {
       if (params.keys.length === 0) return [];
       const allRows = [];
-      for (const chunk2 of chunkSIT26LAZ_cjs.chunk(
+      for (const chunk2 of chunkZBFZGLZE_cjs.chunk(
         params.keys,
         batchConfig.checkUniqueBatchChunkSize
       )) {
@@ -3092,7 +3074,7 @@ function createCommonOperationBackend(options) {
       if (existingRaw !== void 0) {
         const existing = rowMappers.toSchemaVersionRow(existingRaw);
         if (existing.schema_hash !== params.schemaHash) {
-          throw new chunkMRDBBHIZ_cjs.SchemaContentConflictError({
+          throw new chunkX4GDXBOP_cjs.SchemaContentConflictError({
             graphId: params.graphId,
             version: params.version,
             existingHash: existing.schema_hash,
@@ -3140,7 +3122,7 @@ function createCommonOperationBackend(options) {
       );
       const insertedRaw = await execution.execGet(insertQuery);
       if (!insertedRaw) {
-        throw new chunkMRDBBHIZ_cjs.DatabaseOperationError(
+        throw new chunkX4GDXBOP_cjs.DatabaseOperationError(
           "Insert schema failed: no row returned",
           { operation: "insert", entity: "schema" }
         );
@@ -3158,7 +3140,7 @@ function createCommonOperationBackend(options) {
         operationStrategy.buildGetSchemaVersion(params.graphId, params.version)
       );
       if (!targetRaw) {
-        throw new chunkMRDBBHIZ_cjs.MigrationError(
+        throw new chunkX4GDXBOP_cjs.MigrationError(
           `Cannot activate version ${params.version}: version does not exist for graph "${params.graphId}".`,
           {
             graphId: params.graphId,
@@ -3191,7 +3173,7 @@ function quoteSqlIdentifier(identifier) {
 }
 function requireRawExecution(backend) {
   if (backend.executeRaw === void 0) {
-    throw new chunkMRDBBHIZ_cjs.TrustedImportError(
+    throw new chunkX4GDXBOP_cjs.TrustedImportError(
       "This backend cannot execute the raw statements required by trusted import.",
       "backend_unsupported"
     );
@@ -3200,7 +3182,7 @@ function requireRawExecution(backend) {
 }
 function requireStatementExecution(backend) {
   if (backend.executeStatement === void 0) {
-    throw new chunkMRDBBHIZ_cjs.TrustedImportError(
+    throw new chunkX4GDXBOP_cjs.TrustedImportError(
       "This backend cannot execute the index lifecycle required by trusted import.",
       "backend_unsupported"
     );
@@ -3222,7 +3204,7 @@ async function assertTrustedImportDatabaseEmpty(backend, tableNames) {
     []
   );
   if (!rowIndicatesExistingData(rows[0])) return;
-  throw new chunkMRDBBHIZ_cjs.TrustedImportError(
+  throw new chunkX4GDXBOP_cjs.TrustedImportError(
     "Trusted import requires globally empty TypeGraph node and edge tables.",
     "database_not_empty",
     { tables: [tableNames.nodes, tableNames.edges] },
@@ -3234,8 +3216,8 @@ async function assertTrustedImportDatabaseEmpty(backend, tableNames) {
 async function lockPostgresTrustedImportTables(backend, tableNames) {
   const executeStatement = requireStatementExecution(backend);
   await executeStatement(
-    chunkEDN4Y4ZG_cjs.asCompiledStatementSql(
-      chunkEDN4Y4ZG_cjs.sql.raw(
+    chunkOJHD3LXJ_cjs.asCompiledStatementSql(
+      chunkOJHD3LXJ_cjs.sql.raw(
         `LOCK TABLE ${quoteSqlIdentifier(tableNames.nodes)}, ${quoteSqlIdentifier(tableNames.edges)} IN ACCESS EXCLUSIVE MODE`
       )
     )
@@ -3255,8 +3237,8 @@ async function suspendSqliteSecondaryIndexes(backend, tableNames) {
   );
   for (const definition of definitions) {
     await executeStatement(
-      chunkEDN4Y4ZG_cjs.asCompiledStatementSql(
-        chunkEDN4Y4ZG_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
+      chunkOJHD3LXJ_cjs.asCompiledStatementSql(
+        chunkOJHD3LXJ_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
       )
     );
   }
@@ -3286,8 +3268,8 @@ async function suspendPostgresSecondaryIndexes(backend, tableNames) {
   );
   for (const definition of definitions) {
     await executeStatement(
-      chunkEDN4Y4ZG_cjs.asCompiledStatementSql(
-        chunkEDN4Y4ZG_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
+      chunkOJHD3LXJ_cjs.asCompiledStatementSql(
+        chunkOJHD3LXJ_cjs.sql.raw(`DROP INDEX ${quoteSqlIdentifier(definition.index_name)}`)
       )
     );
   }
@@ -3297,20 +3279,20 @@ async function restoreSecondaryIndexes(backend, definitions) {
   const executeStatement = requireStatementExecution(backend);
   for (const definition of definitions) {
     await executeStatement(
-      chunkEDN4Y4ZG_cjs.asCompiledStatementSql(chunkEDN4Y4ZG_cjs.sql.raw(definition.index_definition))
+      chunkOJHD3LXJ_cjs.asCompiledStatementSql(chunkOJHD3LXJ_cjs.sql.raw(definition.index_definition))
     );
   }
 }
 async function analyzeImportedTables(backend, tableNames) {
   const executeStatement = requireStatementExecution(backend);
   await executeStatement(
-    chunkEDN4Y4ZG_cjs.asCompiledStatementSql(
-      chunkEDN4Y4ZG_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.nodes)}`)
+    chunkOJHD3LXJ_cjs.asCompiledStatementSql(
+      chunkOJHD3LXJ_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.nodes)}`)
     )
   );
   await executeStatement(
-    chunkEDN4Y4ZG_cjs.asCompiledStatementSql(
-      chunkEDN4Y4ZG_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.edges)}`)
+    chunkOJHD3LXJ_cjs.asCompiledStatementSql(
+      chunkOJHD3LXJ_cjs.sql.raw(`ANALYZE ${quoteSqlIdentifier(tableNames.edges)}`)
     )
   );
 }
@@ -3322,7 +3304,7 @@ function postgresArray(values) {
 function createSqliteTrustedImportSession(executionAdapter, tableNames) {
   const executePreparedRunBatch = executionAdapter.executePreparedRunBatch;
   if (executePreparedRunBatch === void 0) {
-    throw new chunkMRDBBHIZ_cjs.TrustedImportError(
+    throw new chunkX4GDXBOP_cjs.TrustedImportError(
       "Trusted import requires a synchronous SQLite driver with prepared statement support.",
       "backend_unsupported"
     );
@@ -3344,7 +3326,7 @@ function createSqliteTrustedImportSession(executionAdapter, tableNames) {
           item.kind,
           item.id,
           JSON.stringify(item.props),
-          chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp) ?? DATABASE_NULL,
+          chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp) ?? DATABASE_NULL,
           item.validTo ?? DATABASE_NULL,
           timestamp,
           timestamp
@@ -3365,7 +3347,7 @@ function createSqliteTrustedImportSession(executionAdapter, tableNames) {
           item.toKind,
           item.toId,
           JSON.stringify(item.props),
-          chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp) ?? DATABASE_NULL,
+          chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp) ?? DATABASE_NULL,
           item.validTo ?? DATABASE_NULL,
           timestamp,
           timestamp
@@ -3406,7 +3388,7 @@ function createPostgresTrustedImportSession(backend, tableNames) {
         postgresArray(params.map((item) => JSON.stringify(item.props))),
         postgresArray(
           params.map(
-            (item) => chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp) ?? DATABASE_NULL
+            (item) => chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp) ?? DATABASE_NULL
           )
         ),
         postgresArray(params.map((item) => item.validTo ?? DATABASE_NULL)),
@@ -3427,7 +3409,7 @@ function createPostgresTrustedImportSession(backend, tableNames) {
         postgresArray(params.map((item) => JSON.stringify(item.props))),
         postgresArray(
           params.map(
-            (item) => chunkTQHGE7UC_cjs.resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp) ?? DATABASE_NULL
+            (item) => chunkM5MSP3BI_cjs.resolveStampedValidityLowerBound(item.validFrom, item.validTo, timestamp) ?? DATABASE_NULL
           )
         ),
         postgresArray(params.map((item) => item.validTo ?? DATABASE_NULL)),
@@ -3498,5 +3480,5 @@ exports.tableExistsFromRow = tableExistsFromRow;
 exports.vectorSlotFromCreateIndexParams = vectorSlotFromCreateIndexParams;
 exports.vectorSlotFromDropIndexParams = vectorSlotFromDropIndexParams;
 exports.vectorSlotFromParams = vectorSlotFromParams;
-//# sourceMappingURL=chunk-WCCATHMB.cjs.map
-//# sourceMappingURL=chunk-WCCATHMB.cjs.map
+//# sourceMappingURL=chunk-XMY2SXOH.cjs.map
+//# sourceMappingURL=chunk-XMY2SXOH.cjs.map