@nicia-ai/typegraph 0.49.0 → 0.51.0

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

@@ -1,31 +1,33 @@
-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-VUQZNUHU.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-TYEYRCXL.js';
+import { storeRuntime, STORE_RUNTIME, applyResolvedNodeClaims, TRANSACTION_RUNTIME, AUTO_REFRESH_STATISTICS_ROW_THRESHOLD, getEmbeddingFields, computeFulltextContent } from './chunk-4DKY6RIU.js';
+import { edgeCardinalityClaimTarget, edgeCardinalityClaim } from './chunk-NGQDGL5X.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-YT2IVFAI.js';
+import { getTypeName } from './chunk-LI4K2KEJ.js';
+import { rebuildIdentityClosureForContext, loadCurrentStructuralClasses, loadAssertionsByIds, toTransferAssertion, liveNodeKindsSharingIds, createIdentityFacade, createIdentityReadFacade, validateIdentityForContext, removeIdentityKindsForContext, readIdentityAssertionsForInterchange, readIdentityAssertionPageAtTarget, lockIdentityGraph, foldIdentityForCreatedNodes, importIdentityAssertionsIntoTarget, assertAffectedIdentityClassesConsistent, applyIdentityChangesForContext, refKey, requireNodeValidityEndCompatible, detachIdentityForNode } from './chunk-WFSYYU4W.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, assertRecursiveTraversalSupported, baseField, objectField, arrayField, dateField, numberField, advanceRevisionClock, validateEdgeProps, sqlValueList, getNodeRowsByIds, getEdgeRowsByIds, compileKindFilter, currentReadInstant, compileTemporalFilter, closeRecordedHardDeletedKind, buildPredicateIndex, requireRecursiveTraversalVerdict, historicalIdentityPeerClassQuery, IDENTITY_PEER_CLASS_COLUMNS, compileFieldValue, recordedBindParamBudget, extractVectorSimilarityPredicates, extractFulltextMatchPredicates, currentReadInstantFor, extractTemporalOptions, compilePredicateExpression, getPredicatesForAlias, getFieldPointer, getNodeKindsForAlias, getHybridTargetAlias, throwHistoryUnsafeSqlAccess, throwRevisionTrackingUnsafeSqlAccess, compilePredicateClauses } from './chunk-VAAC7L57.js';
+import { withRecordedRelationsPrecondition, projectGraphBackend, deriveBackend, canonicalEqual, sortedReplacer, projectBackend, chunk, postgresReadWriteRefusedSqlState, isMissingTableError, groupBy, postgresTemporaryTableUnavailableSqlState, isPostgresConcurrentDdlRaceError } from './chunk-QG5VEOKX.js';
+import { assumeRecursiveTraversalSupported, batchPointReadVerdict, resolveRecursiveTraversal, statementExecutionVerdict, createClaimsVerdictThunk, uniqueSidecarBatchVerdict, contributionHealthVerdict, recordedRevisionOriginsVerdict, requireExtras, assertRecursiveTraversal } from './chunk-XORONCV3.js';
+import { createSqlSchema, requireSqlSchema, DEFAULT_SQL_SCHEMA, recordedReadSchemaFor, resolveWriteFencePlan, refuseUnfencedOperationalIdentity, refuseUnfencedClockAllocation, requireExternalRecordedReadSource, createRecordedReadBinding, runOptionallyInTransaction, createTransactionReadBackend, bindExtraIfReachable, BATCH_POINT_READ, CONTRIBUTION_HEALTH, bindExtra, vectorSlotKey, recordedReadSqlSchema, requireRecordedReadBinding, rowPropsToObject, INTERNAL_TEMPORARY_WRITES, ALIAS_CTE_PREFIX, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS } from './chunk-LKZDQ2B4.js';
+import { isKnownKind } from './chunk-M3VTS3F6.js';
+import { compareClaimTargets, encodeTupleKey, uniquenessClaimTarget, subClassComponent, isSameClaimOwner, DISJOINT_CONSTRAINT_NAME, disjointnessClaimAxis, validateEdgeEndpoints } from './chunk-RVUL2HXY.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-6NLYIMJO.js';
+import { SYSTEM_INDEX_DECLARATIONS, resolveSystemIndexTableName, systemIndexName, resolveSystemIndexNames, generateSystemIndexDDL } from './chunk-36VYWVQU.js';
+import { NODE_META_KEYS, EDGE_META_KEYS } from './chunk-LZMQ3SFK.js';
 import { sha256Hex, fnv1aBase36 } from './chunk-K34OPSJK.js';
+import { getDialect } from './chunk-7G5IYROL.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 { assertVectorMinScore, assertApproximateMetricSupported, vectorScoreExpression, vectorMinScoreCondition } from './chunk-PC5NGH5A.js';
+import { isSqlPlaceholder, bindSqlValue, markAnnIndexScan, asCompiledSelectSql, isRawExecutable, renderSql, annIndexScanTypes, sql, asCompiledRowsSql, markForceCustomPlan, asCompiledStatementSql, asCompiledTemporaryStatementSql } from './chunk-7QFRK6PU.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';
 
@@ -1104,11 +1106,16 @@ function compileIdentityClassCte(input) {
   if (!expandsIdentity) return void 0;
   const coordinate = historicalCoordinate({ ast, temporalFilterPass });
   if (coordinate === void 0) return void 0;
+  const recursiveTraversal = requireRecursiveTraversalVerdict(
+    ctx,
+    "historical identity expansion"
+  );
   const peerClasses = historicalIdentityPeerClassQuery({
     schema: ctx.schema,
     graphId,
     coordinate,
-    sameIdAcrossKinds: ctx.identitySameIdAcrossKinds ?? "fold"
+    sameIdAcrossKinds: ctx.identitySameIdAcrossKinds ?? "fold",
+    recursiveTraversal
   });
   return sql`
     ${sql.identifier(IDENTITY_CLASS_CTE_ALIAS)}(${IDENTITY_PEER_CLASS_COLUMNS}) AS MATERIALIZED (
@@ -2907,6 +2914,7 @@ function runRecursiveQueryPassPipeline(ast, graphId, ctx) {
   return state;
 }
 function compileVariableLengthQuery(ast, graphId, ctx) {
+  assertRecursiveTraversalSupported(ctx, "variable-length traversal");
   const strategy = ctx.dialect.capabilities.recursiveQueryStrategy;
   const handler = RECURSIVE_QUERY_STRATEGY_HANDLERS[strategy];
   return handler(ast, graphId, ctx);
@@ -3412,6 +3420,7 @@ function decodeByValueType(value, valueType) {
 
 // src/store/recursive-cte.ts
 function buildReachableCte(options) {
+  assertRecursiveTraversal(options.recursiveTraversal, options.operation);
   const trackPath = options.cyclePolicy === "prevent" || options.includePath;
   const edgeKindFilter = compileKindFilter(
     sql.raw("e.kind"),
@@ -3608,7 +3617,9 @@ async function executeSubgraph(params) {
     dialect: ctx.dialect,
     // Base schema: buildReachableCte derives the recorded swap from recordedAsOf.
     schema: baseSchema,
-    ...ctx.recordedReadBinding === void 0 ? {} : { recordedReadBinding: ctx.recordedReadBinding }
+    ...ctx.recordedReadBinding === void 0 ? {} : { recordedReadBinding: ctx.recordedReadBinding },
+    recursiveTraversal: resolveRecursiveTraversal(params.backend.capabilities),
+    operation: "subgraph"
   });
   const includedIdsCte = buildIncludedIdsCte(ctx);
   let membership;
@@ -4495,6 +4506,7 @@ function runStandardQueryPassPipeline(ast, graphId, ctx) {
 }
 
 // src/query/compiler/index.ts
+var COMPILER_DEFAULT_RECURSIVE_TRAVERSAL = assumeRecursiveTraversalSupported("compileQuery called without a backend");
 function compileQuery(ast, graphId, options = "sqlite") {
   const options_ = typeof options === "string" ? { dialect: options } : options;
   const dialect = options_.dialect ?? "sqlite";
@@ -4520,6 +4532,7 @@ function compileQuery(ast, graphId, options = "sqlite") {
     ),
     ...options_.vectorStrategy === void 0 ? {} : { vectorStrategy: options_.vectorStrategy },
     windowFunctions: options_.windowFunctions ?? true,
+    recursiveTraversal: options_.recursiveTraversal ?? COMPILER_DEFAULT_RECURSIVE_TRAVERSAL,
     ...options_.vectorSlots === void 0 ? {} : { vectorSlots: options_.vectorSlots },
     ...options_.fulltextLanguages === void 0 ? {} : { fulltextLanguages: options_.fulltextLanguages }
   };
@@ -4619,6 +4632,7 @@ function propagateOptions(options_) {
     ...options_.fulltextStrategy === void 0 ? {} : { fulltextStrategy: options_.fulltextStrategy },
     ...options_.vectorStrategy === void 0 ? {} : { vectorStrategy: options_.vectorStrategy },
     windowFunctions: options_.windowFunctions ?? true,
+    recursiveTraversal: options_.recursiveTraversal ?? COMPILER_DEFAULT_RECURSIVE_TRAVERSAL,
     ...options_.vectorSlots === void 0 ? {} : { vectorSlots: options_.vectorSlots },
     ...options_.fulltextLanguages === void 0 ? {} : { fulltextLanguages: options_.fulltextLanguages },
     ...options_.recordedReadBinding === void 0 ? {} : { recordedReadBinding: options_.recordedReadBinding },
@@ -7023,6 +7037,7 @@ function buildCompileOptions(config) {
     dialect: config.dialect ?? "sqlite",
     schema: config.schema,
     windowFunctions: config.backend?.capabilities.windowFunctions ?? true,
+    recursiveTraversal: config.backend === void 0 ? COMPILER_DEFAULT_RECURSIVE_TRAVERSAL : resolveRecursiveTraversal(config.backend.capabilities),
     identitySameIdAcrossKinds: config.identitySameIdAcrossKinds,
     ...fulltextStrategy === void 0 ? {} : {
       fulltextStrategy,
@@ -10134,7 +10149,7 @@ function searchNodeKey(kind, nodeId) {
 function scoreDescending(metric) {
   return metric === "cosine";
 }
-async function fetchNodesForRows(backend, graphId, rows) {
+async function fetchNodesForRows(backend, batchPointRead, graphId, rows) {
   const idsByKind = /* @__PURE__ */ new Map();
   for (const row of rows) {
     const ids = idsByKind.get(row.kind) ?? /* @__PURE__ */ new Set();
@@ -10144,7 +10159,13 @@ async function fetchNodesForRows(backend, graphId, rows) {
   const map = /* @__PURE__ */ new Map();
   await Promise.all(
     [...idsByKind].map(async ([kind, ids]) => {
-      const kindMap = await fetchNodesByIds(backend, graphId, kind, [...ids]);
+      const kindMap = await fetchNodesByIds(
+        backend,
+        batchPointRead,
+        graphId,
+        kind,
+        [...ids]
+      );
       for (const [id, node] of kindMap) {
         map.set(searchNodeKey(kind, id), node);
       }
@@ -10224,7 +10245,12 @@ async function executeFulltextSearch(ctx, nodeKind, options) {
     (a, b) => b.score - a.score || compareCodePoints(a.kind, b.kind) || compareCodePoints(a.nodeId, b.nodeId)
   ).slice(offset, offset + options.limit);
   if (merged.length === 0) return [];
-  const nodeMap = await fetchNodesForRows(backend, graphId, merged);
+  const nodeMap = await fetchNodesForRows(
+    backend,
+    requireDefined(ctx.batchPointRead),
+    graphId,
+    merged
+  );
   const hits = [];
   let rank = 1;
   for (const row of merged) {
@@ -10315,7 +10341,12 @@ async function executeVectorSearch(ctx, nodeKind, options) {
     offset + options.limit
   );
   if (merged.length === 0) return [];
-  const nodeMap = await fetchNodesForRows(backend, graphId, merged);
+  const nodeMap = await fetchNodesForRows(
+    backend,
+    requireDefined(ctx.batchPointRead),
+    graphId,
+    merged
+  );
   const hits = [];
   let rank = 1;
   for (const row of merged) {
@@ -10582,6 +10613,7 @@ async function executeHybridSearch(ctx, nodeKind, options) {
   ).slice(offset, offset + options.limit);
   const nodeMap = await fetchNodesForRows(
     backend,
+    requireDefined(ctx.batchPointRead),
     graphId,
     ranked.map((entry2) => ({
       kind: entry2.kind,
@@ -10722,11 +10754,16 @@ function warnIfLanguageNotAdvertised(dialect, capabilities, language) {
     `[typegraph] fulltext language "${language}" is not in the advertised list for dialect "${dialect}" (${capabilities.languages.join(", ")}). If your backend has this language installed this warning is safe to ignore.`
   );
 }
-async function fetchNodesByIds(backend, graphId, nodeKind, ids) {
+async function fetchNodesByIds(backend, batchPointRead, graphId, nodeKind, ids) {
   if (ids.length === 0) return /* @__PURE__ */ new Map();
   const map = /* @__PURE__ */ new Map();
-  if (backend.getNodes) {
-    const rows = await backend.getNodes(graphId, nodeKind, ids);
+  const bound = bindExtraIfReachable(
+    backend,
+    batchPointRead.extras.getNodes,
+    BATCH_POINT_READ.id
+  );
+  if (bound !== void 0) {
+    const rows = await bound.getNodes(graphId, nodeKind, ids);
     for (const row of rows) {
       if (row.deleted_at !== void 0) continue;
       map.set(row.id, rowToNode(row));
@@ -10744,7 +10781,10 @@ async function fetchNodesByIds(backend, graphId, nodeKind, ids) {
 var StoreSearch = class {
   #context;
   constructor(context) {
-    this.#context = context;
+    this.#context = {
+      ...context,
+      batchPointRead: context.batchPointRead ?? batchPointReadVerdict(context.backend)
+    };
   }
   /**
    * Runs a fulltext search against nodes of the given kind.
@@ -10852,6 +10892,20 @@ function asRawBackend(backend) {
   return backend;
 }
 
+// src/backend/capabilities/recorded-time-ownership.ts
+function resolveRecordedTimeOwnership(capabilities) {
+  return capabilities.recordedTimeOwnership ?? "typegraph-relations";
+}
+function refuseEngineNativeRecordedTimeNotYetImplemented() {
+  throw new ConfigurationError(
+    'This backend declares `recordedTimeOwnership: "engine-native"`, but TypeGraph still allocates its own recorded clock for `history` / `revisionTracking`; the engine-native path lands with a later release. Construct the store without `history` / `revisionTracking`, or declare `recordedTimeOwnership: "typegraph-relations"` and let TypeGraph own the clock.',
+    { code: "ENGINE_NATIVE_RECORDED_TIME_NOT_IMPLEMENTED" },
+    {
+      suggestion: 'Construct the store without `history`/`revisionTracking`, or declare `recordedTimeOwnership: "typegraph-relations"`.'
+    }
+  );
+}
+
 // src/graph-extension/classify.ts
 function classifyModifications(existing, next) {
   const incompatible = [];
@@ -11658,9 +11712,13 @@ async function reduceExpandedWorkingSet(operation, workingSet, direction, reduce
 function nodeIdentityKey(node) {
   return `${node.kind}\0${node.id}`;
 }
-function nodeIdentityKeyFromRow(id, kind) {
+function nodeIdentityFromRow(id, kind) {
   if (typeof id !== "string" || typeof kind !== "string") return void 0;
-  return nodeIdentityKey({ id, kind });
+  return { id, kind };
+}
+function nodeIdentityKeyFromRow(id, kind) {
+  const node = nodeIdentityFromRow(id, kind);
+  return node === void 0 ? void 0 : nodeIdentityKey(node);
 }
 function compareNodeIdentity(left, right) {
   return compareCodePoints(left.id, right.id) || compareCodePoints(left.kind, right.kind);
@@ -13517,7 +13575,10 @@ async function findWeightedShortestPathInWorkingTable(ctx, sourceId, targetId, m
       return state.frontierCount === 0;
     },
     async extractResult(context) {
-      return extractPathFromWorkingTable(context, targetId, maxIterations);
+      const recursiveTraversal = resolveRecursiveTraversal(
+        ctx.backend.capabilities
+      );
+      return recursiveTraversal.supported ? extractPathFromWorkingTable(context, targetId, maxIterations) : extractPathByPredecessorWalk(context, targetId, maxIterations);
     }
   });
 }
@@ -13639,23 +13700,13 @@ async function relaxFrontierRound(context, targetId, iteration, roundBound) {
   return { frontierCount, bestTargetDistance };
 }
 async function extractPathFromWorkingTable(context, targetId, maxIterations) {
-  const { operation, workingTable, graphId, runId } = context;
-  const { dialect } = operation.ctx;
+  const { workingTable, graphId, runId } = context;
   const rows = await context.backend.execute(
     asCompiledRowsSql(sql`
       WITH RECURSIVE chain AS (
         SELECT best.node_id, best.node_kind, best.distance, best.hops,
           best.predecessor_id, best.predecessor_kind, 0 AS position
-        FROM (
-          SELECT node_id, node_kind, distance, hops,
-            predecessor_id, predecessor_kind
-          FROM ${workingTable}
-          WHERE graph_id = ${graphId}
-            AND run_id = ${runId}
-            AND node_id = ${targetId}
-          ORDER BY distance ASC, ${dialect.binaryText(sql`node_kind`)}
-          LIMIT 1
-        ) best
+        FROM (${selectCheapestTargetRowSql(context, targetId)}) best
         UNION ALL
         SELECT w.node_id, w.node_kind, w.distance, w.hops,
           w.predecessor_id, w.predecessor_kind, c.position + 1
@@ -13680,6 +13731,65 @@ async function extractPathFromWorkingTable(context, targetId, maxIterations) {
     totalWeight: Number(target.distance)
   };
 }
+function selectCheapestTargetRowSql(context, targetId) {
+  const { operation, workingTable, graphId, runId } = context;
+  const { dialect } = operation.ctx;
+  return sql`
+    SELECT node_id, node_kind, distance, hops,
+      predecessor_id, predecessor_kind
+    FROM ${workingTable}
+    WHERE graph_id = ${graphId}
+      AND run_id = ${runId}
+      AND node_id = ${targetId}
+    ORDER BY distance ASC, ${dialect.binaryText(sql`node_kind`)}
+    LIMIT 1
+  `;
+}
+async function collectPredecessorChain(first, readPredecessor, maxIterations) {
+  const chain = [first];
+  let current = first;
+  for (let position = 0; position <= maxIterations; position++) {
+    const predecessor = nodeIdentityFromRow(
+      current.predecessor_id,
+      current.predecessor_kind
+    );
+    if (predecessor === void 0) break;
+    const predecessorRow = await readPredecessor(predecessor);
+    if (predecessorRow === void 0) break;
+    chain.push(predecessorRow);
+    current = predecessorRow;
+  }
+  return chain;
+}
+async function extractPathByPredecessorWalk(context, targetId, maxIterations) {
+  const rows = await context.backend.execute(
+    asCompiledRowsSql(selectCheapestTargetRowSql(context, targetId))
+  );
+  const first = rows[0];
+  if (first === void 0) return void 0;
+  const { workingTable, graphId, runId } = context;
+  const chain = await collectPredecessorChain(
+    first,
+    async (predecessor) => {
+      const predecessorRows = await context.backend.execute(
+        asCompiledRowsSql(sql`
+            SELECT node_id, node_kind, distance, hops,
+              predecessor_id, predecessor_kind
+            FROM ${workingTable}
+            WHERE graph_id = ${graphId} AND run_id = ${runId}
+              AND node_kind = ${predecessor.kind} AND node_id = ${predecessor.id}
+          `)
+      );
+      return predecessorRows[0];
+    },
+    maxIterations
+  );
+  return {
+    nodes: chain.map((row) => ({ id: row.node_id, kind: row.node_kind })).toReversed(),
+    depth: Number(first.hops),
+    totalWeight: Number(first.distance)
+  };
+}
 async function findWeightedSelfPath(ctx, nodeId, options) {
   return withInlineIterativeGraphOperation(ctx, options, async (operation) => {
     await assertValidEdgeWeights(
@@ -13918,6 +14028,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 {
@@ -14093,6 +14352,7 @@ function createEdgeCollection(config) {
     graphId,
     kind,
     backend,
+    batchPointRead,
     defaultTemporalMode,
     rowToEdge: rowToEdge2,
     executeCreate: executeEdgeCreate2,
@@ -14198,7 +14458,12 @@ function createEdgeCollection(config) {
     },
     async getByIds(ids, options) {
       if (ids.length === 0) return [];
-      const rowsById = await getEdgeRowsByIds(backend, graphId, ids);
+      const rowsById = await getEdgeRowsByIds(
+        backend,
+        batchPointRead,
+        graphId,
+        ids
+      );
       const matches = temporalRowMatcher(options);
       return ids.map((id) => {
         const row = rowsById.get(id);
@@ -14316,7 +14581,12 @@ function createEdgeCollection(config) {
       }
       const upsertAll = async (target) => {
         const ids = items.map((item) => item.id);
-        const existingMap = await getEdgeRowsByIds(target, graphId, ids);
+        const existingMap = await getEdgeRowsByIds(
+          target,
+          batchPointRead,
+          graphId,
+          ids
+        );
         const results2 = Array.from({ length: items.length });
         const toCreate = [];
         const toUpdate = [];
@@ -14635,6 +14905,7 @@ function createNodeCollection(config) {
     graphId,
     kind,
     backend,
+    batchPointRead,
     defaultTemporalMode,
     rowToNode: rowToNode2,
     executeCreate: executeNodeCreate2,
@@ -14673,7 +14944,13 @@ function createNodeCollection(config) {
     },
     async getByIds(ids, options) {
       if (ids.length === 0) return [];
-      const rowsById = await getNodeRowsByIds(backend, graphId, kind, ids);
+      const rowsById = await getNodeRowsByIds(
+        backend,
+        batchPointRead,
+        graphId,
+        kind,
+        ids
+      );
       const matches = temporalRowMatcher(options);
       return ids.map((id) => {
         const row = rowsById.get(id);
@@ -14884,7 +15161,12 @@ function createNodeCollection(config) {
       const upsertAll = async (target) => {
         const ids = items.map((item) => item.id);
         const existingMap = /* @__PURE__ */ new Map();
-        if (target.getNodes === void 0) {
+        const boundGetNodes = bindExtraIfReachable(
+          target,
+          batchPointRead.extras.getNodes,
+          BATCH_POINT_READ.id
+        );
+        if (boundGetNodes === void 0) {
           const rows = await Promise.all(
             ids.map((id) => target.getNode(graphId, kind, id))
           );
@@ -14892,7 +15174,7 @@ function createNodeCollection(config) {
             if (row !== void 0) existingMap.set(row.id, row);
           }
         } else {
-          const rows = await target.getNodes(graphId, kind, ids);
+          const rows = await boundGetNodes.getNodes(graphId, kind, ids);
           for (const row of rows) {
             existingMap.set(row.id, row);
           }
@@ -15081,7 +15363,7 @@ function createNodeCollection(config) {
 }
 
 // src/store/collection-factory.ts
-function createNodeCollectionsProxy(graph, graphId, registry, backend, operations) {
+function createNodeCollectionsProxy(graph, graphId, registry, backend, batchPointRead, operations) {
   const collectionCache = /* @__PURE__ */ new Map();
   return new Proxy({}, {
     get: (_, kind) => {
@@ -15096,6 +15378,7 @@ function createNodeCollectionsProxy(graph, graphId, registry, backend, operation
         graphId,
         kind,
         backend,
+        batchPointRead,
         ...operations
       });
       collectionCache.set(kind, collection);
@@ -15103,7 +15386,7 @@ function createNodeCollectionsProxy(graph, graphId, registry, backend, operation
     }
   });
 }
-function createEdgeCollectionsProxy(graph, graphId, registry, backend, operations) {
+function createEdgeCollectionsProxy(graph, graphId, registry, backend, batchPointRead, operations) {
   const collectionCache = /* @__PURE__ */ new Map();
   return new Proxy({}, {
     get: (_, kind) => {
@@ -15118,6 +15401,7 @@ function createEdgeCollectionsProxy(graph, graphId, registry, backend, operation
         graphId,
         kind,
         backend,
+        batchPointRead,
         ...operations
       });
       collectionCache.set(kind, collection);
@@ -15135,6 +15419,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 +15449,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 +15488,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 +15505,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 +15656,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 +16385,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 +16394,7 @@ async function materializeRemovals(context, options = {}) {
     edgesTable,
     fulltextTable,
     uniquesTable,
+    edgeClaimsTable,
     captureRecordedRemovals,
     recordedSchema: captureRecordedRemovals ? context.recordedSchema ?? createSqlSchema(backend.tableNames) : void 0
   };
@@ -16236,7 +16550,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 +16582,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 +16792,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 +16832,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 +16857,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 +16949,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 +16986,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"
     }
   );
 }
@@ -16738,7 +17009,12 @@ async function executeEdgeCreate(ctx, input, backend) {
   return edge;
 }
 async function primeEdgeBatchValidationCache(ctx, inputs, backend, seedEndpointRow) {
-  if (backend.getNodes === void 0) return;
+  const bound = bindExtraIfReachable(
+    backend,
+    ctx.batchPointRead.extras.getNodes,
+    BATCH_POINT_READ.id
+  );
+  if (bound === void 0) return;
   const idsByKind = /* @__PURE__ */ new Map();
   const addEndpoint = (kind, id) => {
     const ids = idsByKind.get(kind) ?? /* @__PURE__ */ new Set();
@@ -16751,7 +17027,7 @@ async function primeEdgeBatchValidationCache(ctx, inputs, backend, seedEndpointR
   }
   for (const [kind, ids] of idsByKind) {
     const orderedIds = [...ids];
-    const rows = await backend.getNodes(ctx.graphId, kind, orderedIds);
+    const rows = await bound.getNodes(ctx.graphId, kind, orderedIds);
     const rowsById = new Map(rows.map((row) => [row.id, row]));
     for (const id of orderedIds) {
       seedEndpointRow(ctx.graphId, kind, id, rowsById.get(id));
@@ -16780,52 +17056,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 +17145,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 +17176,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 +17193,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 +17217,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 +17276,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 +17332,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 +17363,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 +17391,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 +17409,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 +17895,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 +17914,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 +17949,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
                   onImmutableLowerBound: entry2.onImmutableLowerBound
                 }
               },
-              target,
+              rawTarget,
               { clearDeleted: true }
             );
             results[entry2.index] = { edge, action: "resurrected" };
@@ -17716,7 +17978,7 @@ async function executeEdgeBulkGetOrCreateByEndpoints(ctx, kind, items, backend,
                   onImmutableLowerBound: entry2.onImmutableLowerBound
                 }
               },
-              target,
+              rawTarget,
               {
                 coalesceUnchanged: ctx.coalesceUnchangedUpsertsEnabled,
                 coalesceCandidate: entry2.row
@@ -17748,13 +18010,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() {
@@ -18418,6 +18674,32 @@ var StoreImplementation = class _StoreImplementation {
    */
   #baseBackend;
   #backend;
+  /**
+   * The `claims` bundle's memoized, at-most-once verdict thunk (ruling B7
+   * refinement 2), minted from `#backend` — the same object every claimed
+   * write actually executes through — once, here, and threaded into every
+   * node/edge operation context this Store builds. Never resolved eagerly:
+   * only the thunk's own first call may reach the bidirectional cross-check's
+   * throw.
+   */
+  #claimsVerdict;
+  /**
+   * Resolved EAGERLY, once, immediately after `#claimsVerdict` — unlike
+   * `claims`, no pilot bundle below has a `crossCheck`, so `resolveBundle`
+   * cannot throw on construction and the thunk's lazy-resolution rationale
+   * does not apply (ruling B8 spec item 2). `batchPointRead` and
+   * `uniqueSidecarBatch` resolve against `#backend`, the object every graph
+   * write and read actually executes through.
+   */
+  #batchPointRead;
+  #uniqueSidecarBatch;
+  /**
+   * The contribution-health methods and `ensureRevisionOrigin` read
+   * `#baseBackend`, not `#backend` (recorded capture never wraps them), so
+   * their verdicts are resolved against `#baseBackend` too.
+   */
+  #contributionHealth;
+  #recordedRevisionOrigins;
   #adapterBackend;
   #captureEnabled;
   #revisionTrackingEnabled;
@@ -18440,24 +18722,35 @@ var StoreImplementation = class _StoreImplementation {
   #search;
   constructor(graph, backend, options, schemaMetadata, adapterBackend) {
     this.#graph = graph;
-    if (graph.identity !== void 0 && (!backend.capabilities.transactions || backend.executeStatement === void 0)) {
+    const statementExecution = statementExecutionVerdict(backend);
+    if (graph.identity !== void 0 && (!backend.capabilities.transactions || !statementExecution.supported)) {
       throw new ConfigurationError(
         "Operational Identity requires an atomic transactional backend with statement execution support.",
         {
           code: "IDENTITY_REQUIRES_ATOMIC_BACKEND",
           transactions: backend.capabilities.transactions,
-          statementExecution: backend.executeStatement !== void 0
+          statementExecution: statementExecution.supported
         },
         {
           suggestion: "Use a transactional SQLite or PostgreSQL driver; Cloudflare D1 and neon-http cannot host identity closure maintenance."
         }
       );
     }
+    if (graph.identity !== void 0 && resolveWriteFencePlan(backend).kind === "unfenced") {
+      refuseUnfencedOperationalIdentity(backend.dialect);
+    }
     this.#baseBackend = asRawBackend(backend);
     this.#adapterBackend = adapterBackend;
     this.#captureEnabled = options?.history === true;
     this.#revisionTrackingEnabled = this.#captureEnabled || options?.revisionTracking === true;
     if (this.#revisionTrackingEnabled) {
+      const ownership = resolveRecordedTimeOwnership(backend.capabilities);
+      if (ownership === "engine-native") {
+        refuseEngineNativeRecordedTimeNotYetImplemented();
+      }
+      if (resolveWriteFencePlan(backend).kind === "unfenced") {
+        refuseUnfencedClockAllocation(backend.dialect);
+      }
       assertRevisionTrackableBackend(backend);
     }
     const explicitSchema = options?.schema === void 0 ? void 0 : requireSqlSchema(options.schema, "store schema");
@@ -18477,6 +18770,13 @@ var StoreImplementation = class _StoreImplementation {
     );
     this.#recordedReadBinding = this.#captureEnabled ? createRecordedReadBinding(readSchema) : externalRecordedRead;
     this.#backend = this.#captureEnabled ? asGraphWriteBackend(createRecordedBackend(backend, resolvedSchema)) : asGraphWriteBackend(backend);
+    this.#claimsVerdict = createClaimsVerdictThunk(this.#backend);
+    this.#batchPointRead = batchPointReadVerdict(this.#backend);
+    this.#uniqueSidecarBatch = uniqueSidecarBatchVerdict(this.#backend);
+    this.#contributionHealth = contributionHealthVerdict(this.#baseBackend);
+    this.#recordedRevisionOrigins = recordedRevisionOriginsVerdict(
+      this.#baseBackend
+    );
     this.#schema = resolvedSchema;
     const rowMapperConfig = rowMapperConfigFor(this.#backend);
     this.#recordedReads = createRecordedReadService({
@@ -18493,6 +18793,7 @@ var StoreImplementation = class _StoreImplementation {
     this.#schemaMetadata = schemaMetadata ?? UNKNOWN_SCHEMA_METADATA;
     this[STORE_RUNTIME] = {
       backend: this.#backend,
+      uniqueSidecarBatch: this.#uniqueSidecarBatch,
       // The query path's own construction, not a second spelling of it: a
       // caller that could only rebuild this object could not observe the one
       // the queries actually run on.
@@ -18543,8 +18844,16 @@ 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,
+            claimsVerdict: this.#claimsVerdict,
+            uniqueSidecarBatch: this.#uniqueSidecarBatch
+          },
+          target,
           upserts,
           releases,
           apply
@@ -18716,6 +19025,7 @@ var StoreImplementation = class _StoreImplementation {
     }
     const scope = createRecordedTransactionScope(
       target,
+      this.#batchPointRead,
       this.#sqlSchema(),
       target.dialect === "sqlite"
     );
@@ -18791,7 +19101,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
@@ -18915,6 +19229,7 @@ var StoreImplementation = class _StoreImplementation {
         this.graphId,
         this.#registry,
         this.#backend,
+        this.#batchPointRead,
         this.#nodeOperations
       );
     }
@@ -18943,6 +19258,7 @@ var StoreImplementation = class _StoreImplementation {
         this.graphId,
         this.#registry,
         this.#backend,
+        this.#batchPointRead,
         this.#edgeOperations
       );
     }
@@ -19492,7 +19808,12 @@ var StoreImplementation = class _StoreImplementation {
         { code: "REVISION_ORIGIN_REQUIRES_TRACKING" }
       );
     }
-    const pendingOrigin = this.#revisionOrigin ?? ensureRevisionOrigin(this.#baseBackend, this.#sqlSchema(), this.graphId);
+    const pendingOrigin = this.#revisionOrigin ?? ensureRevisionOrigin(
+      this.#baseBackend,
+      this.#recordedRevisionOrigins,
+      this.#sqlSchema(),
+      this.graphId
+    );
     this.#revisionOrigin = pendingOrigin;
     try {
       return await pendingOrigin;
@@ -19574,7 +19895,8 @@ var StoreImplementation = class _StoreImplementation {
         graphId: this.graphId,
         backend: this.#backend,
         registry: this.#registry,
-        createQuery: () => this.query()
+        createQuery: () => this.query(),
+        batchPointRead: this.#batchPointRead
       });
     }
     return this.#search;
@@ -20064,7 +20386,11 @@ var StoreImplementation = class _StoreImplementation {
         txBackend
       );
     }
-    const scope = this.#captureEnabled ? createRecordedTransactionScope(txBackend, this.#sqlSchema()) : {
+    const scope = this.#captureEnabled ? createRecordedTransactionScope(
+      txBackend,
+      this.#batchPointRead,
+      this.#sqlSchema()
+    ) : {
       backend: txBackend,
       flush: () => Promise.resolve(EMPTY_RECORDED_FLUSH_INSTANTS)
     };
@@ -20158,6 +20484,7 @@ var StoreImplementation = class _StoreImplementation {
       this.graphId,
       this.#registry,
       txBackend,
+      this.#batchPointRead,
       txNodeOperations
     );
     let edges = createEdgeCollectionsProxy(
@@ -20165,6 +20492,7 @@ var StoreImplementation = class _StoreImplementation {
       this.graphId,
       this.#registry,
       txBackend,
+      this.#batchPointRead,
       txEdgeOperations
     );
     if (receiptRecorder !== void 0) {
@@ -20254,9 +20582,14 @@ var StoreImplementation = class _StoreImplementation {
               }
               return;
             }
-            const rows = backend.getNodes === void 0 ? await Promise.all(
+            const boundGetNodes = bindExtraIfReachable(
+              backend,
+              this.#batchPointRead.extras.getNodes,
+              BATCH_POINT_READ.id
+            );
+            const rows = boundGetNodes === void 0 ? await Promise.all(
               ids.map((id) => backend.getNode(this.graphId, kind, id))
-            ) : await backend.getNodes(this.graphId, kind, ids);
+            ) : await boundGetNodes.getNodes(this.graphId, kind, ids);
             const includeTombstoned = coordinate?.valid.mode === "includeTombstones";
             for (const row of rows) {
               if (row === void 0) continue;
@@ -20808,20 +21141,64 @@ var StoreImplementation = class _StoreImplementation {
    */
   async verifyContributions() {
     const backend = this.#baseBackend;
-    const verify = backend.verifyContributions;
-    if (verify === void 0) {
-      throw new ConfigurationError(
-        "verifyContributions requires a backend that can probe its catalog for contribution tables.",
-        {
-          backend: backend.dialect,
-          capability: "contributions",
-          operation: "verify"
-        }
-      );
-    }
+    requireExtras(
+      CONTRIBUTION_HEALTH,
+      this.#contributionHealth,
+      "contribution verify",
+      () => {
+        throw new ConfigurationError(
+          "verifyContributions requires a backend that can probe its catalog for contribution tables.",
+          {
+            backend: backend.dialect,
+            capability: "contributions",
+            operation: "verify"
+          }
+        );
+      }
+    );
+    const { verifyContributions: verify } = bindExtra(
+      backend,
+      this.#contributionHealth.extras.verifyContributions,
+      CONTRIBUTION_HEALTH.id
+    );
     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`.
@@ -20840,17 +21217,26 @@ var StoreImplementation = class _StoreImplementation {
    */
   async repairContributions() {
     const backend = this.#baseBackend;
-    const repair = backend.repairContributions;
-    if (repair === void 0) {
-      throw new ConfigurationError(
-        "repairContributions requires a backend that can probe and repair strategy-owned contribution tables.",
-        {
-          backend: backend.dialect,
-          capability: "contributions",
-          operation: "repair"
-        }
-      );
-    }
+    requireExtras(
+      CONTRIBUTION_HEALTH,
+      this.#contributionHealth,
+      "contribution repair",
+      () => {
+        throw new ConfigurationError(
+          "repairContributions requires a backend that can probe and repair strategy-owned contribution tables.",
+          {
+            backend: backend.dialect,
+            capability: "contributions",
+            operation: "repair"
+          }
+        );
+      }
+    );
+    const { repairContributions: repair } = bindExtra(
+      backend,
+      this.#contributionHealth.extras.repairContributions,
+      CONTRIBUTION_HEALTH.id
+    );
     const { baseline } = await this.#loadCaughtUp("repair");
     const vectorSlots = backend.capabilities.vector?.supported === true ? resolveGraphVectorSlots(baseline) : [];
     return repair(this.graphId, vectorSlots);
@@ -20890,8 +21276,8 @@ var StoreImplementation = class _StoreImplementation {
    */
   async probeContributions() {
     const backend = this.#baseBackend;
-    const probe = backend.probeContributions;
-    if (probe === void 0) {
+    const probeVerdict = this.#contributionHealth.extras.probeContributions;
+    if (!probeVerdict.present) {
       if (backend.capabilities.contributions?.supported !== true) {
         return { entries: [] };
       }
@@ -20904,6 +21290,11 @@ var StoreImplementation = class _StoreImplementation {
         }
       );
     }
+    const { probeContributions: probe } = bindExtra(
+      backend,
+      probeVerdict,
+      CONTRIBUTION_HEALTH.id
+    );
     const vectorSlots = backend.capabilities.vector?.supported === true ? resolveGraphVectorSlots(this.#graph) : [];
     const entries = await probe(this.graphId, vectorSlots);
     const revision = await this.revisionNow();
@@ -20985,17 +21376,26 @@ var StoreImplementation = class _StoreImplementation {
    */
   async rebuildContribution(scope, options) {
     const backend = this.#baseBackend;
-    const rebuild = backend.rebuildContribution;
-    if (rebuild === void 0) {
-      throw new ConfigurationError(
-        "rebuildContribution requires a backend that can drop, recreate, and re-stamp strategy-owned contribution tables.",
-        {
-          backend: backend.dialect,
-          capability: "contributions",
-          operation: "rebuild"
-        }
-      );
-    }
+    requireExtras(
+      CONTRIBUTION_HEALTH,
+      this.#contributionHealth,
+      "contribution rebuild",
+      () => {
+        throw new ConfigurationError(
+          "rebuildContribution requires a backend that can drop, recreate, and re-stamp strategy-owned contribution tables.",
+          {
+            backend: backend.dialect,
+            capability: "contributions",
+            operation: "rebuild"
+          }
+        );
+      }
+    );
+    const { rebuildContribution: rebuild } = bindExtra(
+      backend,
+      this.#contributionHealth.extras.rebuildContribution,
+      CONTRIBUTION_HEALTH.id
+    );
     await this.#loadCaughtUp("rebuild");
     const registry = this.#registry;
     const graphId = this.graphId;
@@ -21316,6 +21716,9 @@ var StoreImplementation = class _StoreImplementation {
       coalesceUnchangedUpsertsEnabled: this.#coalescesUnchangedUpserts(),
       revisionSchema: this.#sqlSchema(),
       registry: this.#registry,
+      claimsVerdict: this.#claimsVerdict,
+      batchPointRead: this.#batchPointRead,
+      uniqueSidecarBatch: this.#uniqueSidecarBatch,
       ...identityConfig === void 0 ? {} : {
         identity: {
           lock: (target) => lockIdentityGraph(target, this.graphId),
@@ -21371,6 +21774,9 @@ var StoreImplementation = class _StoreImplementation {
       coalesceUnchangedUpsertsEnabled: this.#coalescesUnchangedUpserts(),
       revisionSchema: this.#sqlSchema(),
       registry: this.#registry,
+      claimsVerdict: this.#claimsVerdict,
+      batchPointRead: this.#batchPointRead,
+      uniqueSidecarBatch: this.#uniqueSidecarBatch,
       createOperationContext: (operation, entity, kind, id) => this.#createOperationContext(operation, entity, kind, id),
       withOperationHooks: runHooks
     };
@@ -21988,5 +22394,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-RCBG6YMT.js.map
+//# sourceMappingURL=chunk-RCBG6YMT.js.map