@nicia-ai/typegraph 0.48.0 → 0.50.0

package/dist/{chunk-BRRP76WO.js → chunk-MX7EKQPM.js}

@@ -1,31 +1,32 @@
-import { createEdgeRowMapper, createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, POSTGRES_ROW_MAPPER_CONFIG, normalizeRowTimestamp, normalizeRequiredRowTimestamp } from './chunk-YIURNGXI.js';
-import { rowToNode, executeNodeBulkFindByIndex, executeNodeBulkFindByConstraint, executeNodeFindByConstraint, executeNodeBulkGetOrCreateByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeDeleteBatch, executeNodeDelete, nodeUpsertDirtyCheck, executeNodeUpsertUpdate, executeNodeUpdateWhere, executeNodeUpdate, executeNodeCreateNoReturnBatch, executeNodeCreateBatch, executeNodeCreate, rowToEdge, assertValidityEndMutation, assertClearValidToSupported, edgeWriteNeedsConstraintFence, withAlreadyExistsTranslation, rowToNodeMeta, rowToEdgeMeta, validityEndAfterMutation, checkCardinalityConstraint } from './chunk-KF6K7TGH.js';
-import { storeRuntime, STORE_RUNTIME, applyResolvedNodeUniqueness, createUniquenessContext, TRANSACTION_RUNTIME, AUTO_REFRESH_STATISTICS_ROW_THRESHOLD, getEmbeddingFields, computeFulltextContent } from './chunk-I4GAZH5Z.js';
-import { loadAndMergeGraphExtensionDocument, serializeSchema, buildKindRegistry, ensureIdentitySchemaStorage, loadAndVerifyGraph, identitySchemaCommitPreflight, getSchemaChanges, requiresMigration, mergeGraphExtension, commitNewSchemaVersion, commitNewSchemaVersionWithPreflight, planRemovals, stripGraphExtension, applyDeprecatedKinds, identityKindCascadeNeeded, ensureSchema, loadActiveSchemaWithBootstrap, parseSerializedSchema, extensionKindNames, serializeSchemaProperties, buildGraphExtensionOntologyKeySet, compileTimeOntologyKey, commitNewSchemaVersionIfKindsEmpty, serializeIndexDeclaration } from './chunk-2TYSSBU5.js';
-import { getTypeName } from './chunk-SHFBB23Q.js';
-import { rebuildIdentityClosureForContext, loadCurrentStructuralClasses, loadAssertionsByIds, toTransferAssertion, liveNodeKindsSharingIds, createIdentityFacade, createIdentityReadFacade, runInWriteTransaction, validateIdentityForContext, removeIdentityKindsForContext, readIdentityAssertionsForInterchange, readIdentityAssertionPageAtTarget, lockIdentityGraph, foldIdentityForCreatedNodes, importIdentityAssertionsIntoTarget, assertAffectedIdentityClassesConsistent, applyIdentityChangesForContext, withWriteTransactionSession, lockSchemaVersionForStoreWrite, refKey, requireNodeValidityEndCompatible, detachIdentityForNode, validateEdgeProps, runHookedWriteOperation } from './chunk-ZFMCDJGB.js';
-import { isParameterRef, resolveParameterValueType, fieldRef, compareStrings, buildFieldBuilderForTypeInfo, stringField, createFulltextAccessor, CURRENT_READ_INSTANT_PLACEHOLDER, withPinnedReadInstant, compareCodePoints, assertRevisionTrackableBackend, createRecordedBackend, createRecordedTransactionScope, readRecordedClock, ensureRevisionOrigin, withRecordedFlushObserver, recordedCaptureRequiresCallbackTransactionError, assertRecordedCaptureTransactionIsolation, lockRecordedGraphWrite, generateId, assertCurrentRecordedSchema, baseField, objectField, arrayField, dateField, numberField, advanceRevisionClock, runInsertBatch, edgeInsertDispatch, runInsertBatchReturning, sqlValueList, getNodeRowsByIds, getEdgeRowsByIds, compileKindFilter, encodeTupleKey, runInsertNoReturn, currentReadInstant, compileTemporalFilter, closeRecordedHardDeletedKind, buildPredicateIndex, historicalIdentityPeerClassQuery, IDENTITY_PEER_CLASS_COLUMNS, compileFieldValue, recordedBindParamBudget, extractVectorSimilarityPredicates, extractFulltextMatchPredicates, currentReadInstantFor, extractTemporalOptions, compilePredicateExpression, getPredicatesForAlias, getFieldPointer, getNodeKindsForAlias, getHybridTargetAlias, throwHistoryUnsafeSqlAccess, throwRevisionTrackingUnsafeSqlAccess, compilePredicateClauses } from './chunk-S5TERQVW.js';
-import { canonicalEqual, sortedReplacer } from './chunk-JBQQ7THH.js';
-import { withRecordedRelationsPrecondition, projectGraphBackend, deriveBackend, projectBackend, chunk, postgresReadWriteRefusedSqlState, isMissingTableError, groupBy, postgresTemporaryTableUnavailableSqlState, isPostgresConcurrentDdlRaceError } from './chunk-UGHG7PGX.js';
-import { createSqlSchema, requireSqlSchema, DEFAULT_SQL_SCHEMA, recordedReadSchemaFor, requireExternalRecordedReadSource, createRecordedReadBinding, vectorSlotKey, recordedReadSqlSchema, requireRecordedReadBinding, ALIAS_CTE_PREFIX, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS } from './chunk-NVY5CJFP.js';
-import { runOptionallyInTransaction, createTransactionReadBackend, rowPropsToObject, INTERNAL_TEMPORARY_WRITES } from './chunk-6LN7FIVU.js';
-import { isKnownKind } from './chunk-HEV35TGT.js';
-import { validateEdgeEndpoints } from './chunk-GLHXM7C4.js';
-import { resolveReadCoordinate, withRecordedCoordinate, describeCoordinate, coordinateContext, recordedInstantWallTime, asRecordedInstant, assertValidRecordedInstant, optionalRecordedInstantParts } from './chunk-DZAICA5J.js';
-import { nowIso, validityWindowContainsInstant, validateOptionalCanonicalIsoDate, assertOrderedValidityWindow, preservesImmutableLowerBound, assertWritableValidityWindow, isCanonicalIsoDate, statedBoundMatchesStored } from './chunk-5K2BKEBD.js';
-import { generateIndexDDL } from './chunk-KKBDXCLQ.js';
-import { SYSTEM_INDEX_DECLARATIONS, resolveSystemIndexTableName, systemIndexName, resolveSystemIndexNames, generateSystemIndexDDL } from './chunk-SDBBMD4N.js';
-import { NODE_META_KEYS, EDGE_META_KEYS } from './chunk-P6YLZTRE.js';
+import { createEdgeRowMapper, createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, POSTGRES_ROW_MAPPER_CONFIG, normalizeRowTimestamp, normalizeRequiredRowTimestamp, buildHardDeleteEdgeClaimsByNodeKind, buildHardDeleteUniquesByConcreteKind, buildHardDeleteEdgeClaimsByEdgeKind } from './chunk-S3SDEQMC.js';
+import { rowToNode, executeNodeBulkFindByIndex, executeNodeBulkFindByConstraint, executeNodeFindByConstraint, executeNodeBulkGetOrCreateByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeDeleteBatch, executeNodeDelete, nodeUpsertDirtyCheck, executeNodeUpsertUpdate, executeNodeUpdateWhere, executeNodeUpdate, executeNodeCreateNoReturnBatch, executeNodeCreateBatch, executeNodeCreate, rowToEdge, assertValidityEndMutation, assertClearValidToSupported, runHookedWritePlan, edgeWritePlan, runWritePlan, edgeWriteNeedsConstraintFence, withAlreadyExistsTranslation, createEdgeBatchValidationBackend, rowToNodeMeta, rowToEdgeMeta, unfencedTarget, validityEndAfterMutation, checkCardinalityConstraint, assertsStoredWindowState } from './chunk-2GIV5X4P.js';
+import { storeRuntime, STORE_RUNTIME, applyResolvedNodeClaims, TRANSACTION_RUNTIME, AUTO_REFRESH_STATISTICS_ROW_THRESHOLD, getEmbeddingFields, computeFulltextContent } from './chunk-VTJVMP4I.js';
+import { edgeCardinalityClaimTarget, edgeCardinalityClaim } from './chunk-YA36ABIL.js';
+import { loadAndMergeGraphExtensionDocument, serializeSchema, buildKindRegistry, ensureIdentitySchemaStorage, loadAndVerifyGraph, identitySchemaCommitPreflight, getSchemaChanges, requiresMigration, mergeGraphExtension, commitNewSchemaVersion, commitNewSchemaVersionWithPreflight, parseSerializedSchema, planRemovals, stripGraphExtension, applyDeprecatedKinds, identityKindCascadeNeeded, ensureSchema, loadActiveSchemaWithBootstrap, extensionKindNames, serializeSchemaProperties, buildGraphExtensionOntologyKeySet, compileTimeOntologyKey, commitNewSchemaVersionIfKindsEmpty, serializeIndexDeclaration } from './chunk-2Q45FAIE.js';
+import { getTypeName } from './chunk-7OWE7WD6.js';
+import { rebuildIdentityClosureForContext, loadCurrentStructuralClasses, loadAssertionsByIds, toTransferAssertion, liveNodeKindsSharingIds, createIdentityFacade, createIdentityReadFacade, validateIdentityForContext, removeIdentityKindsForContext, readIdentityAssertionsForInterchange, readIdentityAssertionPageAtTarget, lockIdentityGraph, foldIdentityForCreatedNodes, importIdentityAssertionsIntoTarget, assertAffectedIdentityClassesConsistent, applyIdentityChangesForContext, refKey, requireNodeValidityEndCompatible, detachIdentityForNode } from './chunk-GVYVGGPJ.js';
+import { isParameterRef, resolveParameterValueType, fieldRef, buildFieldBuilderForTypeInfo, stringField, createFulltextAccessor, CURRENT_READ_INSTANT_PLACEHOLDER, withPinnedReadInstant, assertRevisionTrackableBackend, createRecordedBackend, lockRecordedGraphWrite, runInWriteTransaction, createRecordedTransactionScope, readRecordedClock, ensureRevisionOrigin, withRecordedFlushObserver, withWriteTransactionSession, recordedCaptureRequiresCallbackTransactionError, assertRecordedCaptureTransactionIsolation, lockSchemaVersionForStoreWrite, generateId, assertCurrentRecordedSchema, baseField, objectField, arrayField, dateField, numberField, advanceRevisionClock, validateEdgeProps, sqlValueList, getNodeRowsByIds, getEdgeRowsByIds, compileKindFilter, currentReadInstant, compileTemporalFilter, closeRecordedHardDeletedKind, buildPredicateIndex, historicalIdentityPeerClassQuery, IDENTITY_PEER_CLASS_COLUMNS, compileFieldValue, recordedBindParamBudget, extractVectorSimilarityPredicates, extractFulltextMatchPredicates, currentReadInstantFor, extractTemporalOptions, compilePredicateExpression, getPredicatesForAlias, getFieldPointer, getNodeKindsForAlias, getHybridTargetAlias, throwHistoryUnsafeSqlAccess, throwRevisionTrackingUnsafeSqlAccess, compilePredicateClauses } from './chunk-FX5ZW6PN.js';
+import { withRecordedRelationsPrecondition, projectGraphBackend, deriveBackend, canonicalEqual, sortedReplacer, projectBackend, chunk, postgresReadWriteRefusedSqlState, isMissingTableError, groupBy, postgresTemporaryTableUnavailableSqlState, isPostgresConcurrentDdlRaceError } from './chunk-IRPYOHRC.js';
+import { createSqlSchema, requireSqlSchema, DEFAULT_SQL_SCHEMA, recordedReadSchemaFor, requireExternalRecordedReadSource, createRecordedReadBinding, vectorSlotKey, recordedReadSqlSchema, requireRecordedReadBinding, ALIAS_CTE_PREFIX, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS } from './chunk-Y55DLLEG.js';
+import { runOptionallyInTransaction, createTransactionReadBackend, rowPropsToObject, INTERNAL_TEMPORARY_WRITES } from './chunk-PALYTHGM.js';
+import { isKnownKind } from './chunk-DI6VC62F.js';
+import { compareClaimTargets, encodeTupleKey, uniquenessClaimTarget, subClassComponent, isSameClaimOwner, DISJOINT_CONSTRAINT_NAME, disjointnessClaimAxis, validateEdgeEndpoints } from './chunk-5LKOVCPP.js';
+import { resolveReadCoordinate, withRecordedCoordinate, describeCoordinate, coordinateContext, recordedInstantWallTime, asRecordedInstant, assertValidRecordedInstant, optionalRecordedInstantParts } from './chunk-6NKSE5AU.js';
+import { nowIso, validityWindowContainsInstant, validateOptionalCanonicalIsoDate, assertOrderedValidityWindow, preservesImmutableLowerBound, assertWritableValidityWindow, isCanonicalIsoDate, statedBoundMatchesStored } from './chunk-K46SDNQD.js';
+import { generateIndexDDL } from './chunk-WQBAQZHR.js';
+import { SYSTEM_INDEX_DECLARATIONS, resolveSystemIndexTableName, systemIndexName, resolveSystemIndexNames, generateSystemIndexDDL } from './chunk-H3XP6BAV.js';
+import { NODE_META_KEYS, EDGE_META_KEYS } from './chunk-ZRJTM7MT.js';
 import { sha256Hex, fnv1aBase36 } from './chunk-K34OPSJK.js';
 import { DEFAULT_PAGINATION_LIMIT, DEFAULT_STREAM_BATCH_SIZE, SQLITE_PATH_DELIMITER, PG_ARRAY_START, PG_ARRAY_END, PG_PATH_ELEMENT_SEPARATOR, MAX_PG_IDENTIFIER_LENGTH } from './chunk-2EBMPJBO.js';
-import { getDialect, assertVectorMinScore, assertApproximateMetricSupported, vectorScoreExpression, vectorMinScoreCondition } from './chunk-ZDKTPBGV.js';
-import { isSqlPlaceholder, bindSqlValue, markAnnIndexScan, asCompiledSelectSql, isRawExecutable, renderSql, annIndexScanTypes, sql, asCompiledRowsSql, markForceCustomPlan, asCompiledStatementSql, asCompiledTemporaryStatementSql } from './chunk-3DMMGT6S.js';
+import { getDialect, assertVectorMinScore, assertApproximateMetricSupported, vectorScoreExpression, vectorMinScoreCondition } from './chunk-EDLKIQRI.js';
+import { isSqlPlaceholder, bindSqlValue, markAnnIndexScan, asCompiledSelectSql, isRawExecutable, renderSql, annIndexScanTypes, sql, asCompiledRowsSql, markForceCustomPlan, asCompiledStatementSql, asCompiledTemporaryStatementSql } from './chunk-46UGOVRW.js';
 import { createSchemaIntrospector } from './chunk-AMKPPFUO.js';
 import { resolveEmbeddingFields, resolveGraphVectorSlots, resolveDeclaredFulltextLanguage, getSearchableFields } from './chunk-PC2UBAUB.js';
-import { IncompatibleChangeError } from './chunk-D5R42W5D.js';
+import { IncompatibleChangeError } from './chunk-XZW2CTNO.js';
 import { META_EDGE_DISJOINT_WITH, META_EDGE_EQUIVALENT_TO, META_EDGE_SAME_AS, META_EDGE_SUB_CLASS_OF } from './chunk-JXXDZTMN.js';
-import { validateProjectionField } from './chunk-XVWOYKIK.js';
-import { ConfigurationError, UnsupportedPredicateError, ValidationError, KindNotFoundError, EndpointError, EagerMaterializationError, ContributionRebuildUnsupportedError, CompilerInvariantError, CardinalityError, DatabaseOperationError, EdgeNotFoundError, MigrationError, EDGE_IDENTITY_MISMATCH_CODE, UnsupportedBackendCapabilityError, EndpointNotFoundError, GraphAlgorithmConvergenceError, InvalidEdgeWeightError } from './chunk-ZLONH2UD.js';
+import { validateProjectionField } from './chunk-FZHF5UWR.js';
+import { compareStrings, compareCodePoints } from './chunk-HZUB5CON.js';
+import { ConfigurationError, UnsupportedPredicateError, ValidationError, KindNotFoundError, EndpointError, EagerMaterializationError, ContributionRebuildUnsupportedError, CompilerInvariantError, CardinalityError, DatabaseOperationError, EdgeNotFoundError, MigrationError, EDGE_IDENTITY_MISMATCH_CODE, UnsupportedBackendCapabilityError, EndpointNotFoundError, GraphAlgorithmConvergenceError, InvalidEdgeWeightError } from './chunk-YDEJQWOL.js';
 import { jsonPointer, parseJsonPointer, resolveJsonPointer } from './chunk-FWJKWH6U.js';
 import { readOwnProperty, requireDefined, createDataKeyedBag, isInteropProbeKey, hasOwnKey, isPresent } from './chunk-DYATYRY4.js';
 
@@ -13918,6 +13919,155 @@ function createGraphAlgorithms(params) {
   };
 }
 
+// src/store/claims/verify.ts
+function uniquenessAxisGroups(graph, registry) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const [kind, registration] of Object.entries(graph.nodes)) {
+    for (const constraint of registration.unique ?? []) {
+      const target = uniquenessClaimTarget(kind, constraint.scope, registry);
+      const coveredKinds = constraint.scope === "kind" ? [kind] : subClassComponent(kind, registry);
+      const identity = `${constraint.name}\0${target.axis}`;
+      const existing = groups.get(identity);
+      groups.set(identity, {
+        constraintName: constraint.name,
+        axis: target.axis,
+        coveredKinds: /* @__PURE__ */ new Set([
+          ...existing?.coveredKinds ?? [],
+          ...coveredKinds
+        ])
+      });
+    }
+  }
+  return [...groups.values()];
+}
+function uniquenessAxisFor(row, groups) {
+  const covering = groups.filter(
+    (group) => group.constraintName === row.constraintName && group.coveredKinds.has(row.nodeKind)
+  ).toSorted(
+    (left, right) => right.coveredKinds.size - left.coveredKinds.size || compareStrings(left.axis, right.axis)
+  );
+  return covering[0]?.axis ?? row.nodeKind;
+}
+function sortedOwners(owners) {
+  return owners.toSorted(
+    (left, right) => compareStrings(left.concreteKind, right.concreteKind) || compareStrings(left.nodeId, right.nodeId)
+  );
+}
+function targetIdentity(target) {
+  return [
+    target.relation,
+    target.axis,
+    target.constraintName ?? "",
+    target.key
+  ].join("\0");
+}
+function uniquenessViolations(rows, groups, graphId) {
+  const byAxis = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const target = {
+      relation: "uniques",
+      graphId,
+      axis: uniquenessAxisFor(row, groups),
+      constraintName: row.constraintName,
+      key: row.key
+    };
+    const identity = targetIdentity(target);
+    const entry2 = byAxis.get(identity) ?? { target, owners: [] };
+    const owner = {
+      concreteKind: row.concreteKind,
+      nodeId: row.nodeId
+    };
+    if (!entry2.owners.some((held) => isSameClaimOwner(held, owner)))
+      entry2.owners.push(owner);
+    byAxis.set(identity, entry2);
+  }
+  return [...byAxis.values()].filter((entry2) => entry2.owners.length > 1).map((entry2) => ({
+    family: "nodeUniqueness",
+    target: entry2.target,
+    owners: sortedOwners(entry2.owners)
+  }));
+}
+function disjointnessViolations(overlaps, registry, graphId) {
+  return overlaps.map((overlap) => ({
+    family: "nodeDisjointness",
+    target: {
+      relation: "uniques",
+      graphId,
+      axis: disjointnessClaimAxis(overlap.kinds[0], overlap.kinds[1], registry),
+      constraintName: DISJOINT_CONSTRAINT_NAME,
+      key: overlap.nodeId
+    },
+    owners: sortedOwners([
+      { concreteKind: overlap.kinds[0], nodeId: overlap.nodeId },
+      { concreteKind: overlap.kinds[1], nodeId: overlap.nodeId }
+    ])
+  }));
+}
+function edgeCardinalityViolations(rows, graphId) {
+  const byAxis = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const target = edgeCardinalityClaimTarget({ ...row, graphId });
+    const identity = targetIdentity(target);
+    const entry2 = byAxis.get(identity) ?? { target, edgeIds: [] };
+    entry2.edgeIds.push(row.edgeId);
+    byAxis.set(identity, entry2);
+  }
+  return [...byAxis.values()].filter((entry2) => entry2.edgeIds.length > 1).map((entry2) => ({
+    family: "edgeCardinality",
+    target: entry2.target,
+    edgeIds: entry2.edgeIds.toSorted(
+      (left, right) => compareStrings(left, right)
+    )
+  }));
+}
+function fenceDeclarations(graph, registry, graphId) {
+  const uniqueConstraintNames = new Set(
+    Object.values(graph.nodes).flatMap(
+      (registration) => (registration.unique ?? []).map((constraint) => constraint.name)
+    )
+  );
+  const edgeCardinalities = Object.entries(graph.edges).flatMap(
+    ([edgeKind, registration]) => {
+      const cardinality = registration.cardinality ?? "many";
+      return cardinality === "many" ? [] : [{ edgeKind, cardinality }];
+    }
+  );
+  return {
+    graphId,
+    uniqueConstraintNames: [...uniqueConstraintNames],
+    disjointKindPairs: registry.disjointKindPairs(),
+    edgeCardinalities
+  };
+}
+async function verifyConstraintFences(context) {
+  const audit = context.backend.readConstraintFenceViolations;
+  if (audit === void 0) {
+    throw new ConfigurationError(
+      "This backend cannot audit constraint fences: it does not implement `readConstraintFenceViolations`.",
+      { code: "CONSTRAINT_FENCE_AUDIT_UNSUPPORTED" },
+      {
+        suggestion: "Run the audit through a backend built by `createSqliteBackend` or `createPostgresBackend`, or implement the member."
+      }
+    );
+  }
+  const declarations = fenceDeclarations(
+    context.graph,
+    context.registry,
+    context.graphId
+  );
+  const rows = await audit(declarations);
+  const groups = uniquenessAxisGroups(context.graph, context.registry);
+  return [
+    ...uniquenessViolations(rows.contendedUniqueRows, groups, context.graphId),
+    ...disjointnessViolations(
+      rows.disjointOverlaps,
+      context.registry,
+      context.graphId
+    ),
+    ...edgeCardinalityViolations(rows.contendedEdgeRows, context.graphId)
+  ].toSorted((left, right) => compareClaimTargets(left.target, right.target));
+}
+
 // src/store/operations/edge-identity.ts
 function edgeIdentityFromRow(row) {
   return {
@@ -15135,6 +15285,12 @@ var HISTORY_STORE_BACKEND_KEYS = [
   "capabilities",
   "checkUnique",
   "checkUniqueBatch",
+  // The edge cardinality fence. Both members write only the claim relation —
+  // a reservation whose holder is a graph row, never a graph row itself — so
+  // neither can bypass a capture flush, and a history-enabled store that could
+  // not reach them would write constrained edges unfenced.
+  "claimEdgeCardinality",
+  "claimEdgeCardinalityBatch",
   "claimIndexMaterialization",
   "close",
   "commitSchemaVersion",
@@ -15159,12 +15315,19 @@ var HISTORY_STORE_BACKEND_KEYS = [
   "dropVectorIndex",
   "edgeExistsBetween",
   "ensureContributionMaterializationsTable",
+  // Installs a database-global extension — and `ensureTrigramExtension` is the
+  // same operation under its deprecated `pg_trgm`-only name, so the two are
+  // classified together or not at all. Like the `ensure*Table` members they sit
+  // beside, they create storage-level scaffolding and write no graph row, so
+  // neither can bypass a capture flush.
+  "ensureExtension",
   "ensureFulltextTable",
   "ensureIndexMaterializationsTable",
   "ensureKindRemovalsTable",
   "ensureReconciliationMarkersTable",
   "ensureRevisionOriginsTable",
   "ensureRuntimeContributions",
+  "ensureTrigramExtension",
   "ensureVectorSlotContribution",
   "ensureVectorSlotContributions",
   "execute",
@@ -15191,6 +15354,10 @@ var HISTORY_STORE_BACKEND_KEYS = [
   "hardDeleteEdge",
   "hardDeleteEdgesBatch",
   "hardDeleteNode",
+  // Reaps the claims a removed kind's nodes own. Like the sibling
+  // `hardDeleteUniquesByNodeIds` beside it, it clears sidecar rows whose
+  // entity rows are already gone, so it cannot bypass a capture flush.
+  "hardDeleteUniquesByConcreteKind",
   "hardDeleteUniquesByNodeIds",
   "hybridSearch",
   "insertEdge",
@@ -15204,6 +15371,13 @@ var HISTORY_STORE_BACKEND_KEYS = [
   "insertUnique",
   "insertUniqueBatch",
   "probeContributions",
+  // Housekeeping for the relation above: drops claim rows whose holders are
+  // already gone. Writes no graph row.
+  "purgeEdgeClaims",
+  // Read-only fence audit. Writes nothing at all, so it can bypass no capture
+  // flush, and a history-enabled store that could not reach it would have no
+  // way to report which declared constraint its data already violates.
+  "readConstraintFenceViolations",
   "recordContributionMaterialization",
   "recordIndexMaterialization",
   "recordKindRemoval",
@@ -15348,6 +15522,10 @@ function delay(ms) {
   });
 }
 async function ensureTrigramExtension(backend) {
+  if (backend.ensureExtension !== void 0) {
+    await backend.ensureExtension("pg_trgm");
+    return;
+  }
   if (backend.ensureTrigramExtension !== void 0) {
     await backend.ensureTrigramExtension();
     return;
@@ -16073,6 +16251,7 @@ async function materializeRemovals(context, options = {}) {
   const edgesTable = tableNames?.edges ?? "typegraph_edges";
   const fulltextTable = tableNames?.fulltext ?? "typegraph_node_fulltext";
   const uniquesTable = tableNames?.uniques ?? "typegraph_node_uniques";
+  const edgeClaimsTable = tableNames?.edgeClaims ?? "typegraph_edge_claims";
   const captureRecordedRemovals = context.captureRecordedRemovals === true;
   const ctx = {
     backend,
@@ -16081,6 +16260,7 @@ async function materializeRemovals(context, options = {}) {
     edgesTable,
     fulltextTable,
     uniquesTable,
+    edgeClaimsTable,
     captureRecordedRemovals,
     recordedSchema: captureRecordedRemovals ? context.recordedSchema ?? createSqlSchema(backend.tableNames) : void 0
   };
@@ -16236,7 +16416,12 @@ async function materializeOne2(row, ctx) {
   }
 }
 async function closeRecordedAndDeleteLiveRows(ctx, row, target) {
-  const deleteStatements = buildRemovedKindLiveDeleteStatements(ctx, row);
+  const reapsEdgeClaims = await target.tableExists(ctx.edgeClaimsTable);
+  const deleteStatements = buildRemovedKindLiveDeleteStatements(
+    ctx,
+    row,
+    reapsEdgeClaims
+  );
   if (!ctx.captureRecordedRemovals || ctx.recordedSchema === void 0) {
     await executeDeleteStatements(target, deleteStatements);
     return;
@@ -16263,24 +16448,54 @@ async function closeRecordedAndDeleteLiveRows(ctx, row, target) {
   );
   await executeDeleteStatements(target, deleteStatements);
 }
-function buildRemovedKindLiveDeleteStatements(ctx, row) {
+function buildRemovedKindLiveDeleteStatements(ctx, row, reapsEdgeClaims) {
   const graphLit = literal(ctx.graphId);
   const kindLit = literal(row.kindName);
   if (row.entity === "node") {
     return [
-      `DELETE FROM ${quote(ctx.nodesTable)} WHERE graph_id = ${graphLit} AND kind = ${kindLit}`,
-      `DELETE FROM ${quote(ctx.edgesTable)} WHERE graph_id = ${graphLit} AND (from_kind = ${kindLit} OR to_kind = ${kindLit})`,
-      `DELETE FROM ${quote(ctx.fulltextTable)} WHERE graph_id = ${graphLit} AND node_kind = ${kindLit}`,
-      `DELETE FROM ${quote(ctx.uniquesTable)} WHERE graph_id = ${graphLit} AND node_kind = ${kindLit}`
+      // Must precede the edge delete: ownership is discovered by selecting the
+      // connected edge ids, which no longer exist afterward.
+      ...reapsEdgeClaims ? [
+        buildHardDeleteEdgeClaimsByNodeKind(
+          ctx.edgeClaimsTable,
+          ctx.edgesTable,
+          { graphId: ctx.graphId, nodeKind: row.kindName }
+        )
+      ] : [],
+      sql.raw(
+        `DELETE FROM ${quote(ctx.nodesTable)} WHERE graph_id = ${graphLit} AND kind = ${kindLit}`
+      ),
+      sql.raw(
+        `DELETE FROM ${quote(ctx.edgesTable)} WHERE graph_id = ${graphLit} AND (from_kind = ${kindLit} OR to_kind = ${kindLit})`
+      ),
+      sql.raw(
+        `DELETE FROM ${quote(ctx.fulltextTable)} WHERE graph_id = ${graphLit} AND node_kind = ${kindLit}`
+      ),
+      buildHardDeleteUniquesByConcreteKind(ctx.uniquesTable, {
+        graphId: ctx.graphId,
+        concreteKind: row.kindName
+      })
     ];
   }
   return [
-    `DELETE FROM ${quote(ctx.edgesTable)} WHERE graph_id = ${graphLit} AND kind = ${kindLit}`
+    sql.raw(
+      `DELETE FROM ${quote(ctx.edgesTable)} WHERE graph_id = ${graphLit} AND kind = ${kindLit}`
+    ),
+    // Housekeeping, on the same one-owner terms as the uniqueness reap: the
+    // rows this kind's edges held are takeable the moment those edges are gone,
+    // but nothing would ever reap them, so the relation would grow by one row
+    // per removed constrained kind forever.
+    ...reapsEdgeClaims ? [
+      buildHardDeleteEdgeClaimsByEdgeKind(ctx.edgeClaimsTable, {
+        graphId: ctx.graphId,
+        edgeKind: row.kindName
+      })
+    ] : []
   ];
 }
 async function executeDeleteStatements(target, statements) {
   for (const statement of statements) {
-    await target.executeStatement(asCompiledStatementSql(sql.raw(statement)));
+    await target.executeStatement(asCompiledStatementSql(statement));
   }
 }
 async function dropEmbeddingTableStorage(ctx, row, target) {
@@ -16443,6 +16658,39 @@ function literal(value) {
   return `'${value.replaceAll("'", "''")}'`;
 }
 
+// src/store/operations/edge-write-fences.ts
+var EdgeUpdateTargetMoved = class extends Error {
+  constructor(kind, id) {
+    super(
+      `The ${kind} edge "${id}" was replaced between this update's read and its write; re-resolving it. This is internal and is never returned to a caller.`
+    );
+    this.name = "EdgeUpdateTargetMoved";
+  }
+};
+function isEdgeUpdateNoRowError(error) {
+  return error instanceof DatabaseOperationError && error.details.operation === "update" && error.details.entity === "edge" && error.details.reason === "no_row_returned";
+}
+async function withUnmatchedEdgeUpdateRefusal(graphId, target, id, expected, assertedValidFrom, write) {
+  try {
+    return await write();
+  } catch (error) {
+    if (!isEdgeUpdateNoRowError(error)) throw error;
+    const current = await target.getEdge(graphId, id);
+    if (current !== void 0) {
+      assertEdgeIdentityMatches(
+        id,
+        expected,
+        edgeIdentityFromRow(current),
+        "update"
+      );
+      if (assertedValidFrom && current.deleted_at === void 0) {
+        throw new EdgeUpdateTargetMoved(expected.kind, id);
+      }
+    }
+    throw new EdgeNotFoundError(expected.kind, id);
+  }
+}
+
 // src/store/operations/edge-operations.ts
 function getEdgeRegistration(graph, kind) {
   if (!hasOwnKey(graph.edges, kind)) throw new KindNotFoundError(kind, "edge");
@@ -16450,24 +16698,15 @@ function getEdgeRegistration(graph, kind) {
   if (registration === void 0) throw new KindNotFoundError(kind, "edge");
   return registration;
 }
-function buildEdgeEndpointCacheKey(graphId, kind, id) {
-  return encodeTupleKey([graphId, kind, id]);
-}
-function buildEdgeFromCacheKey(graphId, edgeKind, fromKind, fromId) {
-  return encodeTupleKey([graphId, edgeKind, fromKind, fromId]);
-}
-function buildEdgeBetweenCacheKey(graphId, edgeKind, fromKind, fromId, toKind, toId) {
-  return encodeTupleKey([graphId, edgeKind, fromKind, fromId, toKind, toId]);
-}
-function buildCountEdgesFromCacheKey(params) {
-  const activeOnly = params.activeOnly === true ? "1" : "0";
-  return encodeTupleKey([
-    params.graphId,
-    params.edgeKind,
-    params.fromKind,
-    params.fromId,
-    activeOnly
-  ]);
+function edgeInsertWork(prepared) {
+  const claim = edgeCardinalityClaim(
+    prepared.cardinality,
+    prepared.insertParams
+  );
+  return {
+    params: prepared.insertParams,
+    ...claim === void 0 ? {} : { claim }
+  };
 }
 function buildInsertEdgeParams(graphId, id, kind, fromKind, fromId, toKind, toId, props, validFrom, validTo) {
   const insertParams = {
@@ -16484,106 +16723,6 @@ function buildInsertEdgeParams(graphId, id, kind, fromKind, fromId, toKind, toId
   if (validTo !== void 0) insertParams.validTo = validTo;
   return insertParams;
 }
-function incrementPendingCount(counts, key) {
-  const previous = counts.get(key) ?? 0;
-  counts.set(key, previous + 1);
-}
-function createEdgeBatchValidationBackend(backend) {
-  const endpointCache = /* @__PURE__ */ new Map();
-  const countEdgesFromCache = /* @__PURE__ */ new Map();
-  const edgeExistsCache = /* @__PURE__ */ new Map();
-  const pendingOneCounts = /* @__PURE__ */ new Map();
-  const pendingOneActiveCounts = /* @__PURE__ */ new Map();
-  const pendingUniquePairs = /* @__PURE__ */ new Set();
-  async function getNodeCached(graphId, kind, id) {
-    const cacheKey = buildEdgeEndpointCacheKey(graphId, kind, id);
-    if (endpointCache.has(cacheKey)) {
-      return endpointCache.get(cacheKey);
-    }
-    const node = await backend.getNode(graphId, kind, id);
-    endpointCache.set(cacheKey, node);
-    return node;
-  }
-  function seedEndpointRow(graphId, kind, id, row) {
-    const cacheKey = buildEdgeEndpointCacheKey(graphId, kind, id);
-    if (endpointCache.has(cacheKey)) return;
-    endpointCache.set(cacheKey, row);
-  }
-  async function countEdgesFromCached(params) {
-    const cacheKey = buildCountEdgesFromCacheKey(params);
-    let baseCount = countEdgesFromCache.get(cacheKey);
-    if (baseCount === void 0) {
-      baseCount = await backend.countEdgesFrom(params);
-      countEdgesFromCache.set(cacheKey, baseCount);
-    }
-    const pendingKey = buildEdgeFromCacheKey(
-      params.graphId,
-      params.edgeKind,
-      params.fromKind,
-      params.fromId
-    );
-    const pendingCount = params.activeOnly === true ? pendingOneActiveCounts.get(pendingKey) ?? 0 : pendingOneCounts.get(pendingKey) ?? 0;
-    return baseCount + pendingCount;
-  }
-  async function edgeExistsBetweenCached(params) {
-    const cacheKey = buildEdgeBetweenCacheKey(
-      params.graphId,
-      params.edgeKind,
-      params.fromKind,
-      params.fromId,
-      params.toKind,
-      params.toId
-    );
-    if (pendingUniquePairs.has(cacheKey)) {
-      return true;
-    }
-    if (edgeExistsCache.has(cacheKey)) {
-      return edgeExistsCache.get(cacheKey) ?? false;
-    }
-    const exists = await backend.edgeExistsBetween(params);
-    edgeExistsCache.set(cacheKey, exists);
-    return exists;
-  }
-  function registerPendingEdgeForCardinality(insertParams, cardinality) {
-    const fromCacheKey = buildEdgeFromCacheKey(
-      insertParams.graphId,
-      insertParams.kind,
-      insertParams.fromKind,
-      insertParams.fromId
-    );
-    if (cardinality === "one") {
-      incrementPendingCount(pendingOneCounts, fromCacheKey);
-      return;
-    }
-    if (cardinality === "oneActive") {
-      if (insertParams.validTo === void 0) {
-        incrementPendingCount(pendingOneActiveCounts, fromCacheKey);
-      }
-      return;
-    }
-    if (cardinality === "unique") {
-      const uniqueCacheKey = buildEdgeBetweenCacheKey(
-        insertParams.graphId,
-        insertParams.kind,
-        insertParams.fromKind,
-        insertParams.fromId,
-        insertParams.toKind,
-        insertParams.toId
-      );
-      pendingUniquePairs.add(uniqueCacheKey);
-    }
-  }
-  const validationBackend = deriveBackend(backend, {
-    getNode: getNodeCached,
-    countEdgesFrom: countEdgesFromCached,
-    edgeExistsBetween: edgeExistsBetweenCached
-  });
-  return {
-    backend: validationBackend,
-    registerPendingEdgeForCardinality,
-    seedEndpointRow
-  };
-}
 async function validateAndPrepareEdgeCreate(ctx, input, id, backend) {
   const kind = input.kind;
   const fromKind = input.fromKind;
@@ -16676,11 +16815,17 @@ async function executeEdgeCreateInternal(ctx, input, backend, options) {
   const opContext = ctx.createOperationContext("create", "edge", kind, id);
   const shouldReturnRow = options?.returnRow ?? true;
   const convergeOn = options?.convergeOn;
-  return runHookedWriteOperation(
+  return runHookedWritePlan(
     ctx,
     opContext,
+    // A create that runs a cardinality probe, or one converging on a match
+    // key, decides something the write must not have invalidated. A plain
+    // `many` create decides nothing and takes no lock.
+    edgeWritePlan(
+      convergeOn === void 0 ? edgeWriteNeedsConstraintFence(edgeCardinality(ctx, kind)) : "edgeMatchKeyConvergence"
+    ),
     backend,
-    async (target) => {
+    async (session, target) => {
       if (convergeOn !== void 0) {
         const candidateRows = await target.findEdgesByKind({
           graphId: ctx.graphId,
@@ -16707,21 +16852,13 @@ async function executeEdgeCreateInternal(ctx, input, backend, options) {
         id,
         target
       );
+      const work = edgeInsertWork(prepared);
       const row = await withAlreadyExistsTranslation("edge", async () => {
-        if (shouldReturnRow) return target.insertEdge(prepared.insertParams);
-        await runInsertNoReturn(
-          edgeInsertDispatch(target),
-          prepared.insertParams
-        );
+        if (shouldReturnRow) return session.createEdge(work);
+        await session.createEdgeNoReturn(work);
         return;
       });
       return row === void 0 ? void 0 : rowToEdge(row);
-    },
-    {
-      // A create that runs a cardinality probe, or one converging on a match
-      // key, decides something the write must not have invalidated. A plain
-      // `many` create decides nothing and takes no lock.
-      fencesConstraintProbe: convergeOn === void 0 ? edgeWriteNeedsConstraintFence(edgeCardinality(ctx, kind)) : "edgeMatchKeyConvergence"
     }
   );
 }
@@ -16780,52 +16917,52 @@ async function prepareEdgeBatchCreates(ctx, inputs, backend) {
       prepared.cardinality
     );
   }
-  const batchInsertParams = preparedCreates.map(
-    (prepared) => prepared.insertParams
+  const batchInsertWork = preparedCreates.map(
+    (prepared) => edgeInsertWork(prepared)
   );
-  return { preparedCreates, batchInsertParams };
+  return { preparedCreates, batchInsertWork };
 }
 async function executeEdgeCreateNoReturnBatch(ctx, inputs, backend) {
   if (inputs.length === 0) {
     return;
   }
-  await runInWriteTransaction(
+  await runWritePlan(
     ctx,
+    edgeWritePlan(batchFencesConstraintProbe(ctx, inputs)),
     backend,
-    async (target) => {
-      const { batchInsertParams } = await prepareEdgeBatchCreates(
+    async (session, target) => {
+      const { batchInsertWork } = await prepareEdgeBatchCreates(
         ctx,
         inputs,
         target
       );
       await withAlreadyExistsTranslation(
         "edge",
-        () => runInsertBatch(edgeInsertDispatch(target), batchInsertParams)
+        () => session.createEdgesNoReturn(batchInsertWork)
       );
-    },
-    { fencesConstraintProbe: batchFencesConstraintProbe(ctx, inputs) }
+    }
   );
 }
 async function executeEdgeCreateBatch(ctx, inputs, backend) {
   if (inputs.length === 0) {
     return [];
   }
-  return runInWriteTransaction(
+  return runWritePlan(
     ctx,
+    edgeWritePlan(batchFencesConstraintProbe(ctx, inputs)),
     backend,
-    async (target) => {
-      const { batchInsertParams } = await prepareEdgeBatchCreates(
+    async (session, target) => {
+      const { batchInsertWork } = await prepareEdgeBatchCreates(
         ctx,
         inputs,
         target
       );
       const rows = await withAlreadyExistsTranslation(
         "edge",
-        () => runInsertBatchReturning(edgeInsertDispatch(target), batchInsertParams)
+        () => session.createEdges(batchInsertWork)
       );
       return rows.map((row) => rowToEdge(row));
-    },
-    { fencesConstraintProbe: batchFencesConstraintProbe(ctx, inputs) }
+    }
   );
 }
 function batchFencesConstraintProbe(ctx, inputs) {
@@ -16869,7 +17006,7 @@ function edgeUpsertDirtyCheck(ctx, kind, id, existingProps, inputProps) {
     unchanged: canonicalEqual(validatedProps, existingProps)
   };
 }
-async function performEdgeUpdate(ctx, input, target, options) {
+async function performEdgeUpdate(ctx, input, session, target, options) {
   const id = input.id;
   assertValidityEndMutation(input, {
     entityType: "edge",
@@ -16900,6 +17037,7 @@ async function performEdgeUpdate(ctx, input, target, options) {
   );
   const cardinality = edgeCardinality(ctx, input.identity.kind);
   const reentersLivePopulation = options?.clearDeleted === true && existing.deleted_at !== void 0;
+  let reentryClaim;
   const reentersActivePopulation = cardinality === "oneActive" && effectiveValidTo === void 0 && (existing.deleted_at !== void 0 || existing.valid_to !== void 0);
   if (reentersLivePopulation || reentersActivePopulation) {
     await checkCardinalityConstraint(
@@ -16916,6 +17054,16 @@ async function performEdgeUpdate(ctx, input, target, options) {
       existing.to_id,
       effectiveValidTo
     );
+    reentryClaim = edgeCardinalityClaim(cardinality, {
+      graphId: ctx.graphId,
+      id,
+      kind: input.identity.kind,
+      fromKind: existing.from_kind,
+      fromId: existing.from_id,
+      toKind: existing.to_kind,
+      toId: existing.to_id,
+      ...effectiveValidTo === void 0 ? {} : { validTo: effectiveValidTo }
+    });
   }
   const windowVerdict = assertWritableValidityWindow(
     `edge "${id}"`,
@@ -16930,85 +17078,39 @@ async function performEdgeUpdate(ctx, input, target, options) {
     },
     validTo
   );
-  const updateParams = {
-    graphId: ctx.graphId,
+  const fences = {
+    validityLowerBound: windowVerdict.storedLowerBoundFence,
+    validityUpperBound: reentersActivePopulation && existing.valid_to !== void 0 ? { expectedValidTo: existing.valid_to } : {},
+    edgeIdentity: input.identity
+  };
+  const work = {
     id,
-    kind: input.identity.kind,
     props: validatedProps,
-    // The bound the window verdict above READ, carried into the same `WHERE` as
-    // the identity components and on exactly the same terms: present only when
-    // the verdict consulted it, because a component the caller made no claim
-    // about must not become a predicate that refuses legitimate writes.
-    ...windowVerdict.storedLowerBoundFence
+    ...appliedValidFrom !== void 0 && { validFrom: appliedValidFrom },
+    // `validTo` and `clearValidTo` are mutually exclusive in the params, so the
+    // work states exactly one of them.
+    ...input.clearValidTo === true ? { clearValidTo: true } : validTo === void 0 ? {} : { validTo },
+    ...options?.clearDeleted === true && { clearDeleted: true },
+    ...reentryClaim === void 0 ? {} : { claim: reentryClaim }
   };
-  if (input.identity.fromKind !== void 0) {
-    updateParams.fromKind = input.identity.fromKind;
-  }
-  if (input.identity.fromId !== void 0) {
-    updateParams.fromId = input.identity.fromId;
-  }
-  if (input.identity.toKind !== void 0) {
-    updateParams.toKind = input.identity.toKind;
-  }
-  if (input.identity.toId !== void 0) {
-    updateParams.toId = input.identity.toId;
-  }
-  if (appliedValidFrom !== void 0) {
-    updateParams.validFrom = appliedValidFrom;
-  }
-  if (reentersActivePopulation && existing.valid_to !== void 0) {
-    updateParams.expectedValidTo = existing.valid_to;
-  }
-  if (options?.clearDeleted) updateParams.clearDeleted = true;
   const row = await withUnmatchedEdgeUpdateRefusal(
-    ctx,
+    ctx.graphId,
     target,
     id,
     input.identity,
-    updateParams.expectedValidFrom !== void 0 || updateParams.expectedValidTo !== void 0,
-    () => target.updateEdge({
-      ...updateParams,
-      ...input.clearValidTo === true ? { clearValidTo: true } : validTo === void 0 ? {} : { validTo }
-    })
+    // "Did this write assert any window state?" is one predicate with one
+    // owner, consulted here and by the fence appliers that carry it, rather
+    // than re-derived from the params the diagnosis never sees.
+    assertsStoredWindowState(fences),
+    () => session.reviseEdge(work, fences)
   );
   return rowToEdge(row);
 }
-function isEdgeUpdateNoRowError(error) {
-  return error instanceof DatabaseOperationError && error.details.operation === "update" && error.details.entity === "edge" && error.details.reason === "no_row_returned";
-}
-async function withUnmatchedEdgeUpdateRefusal(ctx, target, id, expected, assertedWindowState, write) {
-  try {
-    return await write();
-  } catch (error) {
-    if (!isEdgeUpdateNoRowError(error)) throw error;
-    const current = await target.getEdge(ctx.graphId, id);
-    if (current !== void 0) {
-      assertEdgeIdentityMatches(
-        id,
-        expected,
-        edgeIdentityFromRow(current),
-        "update"
-      );
-      if (assertedWindowState && current.deleted_at === void 0) {
-        throw new EdgeUpdateTargetMoved(expected.kind, id);
-      }
-    }
-    throw new EdgeNotFoundError(expected.kind, id);
-  }
-}
-var EdgeUpdateTargetMoved = class extends Error {
-  constructor(kind, id) {
-    super(
-      `The ${kind} edge "${id}" was replaced between this update's read and its write; re-resolving it. This is internal and is never returned to a caller.`
-    );
-    this.name = "EdgeUpdateTargetMoved";
-  }
-};
 var EDGE_UPDATE_ATTEMPTS = 2;
-async function performEdgeUpdateConverging(ctx, input, target, options) {
+async function performEdgeUpdateConverging(ctx, input, session, target, options) {
   for (let attempt = 1; attempt <= EDGE_UPDATE_ATTEMPTS; attempt += 1) {
     try {
-      return await performEdgeUpdate(ctx, input, target, options);
+      return await performEdgeUpdate(ctx, input, session, target, options);
     } catch (error) {
       if (!(error instanceof EdgeUpdateTargetMoved)) throw error;
       if (attempt === EDGE_UPDATE_ATTEMPTS) {
@@ -17035,29 +17137,38 @@ async function executeEdgeUpdate(ctx, input, backend) {
     "update"
   );
   const opContext = ctx.createOperationContext("update", "edge", gate.kind, id);
-  return runHookedWriteOperation(
+  if (input.clearValidTo === true) {
+    assertClearValidToSupported(backend, "edge");
+  }
+  return runHookedWritePlan(
     ctx,
     opContext,
+    // An in-place props update on a live edge re-derives no constraint verdict.
+    // Clearing an `oneActive` edge's end DOES: it re-admits the row to the
+    // counted active population.
+    edgeWritePlan(
+      input.clearValidTo === true && edgeCardinality(ctx, gate.kind) === "oneActive" ? edgeWriteNeedsConstraintFence("oneActive") : void 0
+    ),
     backend,
-    (target) => {
-      if (input.clearValidTo === true) {
-        assertClearValidToSupported(backend, "edge");
-      }
-      return performEdgeUpdateConverging(ctx, input, target);
-    },
-    {
-      fencesConstraintProbe: input.clearValidTo === true && edgeCardinality(ctx, gate.kind) === "oneActive" ? edgeWriteNeedsConstraintFence("oneActive") : void 0
-    }
+    (session, target) => performEdgeUpdateConverging(ctx, input, session, target)
   );
 }
 async function executeEdgeUpsertUpdateWithOutcome(ctx, input, backend, options) {
   if (input.clearValidTo === true) {
     assertClearValidToSupported(backend, "edge");
   }
-  return runInWriteTransaction(
+  return runWritePlan(
     ctx,
+    // An in-place props update re-derives no constraint verdict: endpoints
+    // are immutable, so cardinality cannot change under it. A coalescing upsert
+    // converges on a match key no database key backs; a resurrect or a cleared
+    // end re-admits the row to the counted population its cardinality
+    // constrains.
+    edgeWritePlan(
+      options?.coalesceUnchanged === true ? "edgeMatchKeyConvergence" : input.clearValidTo === true || options?.clearDeleted === true ? edgeWriteNeedsConstraintFence(edgeCardinality(ctx, input.identity.kind)) : void 0
+    ),
     backend,
-    async (target) => {
+    async (session, target) => {
       if (options?.coalesceUnchanged === true && !options.clearDeleted) {
         const existing = options.coalesceCandidate ?? await target.getEdge(ctx.graphId, input.id);
         if (existing !== void 0 && existing.deleted_at === void 0) {
@@ -17082,17 +17193,13 @@ async function executeEdgeUpsertUpdateWithOutcome(ctx, input, backend, options)
       const edge = await performEdgeUpdateConverging(
         ctx,
         input,
+        session,
         target,
         options
       );
       return { edge, wrote: true };
     },
     {
-      // An in-place props update re-derives no constraint verdict: endpoints
-      // are immutable, so cardinality cannot change under it.
-      fencesConstraintProbe: options?.coalesceUnchanged === true ? "edgeMatchKeyConvergence" : input.clearValidTo === true || options?.clearDeleted === true ? edgeWriteNeedsConstraintFence(
-        edgeCardinality(ctx, input.identity.kind)
-      ) : void 0,
       didWrite: (outcome) => outcome.wrote
     }
   );
@@ -17117,19 +17224,23 @@ async function executeEdgeDelete(ctx, expectedKind, id, backend) {
   );
   if (gate.deleted_at) return;
   const opContext = ctx.createOperationContext("delete", "edge", gate.kind, id);
-  return runHookedWriteOperation(ctx, opContext, backend, async (target) => {
-    await target.deleteEdge({
-      graphId: ctx.graphId,
-      id,
-      kind: expectedKind
-    });
-  });
+  return runHookedWritePlan(
+    ctx,
+    opContext,
+    // A soft delete decides nothing a concurrent write could invalidate.
+    edgeWritePlan(void 0),
+    backend,
+    async (session) => {
+      await session.retireEdge({ id, kind: expectedKind });
+    }
+  );
 }
 async function executeEdgeDeleteBatch(ctx, expectedKind, ids, backend) {
-  await runInWriteTransaction(
+  await runWritePlan(
     ctx,
+    edgeWritePlan(void 0),
     backend,
-    async (target) => {
+    async (session, target) => {
       let affectedCount = 0;
       for (const id of ids) {
         const current = await target.getEdge(ctx.graphId, id);
@@ -17141,11 +17252,7 @@ async function executeEdgeDeleteBatch(ctx, expectedKind, ids, backend) {
           "delete"
         );
         if (current.deleted_at) continue;
-        await target.deleteEdge({
-          graphId: ctx.graphId,
-          id,
-          kind: expectedKind
-        });
+        await session.retireEdge({ id, kind: expectedKind });
         affectedCount += 1;
       }
       return affectedCount;
@@ -17163,13 +17270,24 @@ async function executeEdgeHardDelete(ctx, expectedKind, id, backend) {
     "hardDelete"
   );
   const opContext = ctx.createOperationContext("delete", "edge", gate.kind, id);
-  return runHookedWriteOperation(ctx, opContext, backend, async (target) => {
-    await target.hardDeleteEdge({
-      graphId: ctx.graphId,
-      id,
-      kind: expectedKind
-    });
-  });
+  return runHookedWritePlan(
+    ctx,
+    opContext,
+    edgeWritePlan(void 0),
+    backend,
+    async (session) => {
+      await session.purgeEdge({
+        id,
+        kind: expectedKind,
+        // Housekeeping, not a fence: this edge's claim is already takeable — its
+        // liveness predicate reads a row that no longer exists — so dropping the
+        // row only keeps the relation from growing by one row per hard-deleted
+        // constrained edge. An unconstrained kind holds no claim and pays no
+        // statement for one, the same rule its create follows.
+        holdsCardinalityClaim: edgeCardinality(ctx, expectedKind) !== "many"
+      });
+    }
+  );
 }
 var UNDEFINED_SENTINEL = "";
 function validateMatchOnFields(schema, matchOn, edgeKind) {
@@ -17638,10 +17756,15 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
     }
   }
   function runBatch() {
-    return runInWriteTransaction(
+    return runWritePlan(
       ctx,
+      // A bulk getOrCreate always converges on a match key no database key
+      // backs, whatever its cardinality — the same reason the single-item path
+      // fences unconditionally.
+      edgeWritePlan("edgeMatchKeyConvergence"),
       backend,
-      async (target) => {
+      async (session, target) => {
+        const rawTarget = unfencedTarget(target);
         const { toCreate, toFetch, duplicateOf } = partitionEntries(
           await fetchRowsByEndpoint(target)
         );
@@ -17652,7 +17775,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
           const createdEdges = await executeEdgeCreateBatch(
             ctx,
             createInputs,
-            target
+            rawTarget
           );
           for (const [batchIndex, entry2] of toCreate.entries()) {
             results[entry2.index] = {
@@ -17687,7 +17810,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
                   onImmutableLowerBound: entry2.onImmutableLowerBound
                 }
               },
-              target,
+              rawTarget,
               { clearDeleted: true }
             );
             results[entry2.index] = { edge, action: "resurrected" };
@@ -17716,7 +17839,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
                   onImmutableLowerBound: entry2.onImmutableLowerBound
                 }
               },
-              target,
+              rawTarget,
               {
                 coalesceUnchanged: ctx.coalesceUnchangedUpsertsEnabled,
                 coalesceCandidate: entry2.row
@@ -17748,13 +17871,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
         }
         return { results, writes };
       },
-      // A bulk getOrCreate always converges on a match key no database key
-      // backs, whatever its cardinality — the same reason the single-item path
-      // fences unconditionally.
-      {
-        fencesConstraintProbe: "edgeMatchKeyConvergence",
-        didWrite: (outcome) => outcome.writes > 0
-      }
+      { didWrite: (outcome) => outcome.writes > 0 }
     );
   }
   async function runBatchResults() {
@@ -18543,8 +18660,10 @@ var StoreImplementation = class _StoreImplementation {
         if (upserts.every((upsert) => upsert.constraints.length === 0) && releases.length === 0) {
           return apply();
         }
-        return applyResolvedNodeUniqueness(
-          createUniquenessContext(this.graphId, this.#registry, target),
+        const lock = await lockRecordedGraphWrite(target, this.graphId);
+        return applyResolvedNodeClaims(
+          { graphId: this.graphId, registry: this.#registry, lock },
+          target,
           upserts,
           releases,
           apply
@@ -18791,7 +18910,11 @@ var StoreImplementation = class _StoreImplementation {
       );
     }
     return importIdentityAssertionsIntoTarget(
-      this.#identityContext(target),
+      // The slice the coordinator reads — graph, registry, schema, folding
+      // mode — none of which depend on the target. The target it writes
+      // through is the parameter beside it, which is why this method can take
+      // the narrow statement projection an import frame is able to offer.
+      this.#identityContext(this.#baseBackend),
       target,
       assertions,
       mode
@@ -20822,6 +20945,41 @@ var StoreImplementation = class _StoreImplementation {
     const vectorSlots = backend.capabilities.vector?.supported === true ? resolveGraphVectorSlots(this.#graph) : [];
     return verify(this.graphId, vectorSlots);
   }
+  /**
+   * Read-only diagnostic: every claim axis this graph's data ALREADY contends
+   * for — a scoped unique key two live nodes hold, an id live under both kinds
+   * of a `disjointWith` pair, or a declared edge cardinality two live edges
+   * exceed.
+   *
+   * The claim relations refuse a second claimant from the first write after
+   * upgrade onward, but they repair nothing that predates them: a database that
+   * carried a violation keeps carrying it until a write touches that axis, and
+   * is then refused with the ordinary typed error naming the incumbent. This is
+   * how an operator sees that state before a user does.
+   *
+   * Reports; never repairs. Which of two live claimants keeps the axis is a
+   * data-loss decision that belongs to the operator.
+   *
+   * Declarations are resolved from the active persisted schema, not this
+   * Store's construction-time graph snapshot. A Store left stale by another
+   * instance's `evolve()` therefore audits the constraints that currently
+   * govern the database instead of returning a false clean report.
+   *
+   * @throws {ConfigurationError} `CONSTRAINT_FENCE_AUDIT_UNSUPPORTED` when the
+   *   backend cannot run the audit — an empty report from a backend that never
+   *   looked is indistinguishable from a clean database.
+   */
+  async verifyConstraintFences() {
+    const activeRow = await this.#baseBackend.getActiveSchema(this.graphId);
+    const graph = activeRow === void 0 ? this.#graph : this.#catchUpToStored(parseSerializedSchema(activeRow.schema_doc));
+    const registry = graph === this.#graph ? this.#registry : buildKindRegistry(graph);
+    return verifyConstraintFences({
+      graph,
+      registry,
+      graphId: this.graphId,
+      backend: this.#baseBackend
+    });
+  }
   /**
    * Non-destructively repairs contribution states whose physical storage can
    * be preserved: `missing-marker` and `failed-materialization`.
@@ -21988,5 +22146,5 @@ async function createVerifiedAdapterStore(graph, backend, options) {
 }
 
 export { ExecutableAggregateQuery, ExecutableQuery, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, PreparedQuery, QueryBuilder, RecordedStoreView, StoreSearch, StoreView, UnionableQuery, avg, composeFragments, count, countDistinct, countDistinctEdges, countEdges, createAdapterStore, createAdapterStoreWithSchema, createFragment, createQueryBuilder, createStore, createStoreWithSchema, createVerifiedAdapterStore, createVerifiedStore, defineSubgraphProject, field, having, havingEq, havingGt, havingGte, havingLt, havingLte, limitFragment, max, min, offsetFragment, orderByFragment, sum };
-//# sourceMappingURL=chunk-BRRP76WO.js.map
-//# sourceMappingURL=chunk-BRRP76WO.js.map
+//# sourceMappingURL=chunk-MX7EKQPM.js.map
+//# sourceMappingURL=chunk-MX7EKQPM.js.map