@nicia-ai/typegraph 0.50.0 → 0.51.1

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

@@ -1,25 +1,26 @@
-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 { 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-EVYW3532.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-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 { 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-EDLKIQRI.js';
-import { isSqlPlaceholder, bindSqlValue, markAnnIndexScan, asCompiledSelectSql, isRawExecutable, renderSql, annIndexScanTypes, sql, asCompiledRowsSql, markForceCustomPlan, asCompiledStatementSql, asCompiledTemporaryStatementSql } from './chunk-46UGOVRW.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-XZW2CTNO.js';
@@ -1105,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 (
@@ -2908,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);
@@ -3413,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"),
@@ -3609,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;
@@ -4496,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";
@@ -4521,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 }
   };
@@ -4620,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 },
@@ -7024,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,
@@ -10135,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();
@@ -10145,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);
       }
@@ -10225,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) {
@@ -10316,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) {
@@ -10583,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,
@@ -10723,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));
@@ -10745,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.
@@ -10853,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 = [];
@@ -11659,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);
@@ -13518,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);
     }
   });
 }
@@ -13640,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
@@ -13681,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(
@@ -14243,6 +14352,7 @@ function createEdgeCollection(config) {
     graphId,
     kind,
     backend,
+    batchPointRead,
     defaultTemporalMode,
     rowToEdge: rowToEdge2,
     executeCreate: executeEdgeCreate2,
@@ -14348,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);
@@ -14466,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 = [];
@@ -14785,6 +14905,7 @@ function createNodeCollection(config) {
     graphId,
     kind,
     backend,
+    batchPointRead,
     defaultTemporalMode,
     rowToNode: rowToNode2,
     executeCreate: executeNodeCreate2,
@@ -14823,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);
@@ -15034,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))
           );
@@ -15042,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);
           }
@@ -15231,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) => {
@@ -15246,6 +15378,7 @@ function createNodeCollectionsProxy(graph, graphId, registry, backend, operation
         graphId,
         kind,
         backend,
+        batchPointRead,
         ...operations
       });
       collectionCache.set(kind, collection);
@@ -15253,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) => {
@@ -15268,6 +15401,7 @@ function createEdgeCollectionsProxy(graph, graphId, registry, backend, operation
         graphId,
         kind,
         backend,
+        batchPointRead,
         ...operations
       });
       collectionCache.set(kind, collection);
@@ -16875,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();
@@ -16888,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));
@@ -18535,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;
@@ -18557,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");
@@ -18594,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({
@@ -18610,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.
@@ -18662,7 +18846,13 @@ var StoreImplementation = class _StoreImplementation {
         }
         const lock = await lockRecordedGraphWrite(target, this.graphId);
         return applyResolvedNodeClaims(
-          { graphId: this.graphId, registry: this.#registry, lock },
+          {
+            graphId: this.graphId,
+            registry: this.#registry,
+            lock,
+            claimsVerdict: this.#claimsVerdict,
+            uniqueSidecarBatch: this.#uniqueSidecarBatch
+          },
           target,
           upserts,
           releases,
@@ -18835,6 +19025,7 @@ var StoreImplementation = class _StoreImplementation {
     }
     const scope = createRecordedTransactionScope(
       target,
+      this.#batchPointRead,
       this.#sqlSchema(),
       target.dialect === "sqlite"
     );
@@ -19038,6 +19229,7 @@ var StoreImplementation = class _StoreImplementation {
         this.graphId,
         this.#registry,
         this.#backend,
+        this.#batchPointRead,
         this.#nodeOperations
       );
     }
@@ -19066,6 +19258,7 @@ var StoreImplementation = class _StoreImplementation {
         this.graphId,
         this.#registry,
         this.#backend,
+        this.#batchPointRead,
         this.#edgeOperations
       );
     }
@@ -19615,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;
@@ -19697,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;
@@ -20187,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)
     };
@@ -20281,6 +20484,7 @@ var StoreImplementation = class _StoreImplementation {
       this.graphId,
       this.#registry,
       txBackend,
+      this.#batchPointRead,
       txNodeOperations
     );
     let edges = createEdgeCollectionsProxy(
@@ -20288,6 +20492,7 @@ var StoreImplementation = class _StoreImplementation {
       this.graphId,
       this.#registry,
       txBackend,
+      this.#batchPointRead,
       txEdgeOperations
     );
     if (receiptRecorder !== void 0) {
@@ -20377,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;
@@ -20931,17 +21141,26 @@ 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);
   }
@@ -20998,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);
@@ -21048,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: [] };
       }
@@ -21062,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();
@@ -21143,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;
@@ -21474,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),
@@ -21529,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
     };
@@ -22146,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-MX7EKQPM.js.map
-//# sourceMappingURL=chunk-MX7EKQPM.js.map
+//# sourceMappingURL=chunk-K6OZIHKI.js.map
+//# sourceMappingURL=chunk-K6OZIHKI.js.map