@nicia-ai/typegraph 0.48.0 → 0.50.0

package/dist/{chunk-ACGSAMD3.js → chunk-MJPZNEJZ.js}

@@ -1,13 +1,14 @@
-import { formatPostgresTimestamp, coerceNumericScore, nowIso } from './chunk-YIURNGXI.js';
-import { runtimeStrategyContributions } from './chunk-6SWPJEYN.js';
-import { toDrizzleSql } from './chunk-OMZ37BM2.js';
-import { sortedReplacer } from './chunk-JBQQ7THH.js';
-import { parseDimensionMismatch, deriveBackend, chunk, isMissingTableError, isDuplicatePrimaryKeyError, errorChain } from './chunk-UGHG7PGX.js';
-import { resolveStampedValidityLowerBound, resolveStatedValidityLowerBound } from './chunk-5K2BKEBD.js';
+import { formatPostgresTimestamp, coerceNumericScore, nowIso, buildPurgeEdgeClaims, buildTakeOverEdgeClaim, buildLockEdgeClaims, buildHardDeleteUniquesByConcreteKind, buildInsertUniqueBatch, buildInsertUnique, edgePrimaryKeyConstraint, nodePrimaryKeyConstraint, liveNodeIdsSubquery, buildCheckUniqueBatch, buildCheckUnique, buildHardDeleteUniquesByNodeIds, buildHardDeleteUniquesByNode, buildDeleteUnique, quotedColumn, quotedTableName, codePointOrderKey, sqlNull, expectedValidFromPredicate, edgeColumnList, nodeColumnList } from './chunk-S3SDEQMC.js';
+import { runtimeStrategyContributions } from './chunk-6LEOAIIB.js';
+import { toDrizzleSql } from './chunk-V76FGHY3.js';
+import { edgeCardinalityClaimTarget, EDGE_CARDINALITY_SPECS } from './chunk-YA36ABIL.js';
+import { parseDimensionMismatch, deriveBackend, chunk, isMissingTableError, isDuplicatePrimaryKeyError, errorChain, sortedReplacer } from './chunk-IRPYOHRC.js';
+import { isSameClaimOwner } from './chunk-5LKOVCPP.js';
+import { resolveStampedValidityLowerBound, resolveStatedValidityLowerBound } from './chunk-K46SDNQD.js';
 import { sha256Hex } from './chunk-K34OPSJK.js';
-import { buildFulltextGraphDelete, buildForeignFulltextGraphProbe, getDialect } from './chunk-ZDKTPBGV.js';
-import { sql as sql$1, asCompiledStatementSql, asCompiledRowsSql, isSqlFragment } from './chunk-3DMMGT6S.js';
-import { EmbeddingDimensionChangedError, ConfigurationError, StaleVersionError, MigrationError, SchemaContentConflictError, DatabaseOperationError, UniquenessError, TrustedImportError, ContributionUnavailableError, ContributionRebuildUnsupportedError, StoreNotInitializedError } from './chunk-ZLONH2UD.js';
+import { buildFulltextGraphDelete, buildForeignFulltextGraphProbe, getDialect } from './chunk-EDLKIQRI.js';
+import { sql as sql$1, asCompiledStatementSql, asCompiledRowsSql, isSqlFragment } from './chunk-46UGOVRW.js';
+import { EmbeddingDimensionChangedError, ConfigurationError, StaleVersionError, MigrationError, SchemaContentConflictError, DatabaseOperationError, UniquenessError, TrustedImportError, ContributionUnavailableError, ContributionRebuildUnsupportedError, StoreNotInitializedError } from './chunk-YDEJQWOL.js';
 import { isPresent } from './chunk-DYATYRY4.js';
 import { sql, is, getTableName } from 'drizzle-orm';
 
@@ -251,7 +252,7 @@ function missingTableErrorNames(error, tableName) {
   for (const link of 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`);
@@ -1040,66 +1041,6 @@ 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");
-}
-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('"', '""')}"`);
-}
-function quotedTableName(tableName) {
-  return sql.raw(`"${tableName.replaceAll('"', '""')}"`);
-}
-var CODE_POINT_ORDER_BUILDERS = {
-  postgres: (value) => 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 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 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 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(sql.raw("node_id"), dialect);
 }
@@ -1247,6 +1188,17 @@ function buildClearGraph(tables, graphId) {
     {
       query: 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: sql`DELETE FROM ${tables.edgeClaims} WHERE ${tables.edgeClaims.graphId} = ${graphId}`,
+      ignoreMissingTable: true,
+      requiredTableName: getTableName(tables.edgeClaims)
+    },
     {
       query: sql`DELETE FROM ${tables.edges} WHERE ${tables.edges.graphId} = ${graphId}`
     },
@@ -1507,6 +1459,85 @@ function buildCountEdgesByKind(tables, params) {
     WHERE ${whereClause}
   `;
 }
+var PEER = "peer";
+function qualified2(relation, column) {
+  return sql.raw(`"${relation}"."${column.name}"`);
+}
+function inList(values) {
+  return sql.join(
+    values.map((value) => sql`${value}`),
+    sql`, `
+  );
+}
+function buildContendedUniqueRowAudit(tables, graphId, constraintNames) {
+  const { uniques } = tables;
+  const relation = getTableName(uniques);
+  return sql`
+    SELECT
+      ${quotedColumn(uniques.nodeKind)} as node_kind,
+      ${quotedColumn(uniques.constraintName)} as constraint_name,
+      ${quotedColumn(uniques.key)} as key,
+      ${quotedColumn(uniques.concreteKind)} as concrete_kind,
+      ${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 ${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 = getTableName(edges);
+  const spec = EDGE_CARDINALITY_SPECS[cardinality];
+  const activeOnly = spec.holderLiveness === "liveAndActive" ? sql` AND ${qualified2(relation, edges.validTo)} IS NULL` : sql.empty();
+  const peerActiveOnly = spec.holderLiveness === "liveAndActive" ? sql` AND ${qualified2(PEER, edges.validTo)} IS NULL` : sql.empty();
+  const peerToEndpoints = spec.keyShape === "fromAndTo" ? sql`
+        AND ${qualified2(PEER, edges.toKind)} = ${qualified2(relation, edges.toKind)}
+                  AND ${qualified2(PEER, edges.toId)} = ${qualified2(relation, edges.toId)}
+      ` : sql.empty();
+  return sql`
+    SELECT
+      ${quotedColumn(edges.id)} as edge_id,
+      ${quotedColumn(edges.kind)} as edge_kind,
+      ${quotedColumn(edges.fromKind)} as from_kind,
+      ${quotedColumn(edges.fromId)} as from_id,
+      ${quotedColumn(edges.toKind)} as to_kind,
+      ${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 ${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 = getTableName(nodes);
+  const liveIdsOfKind = (kind) => sql`
+    SELECT ${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 sql`${liveIdsOfKind(kinds[0])} INTERSECT ${liveIdsOfKind(kinds[1])}`;
+}
 function buildInsertEdge(tables, params, timestamp) {
   const { edges } = tables;
   const propsJson = JSON.stringify(params.props);
@@ -2050,215 +2081,6 @@ function buildSetActiveSchema(tables, graphId, version, dialect = "sqlite") {
   `;
   return { deactivateAll, activateVersion };
 }
-function buildInsertUniqueSqlite(tables, params) {
-  const { uniques } = tables;
-  const columns = 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 = sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`
-  );
-  return sql`
-    INSERT INTO ${uniques} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
-      ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${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 = 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 = sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`
-  );
-  const tableName = getTableName(uniques);
-  const existingColumn = (column) => sql.raw(`"${tableName}"."${column.name}"`);
-  return sql`
-    INSERT INTO ${uniques} (${columns})
-    VALUES (
-      ${params.graphId}, ${params.nodeKind}, ${params.constraintName},
-      ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${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 = 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 = sql.raw(
-    `"${uniques.graphId.name}", "${uniques.nodeKind.name}", "${uniques.constraintName.name}", "${uniques.key.name}"`
-  );
-  const tableName = getTableName(uniques);
-  const existingColumn = (column) => {
-    switch (dialect) {
-      case "postgres": {
-        return sql.raw(`"${tableName}"."${column.name}"`);
-      }
-      case "sqlite": {
-        return sql.raw(`"${column.name}"`);
-      }
-      default: {
-        return dialect;
-      }
-    }
-  };
-  const excludedColumn = (column) => sql.raw(`excluded."${column.name}"`);
-  const valueRows = sql.join(
-    entries.map(
-      (params) => sql`(${params.graphId}, ${params.nodeKind}, ${params.constraintName}, ${params.key}, ${params.nodeId}, ${params.concreteKind}, ${sql.raw("NULL")})`
-    ),
-    sql`, `
-  );
-  return 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 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 sql`
-    DELETE FROM ${uniques}
-    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) {
-  const { uniques } = tables;
-  if (params.includeDeleted) {
-    return 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 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 = sql.join(
-    params.keys.map((key) => sql`${key}`),
-    sql`, `
-  );
-  if (params.includeDeleted) {
-    return 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 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) {
@@ -2431,6 +2253,35 @@ function createCommonOperationStrategy(tables, dialect, fulltextStrategy) {
     buildInsertUniqueBatch(entries) {
       return buildInsertUniqueBatch(tables, dialect, entries);
     },
+    buildHardDeleteUniquesByConcreteKind(params) {
+      return buildHardDeleteUniquesByConcreteKind(
+        getTableName(tables.uniques),
+        params
+      );
+    },
+    buildLockEdgeClaims(entries, timestamp) {
+      return buildLockEdgeClaims(tables, entries, timestamp);
+    },
+    buildTakeOverEdgeClaim(params, timestamp) {
+      return buildTakeOverEdgeClaim(tables, params, timestamp);
+    },
+    buildPurgeEdgeClaims(params) {
+      return 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);
     },
@@ -2493,6 +2344,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"
@@ -2594,6 +2448,50 @@ function createCommonOperationBackend(options) {
     }
     await execution.execRun(statement.query);
   }
+  async function claimEdgeCardinalityEntries(entries) {
+    if (entries.length === 0) return [];
+    const targetKey = (entry) => {
+      const target = 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 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 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)
@@ -2976,13 +2874,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) {
+      if (result && !isSameClaimOwner(
+        { concreteKind: result.concrete_kind, nodeId: result.node_id },
+        claimOwnerOf(params)
+      )) {
         throw new 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
         });
       }
     },
@@ -2996,13 +2904,14 @@ function createCommonOperationBackend(options) {
           byTarget.set(targetKey(entry), entry);
           continue;
         }
-        if (existing.nodeId !== entry.nodeId) {
+        if (!isSameClaimOwner(claimOwnerOf(existing), claimOwnerOf(entry))) {
           throw new UniquenessError({
             constraintName: entry.constraintName,
-            kind: entry.nodeKind,
+            kind: existing.concreteKind,
             existingId: existing.nodeId,
             newId: entry.nodeId,
-            fields: []
+            fields: [],
+            axis: entry.nodeKind
           });
         }
       }
@@ -3016,18 +2925,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) {
+          if (owner !== void 0 && !isSameClaimOwner(owner, claimOwnerOf(entry))) {
             throw new UniquenessError({
               constraintName: entry.constraintName,
-              kind: entry.nodeKind,
-              existingId: owner,
+              kind: owner.concreteKind,
+              existingId: owner.nodeId,
               newId: entry.nodeId,
-              fields: []
+              fields: [],
+              axis: entry.nodeKind
             });
           }
         }
@@ -3051,6 +2961,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 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);
@@ -3453,5 +3435,5 @@ function getOrCreateLru(cache, key, cacheMax, create) {
 }
 
 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-ACGSAMD3.js.map
-//# sourceMappingURL=chunk-ACGSAMD3.js.map
+//# sourceMappingURL=chunk-MJPZNEJZ.js.map
+//# sourceMappingURL=chunk-MJPZNEJZ.js.map