@nicia-ai/typegraph 0.59.0 → 0.60.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @nicia-ai/typegraph
 
+## 0.60.0
+
+### Highlights
+
+TypeGraph 0.60 brings the set-oriented read APIs introduced in 0.59 into transaction callbacks. `TransactionContext` now provides `query()`, `neighbors()`, `countNeighbors()`, `subgraph()`, and `batchOnce()`, all bound to the open transaction so read-modify-write workflows can observe earlier writes without leaving their atomic boundary.
+
+The transaction forms preserve the physical guarantees that matter on a held connection: `tx.neighbors()` and `tx.countNeighbors()` each execute as one statement, while `tx.subgraph()` and `tx.batchOnce()` use exact-one-statement plans. Transaction-bound `batchOnce()` composes fluent reads from `tx.query()` with neighbor, count, and subgraph reads from its callback builder, returning independently typed results in tuple order.
+
+The surface is consistent across managed, adapter, receipt-enabled, recorded-time, measurable, and adopted transaction contexts. `withCheckedReads()` remains a root-store API: transaction reads already execute against the transaction's bound session, and callers choose the required snapshot behavior through the transaction isolation options.
+
+### Upgrade notes
+
+- Update hand-built `TransactionContext`, adapter transaction-context, or measurable transaction-context mocks and wrappers with `query`, `neighbors`, `countNeighbors`, `subgraph`, and `batchOnce`. Contexts created by TypeGraph provide these methods automatically.
+- Replace runtime feature checks and edge-read-plus-node-load fallbacks inside transaction callbacks with the typed transaction APIs. Type callback parameters as `TransactionContext<G>` or the appropriate adapter/measurable variant rather than as `Store<G>`; `withCheckedReads()` is intentionally unavailable on transaction contexts.
+- On PostgreSQL, request `isolationLevel: "repeatable_read"` or `"serializable"` when several separate transaction reads must observe one stable database snapshot. `tx.subgraph()` and `tx.batchOnce()` remain one statement regardless of isolation level.
+
+### Minor Changes
+
+- [#689](https://github.com/nicia-ai/typegraph/pull/689) [`956fd56`](https://github.com/nicia-ai/typegraph/commit/956fd560d270dc58fab687f810b2c63abd42694a) Thanks [@pdlug](https://github.com/pdlug)! - Add transaction-bound `query()`, `neighbors()`, `countNeighbors()`, `subgraph()`, and `batchOnce()` reads. Every read executes through the open transaction and observes earlier writes in the callback; `tx.subgraph()` and `tx.batchOnce()` each execute as exactly one statement.
+
 ## 0.59.0
 
 ### Highlights

package/README.md

@@ -42,6 +42,9 @@ batch-scoped builder with `neighbors()`, `countNeighbors()`, and `subgraph()`
 methods. Direct `store.subgraph()` and batch-scoped `read.subgraph()` return the
 same result shape and semantics; the direct form retains backend-tuned hydration
 while the batch-scoped form guarantees one statement.
+Transaction contexts expose the same `query()`, `neighbors()`,
+`countNeighbors()`, `subgraph()`, and `batchOnce()` reads, all bound to the open
+transaction so read-modify-write paths see their uncommitted changes.
 `store.neighbors()` can order by edge metadata or adjacent-node properties,
 while `subgraph({ edgeWindows })` applies per-kind direction, ordering, and
 limits during traversal. See

package/dist/backend/postgres/pglite-store.cjs

@@ -7,7 +7,7 @@ require('../../chunk-G7W67PZO.cjs');
 async function createLocalPgliteStore(graph, options = {}) {
   const impl = await chunkBMGHFZAV_cjs.loadDrizzleBackedModule(
     "./postgres/pglite",
-    () => import('../../pglite-store-impl-DB4RRLB7.cjs')
+    () => import('../../pglite-store-impl-33CI3P3M.cjs')
   );
   return impl.createLocalPgliteStoreImpl(graph, options);
 }

package/dist/backend/postgres/pglite-store.d.cts

@@ -1,7 +1,7 @@
 import { d as FulltextStrategy, e as GraphDef } from '../../types-Dky3sCFz.cjs';
 export { C as ContributionDiagnostic, a as ContributionDiagnosticState, b as ContributionRepairEntry, c as ContributionRepairResult, G as GraphIdentityConfig } from '../../types-Dky3sCFz.cjs';
-import { S as StoreOptions, a as SchemaManagerOptions, U as UnboundLiveStoreOptions, b as Store, H as HistoryStoreOptions, c as HistoryStore, R as RecordedReadStoreOptions, d as RecordedReadStore, L as LiveStoreOptions } from '../../store-CvtRQ8Nb.cjs';
-export { I as IdentityAssertion, e as IdentityAssertionId, f as IdentityAssertionResult, g as IdentityFacade, h as IdentityNode, i as IdentityNodeRefInput, j as IdentityPair, k as IdentityReadFacade, l as IdentityRelation, m as IdentityWriteSummary } from '../../store-CvtRQ8Nb.cjs';
+import { S as StoreOptions, a as SchemaManagerOptions, U as UnboundLiveStoreOptions, b as Store, H as HistoryStoreOptions, c as HistoryStore, R as RecordedReadStoreOptions, d as RecordedReadStore, L as LiveStoreOptions } from '../../store-DdhFpX53.cjs';
+export { I as IdentityAssertion, e as IdentityAssertionId, f as IdentityAssertionResult, g as IdentityFacade, h as IdentityNode, i as IdentityNodeRefInput, j as IdentityPair, k as IdentityReadFacade, l as IdentityRelation, m as IdentityWriteSummary } from '../../store-DdhFpX53.cjs';
 import 'zod';
 import '../../searchable-BEAN91Ce.cjs';
 import '../../resolve-mLksuBg2.cjs';

package/dist/backend/postgres/pglite-store.d.ts

@@ -1,7 +1,7 @@
 import { d as FulltextStrategy, e as GraphDef } from '../../types-Dky3sCFz.js';
 export { C as ContributionDiagnostic, a as ContributionDiagnosticState, b as ContributionRepairEntry, c as ContributionRepairResult, G as GraphIdentityConfig } from '../../types-Dky3sCFz.js';
-import { S as StoreOptions, a as SchemaManagerOptions, U as UnboundLiveStoreOptions, b as Store, H as HistoryStoreOptions, c as HistoryStore, R as RecordedReadStoreOptions, d as RecordedReadStore, L as LiveStoreOptions } from '../../store-sLu0hcRm.js';
-export { I as IdentityAssertion, e as IdentityAssertionId, f as IdentityAssertionResult, g as IdentityFacade, h as IdentityNode, i as IdentityNodeRefInput, j as IdentityPair, k as IdentityReadFacade, l as IdentityRelation, m as IdentityWriteSummary } from '../../store-sLu0hcRm.js';
+import { S as StoreOptions, a as SchemaManagerOptions, U as UnboundLiveStoreOptions, b as Store, H as HistoryStoreOptions, c as HistoryStore, R as RecordedReadStoreOptions, d as RecordedReadStore, L as LiveStoreOptions } from '../../store-B5WZ8E5m.js';
+export { I as IdentityAssertion, e as IdentityAssertionId, f as IdentityAssertionResult, g as IdentityFacade, h as IdentityNode, i as IdentityNodeRefInput, j as IdentityPair, k as IdentityReadFacade, l as IdentityRelation, m as IdentityWriteSummary } from '../../store-B5WZ8E5m.js';
 import 'zod';
 import '../../searchable-Bg2lMPRm.js';
 import '../../resolve-BbjZDYTw.js';

package/dist/backend/postgres/pglite-store.js

@@ -5,7 +5,7 @@ import '../../chunk-Q5QOGVDF.js';
 async function createLocalPgliteStore(graph, options = {}) {
   const impl = await loadDrizzleBackedModule(
     "./postgres/pglite",
-    () => import('../../pglite-store-impl-M5PWKN7Z.js')
+    () => import('../../pglite-store-impl-RDPTOOP3.js')
   );
   return impl.createLocalPgliteStoreImpl(graph, options);
 }

package/dist/backend/sqlite/local-store.cjs

@@ -8,7 +8,7 @@ require('../../chunk-G7W67PZO.cjs');
 async function createLocalSqliteStore(graph, options = {}) {
   const impl = await chunkBMGHFZAV_cjs.loadDrizzleBackedModule(
     "./sqlite/local",
-    () => import('../../local-store-impl-GFBZBCTN.cjs')
+    () => import('../../local-store-impl-QGSRYFZF.cjs')
   );
   return impl.createLocalSqliteStoreImpl(graph, options);
 }

package/dist/backend/sqlite/local-store.d.cts

@@ -1,7 +1,7 @@
 import { B as BundledBackendCapabilityOverrides, d as FulltextStrategy, e as GraphDef } from '../../types-Dky3sCFz.cjs';
 export { C as ContributionDiagnostic, a as ContributionDiagnosticState, b as ContributionRepairEntry, c as ContributionRepairResult, G as GraphIdentityConfig } from '../../types-Dky3sCFz.cjs';
-import { S as StoreOptions, a as SchemaManagerOptions, U as UnboundLiveStoreOptions, b as Store, H as HistoryStoreOptions, c as HistoryStore, R as RecordedReadStoreOptions, d as RecordedReadStore, L as LiveStoreOptions } from '../../store-CvtRQ8Nb.cjs';
-export { I as IdentityAssertion, e as IdentityAssertionId, f as IdentityAssertionResult, g as IdentityFacade, h as IdentityNode, i as IdentityNodeRefInput, j as IdentityPair, k as IdentityReadFacade, l as IdentityRelation, m as IdentityWriteSummary } from '../../store-CvtRQ8Nb.cjs';
+import { S as StoreOptions, a as SchemaManagerOptions, U as UnboundLiveStoreOptions, b as Store, H as HistoryStoreOptions, c as HistoryStore, R as RecordedReadStoreOptions, d as RecordedReadStore, L as LiveStoreOptions } from '../../store-DdhFpX53.cjs';
+export { I as IdentityAssertion, e as IdentityAssertionId, f as IdentityAssertionResult, g as IdentityFacade, h as IdentityNode, i as IdentityNodeRefInput, j as IdentityPair, k as IdentityReadFacade, l as IdentityRelation, m as IdentityWriteSummary } from '../../store-DdhFpX53.cjs';
 import { L as LocalSqlitePragmaOptions } from '../../local-options-CZ1BnIoF.cjs';
 export { D as DEFAULT_LOCAL_SQLITE_PRAGMAS, a as LocalSqliteJournalMode, b as LocalSqliteSynchronousMode } from '../../local-options-CZ1BnIoF.cjs';
 import 'zod';

package/dist/backend/sqlite/local-store.d.ts

@@ -1,7 +1,7 @@
 import { B as BundledBackendCapabilityOverrides, d as FulltextStrategy, e as GraphDef } from '../../types-Dky3sCFz.js';
 export { C as ContributionDiagnostic, a as ContributionDiagnosticState, b as ContributionRepairEntry, c as ContributionRepairResult, G as GraphIdentityConfig } from '../../types-Dky3sCFz.js';
-import { S as StoreOptions, a as SchemaManagerOptions, U as UnboundLiveStoreOptions, b as Store, H as HistoryStoreOptions, c as HistoryStore, R as RecordedReadStoreOptions, d as RecordedReadStore, L as LiveStoreOptions } from '../../store-sLu0hcRm.js';
-export { I as IdentityAssertion, e as IdentityAssertionId, f as IdentityAssertionResult, g as IdentityFacade, h as IdentityNode, i as IdentityNodeRefInput, j as IdentityPair, k as IdentityReadFacade, l as IdentityRelation, m as IdentityWriteSummary } from '../../store-sLu0hcRm.js';
+import { S as StoreOptions, a as SchemaManagerOptions, U as UnboundLiveStoreOptions, b as Store, H as HistoryStoreOptions, c as HistoryStore, R as RecordedReadStoreOptions, d as RecordedReadStore, L as LiveStoreOptions } from '../../store-B5WZ8E5m.js';
+export { I as IdentityAssertion, e as IdentityAssertionId, f as IdentityAssertionResult, g as IdentityFacade, h as IdentityNode, i as IdentityNodeRefInput, j as IdentityPair, k as IdentityReadFacade, l as IdentityRelation, m as IdentityWriteSummary } from '../../store-B5WZ8E5m.js';
 import { L as LocalSqlitePragmaOptions } from '../../local-options-CZ1BnIoF.js';
 export { D as DEFAULT_LOCAL_SQLITE_PRAGMAS, a as LocalSqliteJournalMode, b as LocalSqliteSynchronousMode } from '../../local-options-CZ1BnIoF.js';
 import 'zod';

package/dist/backend/sqlite/local-store.js

@@ -6,7 +6,7 @@ import '../../chunk-Q5QOGVDF.js';
 async function createLocalSqliteStore(graph, options = {}) {
   const impl = await loadDrizzleBackedModule(
     "./sqlite/local",
-    () => import('../../local-store-impl-EPUMDNQJ.js')
+    () => import('../../local-store-impl-VEVK2VGA.js')
   );
   return impl.createLocalSqliteStoreImpl(graph, options);
 }

package/dist/{chunk-MKQY4ZLZ.js → chunk-2DKIJP2R.js}

@@ -1,16 +1,16 @@
 import { createEdgeRowMapper, createNodeRowMapper, SQLITE_ROW_MAPPER_CONFIG, POSTGRES_ROW_MAPPER_CONFIG, normalizeRowTimestamp, normalizeRequiredRowTimestamp, buildHardDeleteEdgeClaimsByNodeKind, buildHardDeleteUniquesByConcreteKind, buildHardDeleteEdgeClaimsByEdgeKind } from './chunk-EFTVYPGQ.js';
 import { assertRecordedInstantOwnershipMatch, resolveRecordedTimeOwnership, requireRecordedTime, isEngineNativeRecordedReadBinding } from './chunk-7GZJ36LN.js';
-import { rowToNode, executeNodeBulkFindByIndex, executeNodeBulkFindByConstraint, executeNodeFindByConstraint, executeNodeBulkGetOrCreateByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeDeleteBatch, executeNodeDelete, nodeUpsertDirtyCheck, executeNodeReplacementBatch, prepareNodeReplacement, executeNodeResolvedMutationSet, executeNodeUpsertUpdateBatch, executeNodeSetUpdate, executeNodeUpdate, executeNodeCreateNoReturnBatch, executeNodeCreateBatch, executeNodeCreate, rowToEdge, normalizePersistedEdgeMatchProps, assertValidityEndMutation, assertClearValidToSupported, buildEdgeMatchKey, resolveAtomicEdgeConvergenceExecutor, resolveEdgeMatchIdentityStorage, runHookedWritePlan, edgeWritePlan, resolveAtomicEdgeDeleteBatchExecutor, runWritePlan, runAtomicProgramWithHooks, unsupportedResolvedMutationSet, resolveAtomicEdgeResolvedMutationSetExecutor, withAlreadyExistsTranslation, ResolvedMutationSetMoved, appliedResolvedMutationSet, edgeWriteNeedsConstraintFence, writeResultAlwaysChanges, resolveAtomicEdgeBatchExecutor, nestedManagedWriteTarget, runResolvedMutationSetConverging, canonicalPersistedJsonValue, assertAtomicDeleteSchemaFenceMatched, edgeMatchIdentityUpdateRefusal, resolveAtomicEdgeResolvedUpdateBatchExecutor, atomicResolvedUpdateAttemptBudget, createEdgeBatchValidationBackend, canFuseSchemaFenceInFirstWrite, isAutocommitSingleStatementWrite, runAutocommitSingleStatementWritePlan, classifyDurableEdgeBatchOutcomes, rowToEdgeMeta, rowToNodeMeta, checkCardinalityConstraint, validityEndAfterMutation, assertsStoredWindowState, unfencedTarget, AutocommitWriteRequiresTransaction } from './chunk-V3JKR2CN.js';
-import { applyResolvedNodeClaims, assertFulltextMember, getEmbeddingFields, computeFulltextContent } from './chunk-6BVZHDAZ.js';
+import { rowToNode, executeNodeBulkFindByIndex, executeNodeBulkFindByConstraint, executeNodeFindByConstraint, executeNodeBulkGetOrCreateByConstraint, executeNodeGetOrCreateByConstraint, executeNodeHardDelete, executeNodeDeleteBatch, executeNodeDelete, nodeUpsertDirtyCheck, executeNodeReplacementBatch, prepareNodeReplacement, executeNodeResolvedMutationSet, executeNodeUpsertUpdateBatch, executeNodeSetUpdate, executeNodeUpdate, executeNodeCreateNoReturnBatch, executeNodeCreateBatch, executeNodeCreate, rowToEdge, normalizePersistedEdgeMatchProps, assertValidityEndMutation, assertClearValidToSupported, buildEdgeMatchKey, resolveAtomicEdgeConvergenceExecutor, resolveEdgeMatchIdentityStorage, runHookedWritePlan, edgeWritePlan, resolveAtomicEdgeDeleteBatchExecutor, runWritePlan, runAtomicProgramWithHooks, unsupportedResolvedMutationSet, resolveAtomicEdgeResolvedMutationSetExecutor, withAlreadyExistsTranslation, ResolvedMutationSetMoved, appliedResolvedMutationSet, edgeWriteNeedsConstraintFence, writeResultAlwaysChanges, resolveAtomicEdgeBatchExecutor, nestedManagedWriteTarget, runResolvedMutationSetConverging, canonicalPersistedJsonValue, assertAtomicDeleteSchemaFenceMatched, edgeMatchIdentityUpdateRefusal, resolveAtomicEdgeResolvedUpdateBatchExecutor, atomicResolvedUpdateAttemptBudget, createEdgeBatchValidationBackend, canFuseSchemaFenceInFirstWrite, isAutocommitSingleStatementWrite, runAutocommitSingleStatementWritePlan, classifyDurableEdgeBatchOutcomes, rowToEdgeMeta, rowToNodeMeta, checkCardinalityConstraint, validityEndAfterMutation, assertsStoredWindowState, unfencedTarget, AutocommitWriteRequiresTransaction } from './chunk-FTDRMXIJ.js';
+import { applyResolvedNodeClaims, assertFulltextMember, getEmbeddingFields, computeFulltextContent } from './chunk-43DOTETB.js';
 import { isBundledRootAutocommitEligible } from './chunk-AHRNKPEV.js';
 import { edgeCardinalityClaimTarget, edgeCardinalityClaimRefusal, edgeCardinalityClaim, edgeCardinalityClaimMode, claimEdgeCardinality } from './chunk-IM4X2ZOR.js';
 import { resolveBackendFulltext } from './chunk-N535PWMA.js';
 import { AtomicEdgeBatchEndpointRefusalError, AtomicEdgeConvergenceTombstoneRefusalError, AtomicEdgeDeleteIdentityRefusalError, AtomicEdgeBatchCardinalityRefusalError } from './chunk-2DNUADXX.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-E6PU35DE.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-W6K6NSRT.js';
 import { countSchemaKindRows } from './chunk-RFMSZ7CF.js';
 import { getTypeName } from './chunk-YXT3CCTR.js';
-import { loadCurrentStructuralClasses, loadAssertionsByIds, toTransferAssertion, liveNodeKindsSharingIds, createIdentityFacade, createIdentityReadFacade, validateIdentityForContext, removeIdentityKindsForContext, readIdentityAssertionsForInterchange, readIdentityAssertionPageAtTarget, lockIdentityGraph, foldIdentityForCreatedNodes, importIdentityAssertionsIntoTarget, assertAffectedIdentityClassesConsistent, applyIdentityChangesForContext, refKey, requireNodeValidityEndCompatible, detachIdentityForNode, rebuildIdentityClosureForContext, assertEdgeMatchIdentityBackendSupport } from './chunk-W4NT4IMI.js';
-import { storeRuntime, STORE_RUNTIME, assertRevisionTrackableBackend, createRecordedBackend, lockRecordedGraphWrite, refuseEngineNativeRecordedIdentityRead, createRecordedTransactionScope, readRecordedClock, ensureRevisionOrigin, recordedCaptureRequiresCallbackTransactionError, assertRecordedCaptureTransactionIsolation, lockSchemaVersionForStoreWrite, createMutationWitness, registerRecordedIdentityMutationWitness, TRANSACTION_RUNTIME, mintsOriginNamespacedAnchor, ensureRevisionOriginsRelation, generateId, runInWriteTransaction, assertCurrentRecordedSchema, AUTO_REFRESH_STATISTICS_ROW_THRESHOLD, withRecordedFlushObserver, withTransactionSchemaFenceLease, withWriteTransactionSession, resetRevisionOrigin, advanceRevisionClock, validateEdgeProps, diagnoseFusedSchemaFenceNoRow, getEdgeRowsByIds, memoizeLeasedSchemaFence, getNodeRowsByIds, hasLeasedSchemaFence, closeRecordedHardDeletedKind, historicalIdentityPeerClassQuery, IDENTITY_PEER_CLASS_COLUMNS, recordedBindParamBudget, throwHistoryUnsafeSqlAccess, throwRevisionTrackingUnsafeSqlAccess } from './chunk-HWWPL2YL.js';
+import { loadCurrentStructuralClasses, loadAssertionsByIds, toTransferAssertion, liveNodeKindsSharingIds, createIdentityFacade, createIdentityReadFacade, validateIdentityForContext, removeIdentityKindsForContext, readIdentityAssertionsForInterchange, readIdentityAssertionPageAtTarget, lockIdentityGraph, foldIdentityForCreatedNodes, importIdentityAssertionsIntoTarget, assertAffectedIdentityClassesConsistent, applyIdentityChangesForContext, refKey, requireNodeValidityEndCompatible, detachIdentityForNode, rebuildIdentityClosureForContext, assertEdgeMatchIdentityBackendSupport } from './chunk-B4P4DAW3.js';
+import { storeRuntime, STORE_RUNTIME, assertRevisionTrackableBackend, createRecordedBackend, lockRecordedGraphWrite, refuseEngineNativeRecordedIdentityRead, createRecordedTransactionScope, readRecordedClock, ensureRevisionOrigin, recordedCaptureRequiresCallbackTransactionError, assertRecordedCaptureTransactionIsolation, lockSchemaVersionForStoreWrite, createMutationWitness, registerRecordedIdentityMutationWitness, TRANSACTION_RUNTIME, mintsOriginNamespacedAnchor, ensureRevisionOriginsRelation, generateId, runInWriteTransaction, assertCurrentRecordedSchema, AUTO_REFRESH_STATISTICS_ROW_THRESHOLD, withRecordedFlushObserver, withTransactionSchemaFenceLease, withWriteTransactionSession, resetRevisionOrigin, advanceRevisionClock, validateEdgeProps, diagnoseFusedSchemaFenceNoRow, getEdgeRowsByIds, memoizeLeasedSchemaFence, getNodeRowsByIds, hasLeasedSchemaFence, closeRecordedHardDeletedKind, historicalIdentityPeerClassQuery, IDENTITY_PEER_CLASS_COLUMNS, recordedBindParamBudget, throwHistoryUnsafeSqlAccess, throwRevisionTrackingUnsafeSqlAccess } from './chunk-QWIR5533.js';
 import { isParameterRef, resolveParameterValueType, fieldRef, buildFieldBuilderForTypeInfo, stringField, createFulltextAccessor, CURRENT_READ_INSTANT_PLACEHOLDER, extractFulltextMatchPredicates, extractVectorSimilarityPredicates, withPinnedReadInstant, resolveBatchWriteVerdict, batchRefusalSuffix, batchRefusalDetails, canonicalEqual, runRetriedUnit, assertRecursiveTraversalSupported, baseField, objectField, arrayField, dateField, numberField, sortedReplacer, compileFieldValue, compileKindFilter, compileTemporalFilter, currentReadInstant, chunk, sqlValueList, buildPredicateIndex, requireRecursiveTraversalVerdict, getFieldPointer, groupBy, delay, currentReadInstantFor, extractTemporalOptions, compilePredicateExpression, isOptimisticRetryTier, OPTIMISTIC_RETRY_ATTEMPTS, getPredicatesForAlias, getNodeKindsForAlias, getHybridTargetAlias, compilePredicateClauses } from './chunk-XWMB3AFN.js';
 import { batchPointReadVerdict, statementExecutionVerdict, createClaimsVerdictThunk, uniqueSidecarBatchVerdict, contributionHealthVerdict, recordedRevisionOriginsVerdict, requireExtras, requireCatalog } from './chunk-ZQIDQHDR.js';
 import { assumeRecursiveTraversalSupported, withRecordedRelationsPrecondition, createSqlSchema, requireSqlSchema, DEFAULT_SQL_SCHEMA, recordedReadSchemaFor, resolveRecursiveTraversal, resolveWriteFencePlan, refuseUnfencedOperationalIdentity, refuseUnfencedClockAllocation, requireExternalRecordedReadSource, createRecordedReadBinding, createEngineRecordedReadBinding, runOptionallyInTransaction, createTransactionReadBackend, bindExtraIfReachable, BATCH_POINT_READ, CONTRIBUTION_HEALTH, bindExtra, projectGraphBackend, deriveBackend, vectorSlotKey, requireRecordedReadBinding, projectBackend, rowPropsToObject, recordedReadSqlSchema, INTERNAL_TEMPORARY_WRITES, postgresReadWriteRefusedSqlState, assertGraphCommandConvergenceIsolation, isSchemaFencedInsertEligible, executeAuthoritativeGraphCommand, assertRecursiveTraversal, isMissingTableError, postgresTemporaryTableUnavailableSqlState, isPostgresConcurrentDdlRaceError, ALIAS_CTE_PREFIX, EMBEDDINGS_CTE_ALIAS, FULLTEXT_CTE_ALIAS, HYBRID_CANDIDATES_CTE_ALIAS } from './chunk-LI7JGO5B.js';
@@ -23145,17 +23145,14 @@ var StoreImplementation = class _StoreImplementation {
    * adapter may reuse one client there too. The portable guarantee is only
    * that at most one query is in flight at a time.
    *
-   * **Not a snapshot — and there is no way to make it one.** PostgreSQL
-   * defaults to read-committed isolation, so a later query can observe a
-   * commit the earlier ones did not. `store.transaction()` takes an
-   * `isolationLevel`, but its context exposes only `nodes` / `edges`: there is
-   * no public way to run a fluent query or a batch inside a transaction, so a
-   * snapshot across fluent queries is not available today. Collection reads
-   * can have one — `store.transaction(fn, { isolationLevel: "repeatable_read" })`
-   * reading through `tx.nodes` / `tx.edges` — but only where the backend has
-   * transactions (other backends refuse before invoking the callback), and a history-enabled
-   * store on PostgreSQL additionally requires `accessMode: "read_only"` or the
-   * call throws.
+   * **Not a snapshot by default.** PostgreSQL defaults to read-committed
+   * isolation, so a later query can observe a commit the earlier ones did not.
+   * When multiple reads need one stable snapshot, use `tx.query()` or the
+   * transaction's set-oriented reads inside `store.transaction(fn, {
+   * isolationLevel: "repeatable_read" })`. `tx.batchOnce()` is one statement
+   * regardless of isolation level. Transaction reads require a backend with
+   * interactive transactions, and a history-enabled store on PostgreSQL
+   * additionally requires `accessMode: "read_only"` for a read-only transaction.
    *
    * **Will not fix an N+1.** Serializing N queries does not reduce their
    * number. The alternatives are set-oriented or chunked rather than
@@ -23217,23 +23214,33 @@ var StoreImplementation = class _StoreImplementation {
    * here.
    */
   async batchOnce(build) {
-    const queries = build({
+    return this.#batchOnceForBackend(this.#baseBackend, 1, build);
+  }
+  #createBatchReadBuilder(backend, attempt) {
+    return {
       neighbors: (source, options) => {
         this.#assertNeighborKinds(source, options.edges);
-        return createNeighborRead(this.#neighborContext(), source, options);
+        return createNeighborRead(
+          this.#neighborContext(backend, attempt),
+          source,
+          options
+        );
       },
       countNeighbors: (source, options) => {
         this.#assertNeighborKinds(source, options.edges);
         return createNeighborCountRead(
-          this.#neighborContext(),
+          this.#neighborContext(backend, attempt),
           source,
           options
         );
       },
-      subgraph: (rootId, options) => this.#createSubgraphRead(rootId, options)
-    });
+      subgraph: (rootId, options) => this.#createSubgraphRead(rootId, options, backend, attempt)
+    };
+  }
+  async #batchOnceForBackend(backend, attempt, build) {
+    const queries = build(this.#createBatchReadBuilder(backend, attempt));
     return executeOneStatementBatch(
-      this.#createHookedQueryBackend(this.#baseBackend),
+      this.#createHookedQueryBackend(backend, attempt),
       queries
     );
   }
@@ -23247,10 +23254,10 @@ var StoreImplementation = class _StoreImplementation {
     this.#assertNeighborKinds(source, options.edges);
     return countNeighbors(this.#neighborContext(), source, options);
   }
-  #neighborContext() {
+  #neighborContext(backend = this.#backend, attempt = 1) {
     return {
       graphId: this.graphId,
-      backend: this.#createHookedQueryBackend(this.#backend),
+      backend: this.#createHookedQueryBackend(backend, attempt),
       schema: this.#sqlSchema(),
       defaultTemporalMode: this.#graph.defaults.temporalMode,
       registry: this.#registry
@@ -23423,30 +23430,29 @@ var StoreImplementation = class _StoreImplementation {
    * ```
    */
   async subgraph(rootId, options) {
-    assertNoRecordedCoordinate(options, {
-      code: "SUBGRAPH_RECORDED_ASOF_INTERNAL_ONLY",
-      message: "recordedAsOf is only available through store.asOfRecorded(...).subgraph(...).",
-      suggestion: "Use store.asOfRecorded(recordedAt).subgraph(rootId, options) instead of passing recordedAsOf directly."
-    });
+    this.#assertPublicSubgraphOptions(options);
     return this.subgraphAtCoordinate(rootId, options);
   }
-  #createSubgraphRead(rootId, options) {
-    assertNoRecordedCoordinate(options, {
-      code: "SUBGRAPH_RECORDED_ASOF_INTERNAL_ONLY",
-      message: "recordedAsOf is only available through store.asOfRecorded(...).subgraph(...).",
-      suggestion: "Use store.asOfRecorded(recordedAt).subgraph(rootId, options) instead of passing recordedAsOf directly."
-    });
+  #createSubgraphRead(rootId, options, backend = this.#baseBackend, attempt = 1) {
+    this.#assertPublicSubgraphOptions(options);
     return createSubgraphRead({
       graph: this.#graph,
       graphId: this.graphId,
       rootId,
-      backend: this.#createHookedQueryBackend(this.#baseBackend),
-      dialect: getDialect(this.#backend.dialect),
+      backend: this.#createHookedQueryBackend(backend, attempt),
+      dialect: getDialect(backend.dialect),
       schema: this.#schema,
       recordedReadBinding: this.#recordedReadBinding,
       options
     });
   }
+  #assertPublicSubgraphOptions(options) {
+    assertNoRecordedCoordinate(options, {
+      code: "SUBGRAPH_RECORDED_ASOF_INTERNAL_ONLY",
+      message: "recordedAsOf is only available through store.asOfRecorded(...).subgraph(...).",
+      suggestion: "Use store.asOfRecorded(recordedAt).subgraph(rootId, options) instead of passing recordedAsOf directly."
+    });
+  }
   /**
    * Internal seam for {@link StoreView} / {@link RecordedStoreView}: runs a
    * subgraph with a coordinate already flattened into the options (including a
@@ -23832,9 +23838,34 @@ var StoreImplementation = class _StoreImplementation {
     };
     return overlayPropertyDescriptors(context, { measure });
   }
+  /** Builds graph reads that execute through one already-open transaction. */
+  #createTransactionReadSurface(txBackend, attempt) {
+    return {
+      query: () => this.#createQueryForBackend(txBackend, void 0, attempt),
+      batchOnce: (build) => this.#batchOnceForBackend(txBackend, attempt, build),
+      neighbors: (source, options) => {
+        this.#assertNeighborKinds(source, options.edges);
+        return readNeighbors(
+          this.#neighborContext(txBackend, attempt),
+          source,
+          options
+        );
+      },
+      countNeighbors: (source, options) => {
+        this.#assertNeighborKinds(source, options.edges);
+        return countNeighbors(
+          this.#neighborContext(txBackend, attempt),
+          source,
+          options
+        );
+      },
+      subgraph: (rootId, options) => this.#createSubgraphRead(rootId, options, txBackend, attempt).execute()
+    };
+  }
   /**
-   * Builds the `{ nodes, edges, sql }` projection bound to a
-   * transaction-scoped backend. Shared verbatim by {@link transaction}
+   * Builds the transaction context bound to a transaction-scoped backend.
+   * Collections, fluent queries, and set-oriented reads all use that same
+   * backend. Shared verbatim by {@link transaction}
    * (TypeGraph opens the tx) and {@link withTransaction} (#134 — the
    * caller opened it) so both surfaces resolve collections, query
    * factories, and the reused graph/registry identically. When history capture
@@ -23890,6 +23921,7 @@ var StoreImplementation = class _StoreImplementation {
     const base = {
       nodes,
       edges,
+      ...this.#createTransactionReadSurface(txBackend, attempt),
       ...receiptIdentity === void 0 ? {} : { identity: receiptIdentity },
       backend: createTransactionReadBackend(txBackend),
       [TRANSACTION_RUNTIME]: { backend: txBackend, runNodeOperationHooks },
@@ -25848,5 +25880,5 @@ async function createVerifiedAdapterStore(graph, backend, options) {
 }
 
 export { CURRENT_ONLY_READ_NAMES, EDGE_TEMPORAL_READ_NAMES, ExecutableAggregateQuery, ExecutableQuery, IDENTITY_READ_NAMES, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, NODE_TEMPORAL_READ_NAMES, PreparedQuery, QueryBuilder, RecordedStoreView, StoreAnalysisCursorStaleError, 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-MKQY4ZLZ.js.map
-//# sourceMappingURL=chunk-MKQY4ZLZ.js.map
+//# sourceMappingURL=chunk-2DKIJP2R.js.map
+//# sourceMappingURL=chunk-2DKIJP2R.js.map