# Oracle coverage and closeout ## RC npm tag policy, 2026-10-29 The maintainer directed RC versions to npm's `latest` tag on 2026-10-29. `CONTRIBUTING.md` records this policy. The release-history model and command/HTTP receivers now expect `latest` for candidate and stable uploads. Exact-version membership still decides whether an upload is needed; an existing version is never republished to move a tag. Existing `rc` aliases are preserved by the separate `npm dist-tag add @ latest` operation. Historical campaign records below retain the former `rc`-only authority and its P01 findings. They are not current tag-policy evidence. The existing histories, comparisons, reach declarations, and run budgets remain intact. The maintainer explicitly stopped local tests during this release. No RED, GREEN, or mutant campaign was run for this policy change; execution evidence is pending CI. The command/HTTP owners do not cover manual tag promotion, production npm credentials, or Actions authentication. ## RC scope partition, 2026-10-29 The [deferred oracle record](oracle-reviews/2026-10-29-pr-2171-deferred-oracles.md) names preserved P09/P10/P11/P12 failures, the appended chunk-24 static receiver, their exact recoverable source snapshot and retained evidence. Their detailed campaign entries below remain a lossless historical record; those named files and appended slices are deferred registrations, not active release coverage or closed laws. Original root metadata and the 24 nullable-facade/public-output type campaigns remain active. For the staged RC publication, the maintainer temporarily removed the duplicate test matrices and DB report merge from the Release workflow on 2026-10-29. Release run [40910451885](https://github.com/TanStack/db/actions/runs/40910451885) succeeded and reported all 20 included RC versions and the two stable versions already published on npm. The release test matrices and report merge are now restored. At the maintainer's request, Convex Collection, Preact DB, and React Router with DB have their public manifests and consumed first-RC release entries restored too. Their initial manual publications and npm trusted publisher setup still require verification; restoring publication eligibility does not establish npm access. The successful release does not close the counterexamples in [#2294](https://github.com/TanStack/db/issues/2294), [#2281](https://github.com/TanStack/db/issues/2281), or [#2296](https://github.com/TanStack/db/issues/2296), or the reach gap in [#2287](https://github.com/TanStack/db/issues/2287). Use [Oracle Testing Rubric](oracle-rubric.md) when adding or reviewing a law. This map identifies existing owners, their judgment, and their limits. It is not a claim that every state or every test has been audited. The [project glossary](glossary.md) owns terms shared by these executable models and their production subsystems. A coverage owner may define narrower local terms, but it must not silently rename a production concept. The [2026-10-10 owner-overlap review](oracle-reviews/2026-10-10-owner-overlap-audit.md) distinguishes canonical laws from their receiving witnesses across packages. ## Convex collection integration The [October 28 health API migration](oracle-reviews/2026-10-28-convex-health-migration.md) receives main's #2168 status, health and cleanup contracts. The snapshot owner now compares public status and health as well as all existing typed row and error comparisons. An invalid first result ends the sync run; its recovery starts a new run through `reload()`. After readiness, invalid results retain rows and report a recoverable failure reason, cleared by a valid result. Both fixed and random 150-history campaigns reach every declared snapshot state, including initial rejection and valid-after-error. The offline source owner also requires reload after its failed first load. This supersedes the older same-run initial recovery claim below, under #2168's maintainer decision. The lazy terminal-graph owner retains every last-row and retired-callback comparison. Its terminal status is now `crashed`, under architecture law 16. Its component and actual-backend drivers use internal lifecycle teardown to exercise that boundary, since law 14 now rejects public cleanup with active dependents. The component driver additionally checks that public rejection. Public cascade cleanup ends dependents instead of preserving their graph rows; core's source-health owner remains primary for that separate law. Synchronous adapter throws are observed as rejected loads, as law 16 now specifies. These are explicit contract migrations, not exemptions from row, receipt or callback comparisons. Provider authentication, reconnect and actual backend paths retain their receiving suite; the new health comparison itself is at the controlled callback boundary, not an arbitrary cloud failure guarantee. The [October 26 oracle repair record](oracle-reviews/2026-10-26-convex-oracle-repairs.md) records rejection of five previously surviving wrong designs, enforced per-campaign reach, and the current replay coordinates. Earlier shrink paths below remain historical evidence for their named source revisions; changed grammars need the new coordinates in that record. Exact-head follow-up records: [source and backend](oracle-reviews/2026-10-23-convex-source-and-backend.md) and [pagination and codecs](oracle-reviews/2026-10-23-convex-pagination-and-codecs.md), both bound to source revision `6511ee4ed0940cd54ee58ceeba7202ca859344b3`. The [public app receiving review](oracle-reviews/2026-10-24-convex-public-apps.md) is bound to test-source revision `4223c39a6d5c2b2e2fedb1a7eee3c0052b5e5013`. The [auth dependency follow-up](oracle-reviews/2026-10-24-convex-auth-dependency-update.md) records patched Auth.js 0.41.3 and Convex Auth 0.0.96 at revision `bae01f788134aa421a9018278ec6d2867519dae3`, with the full final 17-test backend suite passing. The Convex package has these independent judgments: - `packages/convex-db-collection/tests/snapshot-oracle.property.test.ts` compares public rows with the latest valid provider array. It covers missing-row deletion, full-row replacement, reintroduction, empty results, and atomic duplicate-key rejection, through both raw results and successful select projections. Constructive prefixes and generated suffixes cross string, finite-number and mixed keys, including distinct `1` and `'1'`, initial duplicate rejection, and projections that change key representation. Comparisons retain typed keys. - `packages/convex-db-collection/tests/ownership-oracle.property.test.ts` owns concrete options admission separately from snapshot refinement. Its identity model crosses direct and shallow-copy reuse with idle, ready, and cleaned-up owners. Reuse rejects before it can replace the first owner's cached mutation confirmation. Fresh options and separate DbClient descriptor materializations remain independent, including sibling cleanup and rightful-owner restart. The original implementation failed admission at seed 20261022/path 2:0:0; the original two-owner mutation witness settled the first owner to its stale row. The claim repair passes both fixed and random 60-history campaigns and direct replay. It follows the existing LocalStorage concrete-options policy. This owner does not cover arbitrary Collection lifecycle or a real SDK's multi-listener scheduling. SDK tests receive the cached-listener premise and exercise both real clients with either sibling cleaned up before the survivor receives another update. - `packages/convex-db-collection/tests/pagination-oracle.property.test.ts` owns complete finite snapshots across reactive cursor ranges. It varies page sizes 1-4, forward/reverse callback delivery, row insertion/deletion/movement, and required/recommended/no split hints. The reference is the latest input array; the provider fixture independently answers numeric rank intervals. Comparison retains every select and public Collection publication, permits repeated complete snapshots, and rejects partial snapshots or a return to the prior revision after the new revision appears. Pending ranges retain the prior complete snapshot. Split cursors stay inside their returned page ranges. The accepted-row bound rejects over-cap results without partial publication; the omitted-option default accepts exactly 10,000 rows and rejects 10,001. The default-cap boundary, invalid `maxRows` rejection, and cleanup-failure fidelity are fixed tests in `packages/convex-db-collection/tests/pagination.test.ts` (fixed tests; no oracle owner (tracked in #2264)). Its initial-materialization work law also varies 3-40 pages and 1-8 rows per page. The original implementation copied incomplete prefixes and failed at seed 20261022/path 0:0:0:0. The repaired fixed/random campaigns copy each provider row once at first exhaustion. Cache scans still grow quadratically with page count during sequential acquisition, this is not a total-work bound. - `packages/convex-db-collection/tests/offline-oracle.property.test.ts` owns the bridge's ordered argument/mutation/sync stages, durable key propagation, and terminal application-error classification. Argument and mutation failures reject with NonRetriableError; post-confirmation sync failures can retry. The original argument-error path failed this oracle at seed 20261022, path 5:1:1. The repair includes argument construction in terminal classification. Rejected source proposals now follow both initial and already accepted empty/nonempty bases, including later insert/update/delete/replacement, unchanged/changed cache retries and cleanup/restart recovery. - `packages/convex-db-collection/tests/values-oracle.property.test.ts` owns the Convex receiving check for native scalar types, bytes, nested containers, and removed fields across durable storage and fresh readers. Real Collection CRUD mutations supply distinct original/modified operands, equal-payload and changed updates, and removed-field changes; each operand is compared independently. Each owner runs matching fixed and random campaigns and accepts explicit seed/path replay through their CONVEX_*_ORACLE_SEED/PATH environment variables. Each normal campaign has a fresh reach ledger, fails if any declared state has fewer than one reached history, and prints its counts as `ORACLE_REACH` JSON. Explicit path replays run directly with one selected fast-check run and bypass campaign minima; shrink-path reconstruction can evaluate the callback more than once. Snapshot replay uses CONVEX_SNAPSHOT_ORACLE; pagination has separate CONVEX_PAGINATION_ROWS, CONVEX_PAGINATION_WORK, and CONVEX_PAGINATION_BOUND selectors; offline bridge replay uses CONVEX_OFFLINE_ORACLE; native value replay uses CONVEX_VALUES_ORACLE; ownership uses CONVEX_OWNERSHIP_ORACLE. `packages/convex-db-collection/e2e/backend-oracle.test.ts` receives these contracts at an actual isolated local Convex backend using both Convex 1.47.0 SDK clients. Its row-bound rejection is a fixed test in `packages/convex-db-collection/e2e/backend.test.ts` (fixed tests; no oracle owner (tracked in #2264)). It compares pagination with a separately evaluated unpaginated server query, including real server-generated split responses. Its durable driver runs fixed and random insert/update/delete histories through SIGKILL after disk admission and, optionally, a second SIGKILL after server acceptance but before recording outbox completion. It requires no offline provider call, restored Collection rows, and one server receipt after replay with the original key and the expected final server rows. Native payload variation covers inserts and updates. A separate non-idempotent application counter must equal one, and the receipt key must match the on-disk durable key. Restored Collections are compared on every application field, including native payloads. Atomic batches and multi-tab leadership remain outside this backend witness. Replay uses CONVEX_BACKEND_INSERT_ORACLE_SEED/PATH, CONVEX_BACKEND_UPDATE_ORACLE_SEED/PATH, or CONVEX_BACKEND_DELETE_ORACLE_SEED/PATH, with matching operation test selection. The command owns backend startup and shutdown. The offline engine's interruption, settlement, storage, and leadership owners remain primary for those laws; this is their Convex receiving witness. Generated bundles constructively cover known and uncertain acknowledgement for each native payload class while retaining six actual process histories per operation per campaign (36 total). Reach is credited at observed disk admission, server-acceptance and full replay comparisons, not from requested fixture inputs. `packages/convex-db-collection/e2e/public-pagination-oracle.test.ts` receives the finite pagination contract through the actual public `get-convex/convex-demos` functions at revision `2fac21e360bfcceae6065096f1b81480bd8c6fd5`. Its independent append ledger predicts descending message order, indexed author membership, and uppercase/author-initial projections. Both SDK clients exercise all three query forms at page size three, live appends, real TCP connection loss, direct writes while disconnected, and complete recovery after reconnect. Unique authored bodies supply the stable key omitted by the transformed query. It observes every ordered input to select and public Collection publication against complete authored ledger revisions allowed in that phase, plus final source-acceptance rows. Future ledger entries cannot retroactively justify an earlier observation. This receiving relation checks complete available revisions; it does not check monotonicity within one phase. The primary pagination owner checks that law. This is six authored receiving histories, not a new primary pagination model or an arbitrary transformed-key guarantee. Setup fetches the pinned source at run time, with no upstream application source redistributed in this repository. `packages/convex-db-collection/e2e/auth-app-oracle.test.ts` receives the snapshot contract through the official role-based Convex Auth app at revision `45f08008e1257758560948db4280cc4e7d64e84a`. The app's schema, message functions, permission checks, and role updates come from that pinned source. Setup changes only the external sign-in providers to the official Anonymous provider, with ephemeral signing keys and real issued JWTs. An independent set-valued permission policy drives all six read/write/admin operation cells, including demotion and repeated equal-body sends, while a multiset of authored message bodies predicts the public rows at each accepted source checkpoint. Both SDKs must reject an unauthenticated Collection preload; an invalid-token HTTP query is a separate authentication control. The app deliberately allows self-service role selection, so this does not establish secure role administration. The two authored receiving histories do not cover OAuth redirects, email delivery, token refresh, browser auth components, or production hosting. Both public-app fixtures deploy with this package's installed Convex 1.47 SDK. The pagination app's upstream package declares 1.48, its business functions are unchanged here but its original dependency installation is not being tested. `packages/convex-db-collection/e2e/backend-startup.test.ts` (fixed tests; no oracle owner (tracked in #2264)) covers the receiving fixture's occupied-port startup judgment. It holds the former fixed pagination port, invokes the actual pinned public-app setup, and requires a different loopback URL serving a fresh empty query. Expected availability comes from an independently held listener, not a copy of CLI selection logic. An already occupied port is also a valid precondition, and its external owner is never closed. All three fixture setups delegate default port selection to the supported Convex CLI, an explicit user `CONVEX_TEST_PORT` still requires that port. This is a fixed native startup witness, not a concurrent-allocation proof or a promise to start when no free ports exist. A CI run reproduced the original mandatory-port failure at auth port 43330 before any tests ran. The [startup follow-up](oracle-reviews/2026-10-24-convex-backend-startup.md) records exact source revision `4b37df090402469cafed0cf9f5e16b9528dae60f`, the rejected fixed-port control, and the final 18-test run with the former auth port occupied. `packages/offline-transactions/tests/transaction-serializer-oracle.property.test.ts` remains the primary wire-format owner. Its opt-in codec grammar crosses insert/update/delete and arrays of signed 64-bit integers, special floats and binary buffers in modified/original/changes. It uses an independently supplied V8 codec, recreates the reader, and checks missing/mismatched/throwing codecs through both get and getAll while preserving the exact stored bytes. The codec grammar uses real CRUD with independently authored before/after payloads, changed and equal-payload updates, and removed fields. Native class and operand distinctions have enforced measured reach in each campaign. Default unversioned/v2/v3 histories retain their prior expectations. A version-4 record requires its codec, and configured readers continue to accept old formats. The original serializer failed at durable admission for seed 20261022/path 0:0:0:0, a single BigInt insert. The repaired codec path preserves the values. The Convex values receiving owner, `packages/convex-db-collection/tests/values-oracle.property.test.ts`, checks bounded nested native trees, marker-like objects and undefined fields against an explicit type/byte observation. The backend process witness also varies native payloads. Transaction metadata is intentionally outside codec dispatch. The source-snapshot mutant that omits deletion and the partial-row mutant both fail the snapshot owner at public row comparison. Disabling automatic continuation or publishing an incomplete required split fails the pagination owner at public row comparison; replay seeds and shrink paths are recorded beside the property. These bounded tests do not prove continuous unbounded growth, cross-Collection atomic publication, cloud service availability, or power-loss atomicity during a filesystem write. The test backend has no application authorization; production authorization and atomic receipt storage are requirements of each application's server mutation. The October 23 review adds real-Collection source-acceptance histories to the offline bridge owner: idle, pending first result, failed startup, provider failure, and cleanup. Successful empty or nonempty snapshots must actually be accepted. Original idle acceptance fails seed 20261023/path 0:0:0, the repaired fixed/random campaigns and direct replay pass. The same file keeps its ordered-stage model separate from the source-settlement and rejected-acceptance judgments. A rejected durable acceptance stays terminal for that sync run, same or changed cached rows cannot falsely certify a retry, and cleanup/restart with a fresh accepted snapshot recovers. The nonterminal mutant fails seed 20261023/path 0:0 under CONVEX_OFFLINE_ACCEPTANCE_ORACLE_SEED/PATH. Ordinary provider errors retain same-run valid-result recovery. Dedicated codec replay uses OFFLINE_CODEC_ORACLE_SEED/PATH/RUNS; legacy serializer properties keep OFFLINE_ORACLE selectors. The paginated factory now also supports `syncMode: 'on-demand'` for one fixed query with an explicitly aligned finite numeric leading order. The [lazy paging implementation record](oracle-reviews/2026-10-26-convex-lazy-paging.md) records the approved law, semantic RED/GREEN, review repairs, checked mutant replays, source hashes and limits. `tests/lazy-paging-model-oracle.ts` owns the independent exact-window, complete-leading-tie, delivered-evidence successor-work and public-publication comparisons. `tests/lazy-paging-oracle.property.test.ts` runs five fixed/random 60-history families through real Collection controls and ordered live queries. Each current reach state was observed in all 60 histories per campaign. It covers finite/offset/whole/tie/continuation/empty scopes, short nonterminal pages, both splits, no-demand/zero/growth/cached-peer work, rejected acquisition/unload, held initial/moved/repaired windows, cache-before- callback refetch, abort before/after acceptance, held cleanup/restart, and two real applied receipts across publication reentry. Duplicate pending request objects retain both waiters. An invalid lazy startup never publishes readiness. Malformed order declarations are fixed tests in `packages/convex-db-collection/tests/lazy-paging.test.ts` (fixed tests; no oracle owner (tracked in #2264)). The [October 27 strengthening record](oracle-reviews/2026-10-27-convex-lazy-paging.md) supersedes those historical source bindings for the current files. The native `lazy-paging-history-oracle.property.test.ts` adds generated acquisition, retirement, abort, delivery, source-change, application-hold, cleanup and restart actions. Its constructive prefix retires or aborts the wider authorizer while work remains pending, then cleans up with a real accepted receipt held. Both SDK subscription shapes receive stale success/error callbacks. Every source publication is checked against the provider facts available at that publication; optimistic overlays are excluded. Paired hidden suffixes compare actual discovery traces before revealing the suffix. Retain/reacquire alternatives are positive scientific-comparator calibrations, not claims about native retention strategy. `lazy-paging-receipt-model.ts` independently owns the exact many-to-many attempt/establishing-receipt relation. Its controlled real-Collection receiver varies response groups and commit partitions independently, checks cached zero, one/shared/multiple receipts, held idempotent writes, true with zero/one/multiple synchronous receipts, Promise rejection and synchronous throw. Six faulty adapters distinguish borrowed receipts, first-only waits, skipped provider completion, content-only application, premature canceled settlement and a quiescent stranded caller. Native lifecycle checks trace every source/dependent publication and status transition during stale injection at cleanup start, held cleanup and restart; a fresh dependent succeeds while the old one remains terminal. A stale provider-error RED preceded the subscription fencing repair. The [interleaving follow-up](oracle-reviews/2026-10-27-convex-lazy-interleavings.md) adds four receiving families and supplies the current source binding for the shared receipt model/driver. `lazy-paging-interleaving-oracle.property.test.ts` varies legal response delivery, actual acceptance/application, and cancellation orders independently. An authored uncancelable in-flight obligation distinguishes abort before acceptance from withdrawal of already accepted work. Previously initiated work may establish a receipt after abort. The generic core model permits fulfillment after abort once facts, obligations and receipts apply; native/controlled receivers separately check their cancellation outcome policy. Borrowed/first-only receipts and premature in-flight cancellation fail promised observations. Extra waiting on a future peer receipt is contract-permitted; the earlier injected-edge control is not claimed as a rejected waiting strategy. `lazy-paging-native-receipt-oracle.property.test.ts` feeds actual native batches and core receipts into that same scientific model. Independently authored required versions absent at acquisition have unique supplying batches, which can establish two callers. It covers cached zero new edges, a shallow cached caller behind a deeper held peer, canceled/successful shared callers, and explicit cache revalidation to a new version. Early or delayed cached settlement is permitted; responsive post-drain completion is required. Its mutant native receiver returns the already applied startup receipt instead of the actual held receipt. Native attribution here excludes idempotent/superseding facts, reentrant commit observations and cleanup abandonment; the older controlled receiver retains idempotent receipt coverage and its all-responses-first profile. `lazy-paging-version-model-oracle.ts` owns coherent authored revisions and their monotone public frontier. `lazy-paging-version-oracle.property.test.ts` checks every source publication after full lazy acquisition, with multiple accepted revisions held behind real optimistic transactions, both SDK shapes and skipped intermediate revisions. Old complete values may remain while held; rollback and mixed versions fail even when final values are correct. The two mutant controls inject wrong public observations; they calibrate the recorder/model, not a production pager mutation. This profile keeps keys/order stable. General membership changes and partial-prefix retention retain their existing owners. `lazy-paging-failure-history-oracle.property.test.ts` composes preacceptance failure, two owners' shared held batch, cancellation, peer retirement, provider error, held cleanup, stale callbacks and restart. Every old dependent value and status event is checked for terminality; a fresh graph succeeds. Ordinary native errors may recover on a valid coherent result. It does not require an ordinary rejected attempt to wait its receipts. Its terminal controls calibrate the model; production stale-callback mutants remain in the prior repair record. Core `tests/query/load-subset-joint-replay-oracle.property.test.ts` receives the authoritative truncate law through real source commits and two live owners. It composes older uncancelable participants, held receipts, failure followed by ordinary writes, owner retirement, retry and held cleanup/restart. Newest-only publication and ordinary-write reopening production mutants fail the public snapshot comparison. Native Convex does not issue same-run authoritative truncates; these are distinct receiving profiles. Scientific models hold facts, obligations and allowed publications; transport/pager mechanics stay in drivers. No bounded campaign establishes arbitrary nonquiescent temporal progress or every formal schedule product. `e2e/lazy-concurrency-oracle.test.ts` now receives the same receipt and version models at the actual isolated Convex backend through both real SDK clients. Each generated history runs both SDKs, with independently authored stable rows/ranks, varied page sizes/text, shared full acquisitions, real optimistic application holds, post-acceptance cancellation and a cached shallow peer. Before cancellation, unique required facts establish the actual shared held receipt and both callers' missing-fact sets are empty. Cached extra waiting is permitted. After full acquisition, atomic test-server full-relation mutations offer revisions before writing; two distinct accepted revision witnesses are held before application, and the independent writer advances during reader TCP loss. Every active source publication feeds the unchanged version/provenance comparisons. Actual callback snapshots must contain the drained and reconnected revisions; manual checkpoints cannot supply that reach evidence. Actual receipt fulfillment supplies application, even when a newer FIFO revision is already public before the Promise callback runs. The normal family has matching fixed and random four-history campaigns, with both SDK receivers in every history; `CONVEX_BACKEND_CONCURRENCY_ORACLE_SEED/PATH` replays directly. Removing applied waiting and dropping the first updated row are production mutants rejected by the receipt and version laws respectively through both SDKs, with shrink/replay and byte-for-byte restoration. The [backend concurrency record](oracle-reviews/2026-10-27-convex-lazy-backend-concurrency.md) binds sources, commands and results. This backend receiver preserves the stable-key, fully acquired revision profile. It does not claim arbitrary acceptance/application orders, idempotent receipt attribution, accepted cleanup abandonment or native application/provider errors. TCP loss tests transport recovery; it does not promise a provider-error callback. The broader combined failure grammar retains its controlled receiving profile; the boundary receiver below adds the after-acceptance query-error/cleanup subset. Other real backend source/window mutation and framework boundaries retain their existing owners. The [boundary-strengthening record](oracle-reviews/2026-10-27-convex-lazy-boundaries.md) extends these receiving profiles without importing pager mechanics into the scientific models. `lazy-paging-revalidation-oracle.property.test.ts` attributes actual native commits made inside isolated explicit revalidation calls, including equal-valued accepted writes and later supersession. Actual receipt fulfillment proves application; a historical value need not remain visible at its Promise callback. Cached reuse may accept another receipt or owe zero new receipts. Every history exercises both controlled SDK shapes, then an unheld reactive revision, with callback-only publication witnesses and retained semantic errors. This is not evidence that a real Convex backend emits equal-valued query results, nor general attribution of asynchronous/reentrant native receipt edges. `e2e/lazy-boundary-oracle.test.ts` receives ordered windows computed by `expectedLazyRows` and the sequence-observation mode of `LazyVersionModel`. It never compares the whole retained partial source to a full server revision. Every base publication separately receives the real SDK provenance judgment. Generated histories keep an actually unread suffix while atomic server edits insert, delete and move rows across the window. Window growth remains pending on a real held application receipt while two or three later revisions arrive. The same episode then composes two full callers' shared held acceptance, caller abort, a genuine reactive server query error, cleanup-abandoned actual receipts, and a fresh graph while the old graph stays terminal. `LazyReceiptModel` now distinguishes pending, applied and cleanup-abandoned receipts; cleanup authority alone does not discharge an unobserved receipt. The shared `LazyTerminalGraphModel` supplies the old graph judgment to both controlled and backend receivers. Both new families run matching fixed/random campaigns, direct seed/path replay, and both SDKs in every history. Selectors are `CONVEX_REVALIDATION_ORACLE_SEED/PATH` and `CONVEX_BOUNDARY_ORACLE_SEED/PATH`; `CONVEX_LAZY_ORACLE_RUNS_MULTIPLIER` expands both campaign budgets equally. Standard package oracle scripts discover them; the existing browser CI lane runs the backend receiver via `test:e2e`. Calibration distinguishes unchanged-content application shortcuts, lost native deletions, and a separate stale-publication perturbation that ends with correct rows. Exact commands, source hashes and outcome classifications are in the record. This does not close arbitrary scheduling, rank ties in the new backend family, provider errors before acceptance, adversarial keys stale real-SDK callbacks, same-run authoritative truncate, or React rendering boundaries. Those retain their existing owners; the controlled failure family remains broader than its new backend receiving subset. The [application/cancellation follow-up](oracle-reviews/2026-10-27-convex-lazy-app-abort.md) adds three receiving families motivated by issue #2269. `LazyWriteModel` in `tests/lazy-paging-write-model-oracle.ts` independently owns the authored backend ledger and the composition of source revisions, requested windows and one optimistic operation. Backend acknowledgment and optimistic settlement are different boundaries. The publication relation retains every compatible monotone source/window explanation; rejecting an optimistic operation may reveal an older applied source without permitting source rollback after a newer view. Its comparator controls accept that legal history and reject atomic mixing, source rollback, lost confirmed writes and remote effects of atomic rejection. `e2e/lazy-app-write-oracle.test.ts` receives that model through both actual SDKs and the isolated backend. Each history includes confirmed/rejected Collection insert, update and delete handlers, independent visible/unread remote edits, demand growth behind a real held receipt, and an unread suffix. Successful handlers must expose the correct source key at application settlement while real SDK caches are current and notifications are withheld. Every graph publication is judged; the backend is independently checked against the ledger, and drained windows against its exact projection. Rejected server transactions throw after attempting their writes, exercising real atomic rollback. This is not a promise to undo arbitrary handler side effects after a remote commit. Limits: unique ascending numeric ranks, one application operation at a time, bounded strings, no rich-value/reload/health API coverage. `tests/lazy-paging-load-outcome-oracle.property.test.ts` compares the same generated failed-replay/ordinary-write/retry history under synchronous throw and Promise rejection, through direct subscriptions and live queries. It checks original error identity, every public value, failed-publication retention and successful recovery. The comparison permits their different acquisition lease lifetimes. Initial-load equivalence and arbitrary reentry retain the core lifecycle owners; this new family claims the replay boundary only. `tests/lazy-paging-abort-replay-oracle.property.test.ts` receives preacceptance cancellation through both controlled native SDK shapes, followed by two real same-run core truncate replays with disjoint source keys. Abort settles before withheld delivery; no-demand delivery accepts no rows. Retired success/error callbacks after each successful replay cannot resurrect rows, poison current sync or read a retired React watch. Native Convex does not initiate these truncates; the driver supplies that core input. This is no claim about actual SDKs emitting adversarial keys stale callbacks or about bounded work during replay. The existing receipt model still owns accepted writes. This checkout's older core waits for uncancelable baselines; #2269's immediate-core-abort decision belongs to integration with unmerged #2168. The new family exercises their shared cancellable-adapter obligation without silently changing either law. All three families run fixed/random campaigns with direct seed/path replay and declared reach. The follow-up records three rejected production decisions (early handler confirmation, swallowed throws, missing retirement fencing), a misdirected-write driver calibration, shrunk replays and restored GREENs. `tests/sdk-cache-oracle.test.ts` supplies both real SDKs' coherent cache-before- callback premise through legal controlled multi-query wire transitions. `e2e/lazy-paging-oracle.test.ts` receives shared value/coverage/work judgments through both SDKs and the isolated local backend: unread finite tails, window movement, live delete/move, real required/recommended splits, native leading ties with a local trailing order, and same-run TCP reconnect. Native work checking is limited to stable-source acquisitions; mutation/reconnect phases compare values and coverage at settled cuts. `packages/react-db/tests/convex-lazy-paging-oracle.test.tsx` receives exact data, every page, page parameters and lookahead through `useLiveInfiniteQuery`, checking every committed ready tuple, across provider page sizes 1–4. Other framework receiving paths are untested under these owners. The eager mirror and retained lazy prefix default to maxRows 10,000. Retained ranges stay subscribed until cleanup; this is no network-byte, peak-memory, total-call, scan or lifetime subscription-count bound. Whole-source requests may exhaust the query. Core can issue such a request after source restart even for a terminal dependent: the graph remains terminal but its source subscription can survive. The cleanup driver accounts for that actual demand. Terminal graph publication is covered; zero post-error acquisition is not promised here. General query translation, arbitrary application filters/orders, nullable/string leading orders and array select in lazy mode are excluded by the public profile. An incompatible external truncate wrapper is not a Convex reset mechanism. The existing core load-subset replay, transaction, ordered lifecycle and cleanup owners remain primary for replay/failure gates and delayed cancellation. Their 458-test delegated run is distinct from native Convex coverage. Responsive- provider quiescent stalls fail a named progress comparison; continuously nonquiescent work remains a diagnostic limit. The frozen TLA+ design projections are analytical evidence, not proof of this production implementation. Validation at the initial review: 43 adapter checks, 302 offline-engine tests, and seven real-backend tests passed. The October 23 strengthened backend suite passes nine tests with 36 generated crash histories. Final local validation passes 62 adapter checks and 302 offline-engine tests. Exact-head review records accompany this follow-up. The native-value receiving oracle rejects a scalar-as-JSON decoder at the typed-value comparison (seed 20261022/path 0:0); its repaired replay passes. `pnpm size:compare --packages convex-db-collection,offline-transactions --files` measures 2,863 gzip / 2,594 brotli bytes for the new adapter's combined exports, with dependencies external. The shared outbox grows by 192 gzip / 174 brotli bytes. Kyle review repairs add 230 gzip / 213 brotli bytes over the published PR head for actual first-source acceptance and the accepted-row bound. Existing tree-shaken app scenarios remain unchanged. Reusing the sync config materialization hook avoids a parallel startup lifecycle, and the existing page loop enforces the bound without a second pager. A new adapter has no baseline to subtract; normal and paginated sources share one snapshot writer, and the existing outbox supplies durability instead of a second write queue. The codec hook is needed to preserve native values without changing default JSON semantics. Review fixes add 74 gzip / 69 brotli bytes over the initial adapter implementation, paying for concrete-options ownership enforcement and deferring row materialization. Tests and documentation are separate from these shipped production measurements. ## Scope of the oracle repair project [Issue #1808](https://github.com/TanStack/db/issues/1808) commissioned a bounded portfolio audit and repair. The September 11 inventory contained 329 tracked paths: 132 selected/support entries and 197 discovery-tier files. The latter received routing recommendations, not 197 full semantic reviews. Focused examples, type tests, and host-wiring tests remain useful; converting them all to generated tests is not a completion criterion. ## Literate model audit The literate-model pass audits every primary executable owner in [Find an owner](#find-an-owner) and every repository file explicitly named `oracle` or `property`. Derive that strict inventory from the repository rather than copying a count into this document: ```sh git ls-files -co --exclude-standard packages \ | rg '/[^/]*(oracle|property)[^/]*$' \ | sort -u ``` The command includes tracked and untracked package files so an in-progress audit cannot hide a new owner. A surface is complete only when each primary owner states its contract, model, history grammar, production driver, and refinement check—including its public observations and checkpoint—in the executable file. Focused regressions outside that inventory may remain short, but a file named `oracle` or `property` cannot use that allowance to omit the literate structure. The pass must not change product behavior. If clearer prose exposes a missing model rule or assertion, strengthen the oracle and run it against unchanged production first. Track any production failure as separate follow-up work. The same pass audits vocabulary. Shared concepts use the production names in the project glossary. The audit corrected model prose that collapsed a physical acquisition into a request or called an acquisition lease merely a lease. Model-only terms such as an appointment ledger or fault tape remain local and say what production facts they abstract. This is a semantic review, not a rule that test identifiers must copy production's private data structures. | Surface | Status | Completed or next owner | | --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Ordered relations and BTree | Complete | The signed top-K relation, BTree/Map refinement model, and DBSP incrementalization laws are literate. | | D2 operator work | `packages/db-ivm/tests/d2-work.test.ts` (fixed tests; no oracle owner (tracked in #2264)) | A finalized 65-branch graph receives one direct input at the first, middle, or last branch, then a second input on a different branch. The test compares exact forwarded messages and operator invocations after each `run()`: branches without queued input perform no operator work. A connected reversed-registration pair must drain in the same run, and an empty unfinalized graph rejects. The old unconditional loop fails with 64 idle calls per turn. This bounded work check does not establish elapsed latency, fused operators, arbitrary graph topologies, or provider-level live-query work. | | Includes and publication | Complete, [facade rollback](https://github.com/TanStack/db/blob/main/packages/db/tests/query/bucket-facade-rollback-oracle.property.test.ts) ([review](oracle-reviews/perf-lazy-bucket-rollback-copy.md)) | The central recomputation model plus cross-formulation, temporal demand, layered publication, Collection facade lifecycle and space bounds, route-context transport, functional projection, query-shape, optimistic, and source-work owners are literate. They keep the architecture document as their contract source. A failed facade flush restores every facade it wrote, disposes the facades it created, publishes no event or layout revision, and reads the stored rows of no other facade; nested facades across two edges have a fixed histories. The grammar adds optimistic facade inserts and optimistic deletes of shown graph rows; a retired facade must show exactly its visible optimistic rows, and every history ends by settling them and comparing all rows again. A facade commit that throws before committing is generated, and the restore must commit the open sync transaction. Every change pending at a failed root commit, child rows included, stays pending, and the next flush publishes it once. Open: the flush's edge and bucket map copy is unmeasured bookkeeping; disposal between a flush and its rollback has fixed histories only; held facade commits are generated one hold at a time for up to three flushes, and a release that covered earlier flushes checks rows only; the grammar also cleans up a shown facade from outside, lets optimistic rows share graph ids and later rolls them back, after which those keys are compared by value; a holder's cleanup of a shown facade rejects (code 241) and the facade keeps receiving the graph's writes; retiring a shown bucket without the graph's retractions is generated (`contradict`) and throws code 240; optimistic deletes and updates of shown graph rows are generated, and an update's copy keeps the row's key; a facade that `resolve()` created before activation can stay ready and empty after a failed flush (recorded limit). | | Collection lifecycle | Complete | The shared logical-owner/acquisition-attempt/sync-run grammar plus mutation admission, lifecycle trace, publication, replay, disposal, and transaction-refinement boundaries are literate. The lifecycle history driver checks law 13 at every command: an attempt that settled without an abort keeps no core abort listener on its signal (RED on d0cde4778 in 36 histories; a mutant that keeps the replay participant's listener fails 33). `parkedReloadDemandCases` drives a demand parked behind a failed first load through a reload whose new run marks ready, commits a snapshot inside `sync()` before or after `markReady()`, or commits it after the first load settled: one `loadSubset` per replay attempt that starts work and one `unloadSubset` per replaced acquisition (RED on d0cde4778 for `ready-then-snapshot`: two loads and one unload, because the restart joined the attempt before the attempt's own setup ran; a mutant without the per-attempt check fails it). Limits: these are four fixed histories, not generated; a second reload and asynchronous failures are outside them. | | Collection status and health tree | `packages/db/tests/source-health-oracle.test.ts` (`source-health.history`, `source-health.required-history`); the `problem values`, reload invariant, request error, crash recovery, failed join load, root request, Effect, pooled view, and include node grammars are in `packages/db/tests/source-health.test.ts` (fixed tests; no oracle owner (tracked in #2264)) | An independent per-Collection model of the first-load gate, `failureReason` and stopped `error` slots with serials and each slot's frame of failures (maintainer decision: a problem shows its newest failure and lists its frame in `errors`; a failure reason's frame is its sync run's reports until `reportHealthy()`, once per error value, less each failure `reportHealthy(error)` removed, and a reload's new run that reports starts a new one), crashes, and reloads derives each live query's status and expected health tree for direct, join, self-join, nested, include, and pooled-nested shapes. The additive `source-health.required-history` grammars execute all nine existing reach prefixes with generated suffixes, in join/nested contexts with direct subscribers. Each fixed/random campaign independently enforces all 26 reach states; the original 60 random histories retain six shapes and both subscriber choices. Generated histories cross `ready`, `fail`, `report`, `healthy`, `crash`, `reload`, `reload-cleanup-fails` (a retired cleanup that rejects crashes the Collection), `reload-cleanup-held` and `retired-cleanup-rejects` (a retired run's cleanup that rejects later still crashes the Collection, also after a cleanup and a fresh start: the adapter broke its contract for that Collection, by maintainer decision), `cancel` (a commit with an aborted signal changes nothing), `reload-query` (a query's `reload()` reaches every Collection below it that shows an `error`, through nested queries; a crashed query rejects without touching its sources), `cleanup-reload` (cleanup, a fresh start, and a reload in one tick: the cleaned-up run's reload decides nothing for the new one), `snapshot` (`begin({ snapshot: true })` replaces every row at its commit, at any time, also when the reload fails or the Collection crashes before that commit; maintainer decision: only a snapshot or the adapter's `truncate()` replaces rows, and every other write of a reload's new run applies on the kept rows), `mark-ready` (a reload without a snapshot completes at the new run's `markReady()` and keeps the rows; a run's `markReady()` after it is ready or after its `fail()` does nothing, by maintainer decision), `reload-ready-throws` (a first-ready callback that throws while a reload's new run marks ready inside `sync()`, also when the reload starts a cleaned-up Collection through its preload, is reported uncaught and the Collection stays ready, by maintainer decision), and restart. A second `fail()` in a sync run does nothing. A `problem values` grammar checks that `fail()`, `reportError()`, and a crash behave the same for any value, also one that cannot describe itself. The Effect grammar checks that a problem a source already shows when the Effect's gate opens reaches `onHealthChange` once, that a healthy gate announces nothing, and that each later change is one call. The `effect healthy gate` grammar crosses where the gate opens: at the Effect's start, inside an eager source's, a nested query's, or a join's second source's `status:change`, or when an on-demand load settles. A healthy gate that announced its own tree for the status change that opened it failed the three `status:change` openers; an Effect that skips its first healthy change fails the on-demand opener. The lazy grammar's `reload-in-load` checks that a reload from inside the adapter's `loadSubset` rejects and leaves the query running. A query-db receiving witness checks that a direct insert, update, or delete during a reload applies on the kept rows, because it is not a snapshot, and ends with the same rows as during a refetch in flight. A second query-db receiving witness, `housekeeping during a reload` (`query-db.reload-housekeeping`), checks that Query Collection's retention housekeeping keeps the rows during a reload of an eager persisted Collection: an expired persisted retention entry is removed by its expiry timer or by the new run's startup maintenance while the new run's Query fetch is held, and the rows stay, the reload stays in flight, and it ends with the same rows as a refetch. A fourth kind, `expiry-timer-lagging-clock`, makes the expiry timer fire before `Date.now()` reaches `expiresAt`; the entry must still expire in that run, and a callback that drops the early timer fails every time (this was a CI flake and a production bug). The reach counts only begins of the run after the retired one, and the window is observed by polling until the entry is gone. A housekeeping `begin()` marked `snapshot: true` fails it: it replaces the kept rows with none. A third kind, `release-at-startup`, reaches the retention entry that a subset release writes: during a reload of an on-demand persisted Collection, the driver requests and releases a fresh subset through a change subscription in every microtask turn until the new run's `markReady()`, and in the turns after its startup retention maintenance settles each release writes its entry while the reload is in flight; the rows stay and the reload stays in flight in every turn, and it ends with the same rows as a refetch. A retention write marked `snapshot: true` fails it. Release of a Query's rows also begins a housekeeping transaction, but no legal history begins it in the new run while the reload is in flight: core runs the run's cleanup only after retiring its callbacks, and a release takes that path only without a persistence capability, where Query Collection writes no retention entry, so the new on-demand run calls `markReady()` inside `sync()`; a snapshot there is an equivalent mutant for the grammar. The lazy grammar's `deferredStart` dimension starts the child the way a persisted Collection does, after the query asked for data, so every lazy history can begin with a first load that enters the adapter from the deferred start; with `reload-in-first-load` that load calls `reload()`, which must reject (a deferred call that skips the guard fails the generated property, shrunk to the empty history). The lazy join grammar checks which request error the query's node shows after every step: every failure has its own message, and the model shows the newest open failure by the order failures became request errors (maintainer decision). It also compares the node's `errors` with the model's frame after every step: every open request failure once, oldest first, each the very value the adapter failed with; a shared error keeps the place of its first failure, and a failed replay lists its failures in failure order, with the newest on top (maintainer decision; the subscription's own replay error stays its earliest held failure). The window grammar makes the same comparison. A replay's verdict decides every request error of the demand it replayed (maintainer decision: coarse verdict): loads that settle while it is judged decide none themselves, its success clears them all, and its failure replaces them with its failures, every failed load of its current attempt that the query still holds for a key that no later held load loaded. Closed from 30-times runs, each now a named history: a query's reload passes through a nested query that a cascade ended, which is a Collection below it that shows A's error, so that inner query's own reload reloads A and starts it, also when another source's reload rejects and the outer query does not start (`a query reload starts an ended nested query even when another source rejects`; the model had reloaded A past the ended inner query). A synchronous throw from `loadSubset` is a rejection (maintainer decision): the lazy driver's `throw-next` failure holds its demand, so the next demand change or replay requests its key again, and the churn replacement twins (`a churn replacement that throws | rejects leaves its key to the older load after the next demand change`) must agree; the driver sees the abort that releases a thrown load's demand. A replay load the query released does not count for the replay's verdict, even when it loaded its keys before the release (law 9: the replay succeeds only as a replacement for the demand that remains; `a released replay load's success does not count for the replay's verdict`; model). A failed replay request that the query released holds nothing, so a parked demand change that asks for its key again parks it (law 9; `a parked growth asks again for a key whose released replay request failed`; model). The main grammar projects every problem's `errors`(messages, order, and which report each cause is) and rejects a problem whose`message`, `cause`, or `at`is not its newest failure's; it checks that a legal`report`or`healthy`announces one`health:change`(a self-join announced two, one per alias, before the relay was registered once per Collection). The demand model treats a replay's failed request of a parked acquisition, which never loaded, as that demand's own failed first load: it covers nothing, and the next demand change parks a retry that holds the failed replay open (law 10; a 30-times counterexample on b521d29d9 of the model, which let the request cover the key, fixed as`a demand change retries a parked key whose replay request failed`; a production mutant that retires the failed segment without a retry fails it and 12 other lazy histories). The `request error bookkeeping`property checks the shared tracker's listed causes and its change result, including a request with several failures. Its`fail-again`step fails an issuer again with every cause it still lists and one new cause, as a replay's later verdict does: a cause still open keeps the place of its first failure (law 17; RED on d0cde4778, which released the issuer's causes before it counted the new list). The lazy and window grammars make`Date.now()`strictly increasing and check every request error's`at`after each step: a failure the model did not show anew keeps the`at`the node showed for it (RED on d0cde4778 in the named history`a failed replay's error stays when parked demand retires after the child restarts`and in the generated lazy property; reach`replay verdict lists an open failure again`, entered by a prefix in which a parked demand joins a failed replay; a mutant that clears the verdict's request errors before it reports its failures fails the named history). Both grammars also check that no `health:change`of a ready query repeats the tree before it. Open (R18, maintainer decision pending on code weight): a replay's verdict, and a lazy load or demand change that decides several keys, announce once per request error they change, so a listener sees intermediate trees (a verdict that replaces key errors with its failures first shows them cleared); a check that every announcement shows a request error frame the model held fails on d0cde4778 (for example`a failed replay's verdict replaces an earlier open failure`, step 5) and passes with a lifecycle `changeRequestErrors(change)`batch that costs about +57 B gzip, so it is not committed. Limits: these announcement checks skip trees whose query is not ready, because a source crash makes the query announce the same crashed tree twice in one step (seen on d0cde4778 at the lazy grammar's`crash`step); the main grammar owns crash announcements and does not count them. Not fixed (R3, R5): during a reload, before it completes, the new run's`reportHealthy()`clears the retired run's failure reason, and a query's own reload drops the retired run's request errors at the new run's first request error; the main and window models encode that behavior, which is in tension with law 16 ("a reload keeps the node's problems until it completes"), and needs a maintainer decision. Not reached (R8): a retired run's committed but unapplied truncate, from a listener that reenters during`commitPendingTransactions`, can complete the new run's reload. A deterministic work witness (`request-errors-work.test.ts`) bounds one failed 2,000-key segment's report-and-settle work at 20·K visits; the original scan-and-sort tracker used 14,007,001. A lazy named history checks that a demand change which retires a fragmented-churn replacement and another segment, while the replaced segment's replay load has failed, fails the replay for the still-held key (laws 9 and 16); the subscription lifecycle owner's demand-change grammar generates the class. A failed replay does not list the failure of a load the query released before the verdict (law 16; glossary request error: it clears when its demand retires); the named history `a failed replay does not list a load the query released before its verdict`fails on the model that listed it and on a production mutant that keeps a released demand's failure. A cleanup during a reload (ARCHITECTURE law 14; maintainer decision that a reload ends with its run) is a generated step in two grammars. The main grammar's`cleanup-during-reload`runs`cleanup({ dependents: true })`from the Collection's or the dependent query's`health:change`while`reload()`announces`reloading: true`. The lazy grammar's `ending`runs`cleanup()`or`cleanup({ dependents: true })`from those, from the Collection's`loadingSubset:change`, or from a change subscription's `status:change`while the reload retires its demand. In both, the model is an ordinary cleanup: no sync run stays live at the adapter, a reload in flight rejects, the Collection ends`cleaned-up`, and a later fresh start's commit is its diff baseline. Setting the epoch after the reload's announcement, or the truncate after the run's retirement, fails 12 histories; restoring the old flag order, or dropping the epoch return, fails the subscription-status ending. Cleanup from the retired run's adapter cleanup function or from the new run's `sync()`is outside this grammar. A cleanup of a Collection that a cleanup during a reload left`cleaned-up`has no run to wait for and settles at once; the driver holds an adapter cleanup only while a run is live (a 30-times counterexample of the driver). Focused witnesses check that a reload from inside a`loadSubset`call the deferred start runs rejects, that a cleanup run from a subscription's status listener while a reload retires the run ends that reload with its run (no sync run starts and no replacement stays armed), and that a lazy join load that fails after readiness, under an ordered window that filters on it, publishes the output it held. The main grammar also compares the query's row count at the`status:change`that makes it ready with the count the step leaves (law 9): A's truncate commit that marks A ready while the nested shape's outer query waits for its inner query reaches it, in the first load and in a reload of a failed first load; a completion check that ignores the graph's pending work fails it. Limits: row count only, not identity. After every step the check compares status, rows, the projected tree, node identity,`status:change`/`health:change`order, and`findProblems()`. Named histories fix a reload's new-run `failureReason`surviving its completion. Focused grammars cover request errors, overlapping root loads (a request error clears only when a load started after the failure succeeds; 8 histories plus a later clearing load), a query's own failed first load not restarting when an unrelated source becomes ready, reload invariant witnesses (the retired run's open sync transaction is dropped; a canceled reload commit changes nothing and the reload keeps the rows; a diffing adapter sees an empty baseline inside a reload's snapshot), and Effect disposal on a failed first load or crash. The shared framework conformance scenarios`sync-errors-after-readiness`and`crashed-status`judge the hooks;`sync-errors-after-readiness`reads a two-failure`failureReason.errors`and a one-failure`error.errors`through every framework driver. Adapter receivers for reload after a failed first load (the new run's own readiness decides it, not Collection status): query-db, RxDB, and PowerSync focused tests, Electric's integration test, and TrailBase's lifecycle grammar. Adapter receivers for reload of a ready Collection (maintainer decision F19: the reload keeps the rows until it completes; only a`begin({ snapshot: true })`transaction or the new run's own`truncate()`replaces them; every other write applies on them): Electric's integration tests`reload of a ready Collection`(a resumed stream with no changes, or with an update, a delete, and an insert, applies them on the kept rows and completes at up-to-date; a stream that cannot resume replaces the rows with its fresh snapshot; a must-refetch keeps the rows through its reset-marker commit and replaces them at its snapshot) and`an on-demand reload keeps its rows and ends with the source's rows`(resumed or not: the replayed subset's rows apply on the kept rows, and the adapter writes an update for a kept key, since core no longer rewrites a kept-key insert and sweeps nothing; the adapter owns removing rows deleted while no stream listened, [#2269](https://github.com/TanStack/db/issues/2269)), and`a progressive reload that cannot resume keeps its rows through a subset load`(no kept row vanishes before the atomic swap, the kept key takes the source's value, the live query has no error; it failed on the parent core with DuplicateKeySyncError); query-db`a reload of a ready eager | on-demand Collection keeps its rows and ends as a refetch does`; PowerSync `eager mode: a reload of a ready Collection keeps its rows and ends with the table`(three batches in one snapshot transaction); RxDB`a reload of a ready Collection keeps its rows and ends with the documents`(a first run that missed changes; two fetch batches); and TrailBase's lifecycle grammar`a reload of a ready eager Collection`(10 histories; see its ORACLE.md). On the parent core, Electric's resumed and must-refetch cases, query-db on-demand, PowerSync, and TrailBase's two-page cases fail; RxDB's passes and guards the port. Each of these mutants fails them: a resumed Electric run whose first commit replaces rows; a fresh Electric, PowerSync, or RxDB load without a snapshot; and a query-db housekeeping or direct write marked`snapshot: true`. A reload keeps every row its new run does not rewrite, and core deletes no kept row on its own (maintainer decision; removing a row the backend deleted is the adapter's job, [#2269](https://github.com/TanStack/db/issues/2269)); the adapters' own on-demand reload receivers belong to their packages. Adapter receivers for an on-demand reload (maintainer decision: no core sweep; a held key is written as `update`; issue #2269): Electric `an on-demand reload keeps its rows and ends with the source's rows`(resumed: deleted rows go through the log; cannot resume: a row deleted while no stream listened stays), query-db`a reload of a ready on-demand Collection keeps its rows and ends as a refetch does`(row ownership removes the deleted row), PowerSync`an unchanged row survives an on-demand reload`(the adapter's own tracking removes the deleted row), and the TrailBase grammar`an unchanged row survives an on-demand reload`(a row deleted with no event stays). Without Electric's`syncedKeys`seed and its update-for-held-key write, its non-resumed and progressive witnesses fail. Subset snapshot rows go through the same`syncedKeys`check as stream rows. PowerSync`eager mode: a reload whose later batch fails keeps the rows and the next reload ends with the table`checks core state: no open transaction remains and the accepted rows equal the kept rows; a snapshot begun before the batches fails it. Abort receivers (an abort ends the load): Electric, PowerSync, TrailBase, and query-db`an aborted load writes no rows and its late result changes nothing`; each fails under a mutant that ignores the signal at that adapter's stop point. Limits: an Electric abort while a request is in flight still lets the SDK publish its rows; query-db applies a late result after an abort without `unloadSubset`(a replay replacing the load within a run), whose data is current, so it costs a write, not correctness; RxDB has no on-demand path. Electric's`a ready after the stream gave up changes nothing`witnesses that`markReady()`after the run's`fail()`is a no-op (F6): the SDK gives up while a ready run's up-to-date commit waits for a wrapping sync's acceptance, and the acceptance arrives afterwards; there is no unhandled rejection and no status or health change. It fails on the parent core with an unhandled`CollectionStateError`. Limits: the progressive and on-demand Electric witnesses are fixed examples, not generated histories. A joined-filter grammar checks that a failed join load lets an ordered window move again. An Effect has no request errors: a failed load after its gate still ends it, and the Effect load-failure grammar checks that. An on-demand reload grammar crosses the new run's first commit (an empty `markReady()`or a row commit inside`sync()`, or `markReady()`after it returns) with an unfiltered and a filtered query. While the new run's loads are in flight, it checks that the query keeps the old run's rows and that a direct read shows the kept rows with the new run's own commit on top (no snapshot came). After the loads settle, it checks the new run's rows. A late-first-load grammar enumerates an on-demand Collection that fails its first load, stops after readiness, or crashes after a direct or joined query is ready, then calls the query's`reload()`. A query that follows its source into `error`after showing data fails it, and so does a query reload that skips a source still in its first load. A focused RxDB test checks that a change-stream error calls`fail()`before and after readiness. The generated grammar also keeps each Collection's rows and the sync run's open transaction:`write`and`commit`steps span other steps, the driver writes like a diffing adapter, a`write`can omit the`tag`field (an update merges into the row, an insert replaces it, also when a failed reload's open transaction applies on the kept rows), and after every step the check compares rows, the adapter's baseline, the query's rows, a direct subscriber with the initial state on each source when the history includes one (its rows equal the Collection's within one Collection lifetime, also while a reload is in flight or after it fails; a source that starts again after cleanup gets a fresh one), and an Effect over A (ended, source errors, listeners left).`cleanup-hold`and`cleanup-settle`steps run every other step while adapter cleanup is pending, including a crash, a new Effect, and the query's reload, which restarts a query a cascade ended. A second generated property,`source-health.on-demand`, drives a root window over an on-demand Collection: window moves, settle-all outcomes, source reloads, and the source's own calls, with requested loads reported from the adapter boundary; it checks the query's status, its request error, the source's node, and the window's rows. A third, `source-health.lazy-demand`, drives an eager parent Collection left-joined to an on-demand child Collection: parents come and go, loads settle ok or failed, the child source reloads, and the source makes its own calls; the driver reports each load's requested keys from the adapter boundary. It checks the query's status, its request error (which clears when a later load of the failed key succeeds or when the query no longer needs that key), and each parent's child. The lazy and window drivers can add a direct subscriber with the initial state on the on-demand source (its rows equal the Collection's at every step; the driver answers its own requests at once), and the lazy driver can add an Effect over the same join (at quiet checkpoints it has the query's rows; a delete that a later insert undoes between checkpoints is not observed). The lazy driver also crosses a child that holds `markReady()`until a`child-ready`step, so the child can be`loading`or fail its first load when it reloads, a reload stays in flight past its new run's first commit, and a second`reload()`returns the first one's promise; and the child adapter's own`truncate()`(a must-refetch in the same sync run, also while a reload is in flight: its replay requests every needed key, also one whose load threw, and a demand change's replacement that applies releases the coverage it replaces), loads that throw, and source reloads during the first load: the first load waits for the whole replay, and a replay fails only for a key the query still needs when it is judged. The child adapter honours aborts; an adapter that ignores them is outside the contract (maintainer decision: an abort ends the load). In the on-demand grammar, a window move after a failed replay waits for the next successful replay, and a later reload aborts it. A reload starts its replay when it retires the sync run, so a load the reload aborted is over and its consumers wait for the replay, as after a truncate; a named history checks that the retired run's load decides nothing when its abort rejects it. A named history checks that a truncate after a reload's failed replay replays the demand again. The on-demand window grammar adds`settle-aborted-fail`and`settle-aborted-ok`, which settle only the loads the query aborted, with declared reach for an aborted load that settles beside a pending load after a request error. A source reload that aborts the app's retry after a request error leaves that error to the replay's verdict: the retry's late rejection or success decides nothing, and a failed replay's verdict replaces the retry's failure. On 2bc79fc7c the coarse verdict's window histories fail, and a mutant whose replay failure reports no error fails 37 tests. Window moves never abort a root load outside a replay, so a root load's late success after an abort outside a replay is unreached (a mutant that lets it clear the root error survives); page-distinct root failures are not modelled: the grammar keeps one logical window demand, as law 16's "later load of that Collection" wording allows. The lazy grammar's `remote-delete`step deletes a child at the provider with no stream event; a child Collection rows check after every step checks that a reload keeps that row (maintainer decision: no reload sweep; RED on 2bc79fc7c, which swept it). The main grammar's blind`insert`write checks that an insert of a key the baseline holds throws, during a reload as at any time (maintainer decision; RED on 2bc79fc7c, which turned a reload's insert of a row the retired run left into an update; a mutant that lets a reload's insert of a held key apply fails 12 named histories); the lazy grammar's diffing adapter writes an`update`for a kept child. Limits: the window grammar has no provider deletion. Every truncate replays the demand again, also one the reload's new run sends while the reload's own replay is open or after it settled (F8: a latch that skipped the reload's own truncate let a replacement delete replayed rows with nothing re-requesting them); a reload with no held acquisition keeps the rows and replays nothing. The window grammar's`reload-query`reaches the query's own reload while its node shows a request error: the query keeps its rows, its node's error, and`reloading`until its new run's window load settles, keeps the window it showed (a window move waiting for a replay ends with the retired run), and then shows only the new run's failure, if any (F4). During the query's own reload the window grammar also issues window moves and`restart`. A move of the new run whose load fails keeps the reload, its rows, `reloading`, and its promise until a later move's load succeeds, and a failure the new run reports shows on the node at once (maintainer decision). `restart`(cleanup and preload of the query) discards the window and any own reload in flight, so the new lifetime loads the initial window. Its limits: no source reload, report, or aborted settle during the own reload; the reload starts only when the source shows no problem; and a restart ends the request-error announcement watch for the rest of the history. Named histories also fix that a later load of a failed key clears its request error while an unrelated load is still pending, that a load failing during a replay is decided by the replay's verdict, that a reload during the first load fails it only for a demand still held when the replay is judged, and that a reload keeps a window move that joined the replay while it aborts a later move that waited. Mutants that restore last round's reload, cleanup, Effect, and replay bugs, and a request error that outlives the failed key's demand, each fail named histories. Witnesses fix that cleanup start announces the problems it drops, that a reload rejects during pending adapter cleanup, that a ready callback that throws still settles a reload, that a failed reload keeps its rows as a diffing adapter's baseline, that a query's own reload settles with its new run (a load that fails again, or a graph that throws), that a source's or the query's reload clears a request error, that an Effect over a source already in`error`or`crashed`ends, and that a pooled view keeps node identity when its source alias is`root`. Later witnesses fix that a reload's open transaction applies on the kept rows after the new run fails, that an Effect over a stopped source leaves no load, subscription, or listener on it, that cleanup start keeps an `error`status's cause, that a source reload's replay keeps a request error that failed after it started, and (query-db) that a late recovery counts when another Query fails meanwhile. The query-db grammar`failureReason follows the still-failing Queries` (`query-db.failing-queries`, an enumerated `oracleProperty` in `packages/query-db-collection/tests/failing-queries-oracle.test.ts`, whose four declared states are checked by a grammar calibration over the enumeration) enumerates every history of four fetches over two subsets' Queries, directly and behind the persisted wrapper (a receiving witness: the wrapper must relay `reportHealthy(error)`'s value). Its model keeps each failing Query's latest error value and the listed values, one per value, oldest first (review: one entry per failing Query, and a value stays listed while any failing Query holds it); fetches succeed, fail with a fresh error, or fail with one shared value; after every fetch it compares the listed causes by identity and order, the shown `message`and`cause`, each kept failure's `at`, and health tree identity (ARCHITECTURE law 17): a fetch that leaves the frame as it was keeps the node and its `failureReason`object and announces no`health:change`. Declared reach includes a Query that fails again while listed and one that recovers with two failures listed while another fails. RED on the parent: a recovered Query's failures stayed listed. The main grammar's `report`and`healthy` steps can name a listed failure's error value or an unlisted value with the same message; a report of a listed value and a healthy call for an unlisted one leave the frame as it was and must announce nothing (maintainer decision), and a healthy call for a listed value removes only that failure. Limits: replacing a Query's failure announces two health:change events (add, then remove). The [snapshot oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/live-query-observer-snapshot-oracle.property.test.ts)'s health grammar (`live-query-observer.snapshot-health`) generates `report`, `healthy`, `write`, `subscribe`, `unsubscribe`, and `read`over one ready source and checks that every`getSnapshot()`shows the current`failureReason`, `hasErrors`, and `isSyncError`, on detached reads, attached reads, and across the attach cut, and that the tree keeps its identity while unchanged; after a round trip between reads that ends on the previous read's content, either identity is legal (glossary, health tree). Each read also compares the `failureReason`'s `errors`(messages in order, each cause by identity) with the model's frame, and a declared reach state reads a frame of several failures. Limits: one source,`failureReason`only, no hydration seed, no framework. The shared conformance cells`crashed-status`and`crashed-status-during-first-load-{collection,query}`read each driver's status flags without reading`data`, and require Solid's resource path to show `crashed`, not `error`, when preload rejects for a crashed Collection. By maintainer decision, an error boundary receives an Error for a failed first load or a crash: the cause itself when it is an Error, otherwise an Error with the problem's message whose `cause`is the reported value; React's`useLiveSuspenseQuery`and Solid's resource witnesses cover a failed first load and a crash, each with an Error and a non-Error cause: a failure inside sync and after mount, a sync function that throws, and a later crash (after readiness for React, during the first load for Solid). A crash path that throws the raw cause fails the non-Error crash cells in both. The replay refinement oracle's`settle`command can keep holding loads that start during the step, so a held retry keeps a failed join load's request error visible. A crash-recovery witness checks that nothing recovers a crash in place and that a cascade cleanup gives a fresh start with only the new run's rows; a`reload()`that recovers a crash, a cleanup that keeps the crashed run's rows, and a crash that survives cleanup each fail it. The three generated properties share one model: the main grammar's source model drives the on-demand Collection of the window and lazy grammars too (a load that succeeds is one sync transaction, so a reload's first load replaces every row), and one demand model, from ARCHITECTURE laws 9, 10, and 16, judges the window grammar's single window demand and the lazy grammar's per-parent keys. The lazy grammar checks the request error after every step, also while a replay is open or after one failed, and both grammars check a coverage law: once the query is ready, every held key has a load the adapter still serves, its rows, a replay failure awaiting judgment, or a shown request error (an aborted load without a replacement fails it). Named histories fix the cases that closing the earlier open item found: a demand parked behind a child whose first load failed joins the open replay, also an in-flight one when the child restarts (the CI counterexample seed -838690579: production replaced the in-flight replay and lost its own failed load;`a reload after the source stopped replays its demand and fails with every load`); a failed replay stays open while the query holds demand, and its error clears when its failed demand retires after the rest loaded (law 9); a load the truncate aborted does not clear a request error; a held replacement that loaded decides the demands it replaces; and a cascade cancels a query's pending reload. Law-silent, recorded with the maintainer: a truncate's `markReady`option does nothing on a ready Collection, also after`fail()`; a cleanup after a crash that followed cleanup settles at once; a truncate after `fail()`is outside the grammars; a window move with no request is served from loaded rows. A child whose first load failed parks new demand without a request; by maintainer decision the lazy model predicts the parked acquisition from law 10 (growth or churn), and a declared reach state and prefix enter that region. Named histories fix that a replay re-requests parked demand and then publishes, that a released parked demand parks again, that a replay's failed request keeps its acquisition's coverage, and that a later change drops a parked replacement that no longer matches. ARCHITECTURE law 16 states the rule. A query that crashes while it starts, because a Collection it reads is still cleaning up, reads nothing: it announces nothing more and no cascade ends it (maintainer decision). A pooled view that is unsubscribed, outlives its source's`cleanup({ dependents: true })`and restart, and then subscribes again stays`cleaned-up`, while a live-query Collection restarts; the pooled cleanup-admission grammar crosses observed and unobserved views but never restarts their source; a follower tab does not see a provider failure on the leader outside a pending request. | | Paced mutations | Partial | The core virtual-clock owner checks strategy timing, admission, cleanup, and settlement. The React render-cut owner checks committed callback ownership across suspended and committed transitions, descendant layout effects, and StrictMode while preserving mutate identity. Callback affinity to transaction admission, other frameworks, new debounce/throttle admission after cleanup, failed persistence, and broader generated schedules remain open. | | Optimistic state | Complete | The independent base/intent/source-queue graph plus outcome, transaction-payload, and publication drivers are literate. | | Drafts and native values | Complete | Native differential behavior, draft change tracking, detachment and its class-instance exception, adversarial keys, aliases, cycles, and Map/Set live iteration are literate. | | Query DB and observer | Complete | Query-scope row ownership, subset identity and cancellation, failure and recovery, and the per-listener eligibility ledger are literate. | | Query DB SSR dehydration | Fixed QueryClient/Seroval boundary | Successful on-demand entries with a compound predicate, a request signal, and an ordered cursor with a custom comparator retain their row and user metadata through Seroval's reconstructed stream payload and Query Core hydration; request options are absent from the stream, while query functions retain the original values. The TanStack Start router and browser Collection resume path still need a host witness. | | Ordered acquisition | Complete | Exact demand identity, applied settlement, independent pagination recomputation, request work, lifecycle products, replay authority, source-generation readiness, and transaction-refinement abort boundaries are literate. An initial full-source ordered load shares the synchronous readiness cut ([historical review](oracle-reviews/initial-full-source-sync-readiness.md)). The ordered-lifecycle oracle covers an inexpressible-boundary fallback before first publication when every acquisition returns literal `true`. It also checks a later null-boundary fallback after the first joined window publishes, across literal, Promise, and held-receipt responses, including a held receipt after child demand settles ([review](oracle-reviews/issue-2152-initial-ordered-fallback.md)). The ordered loader state oracle also has a generated request-authority grammar (`ordered-loader.request-authority`, fixed and random campaigns). It drives the real loader over a fake subscription through settlements in any order, failures, deferred invalidation and report reactions, ordinary passes and window moves, and began with four laws from a TLA+ model (#2191): a successful repair keeps its acquisitions until a covering read succeeds; quiet loading holds nothing older than its last authoritative read; a superseded request's failure is recovered by a full-source read without an explicit retry; and once quiet, an invalidation and a pass issue a read unless a full-source read covers the source. Scenarios also throw from the first release callback, answer a repair synchronously from installed rows, and let a page's own delivery invalidate ordering; named fixed histories keep the traces they found, each of which failed on main (a throwing release that unwound a resumed repair, a synchronous repair waiting behind a superseded request, and a self-invalidating page whose tie was never retired). On main it found a superseded tie that failed after its repair finished and a newer invalidation's reaction was deferred, which left refills blocked; a named fixed history keeps that trace. A stale prefix that retires the repair's prefix fails the held law, and a stale request held after the repair finished fails the leak law. The grammar also crosses unexpressible boundaries, joined work that defers loading, truncate replay that succeeds or stays pending, optimistic departures, source deletes, the bounded backoff retry, window moves that shrink or widen, plans that read only the full source, and reports inside the loader's own first page. A replay owns the requests issued before its truncate, and when the subscription still holds a full-source lease the settled replay covers the source. These dimensions found three more defects, each kept as a named fixed history: a repair prefix that settled after a replay started its replacement took the replacement's chain tag and was never retired; a replay counted a full-source read as complete after an explicit retry had released it; and a failure from before a truncate dropped the next repair's staged step. Each of the seven defect replays fails on the loader at the branch's merge base with main. A later law, one request at a time, found that a replaced repair chain's prefix still counted as current and issued a tie beside the replacement's prefix; a chain is now superseded by any newer authority start. The failed-lease law also counts a covering replay, which a named fixed history reaches. Repeated random campaigns then found a repair request that settled after full-source coverage and stayed held; full coverage now retires it. The held law counts a later prefix that a successful replay reacquired while it was in flight. Four histories from TCP's known error classes followed: a request the provider never answers (a lost segment), a release callback that truncates synchronously (a reentrant reset), a window offset other than zero, and an at-most-once release law with no release while a replay owns the demand unless an explicit retry replaces it or a held full-source lease covers it. They found that the backoff retry's release pass kept releasing failed demands after a release started a truncate; every release pass now stops on a reentrant reset. The oracle now observes epoch moves as calls to `invalidateSourceOrdering()`, so it tells a replacement chain from a chain step exactly. The loader's work slot and debt now move only through a transition table that throws `OrderedLoaderInvariantError` on an illegal move or an incoherent work and debt pair; the oracle records any such error as a broken law, so its generated histories fuzz the table. A covering-lease law (a full-source lease whose read succeeded or whose demand a replay reacquired is never released) found that a full-source transport failing after a covering replay turned complete coverage into an own failure; the table then found that a repair request failing after a replay finished its chain did the same. Mutants that drop each new guard fail. A release callback that runs an ordinary pass synchronously, as a graph run does when the release delivers deletes outside a transaction, found that the pass issued a page while another request was settling, and that request then issued its tie; every release pass now blocks refinement until it unwinds. A dispose command and a release callback that disposes the loader check that a disposed loader issues and releases nothing; mutants that drop the loader's own `active` checks in the release pass and in failure handling survive because dispose resets the cursor, so those checks were removed. TLA+ run 3 (`LoaderTable.tla`) models the table with truncate and replay; its safe rules pass with 9,368,122 distinct states, and each of the four guards from this round, removed alone, produces a counterexample. Reverting any one fix fails its replay and a campaign. The generated histories also stack a second truncate on a pending replay and truncate after a failed replay, each with reach. A lease missing from its map during a release pass is now an invariant violation; no history reaches it. A second high review found that a covering replay did not retire a superseded failed lease from before its truncate, because the failed-lease law exempted every replay-owned request. The law now judges a superseded failure that was live (it failed in the incarnation it was issued in) once a covering replay settles after it, and the replay retires those leases. The subscriber now schedules the replay's graph run in a finally. The replay-refinement oracle is the receiving witness: its generated ordered section (`replay.ordered-window-faults`) drives a real on-demand Collection and an ordered live query through rank moves, held and failed loads, truncates, and unloads that throw without a truncate, while a replay starts, and while it settles. Its settled-window law found that a release throwing after a successful ordered load left the window on old rows, because the builder counted the rejected participant as a failed load (also on main); the loader now marks release errors and the builder publishes. It also fails without the subscriber's finally. The section now also crosses tied ranks (its law compares the window's rank sequence and each shown row's current rank), a peer live query on the same source, offset 1, descending order, and explicit window moves; a move that rejects after a failed source recovery leaves the window, and one rejected only by a release failure still moves. A reported-faults law accepts injected faults as rejected loads, thrown releases, rejected moves, or errors the subscription rethrows from a microtask, and rejects any other escaped error. These found that a window move whose load succeeded was recorded as failed when a release threw, so the window stayed private until another move. A throwing release is an adapter bug, so the loader now reports it uncaught from a microtask and changes nothing else; the reported-faults law rejects a move that a release failure rejects, and the request-authority oracle requires each throwing release to be reported uncaught exactly once (a mutant that swallows the error fails). It also crosses a joined marker source: a LEFT join that keeps marked or unmarked rows, and an inner join. The marker source is eager or on-demand, with marker loads that are held, fail, and truncate. This found that an on-demand joined source whose loads finished without delivering a row left the window on old rows, because nothing ran the graph that the pending joined work held; the subscriber now runs it when a joined source becomes ready. A truncate never aborts a window move: the move waits for any replay that holds publication and then applies (ARCHITECTURE.md), so a move that rejects with `AbortError` during a history is an escaped error. (An earlier version of this entry claimed a named fixed history reached an aborted-move branch; no history reached it, and the branch, which quietly accepted such a rejection, is gone.) Recovery truncates the marker source too, because a failed marker replay keeps the last complete publication until that source replays. A mutant-mutant pass over the loader's guards found guards that no ordered oracle kills. A differential instrument then ran 3,000 generated request-authority histories through the loader and each mutant and compared every request's shape, outcome, and release. Three guards the code makes redundant are deleted: the backoff timer guard, the explicit-move check in the retry callback, and the `requiresFullSource` check on a report. An ignored-report law now kills two of the mutants that changed public requests: a report issues no authoritative request before any request settled (a request in flight still owes an exact result for its own options) or while the window is inside the loader's own first prefix. Named replays reach both, and the random campaigns judge them in quiet histories. A random ordered-work campaign later found that the first-prefix check was unsound: it took the next installed row as the next source row, but a signalling refetch moved the page's end before the tie the loader had read, so that tie's row stood past the page while a row tied with the new end was never sent, and a later window move skipped it. The loader now accepts the row only when its page read it or when it read the tie of the page's current end. When the end moved, it repairs (see the later maintainer decision below); query-db's first-page witness requires bounded reads only, no full-source read, and an unchanged count of active Queries. The optimistic-window cases that allow but do not require a refill still bound any refill that occurs: an ordered read within the refill bound or a predicate read, never the full source (a mutant that made the growth read unbounded fails them). The ordered-work model now sorts `undefined` ranks with `null` ones, as the comparator does, and its histories generate both; nullish ranks tie in its window and in-flight comparisons. An `undefined` end also matches a loader that attempted no tie; a nullish end is never an expressible cursor, so the loader has started or will start a full-source read, which covers the source either way. A guard against that match survived the generated campaigns as an equivalent mutant and was removed. The ordered-work oracle keeps the trace as a named fixed history that fails on main, and the request-authority oracle has an unproven-report law (a report over a first page that no row it read proves starts a repair or reads the end's tie), whose replay and fixed campaign fail on main; the broad campaigns reach that law in about one history in 10,000, so an unproven-report campaign (`ordered-loader.unproven-report`, fixed and random) settles the first page, settles the read after it, and reports, over random case parameters and a random suffix, and declares its reach (about a third of 300 histories); `main`'s loader fails both runs. Its fake subscription now reads installed rows as the subscription does, applying a tie's equality, a cursor, and a limit; when its reads ignored the limit, the tie was always the last installed row's, so the first-prefix ignore branch was unreachable. The cost law's per-chain bound, three requests, was an artifact of that fake: it is now a prefix plus a tie and a page per installed row, and it also judges an unindexed window that still needs rows, which grows its prefix instead of reading the full source. The report campaign (`ordered-loader.unproven-report`, 1,000 runs; at 600 a random seed could miss the minimum) now starts each history with one of eight prefixes and declares reach for each report premise: a proven first page, a page that read past a window that shrank, a held full-source read, a head insert that moved the page's end, an owed repair, authoritative work in flight, a release of the older tie that truncates or disposes the loader, and a report to a disposed loader. The unproven-report law requires a bounded repair or the end's tie when every installed rank is expressible; a full-source read no longer satisfies it (a mutant that forced full debt after a report passed before). The cost law also rejects a repeated read: within one invalidation, no prefix, tie, or page repeats more often than the ordering epoch moved. Two laws are stronger: an ignored report, over a proven first page or a held full-source read, issues no request at all, where it used to forbid only authoritative ones; and a report while a repair is owed reads no tie or page before the repair. Deleting the moved-end early return in `revalidateLoadedCoverage`, or its past-window term, fails the first law, and deleting the owed-debt term in `loadMovedEndTie` fails the second; a deletion sweep had found all three surviving every oracle. With that reach, the report path's own `!active` checks were deleted: `dispose()` advances the generation that the stale-run check after the release reads, and a disposed loader issues nothing, which the dispose law judges. A head insert can carry a `-Infinity` rank, and two more laws judge every request: the loader never reads the tie of a rank no cursor can express, and the first finite request after a truncate has no cursor. The fake's `dataNeeded` now counts the window rows not at or before the boundary it is given, where it returned a constant. With those, the stale-run check after the older tie's release fails the reset law when a release truncates the loader and the window then grows (a prefix declares that reach), and removing `loadBoundary`'s own unexpressible-value check fails the unexpressible-tie law. The covered-source early return and the staged-continuation term were deleted: coverage that a full-source read completed holds the work slot, whose check then decides the report, and a staged finite continuation cannot coexist with a proven end, while a staged repair step owes a repair. The ignored-report law's full-source branch no longer needs a quiet history, since such coverage owes nothing, and a prefix reaches a paged loader whose repair fell back to a full-source read; removing the work-slot check then fails it. The unexpressible-end term in `loadMovedEndTie` stays: the unindexed-refetch random campaign found that without it an unindexed loader reads the full source through the boundary fallback where its bounded prefix repair would do, and a named fixed history of that trace fails without the term. Maintainer decision, later: a report whose page end moved now repairs instead of reading only the new end's tie, to cut shipped bytes; `loadMovedEndTie` and its guards are gone, so their mutants above no longer exist. The laws stay and judge the repair path: the ignored-report, owed-repair, unexpressible-tie, and reset laws all still run, and the unproven-report law accepts a repair. The report campaign drops its two prefixes whose release of the older tie truncated or disposed the loader, since a report no longer releases anything, and the query-db replay of an insert into a top-N list now expects the bounded repair's prefix and the new end's tie. Still open there: the `Object.is` term of the moved-end check. It skips work when the loader already read the end's tie, and it decides differently from its fallback only while other work is in flight, which the ignored-report law's quiet premise excludes. The ordered-work oracle owns that branch instead: peers over a refetching provider stay in its grammar for source filters (#2155 excludes only joined filters), and a proven-report law requires that a report which changes nothing the first query's own page and end tie prove, with the model's next row installed and no installed row deleted or reordered, starts no request for it and leaves it owing no `refetch: true` repair. A campaign fixed to that premise must reach it, and a loader that repairs every report fails both its fixed and random runs. A staged end tie that pending joined work defers is read by the pass after that work finishes; a request-authority named fixed history reaches it, and a loader that drops the staged tie fails it. The unproven-report law judges that later pass, and a truncate, failure, move, or disposal in between voids what the report owed. A history that starts during the initial preload found that a window move deferred behind a marker replay, which the source truncate then discarded, rejected with that replay's `AbortError`, so the older move's window won (also on main). A deferred move now waits for every replay that holds publication and applies unless one failed or cleanup ended the sync run; a named fixed history fails without the fix. The ordered-work refetch law also required no full-source read after a signalling refetch for an unindexed plan, which the architecture then let refill a short window from the full source; random seeds found it on main. Maintainer decision on this branch: an underfilled unindexed prefix never reads the full source, because that read is unbounded. It grows instead: each growth asks for twice the last prefix, and it stops once the last growth added no rows. A deletion sweep showed that the older condition's other term, a prefix that reads short, follows from that one. The refetch law now forbids a full-source read after a signalling refetch with no unindexed exception. The named fixed history of a short unindexed window and the fixed unindexed-refetch campaign (`ordered-work.eager-unindexed-refetch`, fixed and random, with reach on windows the prefix fills and windows it leaves short) failed on the full-source fallback and pass with growth; the full-source mutant still fails them. Growth made a new optimistic history possible: an unindexed one-row window behind a joined or anti-joined filter that installs only the prefix it grew to, whose departure leaves the replacement row missing. Sixteen fixed optimistic-window cases (update and delete, both consumers, acknowledge and rollback) cover it, with a refill bound of twice the installed prefix plus the overlaid row. A loader without the stop rule never reaches a fixed point; a loader that stops whenever the prefix reads short leaves those windows empty after settlement, because the pending departure hides a row from the count. The existing unindexed optimistic cases now allow, but do not require, a request behind a joined filter when the replacement row is installed: growth proves rows only up to its prefix, where the full-source fallback had proven every row (a maintainer-approved expectation change). The proven-report random campaign now declares its reach too. One mutant still changes requests without a law: dropping the optimistic-refill flag turns a refill into a refetching prefix. Six more are equivalent in the fake but stay, because the fake cannot reach their premise or they encode a documented rule: the own-first-page check behind a held sync transaction (the fake never holds one), a truncate moving complete coverage back to held, clearing the pending request when a full-source read starts (the fake never answers a full-source read synchronously), staging a joined `more` continuation, the staged-continuation guard before an unindexed prefix, and the drain re-entry guard (a long synchronous chain would otherwise recurse). An include dimension adds a `toArray` child that reads the marker source for each shown row, and an include-children law requires each shown row's markers to equal the model wherever the window law holds; a mutant that never loads newly demanded child keys fails it in an include-only scenario. A newest-move law requires a superseded window move to resolve only after the newest move settles (a superseded move that fails still rejects with its own error), and the model lets the newest move that resolved set the window; it found that a superseded move resolved as soon as its own load settled, so awaiting it showed neither window. The terminal-error law also allows `error` after a load fails while the query is still loading, the documented initial-load failure; a lazy join source is exempt. Limits: includes are one level deep. It also found that a release failure in lazy joined demand during a window move rejected the move, because the subscription reported it as a load error. A window law now lets the newest move win; it found that two moves deferred by a pending source recovery could resume in the opposite order, so the older request replaced the newer window. `setWindow()` now ignores a deferred call that a newer call superseded. A terminal-error law allows a final `error` only after a lazy join demand load, on either side, failed outside a truncate's recovery; named fixed histories reach that branch. A load belongs to a recovery when it asks again for a demand its source held before the truncate (the same request data), or when the graph starts it while the truncate commits. The first model read a flag set only during the commit, but subscriptions start replay loads in a later microtask, so it counted every replay load as new demand and allowed `error` after any failed replay load; a random campaign found the reverse case (#2224): a marker truncate privately moved the window, the include's new demand started outside any replay because releasing its old demand ended the subscription's replay, and its failure ended the query. The demand controller now starts new coverage before it releases retired coverage, a query subscription opens a replay at every truncate even without demand (a replay that starts no recovery work and reports no loading), and a demand failure that fails its subscription's replay keeps the last publication instead of ending the query once the query has first become ready. The section also generates histories that start during the initial preload, with an initial-readiness law (the preload has settled once loading is quiet), marker loads whose aborted requests reject with `AbortError` as the source contract asks, and settles of the newest held load. These found two older defects on main: an aborted lazy demand request that rejected after its truncate replay succeeded ended the query, and so did a superseded segment that the controller released; the controller now treats an aborted request as obsolete demand, which its replay or newer coverage decides. Named replays keep each trace; reverting each production change fails one of them, and a mutant whose replay rebuilds its request data fails the campaigns' replay-load reach witness. The ordered-lifecycle oracle owns the truncate-work witness: a zero-limit window issues no request and reports no loading at a truncate, while a one-row window reacquires. A retention law then judges law 9 at generated checkpoints: a truncate raises a publication barrier, every load its source starts while the barrier is up joins it, a participant's failure fails the replay while its logical demand is held, and while any barrier is up the query shows exactly the rows it showed when the first one rose. It runs after every command and once loading is quiet. A failed-replay campaign (`replay.ordered-failed-replay`, fixed and random) starts each history by holding loads, truncating a source, optionally starting demand, and failing a held load, with a branch that fails an include demand while its marker replay still loads; it declares four reach states in `oracleProperty`'s `histories.states` (a judged failed replay, a judged held replay, a demand started after the commit that fails while its replay loads, and the include form of that demand). A replay participant now also counts as recovery for the terminal-error law, so a demand that starts after the commit while its replay is open is judged in generated histories, not only by a named fixed history. A mutant whose failed replay releases the publication gate fails both failed-replay campaigns and the broad campaigns; a mutant that ends the query when such a demand fails fails both failed-replay campaigns; the branch's production files reverted to `main` fail both. A preload-recovery campaign (`replay.ordered-preload-recovery`, fixed and random) starts every history during the initial preload over on-demand markers and declares two more states: lazy demand in a replay that fails before the first ready, and a window move that waits behind a replay a newer truncate discards. A builder whose deferred move a discarded replay rejects, and one that keeps a failure before the first ready non-fatal, each failed only a named fixed history before; both now fail the fixed campaign, whose seed kills both (each dies in about half of 200-run seeds, so the random campaign kills each about half the time). Building the law found three model errors, each corrected from ARCHITECTURE.md: a failure is scoped to its logical demand, so a retired failed demand and the demand that replaces it publish when the replacement succeeds; a replay completes when its last participant's rows apply, so demand that a deferred window move starts afterwards does not join it; and an ordered tie request (a `where` on rank) is not lazy demand, which the terminal-error law had treated it as, so a failed tie request had excused a terminal error. A query's subscriptions to one collection now share one replay barrier (ARCHITECTURE.md, "Replay participants and failure"): a probe found that in a query that joins and includes the marker source, a marker truncate retired the include's only demand privately, its emptied replay closed while the join's replay still loaded, and include demand the graph then started failed outside every replay and ended the query. A sibling-demand branch of the failed-replay campaign declares that state; the branch's code before the fix fails the named fixed history and both campaigns at `convergence: terminal error`, and removing either sibling hold (at replay completion, or for an emptied replay) fails all three. The random failed-replay campaign then found the other half: one subscription's replay failed, the other's finished once it settled, and demand that a rank move then started on the finished subscription failed and ended the query, because the subscriber judged the failure by its own subscription. The subscriber now asks whether a replay of the source's collection failed; a named fixed history (`a demand that fails after the sibling subscription's replay failed`), a `failedSiblingDemandFailures` reach in the sibling branch (which now may move a row and fail the oldest held load), and both campaigns at 400 runs fail at `convergence: terminal error` on the per-subscription rule. A design that judged a failure against any failed replay of the query, across collections, used to survive, because the convergence check runs after an explicit window move, which retries a failed row demand. A strict terminal-error law now requires a failed lazy demand outside every recovery to end the query (ARCHITECTURE.md, error 228), skipping only failures the model cannot place: after a load threw, and, with a peer, a load that joined a replay. Merge with #2257: its review (CF01, [record](oracle-reviews/2026-10-26-pr-2257.md)) judged a new keyed request that a truncate commit starts as terminal, and called non-fatal recovery of that demand a future contract. This PR adopts that contract by maintainer decision. The merged owner keeps CF01's initiating-request receipt check as a second account of every terminal error, at each history cut and at convergence, plus its named fixed histories and the `replay.subscription-demand-origin` and `replay.keyed-request-failures` campaigns, with their two reach-state pairs measured on this owner's model. Both demand origins, new demand during a marker commit and a settled demand that the replay asks for again, must stay nonterminal after the first ready. An always-fatal `failDemand` mutant fails 15 tests, including both ported campaigns; a never-fatal mutant fails the strict law in 8. CF01's duplicate of the #2224 named fixed history is folded into this owner's existing one. Merge with #2168 (ARCHITECTURE.md law 16): after initial-query readiness no load failure ends a live query, and a failed lazy demand is a request error on the query's node. That supersedes the strict terminal-error law, the error-228 rule, and the always-fatal and never-fatal mutant results above for a query that has been ready. The replay owner now allows a terminal error only after a load failed while the query was still loading, judged at each history cut and at convergence, and it adopts #2168's request-error witness (`requestErrors`); the excusals for thrown and unplaced failures went with the strict law. #2168's design already starts new demand before it releases retired coverage, and it treats a synchronous `loadSubset` throw as a rejection whose owner's release unloads it (the subscription oracles fix that unload), so the adapter-release law now counts a thrown load as acquired. It lacked the shared barrier, the failure hold behind a sibling's failed replay, and the deferred window move's wait, which the merge ports onto it. Without the deferred-move loop, 8 tests fail, #2221 trace 2 among them; without `failReplacement`, the two-failures named fixed history fails; without the sibling wait, that replay and both failed-replay campaigns fail. A deferred move rejects when a reload ends the sync run of the query or of a source, which the source-health oracle requires. The window-request reset went: a move can no longer throw, and deleting it failed nothing. The replay that a truncate opened without demand went too: under law 16 its demand's failure no longer ends the query, and its named fixed history passes on #2168's subscription. Review of the merge (2026-10-28): the replay owner gained a request-error account. After initial-query readiness, each failed lazy demand load that is still owed must appear among the query node's open request failures, by its injected error object, at every history cut, and no request error may stay after recovery replays every source (authority: ARCHITECTURE.md law 16, law 17, and the glossary's request error). A failure is met when its demand retires, a later load of the source covers its keys, or a later replay of the source completes; a failure inside a replay owes nothing until every participant settled. A terminal error now needs a load that failed while that same query was loading, so a peer's initial failure no longer excuses `live`. A thrown load joins a replay that no participant joined yet, and the failed-sibling branch now generates a held retry. `requestErrorChecks` reaches the declared minimum of 5 in each failed-replay campaign. Mutants: demand outcomes that never report an error fail 9 tests at the per-cut check; a successful replay that keeps its request errors fails 22 at the stale-error check. Limits and open items: the account shares one replay across a query's subscriptions to a source, so it cannot judge one subscription's request error while another load of that source is held. The reviewer's finding that `failReplacement`'s replay, which has no recorded failure, completes when every demand that joined it settles is closed as a law revision by maintainer decision: the hold ends when every demand load that joins it loads, a later replay of the source succeeds, or the subscription's last demand retires (ARCHITECTURE.md, "Replay participants and failure"). The query retries the failed demand at once and that retry joins the hold, so the hold cannot publish without the failed demand's rows. The replay oracle judges each subscription's request-error verdict by the subscription that a load names, and its failed-replay campaigns declare the premise (a subscription's load succeeds while that subscription's failure is still owed; 30 fixed and 24 random histories at the normal budget). No live-query history violates the request-error or retention law there; a mutant that completes such a hold when any participant settles fails both failed-replay campaigns at the retention law. A subscription-level `it.fails` test that asserted the earlier, stricter wording (no joined demand may end the hold) was removed with the revision. Limit: the oracle drives the hold only through live-query histories, where the retry always joins; a direct `Collection.subscribeChanges` caller that never retries is outside the live-query contract. Which failure a deferred window move rejects with, when its replay has several, is not specified: `main` rejected with the replay's earliest failure, and this branch rejects with `lastSubsetError`; by maintainer decision the move rejects with its replay's earliest failure that still decides it (law 17 decides which count: a retired demand's, a retried request's, and a replaced demand's failures do not). An identity law now judges deferred moves that start before any failure of the replays they wait on; on the parent code both failed-replay campaigns and the named fixed history `a window move behind a replay with two failed loads` fail with "replay error identity", and the deferred-move loop that rethrows a non-abort replay error passes. The request-error account decides failures per key: a later load of the source that asks for some of a failure's keys decides them, and keys it no longer asks for left the demand. The held-retry branch then found, at three times the run budget, a marker change publishing over a window that the model retained after a failed marker replay (`hold, truncateMarkers, settle ok, settle ok, settle fail newest, mark 3 off`, ascending, offset 1, limit 1, includes over on-demand markers). It was a model defect: the query retries a failed demand at once, and when that retry loads the failed keys the failure no longer counts (ARCHITECTURE.md law 17), so the replay succeeds and publishes. The model now clears a replay failure when a later load of the replay loads its keys. The replay oracle passes at the normal budget and three times at three times it, and production without `failReplacement` still fails its named fixed history at the retention law. A move whose `setWindow` throws synchronously after the request generation increments is reachable only through invariant errors, which probes for a throwing subscriber, a crashed source, and a throwing `select` did not reach. An aborted request's rejection and the failure of a segment that newer coverage released are not failures. That design now fails both failed-replay campaigns. An independent oracle review then narrowed several judgments. The terminal-error excuse after a synchronous throw applies only to the thrown error itself, ending the query after the step that threw; the throw's own step, and every other failure, are judged strictly (a per-history flag had excused every later failure). A load that fails outside every barrier after a failed demand of its source retired is unplaced, because the failed replay may still hold through the subscription's other demands, which the adapter cannot attribute. Limit: with a peer, the strict law accepts either query ending, since the adapter boundary cannot tell which query's subscription issued a load; attributing each failure to its query's subscription would close that. The window check now also requires every shown row to be eligible and to appear once, so a tie cannot hide a row the join rejects. A synchronous-throw dimension (`markerThrows` arms the next marker load to throw while it starts) found that a load throwing inside an open replay ended the query: the subscription dropped the demand, so its failure did not fail the replay, and the subscriber treated the throw as fatal. The subscription now hands the replay a rejected participant for such a throw and keeps the demand, which a later replay retries; named fixed histories (`a replay load that throws while it starts`, `a demand whose load throws inside its open replay`), a `thrownReplayDemands` reach in a thrown-demand branch, and both failed-replay campaigns (now 600 runs) fail on the parent code, and a mutant that later unloads the never-acquired load fails the adapter-release check. Model corrections, each from the adapter-boundary rule that a thrown load acquires nothing: a thrown load joins a replay only if it still has a participant or a failure; an armed throw expires before the drain; and a thrown demand's retirement is invisible, so the retention law skips the marker barrier from a throw to the end of its episode (a later barrier in the episode inherits the ambiguity, which also corrects the existing release-throw case), and a failure that joins an already failed or ambiguous barrier may end the query. Maintainer decision: a synchronous throw inside an open replay fails that replay as a rejection does, so the subscription replay oracle's `new request throws` case and five `live-query-collection` cases, which expected a thrown new demand to roll back, now expect the rejection outcome. Limits: a design that dropped a thrown demand and let its replay succeed passes wherever only retention could see it; after a history command follows a throw, a terminal error is excused, because the model cannot see whether that command retired the thrown demand and with it its failed replay (a demand that waited on that replay then fails outside it). The named fixed histories judge the throw's own outcome strictly. The failed-replay random campaign at five times its run count then found a retention counterexample with no throw, on the parent code too: a join and an include of one marker source; one subscription's replay fails, the other's finishes, and a row move starts demand on it whose load fails, which the shared barrier kept from ending the query; a marker change then retired the first replay's failed demand, which discarded that replay and published an empty window, because the second failure held nothing. That failure now fails its own subscription's replacement, which holds until a later replay succeeds or the subscription's last demand retires. A named fixed history of the trace fails without the hold, and a `partialFailureRetirements` reach (a failed demand retires while another failure still holds the barrier) is declared in the failed-replay campaign; the campaigns themselves do not fail without the hold, so the named fixed history is the witness. A window move whose load throws while it starts counts as a settled, failed move in the model (it used to stay pending, so the newest-move law misjudged the older move), with a `thrownMoves` reach. The broad random campaign at five times its run count then found an older move whose settlement resolved with itself: the newer move threw after it bumped the request generation and before it replaced the latest request, so the older move's settlement returned its own promise, a chaining cycle that escaped as a TypeError. A call now clears the latest request when it bumps the generation, so no older move can wait on itself; a named fixed history fails without that. The same assignment covers a move deferred behind a replay, which had the same shape (an independent review found it can hang forever when a newer move throws between the replay settling and the deferred move resuming); that microtask limit is outside the grammar, which flushes between commands, so only the shared mechanism, not that path, has a witness. The ordered-work oracle also keeps the trace from #2221 as a named fixed history: before prefix growth the loader read the full source twice after a signalling refetch past a NaN boundary; with growth it reads none. Limits: the adapter boundary cannot tell which query issued a load, so the retention law and the participant rule skip histories with a peer. The retention law judges barriers that rise after the query first became ready; before that the initial-readiness law governs. It skips a barrier where a release threw while the replay started, which may fail that replay. Core now reports a throwing `unloadSubset` uncaught and fails nothing with it; the subscription lifecycle, replay, Effect disposal, includes-temporal, and subset-error oracles check the uncaught report, once, with the adapter's error. The request-authority oracle now also generates requests that throw while they start, the last history only TLA+ covered, with an error-identity law: a failed request's participant reports that request's own error. It found that a superseded failure whose recovery read threw at its start reported the start error instead (review finding 6). The state oracle compares every current failed request's participant reason with its own originating Error by identity. Release cleanup cannot replace that reason, even when the thrown value's message starts with “release ”. A bounded 16-case checker calibration crosses index availability, widths 1/2, actual throwing release absent/present, and ordinary/full-source plans. It feeds three wrong participant reasons into the same model/production-driver/comparison; the original prefix waiver and an actual-release-only waiver fail at that check. The existing fixed/random 10,000 authority histories declare and enforce current-request-error reach and actual cleanup-fault/current-request-error overlap. Scope ends at the loader participant and separate uncaught-cleanup observations; it adds no provider/framework or intermediate-publication promise. The state owner's shared error-identity calibration and paired generated campaigns enforce these checks. A cost law then checks, after loading is quiet and a bounded repair is available, that one invalidation reads no full source and issues at most one chain per ordering epoch move (in the fake, a prefix, a tie, and a refill); a mutant that always repairs with a full-source read fails it. The replay-refinement section's status law requires a quiet live query and its peer to stay ready when no load failed. Limits: whether a release runs the graph at once or defers it to a transaction belongs to the scheduler, and the oracle generates both forms without checking the scheduler's choice; the fake's rows do not move except for the unexpressible boundary; publication holds stay with other tests; the laws do not judge requests issued before a truncate; a hung authoritative request suspends the leak law for its unfinished chain; a recovery start that throws during a superseded failure is rare in the campaigns, so a named fixed history owns it. | | Indexed predicate filtering | Complete for bounded dotted-path collision | An independent row filter checks direct predicates and public callback predicates for a dotted scalar field beside a nested path, with and without an index. Selected-field ordering checks the same distinction through `$selected`. | | WHERE predicate publication | Complete for bounded predicate and sync-transaction grammar | The contract, Kleene reference evaluator, snapshot and change-history grammar, three subscriber consumers plus direct snapshot, and per-commit key-set refinement check are literate. A fixed same-key update checks live-row and direct-subscriber payloads; a focused descriptor boundary checks stored-row prefilter safety. Generated cleanup and restart histories for filtered subscribers remain open. | | Joined result keys | Complete for bounded two-source key and whole-source receiving grammars | The nested-loop pair model retains delimiter-, typed, infinite and `NaN` keys. The November 5 extension crosses whole-source selection and spreads, direct/QueryRef receivers, all four join kinds, either selected side and authored collisions. Each of 192 finite histories and fixed/random 80-history campaigns compares root Collections, include facades, toArray and materialize at six cuts. Published `$key` equals the actual default pair or explicit custom key; the other three fields retain source attribution. Inline authored fields and multiplicity remain unchanged. Value-only updates and rejoining preserve key sets. The 4,608 declared receiving states must each reach once. More than two sources, arbitrary nested projection/QueryRef depth, custom-key functions outside the generated key grammar, arbitrary optimistic overlap, frameworks and real providers remain outside this owner. | | Grouped result keys | [Grouped result key oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/query/group-result-key-oracle.property.test.ts) | A grouped live-query Collection gives each group one key of the Collection key type, a string or a number, whatever the group value. Maintainer decision (2026-10-27): grouped keys match the declared key type rather than widening it to nullish keys. Group values come from strings, numbers, `NaN`, `null`, `undefined`, booleans, a bigint, strings that print like those values, and strings in the reserved `\u0000tanstack-db:` namespace; histories move, delete, and insert rows. After preload and each synced change, the (group value, count) pairs equal an independent partition by type and value, every key is a string or number, no two groups share a key, and a group that survives a change keeps its key. Reach: each of the three states (a nullish group published, a group value published beside a string that prints like it, and a key kept across a change) is named by a constructed history that splices its steps at the front of a generated history, so every campaign enters each state; a builder that omits its steps fails the framework's reach check. Random histories also reach them (campaign counts including the constructed histories, 48 to 53, 23 to 30, and 61 to 65 across seeds 1 to 5 and the fixed seed). RED on the parent commit: keys `undefined`, `null`, `false`, and `10n`. Mutants that encode with `String(value)` (lookalike keys collide) or that encode only nullish values (boolean keys) fail. Encoding only the internal D2 key is equivalent in this domain, because the Collection keys rows by the public group key. A focused witness in `collection.test.ts` checks that `sync.write` rejects `undefined`, `null`, boolean, and bigint keys before staging them, and that a later valid write commits alone. A sync adapter that writes such a key breaks its contract, so this is a fail-fast invariant witness under AGENTS.md ("Separate Valid Edge Cases from Contract Contradictions"), not a generated owner; SortedMap never receives these keys. Not covered: Dates, `-0`, objects, and multi-field groups, whose values the aggregate select oracle owns; real sync adapters, since the source is a controlled mock. | | D2 Index storage | Complete for bounded prefix grammar | The contract, plain-`Map` multiset model, prefixed and unprefixed value grammar, `Index` driver, and per-addition `get`/`has` check are literate. Compaction, presence tracking, and structural payloads remain outside this owner. | | Pooled live queries | Complete for bounded eq-filter grammar | The contract, independent `eq` model, live-query Collection second formulation, sync/optimistic/mount/cleanup-restart grammar, observer driver, and per-step refinement check are literate. On-demand and persisted sources, `DbClient`, Suspense, and every clause beyond `eq` conjuncts keep the live-query Collection. | | Live-query deferred acquisition | Complete for bounded synchronous grammar | The law, independent model, history grammar over source states, shapes, and depth, real-Collection driver, and per-step refinement check are literate. Pooled views and DbClient stream preloads have their own blocks. The grammar also adds a peer consumer starting the source and a source truncate before the first subscriber; fixed blocks cover a subscriber that outlives cleanup, reads that wait for readiness, and release of two independent descriptor sources when one start fails. Asynchronous sources, several live-query consumers, and general failure histories stay open. | | Flat-row change tracking | Complete for bounded flat-row grammar | Flat and proxy trackers and an independent change model run the same generated callbacks. Nested values fall back to the proxy, which its own oracles own. | | Production error messages | `packages/db/tests/production-error-messages-oracle.test.ts` | Every public error class keeps its development message for frozen sample inputs, and its coded production line shows the JSON of each shown input, even for adversarial inputs. Every plain `Error`, `TypeError`, `RangeError`, or `AggregateError` site in `packages/db/src` keeps its frozen development template, has a code, and passes each showable interpolated expression or one of its sub-expressions; the TypeScript checker keeps plain objects, such as rows, out of production lines. A projection of an object, such as `Object.keys(handlers)`, is not required. Every `console` call whose argument holds library text is coded, development-only with its text frozen per guarded region, or a development-only decoration of a value. Text that reaches the console through a parameter, such as `setErrorState(message)`, is coded where it is written; the census cannot follow it. `scripts/test-production-errors.mjs` checks that a production bundle drops the full text and every development-only hint, in ESM and CommonJS. Errors built from a caller's value stay outside this owner. | | Lazy target path identity | Focused compiler boundary | A same-source union/coalesce witness keeps dotted and nested demand paths distinct during target deduplication. | | Correlated include path identity | Focused public route-context witnesses | One-level and nested includes keep dotted and nested parent paths, including ancestor aliases, distinct. Conditional result paths receive separate routes. Fixed fixtures cover initial reads and selected source updates; other recursive source forms and arbitrary path segments remain outside this witness. | | Alias scope identity | Generated cross-scope alpha-renaming and finite exact-output refinement | Optimizer copies, wraps, and collapses keep `SourceId`; captured refs retain lexical bindings under ancestor shadowing; ancestor/descendant source declarations need distinct builders while sibling placements may reuse one; public aliases remain visible. The bounded paths and remaining limits are in the owner row. The [ad5e0108 review](oracle-reviews/issue-2072-alias-shadowing-ad5e0108.md) adds finite self-join, joined-context, and captured whole-row witnesses. The [outer-join follow-up](oracle-reviews/issue-2072-alias-shadowing-outer-joins.md) covers absent RIGHT/FULL sides and captured ancestor join operands. | | Join equality and cold acquisition | Complete | Independent cold relational recomputation, acquisition evidence, established equality domains, replacements, and scan/index routes are literate. | | Opaque backend pagination | Complete | The full-relation value model plus opaque token, cache generation, publication, browser acquisition, and live-window integration owners are literate. | | Electric and TrailBase | Complete | Electric replica and recovery models, installed-SDK HTTP delivery, PostgreSQL serialization, and TrailBase's controlled RecordApi/native-stream lifecycle are literate with their real-provider limits intact. | | PowerSync | Fixed tests only | Patch conservation, effective-update receipts, metadata and falsey changes, declared-view keys, transformed schema output, logging, cleanup, and native SQLite reach are covered by fixed tests in `correctness.test.ts`; no oracle owns them (tracked in #2264). | | SQLite persistence and native hosts | Complete | Persisted hydration/replay and ownership, shared-handle driver transaction laws, OPFS page and diagnostic state machines, and the 113-law native conformance manifest are literate. Native execution remains distinct from registration and shim evidence. | | Offline execution | Complete | FIFO retry, scheduler eligibility, leadership replay, transaction settlement, and typed wire serialization are literate. The [FIFO retry oracle](https://github.com/TanStack/db/blob/main/packages/offline-transactions/tests/fifo-retry-oracle.property.test.ts) is the `oracleProperty` `offline.fifo-retry`: each transaction's planned retriable failures, permanent failure, and phase-write or deletion fault are history data, and a model of the README's FIFO, retry, and settlement contract judges calls, settlements, and the outbox at the deadline cuts and after every retry. Reach comes from production. Four states are state probes in `TransactionExecutor` (`offline-transactions#retry-before-peer`, `#permanent-failure-before-peer`, `#phase-write-fault`, `#fault-before-peer`); `predict` says from the plans alone which histories enter each, and reach agreement must hold in every history. The storage fake reports `deletion fault` when it refuses the removal, and the driver reports `retried head` and `retried tail` as measured states. Four constructed histories enter the gating states on every run, and each campaign reaches every gating state at least 13 times. Mutants that let a ready tail pass the delayed head, retry without backoff, drop a permanent failure's caller rejection, swallow a phase-write error, keep an outbox row after removal, keep running after a storage fault, or keep arming a retry timer once nothing is left to run fail the oracle, and misplaced or removed probes fail reach agreement. The idle law (an executor with nothing left to run holds no timer) is the maintainer's decision of 2026-11-06: an idle spin is a bad bug. The driver runs at most 1,000 retry timers after the deadline, one at a time, so an executor that never goes quiet ends the history at once and the idle law judges it; while work is pending, timer counts and polling strategy stay outside the judgment. A mutant that keeps the scheduler's active ID after a failure stalls the driver, so it is killed only by the test timeout, not by a named law. Open there: retry hooks, leadership changes, and storage faults on a permanent failure's removal. The check labels a call after a storage fault as FIFO order rather than the stop law. The [interruption settlement oracle](https://github.com/TanStack/db/blob/main/packages/offline-transactions/tests/interruption-settlement-oracle.property.test.ts) is the `oracleProperty` `offline.interruption-settlement`. It moves one leadership loss, offline change, or disposal across individual microtask turns after one to three commits on disjoint keys, with storage and provider answers immediate or released by a generated data schedule (storage in order, the provider before or after any pending storage operation), then recovers by regaining leadership, going online, or restarting over the same storage. It requires that no provider call or new outbox admission starts while fenced, that each admitted ID reaches the provider once and in commit order, that a fulfilled commit's row is already gone from storage, that commits settle with their provider outcome after a regain or reconnect, and that the outbox ends empty. Reach is measured per campaign for interruptions before admission, between admission and the provider call, and after it, for each interruption; eight fixed histories enter every reachable landing on every run. Mutants that drop the execution loop's fence, drop the admission check, or check admission before awaiting initialization fail it; an un-awaited outbox deletion passes the immediate timing and fails the scheduled one (law durability). Open in that timing sweep: shared keys and overlapping old and new executors. Its imported [handoff companion](https://github.com/TanStack/db/blob/main/packages/offline-transactions/tests/interruption-handoff-oracle.ts), property `offline.disposal-handoff`, enforces [decision offline-disposal-handoff-2026-11-10](oracle-reviews/issue-2254-executor-handoff.md): disposing an executor preserves caller promises and optimistic state on surviving Collections; a sequential same-runtime successor over the retained outbox, retaining every configured Collection under its existing registry key, settles the original callers. Generated histories cover manual/default/explicit auto-commit/actions, live/restored optimism, shared/disjoint keys, repeated replacements, multiple waiters, new storage adapter objects, provider success/permanent rejection, and held/failed deletion. The comparison observes original receipts, per-ID waiters, authored public rows and durable IDs after disposal, restoration, held provider/deletion, and each outcome. A throwing restoration-settlement subscriber on the final outcome must not strand another old waiter. All nineteen declared states are measured per campaign; constructed histories force retained and replaced affected-Collection receiving paths for every API, registry growth, and restored optimism with no old waiter. A fresh affected Collection with an unchanged ancillary Collection must leave old callers pending and must not complete their old snapshots. The comparison preserves core rollback cascading among pending restored snapshots with the same serialized globalKey, including across Collection objects; live persisting transactions do not join that cascade. The any-configured-Collection-overlap mutant fails scope isolation at successor completion. The original implementation fails caller settlement at successor completion; disposal rejection, lost restoration cleanup, a global ID broker, and exception-aborted handoff fail named comparisons. Limits: one to three transactions/replacements/old waiters, one transaction-bearing Collection, controlled provider/storage, no overlapping issued executors or cross-tab promise transport. Fresh Collection objects do not inherit old callers. Decision `offline-copied-outbox-limit-2026-11-10` explicitly keeps copying or migration between independent outboxes outside this handoff guarantee: a copied row with the same transaction ID and Collection objects can settle the original caller while its original row remains. The API has no durable outbox identity; the Offline execution owner does not claim copied-store isolation. Changes to other configured Collection identities, registry keys, or transactions affecting several Collections are outside this bounded grammar; retaining all configured entries is the promised sufficient handoff condition. The gap CLI now routes completion/restoration mutations to this owner. Its zero-to-three explicit old-waiter dimension rejects lost restoration-only ownership. The processing-promise observation rejects both mutants that suppress a restoration subscriber exception, while preserving delivery to every caller. Its additional property `offline.disposal-issued-handoff` crosses an issued retired provider with a retained-Collection successor awaiting leadership, with unchanged or growing registries. It reuses the handoff model/check and observes original and successor callers before releasing leadership; after an issued deletion failure, online successor replay removes the terminal marker without changing those first caller outcomes. Generated histories cover every creation API, live/restored optimism, provider success/rejection, deletion failure and throwing restored-settlement subscribers, one transaction and one to three replacements. The old directional match fails caller settlement. Both delivery directions require complete registry containment in one direction; a shared ancillary Collection remains insufficient. Authority is public Transaction.touchCollection(): every Collection recomputes before the first error is thrown. The same handoff model/check also judges `offline.disposal-review-boundaries`. Its generated histories cross six actual storage-deletion rejection values (Error, undefined, null, false, zero, and empty string), a throwing nonfinal restored subscriber followed by a queued peer, and predecessors left live but offline while only the successor executes. Four API paths and both optimism origins are declared and constructively reached. A controlled timer dispatch makes peer progress deterministic without requiring same-batch execution. The raw-storage-error, disposed-only-recipient, and instance-only-settlement mutants fail caller settlement; removing reverse registry containment still fails the issued-handoff comparison. This does not add an all-error logging or concurrent-issued-outcome policy. The companion also registers offline.disposal-handoff-resources: twelve generated plus seven constructed histories per campaign reuse the same model, production driver and comparison, with retained Collections and acknowledged deletion. A unique configured detector on the first retired executor supplies a Node/V8 heap sentinel. The observer first counts one held instance; after every outcome, disposal, and release of test-owned executor references, full GC must count zero while the Collections remain active. Both registration-release mutants fail resource release. This witnesses retention of that configured resource, without reading the completion registry, specifying a GC deadline, or claiming absence of every object leak or browser GC behavior. The [gap CLI evidence](oracle-reviews/issue-2254-executor-handoff.md#remaining-gap-closure-2026-11-10) records all four named-law kills and their stable keys. The refreshed [full-source audit](oracle-reviews/issue-2254-executor-handoff.md#refreshed-full-source-audit-and-receiving-configuration), run `954a142cffbb`, audits implementation `248ff7922` and source SHA-256 `2f7299ec03b2a4f741c7ad485c3fdc09454ca1e8c08a2e3c8e46034f06e29b5a`: 304 operators yield 280 reproducible assertion kills (270 named-law, ten untagged), 18 survivors, five unreached cases and one setup error. There are no crashes, timeouts, exclusions or nondeterministic routes. Of 53 changed-line operators, 51 are killed; two survivors undo only the repeated-registration optimization and preserve caller outcomes while adding configuration reads. All 24 raw residual labels are retained. Two exact barrier mutations (M96/M100) separately fail the real QueryDB receiving comparison at batch completed; package-local discovery cannot supply that relocated route. The other 22 residuals comprise eight bounded typed/call-path equivalences and fourteen observable differences without a stronger accepted promise, including follower-read failure, controls after a throwing configuration accessor, and registration work. These are not global equivalence claims. Earlier run `fd3da244acf0` and its 298-operator totals belong only to prior source hash `dff0f5…`. The same primary owner imports generated API/control, settled-ID horizon and coordination/barrier companions. A separate receiving unit enforces environment selection, startup failure, diagnostic shape/provenance, and unread initialization rejection. The [real QueryClient/QueryDB receiving runner](../../packages/query-db-collection/tests/offline-executor-refresh-oracle.test.ts) uses the registration-free [barrier model/check](../../packages/offline-transactions/tests/executor-refresh-barrier-oracle.ts) to require restored-replay refetch settlement with fresh rows. QueryDB owns this registration and its dependencies; the offline core runner imports only the shared judgment. Local persisting mutations retain QueryDB's separate fetch-settlement exception. Limits remain controlled probe/election/storage/backend premises; no native browser durability or event claim. The settled-ID horizon campaign spans 998–1003 unique empty transactions over every creation API. Public controls do not add a management policy after malformed configuration aborts construction, and follower initialization does not acquire a new no-read promise. The settlement oracle's generated FIFO histories draw each transaction as one record (outcome; manual commit, auto-commit with the option set or omitted, or an `OfflineAction`; receipt read or not), use `when('settled')` as an auto-commit's receipt, and require that no failure escapes as an unhandled rejection, also when nobody reads the receipt, and that settlement logs no failure again and writes no debug output. An empty transaction on any commit path may precede each one; its receipt and completion waiter must fulfil without reaching the provider or the outbox. A manual transaction that writes a row and rolls back before it commits may also precede each one; its waiter must reject with an Error that names the rollback. A focused witness rolls a transaction back while it persists, for both provider outcomes: its waiter must wait for the executor and report the executor's outcome. After every transaction settles, a new waiter for each one must reject within a turn rather than hang. An unread receipt still settles with its own outcome when read afterward, and a caller may register its completion waiter before admission on every path but `OfflineAction`. A focused witness fails the admission outbox write on every commit path and requires the receipt to reject with the storage error, without an unhandled rejection or a repeated log; a failed outbox write stops the executor, so generated histories do not continue past one. Open: the generated failure source is the mutation function only; manual commits always follow their own `mutate()` at once, so a pending manual transaction behind a failing shared-key sibling is not generated; a throwing `mutate()` callback is not generated, because core keeps its transaction pending; a rolled-back-before-commit transaction is generated only on the manual path, with its own key and its waiter registered after `mutate()`, so a secondary rollback of a pending transaction by a failing sibling, whose waiter gets the generic rollback Error, is not generated. | | Frameworks | Complete | Shared live-query and infinite-query models are literate. Each framework keeps its own realm, ownership, and scheduling driver. | | Structural values and ordered primitives | Complete | Structural hashing, deep equality, comparison, cursor denotation, index refinement, and query-identity output equivalence are literate. MultiSet consolidation (`ivm.multiset-consolidate`, [owner](https://github.com/TanStack/db/blob/main/packages/db-ivm/tests/multiset-consolidate-oracle.property.test.ts)) keeps one record per identity under the keyed, primitive, or structural rule, with the first record and the summed multiplicity, and leaves its input unchanged. Six declared states are production probes (`db-ivm#...` in `packages/db-ivm/src/multiset.ts`): the three rules, `records merged`, `join tuples merged`, and `only pairs without a key`. The model predicts each one from the history alone, and reach counts a state only where the probe and the prediction agree (`reach agreement`). Each state has a constructed history, so every campaign enters it; the grammar modes are generator dimensions, not reach. Sixteen mutants are killed, each by both campaigns: wrong identity rules, merge sums, retained records, zero-sum output, -0 handling, input mutation, and wrong or missing probe placements. Limits: output order is not part of the law; structural identity uses a 32-bit hash, so no injectivity is claimed; the probes are development-only behind each function's `probing` constant (the production bundle equals the bare-guard bundle, which drops every probe, up to identifier names), and they show where production enters a state while the check judges the output. The empty multiset takes rule 1 by the law's vacuous "every record" reading, which no output depends on. | | Mixed-kind ordered prefixes | Bounded | Eager BasicIndex and BTreeIndex paths compare ascending and descending direct and live-query windows with an unindexed scan across mixed value kinds and paired source changes. One retained on-demand BTree history checks settled windows after a number/bigint transition, a finite request for a missing row, and a cursor request after index eligibility changes. Other provider paging histories remain open. | | Boundary refinements | Complete | Cleanup/restart admission, metadata publication, retained state, acquisition cells, D2 source reconciliation, top-K support windows, and nested Query work bounds are literate. | | Small structures and test mechanics | Complete | SortedMap, cleanup appointments, and guarded replay are literate. | ### Guide-audit boundary handoffs The cleanup/restart owner checks ordinary subscription admission and deferred acquisition resumption during held adapter cleanup. Its eighteen cases cross loading/ready/error status, eager/on-demand sources, and direct, snapshot, or resumed admission. The three-cut model requires rejection before subscriber ownership or acquisition, followed by successful explicit admission after cleanup settles. Twelve Effect receiving cases cross both source modes, all three prior statuses, and cleanup on the first or second joined source. A late Effect returns disposed, reports the cleanup once, and retains no subscription or cleanup observer. A new Effect after settlement is admitted. The original implementation fails all eighteen admission cases; a guard limited to fresh subscribers misses six resumption cases. A guard without earlier Effect cleanup observation fails the twelve receiving cases during construction. The owner covers these controlled adapter cuts, with cleanup rejection and terminal-listener restart covered by its existing histories. It does not establish arbitrary concurrent framework schedules or actual provider shutdown. The [migration feedback review](oracle-reviews/2026-10-22-dbclient-migration-feedback.md) records the rejection policy and exact calibration. The eight-item follow-up at reviewed head `16824f677` extends the same owners. The cleanup/restart owner adds six plain/live-query logical-demand cases at idle, ready, and cleaned-up cleanup start, plus six admission outcomes that distinguish a pending cleanup promise from an actual replacement sync run. The deferred-acquisition owner adds render-deferred eager/on-demand sources and explicit deferred subscription/resumption histories across both query shapes and one/two live-query levels. The React descriptor driver receives resumption after a real abandoned suspended render through the existing startup judgment. The observer-history owner adds eight failed-setup histories, with both modes, one/two failures, cleanup rejection or real sync-start failure. Client, status, and layout leases are checked immediately, then retry, publication and release. Two late-listener seed failures retain a healthy peer and exclude the failed listener from later publications. Eight stream-preload histories cross pending or successful streams, both source modes and a render deferral. The real React streaming test receives the on-demand premise while retaining server rows until browser acquisition completes. The pooled release owner adds twelve new/retained/released partition histories through held loading/ready cleanup and two startup-cleanup reentry histories. The subscription boundary owner adds 28 resumption/retirement histories crossing loading, ready and acquiring notifications, cleanup, source mode and render gate. The shared token-count model forbids restoring a retired owner. Deferred-demand cancellation fixtures now create logical demand before explicit resumption; render-owned queued loads remain covered by the DbClient fixture. These finite extensions do not establish arbitrary async/provider schedules or new framework error policy. The [follow-up audit](oracle-reviews/2026-10-22-dbclient-migration-feedback.md) records original RED, mutant controls, and the unchanged rejection decision. A subsequent current-head summary exposed cleanup during ownership transfer. The deferred-acquisition owner adds 192 surviving-owner histories crossing both source modes, shapes, depths, ordinary/resumed/deferred readers, render gates, source loading/ready cleanup, and explicit restart later or from terminal publication. They check the complete post-cleanup status trace, ownership, replacement acquisition, readiness and rows. The previous implementation fails 44 assertions; retaining ownership without fencing first-demand cleanup fails 16. The controlled grammar does not claim arbitrary recursive cleanup or async provider work before acquisition. This owner retains those wider witnesses. The ten-finding high review adds generated error-provenance and partial-setup histories to the existing owners. The deferred-acquisition owner crosses ready, returned-error and thrown starts, before/during handoff, with defined/absent causes. Its independent start-handoff judgment also feeds real React ordinary and infinite hook drivers. Each hook now has independent fixed/random campaigns and reach minima for returned/thrown source failures before/during commit, including absent causes. They compare readable error/boundary behavior after commit, one source start, and ownership immediately after unmount, before GC. Independent startup owns a pre-commit throw; the later hook reads error status. The restored broad-rethrow defect fails both observations for each hook. Explicit DbClient preload continues to report source startup failures. Pooled lifecycle histories add released partitions whose synchronous late cleanup callback returns or throws, including 1–3 healthy status peers. The same pooled release owner now generates bootstrap callback return/throw, Error/undefined, zero through three healthy observers, callback position before/after those peers, and `gcTime` 1–3 through both ordinary compiled and pooled core observer paths. Failed granular bootstrap retains no unreturned ownership after the grace period; surviving peers retain their source until release. Held source cleanup gives every admitted wholesale observer one terminal error snapshot and callback despite a sibling throw, then preserves the exact reported failure at settlement. First-return, surviving-peer, cleanup-start, settlement and final-release/GC cuts distinguish ownership rollback from all-peer status delivery. Original production and repairs that implement only one of those obligations fail the respective public comparisons. These are controlled core receiving paths, not framework scheduling or remote-provider shutdown evidence. Observer histories add early capability or sync failure, one/two failed attempts, both modes and reentrant surviving peers, then explicit retry/publication/release. First-party persisted readiness does not throw at registration; that premise is a controlled core-capability claim. The lifecycle owner adds held/immediate cleanup and actual post-transfer notification throws across 1–3 demands, checked after replacement readiness. Original and narrow-mutant assertions calibrate these cuts. All six new properties have declared reach, paired fixed/random campaigns and guarded seed/path replay. The [high-review audit](oracle-reviews/2026-10-22-dbclient-migration-feedback.md#high-review-of-ten-findings--2026-10-23) records counts and finite limits. Two historical high-review claims, H04 and H08, remain `confirmed-open` evidence gaps, with no reproduced contract counterexample or closure credit. They are not accepted exclusions or refuted by the neighboring controls. For H04, the pooled lifecycle owner needs a legal eager-source `subscribeChanges` throw that reaches the partition's terminating catch and whose contract promises same-partition, same-run recovery; current eager `reportError()`/`reportHealthy()` histories keep both shared views ready and recover their health. On-demand sources are ineligible for pooling, so their throwing probes do not reach this path. For H08, the lifecycle/deferred-acquisition owners need a synchronous post-transfer notification throw that keeps retained demand detached past supported replacement readiness; generated real throws currently acquire afterward through the status listener. Resumption can skip its immediate restart when that notification throws. An implicit retry without another readiness signal is not established by the current contract. A broader recovery promise needs an explicit decision; a legal failing trace under the existing promise needs enforcement in these owners. Arbitrary provider outages, callback programs and other frameworks' error policies remain outside these new witnesses. The approved cleanup admission rejection policy remains unchanged. The Collection lifecycle history owner includes a 26-cell cleanup-restart matrix. It crosses explicit and default eager sources with absent or present loaders, empty or nonempty replacements, and no interruption, truncate during loading, or a failed first load followed by `reload()`, which must keep the waiting caller for the new sync run. On-demand controls use settled subset acquisition. A cleanup-detached eager demand remains active, its `onLoadSubsetResult` promise stays pending through these pre-ready cuts, and it starts no physical subset acquisition before fulfilling with the exact replacement. The focused Query Collection test receives the successful-restart law through automatic Collection GC, an eager Query Collection, and `DbClient.preloadLiveQuery`. Demands first admitted after eager restart, terminal eager failure, retired or concurrent eager owners, and same-turn interruption schedules remain open. The broader generated lifecycle histories cover those ownership operations only in on-demand mode. Before the truncate repair, the four eager loader-present truncate cells fulfilled at the loading checkpoint; their loader-absent controls stayed pending. This distinguishes sync mode from the adapter's incidental shape. The [issue #2163 audit](oracle-reviews/issue-2163-eager-restart-truncate-bb2122012.md) records the exact-head ORC-001–014 outcomes, RED/GREEN calibration, review ledger, and remaining limits. The includes-space owner (`packages/db/tests/query/includes-space-oracle.test.ts`) now varies leaves per twig across 0, 1, and 10. Public leaf rows change from 0 to 10 to 100 while 13 Collection facades remain. This protects facade ownership for the fixture's fixed root/branch/twig topology; route churn, D2 demand retention, and a heap bound need separate witnesses in the includes owners. The virtual-row-fields owner (`packages/db/tests/query/virtual-row-fields-oracle.test.ts`) checks all four public fields on row roots and keeps inline values in their selected shape. Its finite 1,056-history attribution grammar crosses single/joined sources, structured projections/spreads and functional projections/spreads/direct source returns, and none/each/all reserved-field collisions. Each form crosses direct output, QueryRef depths one/two, joined and functional QueryRef consumers, either union branch position and a union consumed through QueryRef. Eight further histories cross nullable later spreads, spread order and which source has a pending write. Comparisons at preload, a held optimistic source update, and settlement enforce the maintainer rule: structured source spreads and direct functional source returns retain source metadata; new objects and ordinary projections receive output Collection metadata. Each collision is an independent axis, including `$collectionId` by itself; selecting a reserved name cannot choose a source. The reach check requires observations from joined and single pending sources, colliding projections, direct functional returns, QueryRef and union pending observations, and a null later spread. Authored ordinary fields can select source pending state without changing output metadata. The original source-guessing compiler fails the same comparisons. Supplemental regressions for two spread orders, unmatched RIGHT joins, facade projection metadata and inline values live in `virtual-row-fields.test.ts`. This boundary does not establish arbitrary nested projection histories beyond these two QueryRef levels, every join kind under source changes, framework receiving paths or provider behavior. The whole-source receiving grammar keeps `NaN` source keys on sync paths but does not target them with ordinary optimistic updates. A setup probe with left keys `[NaN, "b]", "a"]`, right keys `["a", 1, NaN]`, two matching rows per side, and `left.update(NaN, row => { row.label = "held" })` throws `KeyUpdateNotAllowedError` although its key did not change: mutation admission compares keys with `!==`. This separate Collection mutation-admission gap belongs to the **Collection lifecycle / mutation startup** entry (`packages/db/tests/collection-mutation-startup.test.ts`; fixed tests with no independent admission oracle, tracked in #2264). It needs a SameValueZero key witness across unchanged-key optimistic updates. The failure occurs during admission before the joined update checkpoint, outside this repair claim. The November 5 pair-identity decision separates joined `$key` from source attribution. The selected source retains `$origin`, `$hasPendingWrites` and `$collectionId`; the result owns its actual pair or explicit custom key. The join-result-key owner now checks fanout, source attribution and authored inline values together through root, QueryRef and materialized receivers. This owner retains its custom-key, nullable facade and source-spread controls under that approved rule. Inline `$key` remains authored. The prep review adds 102 histories for implicit single-source/joined output and functional direct-source returns after inherited inline materialization. Direct/QueryRef receivers, each source's held write, every authored collision, and absent/array/singleton input distinguish source attribution from output attribution. All 72 path/source/checkpoint states reach their required minimum; 408 comparisons check complete row values and physical entry keys at preload, held mutation, settlement without confirmation, and a later remote write. The unchanged implementation fails 56 of the full owner's 1,706 tests while all 1,604 prior tests pass. Restoring namespace-sidecar loss or implicit joined source attribution fails the extended comparison. These eager-source histories do not establish framework timing, rejected-write combinations or arbitrary include depth. See the [prep-review evidence](oracle-reviews/2026-11-05-boundary-only-prep-review.md). The attribution driver compares both authored rows, every ordinary field and all four virtual fields, then deletes the non-first row. Half its histories configure independent projected keys; default-key differential evidence remains supplemental. Another 264 histories populate both union branches with numeric 1 and string "1", different source Collection IDs and equal labels. Either branch holds a write while its peer is deleted/reinserted. Branch order and QueryRef consumption vary. Each direct/QueryRef × source/output attribution × pending-side path must reach held, reinserted and settled comparisons. Fourteen checker controls reject omitted/duplicate peers, missing ordinary IDs, wrong keys, union-wide source attribution and stale pending/origin fields; reordered allowed results pass. Evidence and review corrections are in [implementation chunk 3](oracle-reviews/2026-10-28-pr-2171-oracle-chunks.md). A further 112 histories recompute changing left-join topology while a left write persists, through join-key changes or delete/reinsert. They cross five projection shapes, useful spread orders, independent success/rejection (including both with distinct errors), and either settlement order. A right write overlaps and receives a same-key queued sync confirmation. Full snapshots, every callback's installed read, change/previous-value payloads and a downstream metadata projection are compared at initial, held, topology, acceptance, settlement and later remote cuts. Aggregate callback deltas reject whole-batch repetition; batch partition remains permitted. Eight calibration cases reject stale reads/events, wrong previous values, duplicate messages/batches, omissions and lost earlier failures. Per shape/topology reach requires both receiving layers, both rejection states and both settlement orders. See [chunk 4](oracle-reviews/2026-10-28-pr-2171-oracle-chunks.md). Another 132 histories receive the same metadata grammar through Collection facades and inline toArray/materialize controls. Two parent routes share a bucket, move to a populated or empty destination, retire the last route, then reactivate while a child write persists. Success/rejection and later source updates are observed. The primary includes owner supplies an independent active-interval model: retained routes share one ready facade, retired handles stay ready/empty, and a new interval gets a new handle. This assumes no facade-local optimistic mutations. Every shape declares active empty readiness and nonempty child receiving cuts. Six lifetime and four inline-value mutant controls reject wrong observations. See [chunk 5](oracle-reviews/2026-10-28-pr-2171-oracle-chunks.md). Functional callback-input observations have a separate receiving boundary in `virtual-row-fields-input-oracle.test.ts`, sharing the existing source metadata judgment. The maintainer's 2026-11-05 boundary-only decision supersedes O12's October 28/30 callback-normalization policy. Intermediate callback inputs, inline values and Effect outputs retain authored fields, including explicit reserved-name overrides. Direct source rows retain genuine metadata. Published Collection metadata attribution remains with the publication owner above. Thirty-three authoring descriptions cross seven QueryRef/join/union paths, five callback forms (select, where, having, where-select, having-select), and root, wrapped child, direct child and real Effect receivers. Flat union children require a named QueryRef for include correlation; direct flat union children remain inadmissible. The finite grammar has 4,290 receiving histories and 20 direct-source controls. Each receiver checks immutable callback captures and complete derived or predicate-filtered output at initial readiness, held mutation, settlement and remote next use. Effects also check exit/reentry, every delivered value and previousValue, continuity in both callback channels and silence after disposal. Before/after source facts permit retraction evaluation. Startup LEFT joins may expose an absent side; after source exit the unmatched peer remains a result. Reserved fields use presence/readable value, with ownership diagnostic. Ordinary own undefined remains distinct from absence. Another 132 histories retain inline array/materialized authored values through direct and QueryRef paths; 66 reject compiled Collection inputs before callbacks. All 20,720 callback and 594 inline/rejection states reach once. Another 396 histories use exported `compileQuery`, the same exact QueryIR and D2 input streams, both compilation orders, shared/separate caches, and FROM, joined-source and union-branch placement. At initial graph drain, all 1,188 states compare callback captures, complete derived output and raw authored output. Raw output uses a shared-cache/separate-cache differential, while both executions still undergo the independent callback/derived-output judgment. The union optimizer clones branch IR: counters establish original-key reuse for FROM/JOIN, while union checks propagation/transparency without claiming that cache hit. This receiver supplies no Effect-root metadata attribution law. The owner retains all 4,923 original tests and adds one symbol checker control, with 20,720 callback states, 594 inline/rejection states and 1,188 compiler states. Before the boundary-only production edits, the revised independent model rejected 4,106 comparisons on unchanged code; all declared states reached once, including real Effect and Collection receivers. Predicate membership follows the authored value. Complete nested ordinary values remain strict, including nested reserved names. The only root-metadata omission in the common input comparison is an actual published flat-union Collection root; the publication owner judges that attribution. See the [boundary-only implementation record](oracle-reviews/2026-11-05-boundary-only-metadata.md) for GREEN, hostile mutants, source bindings and limits. The [historical runtime repair record](oracle-reviews/callback-metadata.md) preserves the earlier policy's evidence and lossless review audit; those callback-normalization expectations are retired by the maintainer decision, not inferred from production output. The ordered-work owner, `ordered-work-oracle.property.test.ts`, adds 144 finite histories through `ordered-compiler-cache-driver.ts`. Two compilation orders, shared/separate caches, FROM/JOIN/union paths, two projection forms, two order directions and three window moves exercise actual source Collections and the real OrderedSourceLoader. The independent installed-window model checks signed output bags at initial, moved and returned cuts. Original registration overwrite fails 48 histories; the repaired full 424-test owner passes. All 432 new states reach once. This receiver claims the controlled compiler/loader boundary, not public Collection window-promise integration. Its 280 existing histories retain their Collection/Effect receiving evidence. Separate metadata-mode pipelines remain a permitted representation; no one-pipeline performance promise follows. The [runtime repair record](oracle-reviews/callback-metadata.md) retains the commands, source bindings, lossless nine-item audit, calibrations and limits. Historical instrument acceptance remains in [chunk 17](oracle-reviews/2026-10-28-pr-2171-oracle-chunks.md). The separate static receiving-type failures in the [deferred record](oracle-reviews/2026-10-29-pr-2171-deferred-oracles.md) remain open. This extension does not establish arbitrary descriptors/prototypes, greater recursive depth, same-source overlapping transactions, other dynamic join kinds, truncate, provider scheduling, framework receivers or construction failure cleanup. The neighboring includes publication owner removes virtual fields from its own comparison; the new metadata timeline supplies this bounded core publication judgment without claiming those broader paths. The generated persistence option type/admission owner is `packages/db-sqlite-persistence-core/tests/persisted-options-type-oracle.ts`. It generates row shapes (1–4 scalar, nullable, array, or nested fields), six key domains, field optionality/readonly modifiers, utility signatures, numeric schema versions, and network deadlines. Each shape retains 30 construction forms across local/synced, schema-free/transforming schema, typed-spread/inline arguments, and inferred/partial/full type arguments, including contextual schema callbacks. Twelve configured forms cross eager/on-demand/network-first options with schema and sync modes; network-first remains eager. Two schema-free forms supply a phantom schema generic without a schema value and still preserve row input. Eight modifier neighbors cross mutable/readonly first fields with schema and persistence modes, bringing each shape to 52 core or 53 browser constructions. Transforming schemas accept their output as input, as required by the schema guide: their distinguished field narrows string | number to number, and output optional fields remain optional on input. Exact input equality distinguishes the two domains; inserting an output row is a legal neighboring observation. Independent type laws compare insert input, complete published row types, exact keys, user utilities, added local persistence capabilities (including optional leadership/reload signatures), option types, and contextual getKey / markReady callbacks. The browser driver uses real Query Collection options. Declared schema-compatible-input, readonly-input, readonly-output and mutable-fields reaches occur structurally in every generated history. Its independent closed capability model checks direct-write signatures, observer state, refetch parameters and a non-any Promise-array envelope. A supplemental before/after relation preserves the full Query utility types; QueryObserverResult's internal payload has no independent model here. Fresh-object sync rejection uses an exact unsuppressed overload diagnostic and a legal neighbor that changes only sync, so a collateral option error cannot substitute for the promised rejection. Core and browser `persisted-options.test.ts` runners share the grammar/model and use their respective receiver tsconfig. Package and root `test:oracles` commands select them. Both run 12 histories with seed 2259 and 12 with a fresh seed, measure per-path reach, and accept the shared seed/path/property replay interface (`persisted-options.types.core` / `.browser`). A shared semantic builder retains source and declaration diagnostics while caching dependencies; timeouts scale with the campaign multiplier, and histories yield for worker RPC. This owner does not execute runtime parsing, adapter I/O, sync, or publication, and does not check built declarations, npm resolution, other host packages, every TS version, arbitrary extra-property structural assignment, or the internal semantics of trusted PendingMutation/LoadSubsetOptions carriers. The [type-preservation audit](oracle-reviews/pr-2259-persisted-option-types.md) and `scripts/calibrate-persisted-option-types.mjs` preserve parent RED, GREEN, legacy-suite survival, mutant-mutant evidence, and runnable overlay recipes. The readonly-row overlay strips user-property readonly modifiers from get's return while retaining readonly virtual fields. The prior grammar accepted it; the modifier histories reject it at the shared exact published-row comparison. The maintainer chose rejection for local caller utility collisions. The same owner's runtime admission grammar checks the three reserved names acceptMutations, getLeadershipState and forceReloadSubset, individually and in combinations, against both public core/browser wrappers. It crosses local/synced options, schema presence, function/undefined values, and enumerable/non-enumerable/inherited properties. Rejection must be an InvalidPersistedCollectionConfigError before persistence resolution; ordinary local utilities and synced adapter utilities remain available. Each fixed/fresh campaign measures all ten admission states under `persisted-options.utilities.core` / `.browser`. No Collection is created, and no sync, SQLite I/O, native-host or publication claim follows from this path. The versioned audit records the user decision, original overwrite RED, GREEN, and guards that check only own/truthy properties or omit a reserved name. Other existing fixed type checks cover adjacent compile-time boundaries: `packages/db/tests/mutation-handler-type.test-d.ts` (fixed tests; no oracle owner (tracked in #2264)) checks sibling Collection/key/utilities in mutation handlers; and `packages/db/tests/query/virtual-row-fields-reference-types.test-d.ts` retains concrete helper examples. The generated public type owner is `packages/db/tests/query/virtual-row-fields-types-oracle.test.ts`. Its 24 finite row descriptions vary key domain, scalar type, nested optionality and discriminated union membership. Shared runtime/type authoring dimensions cross five projection shapes and eight compositions; seven child shapes cross the legal facade/toArray/materialize/findOne forms; array/Date facades are rejected inputs. Each generated body also runs public query/index construction, with an explicit index type and failure-preserving cleanup. Two admission controls reject opaque facades and optionless indexes at their actual boundary. A reusable recursive type signature checks values, exact keys, required/optional and readonly modifiers per union member, without rejecting duplicate equivalent union members. Public-source imports compile through the actual TypeScript compiler; all diagnostics retain their file, span and code. Seven mutant controls challenge value enrichment, nullability, one-branch readonly loss, nested any/metadata/modifiers and Date metadata any. Their rejection requires failed type-law constraints, not syntax or setup errors. The normal test:oracles command selects this owner. The 2026-11-05 boundary-only implementation extends the primary owner above with 48 authored collision/path/selection states and 18 grouping/collision neighbors for every one of the 24 source descriptions. Actual contextual where/having/select, inline and Collection types use one declared-shape law; all new states reach 24 times. The extended owner rejects 24 consumers before the type repair and passes all 33 checks afterward. Publication replaces reserved names instead of intersecting authored collisions. Flat union HAVING also retains its documented `$selected` context in the expected type. The [implementation record](oracle-reviews/2026-11-05-boundary-only-metadata.md) binds RED/GREEN, mutants and source evidence. This revises the primary owner's ordinary projection policy; the chunk-24 account below remains historical and does not imply that its companion files exist on this base revision. The prep review extends this same owner with 48 structured-reference states, 12 structured selected-context states, 48 grouping-boundary states and 12 visible-aggregate depth/collision states. Structured WHERE/SELECT and grouped HAVING judge authored reserved names and field values; direct-source controls retain genuine metadata. Empty callbacks/helpers before/after selection, accumulated grouping and an explicitly typed `groupKeys` context distinguish empty grouping from erasing an existing group. Aggregate depths 0/7/8/9/10/16 distinguish removal of the old depth-eight cutoff from moving it one level. Intermediate QueryRef, inline and published result types use the shared shape law. The repaired owner passes all 33 checks, and isolated context-enrichment, selected-context-enrichment, unconditional-grouping and depth-cutoff mutants fail only native type constraints. See the [prep-review evidence](oracle-reviews/2026-11-05-boundary-only-prep-review.md) for pre-edit RED, corrected carrier expectations, reach and source bindings. The CI follow-up adds three conditional inline-wrapper choices to all 24 source descriptions: array/array, array/materialized array, and array/singleton. Each legal consumer runs public construction before native type comparison at the QueryRef functional input and Collection result. Wrapper choice must expose materialized values, with singleton absence preserved. The unchanged mapping fails 24 consumers with TS2344 only; the distributing mapping passes all 33 checks. A restored-mapping mutant rejects the same shape assertions. This owner does not yet judge arbitrary unions of opaque, scalar and include wrappers. The publication owner also adds grouped and ungrouped aggregates through direct and QueryRef receivers, with held inserts, settlement and later remote inserts. Counts change while projection metadata belongs to the output Collection. Single-field wrong-source observations calibrate every metadata assertion. See the [CI evidence](oracle-reviews/2026-11-05-boundary-only-ci-review.md). The dynamic-emptiness follow-up extends this same owner with 15 grouping-list forms, each crossed with six authored collision choices and all 24 source descriptions. Mutable arrays, readonly arrays and empty-or-one tuple unions construct both empty and nonempty return values, through callbacks and `groupKeys`. The independent declared-shape law gives these lists an optional missing `$key`. Statically empty lists retain no generated key, statically nonempty tuples retain a required key, and accumulated definite grouping stays required. QueryRef callback, inline array and published Collection types use the same comparison. The original concrete witness was `const keys: Array['id']> = []`, consumed through QueryRef `fn.select(({ inner }) => inner.$key)`. Here `PublicRef` names the public `Ref` export. The original inference accepted a required key while a runtime probe observed no `$key` property. Its nonempty neighbor observes the generated key. This was an enforcement gap, not an accepted product limitation. The extended native owner rejects the unchanged implementation before repair. Always-required, omit-all-array-keys and erase-prior-grouping mutants each fail native shape constraints. This closes the declared-list inference gap within the generated forms; explicit `any` erasure, including a helper with only its context type argument supplied, retains the existing compatibility behavior. The follow-up model refactor derives this key law from each call's declared possibilities rather than storing a final keyed answer per case. All 24 generated consumer programs remain byte-identical, and a last-call-only rival fails native constraints. See the dynamic-grouping evidence in the [high-review record](oracle-reviews/2026-11-05-boundary-only-high-review.md). The high review adds 27 function/conditional forms with aggregate and ordinary controls to this same public-type owner, for all 24 source descriptions. Inferred expressions now retain type-only aggregate provenance through function arguments and conditional conditions, branches and defaults. Ten nested coalesce wrappers distinguish propagation from a shallow repair. The shared shape/value law checks generated intermediate keys and scalar values. Unchanged production rejects 35 native constraints on the selected source description; the repair passes all 33 owner checks, with all 313 declared states reached 24 times. Ignoring provenance restores the native constraint failures. Transpiled builder JavaScript is unchanged. This repairs `gt(count(row.id), 0)`, wrapped coalesce and the other admitted inferred forms. Explicit widening to `BasicExpression` and the existing six-or-more-pair `caseWhen` any fallback erase input facts and remain outside this inference claim. The owner needs generated explicit-erasure contracts before promising recovery of those facts. No runtime key loss is accepted. See the [high-review evidence](oracle-reviews/2026-11-05-boundary-only-high-review.md). Chunk 24 extends this same owner with `virtual-row-fields-receiver-types-oracle.ts` and the native compiler support `virtual-row-fields-receiver-types-support.ts`. Its 34 context families cross the same 24 source descriptions: 14 recursive ordinary-selection callback paths, 16 direct/QueryRef child materializers and four positive source-row neighbors. All 816 consumers admit without diagnostics. The independent declared-shape law checks 4,608 actual callback, rest, parent, query-output, Collection/get, inline and published-facade markers. All 6,240 syntax/admission/marker reach states execute once. The callback input retains required ordinary routeGroup until real rest destructuring removes it; nested ordinary fields named like virtual fields keep their declared types. Unchanged production has 684 intended RED receiving histories: 672 ordinary callback/parent/inline metadata leaks and 12 structured source-spread union precision losses. The other 132 receiving histories pass. The original 24 campaigns and the separate 374 strict chunk-21 callback markers remain intact. The paired source/direct-facade neighbors pass except for the recorded union spread defect. Forty-three compiler/checker/AST controls reject fabricated input metadata, lost genuine metadata, routing or nested fields, wrong optionality, modifiers, containers, absence and displaced or annotated inference markers. The finite matrix stays mandatory under partial selection and unrelated seeds; checker-only selection enters no native matrix. Independent review found that a marker moved into an ordinary map helper could observe a reconstructed clean record while the real functional input still leaked metadata. The original syntax checker accepted that source, and all type judgments passed. The shared-grammar calibration first reproduced that false green. The checker now requires the marker's arrow to be the fn.select argument, and requires a rest declaration directly in that same callback block. This static slice does not infer allocation identity or promise exact provenance for opaque source-valued callbacks or top-level reserved-name collisions. The executed equal-type direct/copy experiment records identical public callback, query, downstream-input and output types. It does not change the runtime law or weaken any existing strict ordinary-shape marker. Additional static receiving functions are compiled, not invoked; runtime callback execution stays with the existing metadata input owner. No production repair or closure is claimed. Unchanged production fails the nullable whole-row facade comparison in each of the 24 descriptions: its type loses the empty-row alternative and presents ordinary fields as required. The metadata runtime owner receives that law with a legal correlated include, initially matched or unmatched, then two match transitions. Empty facade rows have required output metadata; inline empty values remain empty. That runtime path passes. Production type repair is explicitly deferred until all RC oracle chunks finish. Built declaration/npm resolution and adapter Promise admission remain receiving work under the [RC challenge](oracle-reviews/2026-10-28-pr-2171-oracle-challenge.md). These source type checks do not prove runtime parsing, I/O or arbitrary publication paths. The shared-driver fairness owner now distinguishes K=1 from K=2 at the second hydrate and checks full logical persist FIFO order. Its Node and Chromium production drivers apply one comparison, `findSharedDriverFairnessLawViolations`. It checks hydrate admission and completion, public rows rebuilt from the scenario seeds, persist FIFO order, the non-preemptible running persist, and the K=1 cut at each hydrate. The K=1 reference bounds completed persists only from above, so a synthetic preempted running persist passes it and fails only the non-preemptible law. The [Chromium OPFS receiving spec](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/e2e/shared-driver-fairness-oracle.opfs.spec.ts) states no expected results of its own and adds a cold SQL read. It runs a neutral history, a held-BEGIN storm with every persist before the hydrates, and an interleaved storm with hydrates queued ahead of later persists. The persist-first scheduling fault fails both storms at the shared comparison. This closes the bounded real-OPFS handoff at logical adapter completion for those histories. It does not establish durable write order after reopen, naturally occurring contention, a browser matrix, multi-context coordination, elapsed-time latency, or unbounded eventuality. The D2 source reconciliation owner checks its helper and controlled Effect and live-query consumers. Fixed truncate/replay and cleanup→preload graph-restart cuts run on both eager-index and scan-fallback routes. Its generated histories still do not cover arbitrary graph shapes or real provider event delivery; the Electric real-provider E2E owner must supply that external premise before a cross-boundary claim. PowerSync's correctness owner reaches native local SQLite and records an SDK-delivered watcher callback after a metadata-bearing `Collection.update`; registration is wrapped for observation while delivery uses the SDK callback. The oracle checks the public and SQLite rows and the exact queued CRUD patch. Its held watcher callbacks are a controlled delivery premise, and its trailing no-op and tracked metadata-only cases enter through the public transactor with synthetic mutations rather than `Collection.update`. Neither path establishes remote backend upload or that Collection updates can construct those zero-field mutations. The Query DB nested-shape work owner checks both an all-reachable finite tree and an on-demand irrelevant-branch variant. At preload, one or three disconnected branches leave the public tree and delivered rows unchanged and cause exactly one acquisition attempt and one Query provider call per child level. Provider scans, internal index traversal, facade allocations, and elapsed time remain outside this owner; DB includes-work counts source Collection reads and delivered changes, not internal index traversal. The DB includes-work owner (`packages/db/tests/query/includes-work-counter-oracle.test.ts`) also generates an ordered parent (a page, a `findOne` with or without an `offset`, or an `orderBy` alone), optionally narrowed by `setWindow` before start and moved by it later, with `distinct`, a static parent filter by `eq` or `inArray` on the correlation field, and a static child filter on the grandchild correlation field. Its child source Collections are local or on demand; the on-demand test handler stands in for both the sync adapter and the provider. Child forms are `materialize`, a child Collection, a child `orderBy`, a child `limit`, a child `findOne`, nested includes, and limited nested includes. Histories insert, delete, and move parents, insert and delete children, and move the window, with 60 base runs per campaign; a reconstruction check requires at least three executed fixed cases for each premise, and every checkpoint asserts `getWindow()`. A `findOne` keeps its compiled limit (1, or 0 for `.limit(0).findOne()`); an ordered `findOne` has a movable window, and an unordered one is a fixed one-row result that accepts only its compiled limit at offset 0. Rows must equal a relational model. Preload may load only the children of the shown rows' groups, and a step only those of rows that entered the window and were not shown before it. A static filter creates static child demand before the query runs only when no enclosing query is windowed or a `findOne`, and either the query is neither windowed nor a `findOne`, or it is a `findOne` that shows one row for one named correlation value, with no `offset`, and offset 0 at start if a window was requested before start. Fixed histories show each case the rule closes: a window requested before start (12 child rows for a bound of 2 before the rule), grandchild demand below a windowed parent, a `findOne` with `limit(0)`, and a `findOne` moved past its one named value before start; a detail page whose window before start is at offset 0 still starts its child acquisition attempt at once. A focused test requires `setWindow` to throw `SetWindowFindOneLimitError` for any other `findOne` limit and `SetWindowRequiresOrderByError` for an offset move on an unordered `findOne`. A `findOne` detail page with on-demand parent and child starts its child acquisition attempt beside its parent's. On main, a late page delivered 120 child rows for a bound of 9. Routers that add the row after the window fail the generated campaigns; routers that add every row in an edge tie group fail a fixed collapse and the detail page; a child that takes over `setWindow` fails the rows law. Focused tests require a window inside a `from` or joined subquery not to answer `setWindow`. Recorded limit (#2151): while an index-backed parent top-K refills within one graph run (a held row moved out, a tie group loaded at the window edge, a forward window move), it can briefly hold a row outside the window it shows once its ordered acquisition completes, and load that row's children; the public snapshot stays correct. A refill checkpoint is a model observation that combines an ordered acquisition and whether it completed: the parent Collection delivers more change batches than the initial load or the step's own parent write. The generated campaigns skip only its work bound. In the fixed campaign (60 runs, seed 2137), the work bound checks 285 of 290 checkpoints strictly: preload 60 of 60, parent inserts 45 of 45, parent deletes 34 of 35, rank moves 43 of 43, child inserts 36 of 36, child deletes 37 of 37, backward window moves 18 of 18, and forward window moves 12 of 16. Six fixed histories cover the known traces and allow exactly the one extra child row each shows; with no overshoot allowed, each fails. Four fixed forward moves (local and on-demand children, with and without `distinct`) allow none. Each generated campaign counts the forward moves its own runs check strictly and fails if it counts none. Open in-scope paths, all owned by this includes-work owner unless noted: refill checkpoints need the #2151 fix (holding include demand until the ordered acquisition completes) before the work bound can check them; includes inherited from a `from` subquery and inputs to `fn.select` still route from every row before the window, and need generated forms under the work bound; the edge tie group router is caught only by fixed cases, and needs a generated tie at the window edge on a checkpoint without a refill; a child compile error after the parent's `orderBy` still leaves the parent's auto-index (owner: compiler tests), and needs a focused witness that the index does not outlive a failed compile. The same owner checks ordinary nested source payload work. Its block-count grammar (0–40, with fixed 0/1/20/40 cases) crosses fourteen paths: source, join, QueryRef, union, implicit and functional selection, direct predicates, projected QueryRef WHERE/HAVING, and correlated inline, callback, implicit, Collection and grouped HAVING paths. Each checks the full selected document and its identity at preload and two synced replacements. Both singular and batch descriptor APIs count discovery inside source payload containers, which must be zero. Each fixed/random campaign executes twelve inputs; all fourteen states must be reached inside every input: 336 path histories and 1,008 public checkpoints. This measures metadata discovery, not hashing, arbitrary user callbacks, proxy traps or elapsed latency. The prep review separates expected payload content from the object supplied to production. The shared checker independently reconstructs content from block count and tick, and separately checks source reference identity. Mutating the source's tick at the initial checkpoint falsely passed the earlier checker; the revised checker rejects that mutation on all fourteen paths in each campaign. The grammar, work budget, checkpoints and fixed/fresh run counts stay the same. See the [prep-review evidence](oracle-reviews/2026-11-05-boundary-only-prep-review.md). The [initial repair](oracle-reviews/2026-11-05-nested-row-performance.md) covered seven paths. The [policy exploration](oracle-reviews/2026-11-05-metadata-policy-exploration.md) exposed remaining QueryRef predicate and correlated scans. Those paths are now in the owner's grammar. Their unchanged-production RED reached actual public checkpoints before rejecting 2/2/6/12/6/6 scans even on empty documents. A subsequent valid grouped HAVING fixture rejected two scans before that production path changed. Compiler-owned metadata now travels outside alias values, and materialization resolves only compiled include paths. Value laws remain with the route-context, metadata-input and publication owners. Existing budgets and unrelated semantic comparisons are preserved. See the [implementation evidence](oracle-reviews/2026-11-05-boundary-only-metadata.md) for mutants, measurements and remaining limits. The ordered-lifecycle owner also crosses deletion and retargeting of the first window's join marker after that window is public but the live-query Collection is still `loading` on child demand. The next ordered page ends at null; a later unfiltered full-source request supplies the new eligible row. A finite join model checks the final public window and the net delete/insert change events, and each callback's rows must match its changes. Four more histories hold the fallback provider Promise after root 3's writes apply, then retarget marker 2 to root 2 before settling it, with pending or settled child demand. They check both public cuts, final rows, and every callback, while allowing a coherent root-3 window to publish before the second marker change. These controlled histories do not assert synchronous timing after first publication. Four neighboring histories retarget marker 2 to root 4 while that provider Promise is pending, then write root 4 only after releasing the Promise gate. The independent join model checks the final window and callbacks. The adapter observes that the cursor-page acquisition lease remains active while the full-source Promise is pending and retires after it settles; ignoring provider settlement fails at that held lease cut. Other marker actions, overlapping root-source changes, and provider rejection remain open. Real adapter delivery and an on-demand React first commit need receiving witnesses. Three Ordered acquisition companions own distinct controlled cuts: `packages/db/tests/query/load-subset-replay-refinement-oracle.test.ts` checks held replay authority and public snapshots, and its generated ordered section checks an ordered window under load failures and throwing releases; `packages/db/tests/query/load-subset-source-readiness-refinement-oracle.test.ts` checks source-generation readiness, progressive old-child retention, and retired-route publication; and `packages/db/tests/query/load-subset-transaction-refinement-oracle.test.ts` checks before, during, and after-commit abort boundaries with applied receipts. These fixtures do not establish real-provider cancellation or framework timing. The replay-refinement status driver observes initiating keyed snapshot-request receipts rather than inferring logical demand from truncate callback timing. At each history command and final convergence, terminal errors must also satisfy the independent retained-demand classification described below. Its generated histories declare and measure initiating keyed-request rejection and keyed-reacquisition failure separately. A fresh include request issued during marker truncate can fail terminally; failed reacquisition of an established include or marker request retains the last publication until recovery. The status comparison does not independently establish correct settlement of the initiating receipt. Peer scenarios retain one history-level failure allowance, so per-receiver failure isolation remains outside this comparison; the owner is this replay-refinement oracle, with a needed witness that fails one receiver's current request while comparing another receiver's status at the same checkpoint. This is a stated observation limit, not a retirement of the per-demand error-ownership law. The replay error-identity comparison keeps subscription ownership separate from the source-wide publication barrier. CI seed `1926301329`, path `251:2:1:4:2:2`, exposed a false failure: an include replay rejected while a join replay still loaded, and the comparison required the join's earlier failure instead. Adapter request data now identifies each load's subscription. Only failures and covering replacements within that subscription compete for its replay error. A 96-history finite grammar crosses root/marker replay, oldest/newest failure order, four join forms, both directions and three window widths. It measures 52 histories with multiple failures of one subscription and six with sibling failures; both require at least five. The old source-wide comparison and a production mutant that returns the last replay failure each fail the intended identity assertion. Publication, request-error, retirement, readiness and convergence comparisons and campaign budgets remain. This is a controlled Collection/live-query witness, with no provider or framework claim. Evidence and the oracle self-review are in [the callback metadata record](oracle-reviews/callback-metadata.md#replay-error-identity-ci-follow-up-2026-10-30). The ordered replay owner distinguishes replay renewal from an ordinary lazy demand created during another subscription's replay. Its adapter records the leases held at truncate, then matches subscription identity and independently evaluated key predicates once per renewed lease. New owners and different keys remain ordinary demand. Terminal-error assertions run after each history action and at convergence. Named neighbors require a new include demand's failure to be terminal and a settled joined demand's failed replay to remain nonterminal. The CI seed `-1751969525`, path `67:11:10:12:1:8:7:7`, reaches the former. The normal broad campaigns did not each reach both critical failure origins in the declared-reach audit. A second property in the same owner, `replay.subscription-demand-origin`, generates zero to three prior replays, marked-row rank moves and ordinary/renewal failure schedules. Its 75-history fixed and random campaigns must each reach new demand failing during marker replay and a settled demand's failed renewal. The adapter witnesses non-aborted failure independently of expected terminal status. A positive terminality check rejects ignored ordinary failures. Source-wide, subscription-blind and always-terminal controls also fail. Broad reach counts each of its existing seventeen required dimensions once per history. The [declared-reach audit](oracle-reviews/2026-10-22-dbclient-migration-feedback.md#audit-against-the-declared-reach-rules-from-pr-2233) records counts, exact replay coordinates, calibration and chronology limits. This projection covers the grammar's five numeric keys and one-level includes; it does not establish arbitrary predicates or provider-driven replay schedules. The ordered-work owner has a 96-cell optimistic-departure matrix over source, joined, and anti-joined filters; update and delete; Collection and Effect; acknowledgement and rollback; one- and two-row windows; and indexed and unindexed loading. Its independent installed-ID model applies one overlay, sorts, and slices. Two indexed controls install a replacement independently of index and query shape. A non-prefix witness installs rows 3 and 1 while row 2 is missing: deleting 3 must publish `[1]` immediately and then acquire 2. The six-row provider ledger includes rejected leading and irrelevant trailing rows, so useful bounded progress differs from full-source overfetch. Eight source/joined histories settle before the held provider answer; eight more mutate the joined-side marker for joined and anti-joined windows. Eight complete-local-extent histories cross ascending order, offset, a tied head, an exhausted window, and acknowledgement or rollback. Four on-demand ascending limit-one histories cross joined/anti-joined filters with acknowledgement/rollback. A rank-only acknowledgement and a combined rank-and-membership departure rollback are adjacent controls. After an acknowledged marker departure, restoring that marker must restore both rows and its Collection or Effect publication. Its held-load grammar also replays an unindexed descending joined window in which an installed null-ranked row fills the visible window beyond the settled provider prefix. After earlier deletes and held answers, the owner compares public rows with an independent full-source sort; a boundary-blind refill check leaves the next eligible filler row unseen and fails at the final checkpoint. For signalling refetches, the no-new-full-source work assertion applies to indexed numeric orders with finite ranks. Unindexed underfilled continuations and unexpressible null or NaN boundaries may use full-source recovery; the owner checks their row law but does not claim bounded transfer for them. At the immediate cut, both consumers must publish the recomputed installed-row window, even if it is short. Missing extent must start a useful finite acquisition while the mutation persists. A provider sync transaction queued behind persistence stays private until application; its publication can occur before the applied-receipt promise resolves. The oracle observes answer-before- and answer-after-settlement schedules, callback-visible rows and publication suffixes, receipt/provider state at the relevant cuts, and two later task turns. Every pending indexed acquisition must be a bounded ordered page or a single-rank boundary probe; a source-filter request must reject an ineligible row at a relevant rank. It rejects a repeated identical request without progress in the same settlement phase, a full-source request passed off as bounded refill, and a broad request after a valid refill. The request ceiling is an emergency guard, not a fixed-point proof. Effect callbacks establish membership; Collection callbacks also preserve order. The reviewed base suppressed #2169's immediate departure and gave the controlled indexed joined-delete histories no useful refill row. The current loader repair prevents optimistic overlays from being classified as authoritative source-order loss. The exact mismatch ledger is gone; all exercised histories must satisfy the model. The [#2169 review record](oracle-reviews/issue-2169-optimistic-window.md) contains the RED/GREEN evidence and scope. The Query DB `optimistic-ordered-refetch-oracle.test.ts` owner runs #2169's mutation-handler `utils.refetch()` with real QueryClient observers; restoring the old loader classification fails its immediate `[2]` checkpoint. It checks the held and settled callback-visible windows. It rejects an unordered request whose full predicate scope is not one rank, even if its capped answer has one row. #2148's exact historical provider replay is not published, although the controlled ascending joined and anti-joined limit-one path is now exercised. With #2154 integrated, the Query DB receiver also invalidates a shifted ordered page while the optimistic update persists. It requires one loaded-subset report, a bounded acquisition after that report, no retraction of the immediate `[2]` window, and final `[5, 2]` rows. Disabling the loader's report-triggered revalidation fails at the acquisition checkpoint. This fixed history does not cover every refetch shape or a second optimistic change during held repair. The installed ascending/offset/tie/exhausted witnesses do not prove those provider-refill schedules. Provider rejection, rank-only rollback and other rank-move histories, overlapping optimistic transactions, exact callback payloads, and framework render timing remain outside this controlled owner. The later Ordered acquisition table retains #2148's historical replay ownership. The core `load-subset-oracle.property.test.ts` now distinguishes each exact demand-key option through one-axis pairs; its derived-sync expected-failure guard and controlled-adapter scope remain explicit limits. The QueryRef owner checks DISTINCT support through source deletions, last-support removal, reinsertion, and person enable/disable. It checks nested and flat aggregate joins through source updates, and ordered joined `findOne()` through initial, singleton, empty, restored, and changed-join-key cuts. An unordered `findOne()` QueryRef used on either side of a join keeps one default-key row through deletion and reinsertion. The optimizer aggregate owner checks the initial public inner join of a global aggregate with accepting, rejecting, and absent outer predicates; a materialized-Collection formulation supplies matching and nonmatching controls. Other `singleResult` forms, join forms, and scheduling cuts remain outside these owners. The offline scheduler owner (`packages/offline-transactions/tests/KeyScheduler-oracle.property.test.ts`) checks FIFO eligibility and retry order at the scheduler boundary, as the `oracleProperty` `offline.key-scheduler-fifo-ledger`. Before its port the generator drew histories of at most 12 commands (fast-check's default array size) with a biased selector, so 4 of 150 histories per campaign started any transaction and 1 retried; generation now draws 1 to 50 unbiased commands, and about a quarter of histories start work and about one in fifteen retries. Histories also duplicate a pending ID, as outbox replay does, and schedule `missing`, the ID replay snapshots name without the scheduler holding it. `schedule` must return false for a duplicate (law `dedupe`, authority: TransactionExecutor uses that result to find newly loaded transactions); keeping the first record on a duplicate awaits a maintainer decision. The declared state `duplicate schedule` is the first state bound to a production probe: the model predicts which histories duplicate a pending ID, the scheduler's development-only `duplicate-schedule` probe reports which ones production rejected, and the two must agree in every history (law `reach agreement`). A constructed history fills all five slots and then duplicates one, so every campaign reaches `duplicate schedule at capacity`, which the driver records. Reach for command types comes from the commands the driver executed. It does not observe the executor's awaited outbox update between `updateTransaction` and `markFailed`, or public caller settlement. Those receiving cuts belong with `packages/offline-transactions/tests/transaction-settlement-oracle.property.test.ts`. The transaction serializer owner uses controlled Temporal constructors and fake storage; a claim about native Temporal or browser storage needs a receiving witness in those runtimes. The offline settlement owner follows the README's success boundary: the configured `mutationFn` has returned and the storage adapter has acknowledged outbox deletion. Its controlled storage histories hold and fail deletion, stop the executor and queued peers on a storage failure, reject new admission, and restart after a persisted `deletion-pending` phase. A marked row skips provider replay even when `beforeRetry` filters all ordinary pending work; an old unmarked row still replays. Adapter tests prove that IndexedDB transaction failure and localStorage `removeItem` failure reject rather than masquerade as deletion. When a caller removes an active row with `removeFromOutbox` or `clearOutbox` while its provider is held, the caller remains pending until that provider returns. The controlled witness then checks provider calls, public settlement, and the empty outbox. The leadership owner checks that an earlier `deletion-pending` row with the same persisted timestamp is deleted before its later peer reaches the provider. This restart witness uses storage insertion order to distinguish creation order; independent storage writers and native browser hosts remain outside its claim. These witnesses do not establish physical power-loss durability, a real provider's idempotency, or the crash window between provider completion and the phase write. The provider must honor the supplied idempotency key in that window. Older application versions that do not understand the phase can also replay a marked row. Native browser restart and multi-owner handoff of the marked phase remain receiving witnesses for this owner. The same owner also needs a captured failing seed-and-shrink-path replay for its generated settlement property. The [deletion-settlement review record](oracle-reviews/2026-09-30-offline-deletion-settlement.md) preserves its earlier executable revision. The [fail-stop follow-up](oracle-reviews/2026-09-30-offline-fail-stop-followup.md) records the revised storage-failure law, RED/GREEN witnesses, and limits. The guarded replay owner (`packages/db/tests/oracle-replay.test.ts`) now checks that named pagination and index campaigns execute only the requested replay campaign. An unrelated failing fixed campaign no longer runs first. The [prep-PR review record](oracle-reviews/2026-09-30-prep-pr-followup.md) records these four review repairs at their exact executable revision. ### Recent fix-wave authority inventory This inventory records the permanent authority for the September 17 fix wave. It distinguishes an executable oracle from a specialized real-provider authority and does not award oracle credit for a filename alone. | PR | Classification | Permanent authority and campaign | | ------------------------------------------------- | ----------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [#1831](https://github.com/TanStack/db/pull/1831) | Fixed tests; no oracle owner (tracked in #2264) | PowerSync's `packages/powersync-db-collection/tests/correctness.test.ts` (fixed tests; no oracle owner (tracked in #2264)) crosses real PowerSync receipts and native SQLite behavior. It runs in the package test campaign; portable declarations retain compiler authority. | | [#1832](https://github.com/TanStack/db/pull/1832) | Equivalent specialized authority | `packages/electric-db-collection/e2e/sql-predicate-semantics-oracle.e2e.test.ts` and `packages/electric-db-collection/e2e/subset-sql-acceptance.e2e.test.ts` run through the package's real-provider `test:e2e` campaign. Compiler unit tests are collateral, not substitutes for either service boundary. | | [#1833](https://github.com/TanStack/db/pull/1833) | Explicit oracle | `packages/db/tests/query/pagination-oracle.property.test.ts` owns inherited collection collation, actual `item2`/`item10` order, exact request options, mutant lexical/numeric controls, and both scan and auto-index paths. It runs in `@tanstack/db`'s `test:oracles` campaign. | | [#1834](https://github.com/TanStack/db/pull/1834) | Explicit oracle | `packages/db/tests/query/cold-join-reconciliation-oracle.test.ts` owns join/predicate equality equivalence across the established value domains, binary/string and nullish controls, replacement histories, raw lazy demand, and scan/auto-index paths. It runs in `@tanstack/db`'s `test:oracles` campaign. | | [#1835](https://github.com/TanStack/db/pull/1835) | Explicit oracle | The existing `packages/db/tests/collection-state-retention-oracle.property.test.ts` and `packages/db/tests/optimistic-transaction-oracle.property.test.ts` owners cover separate collection-state and transaction-history laws. Both were already registered in `@tanstack/db`'s `test:oracles` campaign; focused storage/local-only tests remain collateral. | | [#1837](https://github.com/TanStack/db/pull/1837) | Explicit oracle | The offline scheduler, leadership replay, and serializer owners cover selective replay retirement, durable per-ID settlement, stale-read fencing, lifecycle recovery, native scalar encoding, and prior wire compatibility. They run in the package test campaign. Every generated campaign in these owners uses the shared `TANSTACK_DB_ORACLE_{SEED,PATH,PROPERTY}` replay interface, with one property per campaign (`offline.fifo-retry`, `offline.leadership.*`, `offline.serializer.*`, `offline.settlement.*`). | | [#1842](https://github.com/TanStack/db/pull/1842) | No shipped-law case | The PR changed only focused observer tests and introduced no production behavior. `packages/db/tests/live-query-observer.test.ts` remains the correct evidence; no synthetic oracle or campaign claim is added. | [PR #1816](https://github.com/TanStack/db/pull/1816) preserves existing witnesses, repairs false-green assertions and drivers, adds missing histories, and includes narrow runtime fixes reproduced by the stronger tests. The later ten-area audit found 59 actionable findings or optional suggestions: 46 repaired, one partly repaired storage item, nine contract decisions, and three deferred suggestions. These are **not counts of production bugs**. The earlier 13-item review is a separate ledger, not another 13 unique defects. ## Find an owner Paths below are relative to the repository root. Follow each suite's domain comment and the current API/architecture contract before extending its model. For paced mutations, `packages/db/tests/paced-mutations-oracle.test.ts` owns core strategy timing, admission, cleanup, and settlement. It does not cross a framework render boundary. The React receiving owner is `packages/react-db/tests/usePacedMutations-render-cuts-oracle.test.tsx`. Its independent model selects the committed callback owner when a transaction is admitted. The bounded grammar calls before and after a candidate render, releases a suspended render to commit, and calls from a descendant layout effect with delayed or immediate persistence, with and without StrictMode. It compares ordered callback traces and public Collection rows at the mutation cut, the trace after persistence, and mutate identity at the commit cut. It does not establish callback affinity across a commit between transaction admission and persistence, server delivery, arbitrary React schedules, or behavior in another framework. The [PR 2170 review](oracle-reviews/pr-2170-react-paced-render-cuts.md) records the render-time and layout-effect mutant kills. For standalone descriptor queries, the primary owner is `packages/react-db/tests/descriptor-query-binding-oracle.test.tsx`. It checks one prebuilt Query with a reusable factory descriptor under two DbProvider clients. Disjoint-key inserts and same-key updates with different client values are compared against plain per-client maps after initial publication, each write, and a mounted A→B→A provider switch. It checks the public `$key` against each projected row ID, exact public key sets, and identity equality with direct Collection formulations. The same owner crosses join, nested FROM, union, and include placements of two standalone descriptors under two clients with equal row keys and different values. Complete selected rows are compared with plain per-client values after initial publication, a child write in the first client, and a parent write in the second. A first-client-only binding mutation fails at the second client's initial public-row assertion. This finite matrix does not observe on-demand requests or arbitrary write interleavings. The receiving include also crosses shadowed and renamed child aliases while projecting a captured parent value. It compares both clients' public rows at the same three cuts. An alias-only parent lookup fails the shadowed initial row while the renamed control passes. Dropping binding IDs during descriptor materialization fails the bound-versus-unbound public hash comparison in both alias forms. More include depths remain outside this cell. The receiving outer-join history crosses RIGHT/FULL, correlation on the main or joined source, shadowed/renamed aliases, eager/on-demand sources, and two clients with equal keys and different values. Plain per-client maps predict complete public rows after initial acquisition and five source writes, including an absent main side, an absent joined side, and return of the main side. It also checks each client's source starts, on-demand requests, and descriptor-binding hash. An absent-main join-route mutant fails the public-row check at initial acquisition. Multi-join receiving histories and arbitrary write interleavings remain outside this finite matrix; the core alias owner covers its own bounded multi-join grammar. The same owner also checks a prebuilt Query consumed by `useLiveQueryEffect`: two clients with the same row key report their own initial enter events, and one mounted Effect reports the new client's row after a provider switch. After that switch, an old-provider write produces no update event and a new-provider write produces one. The event-history check rejects an Effect that retains the old subscription. It checks that a descriptor Collection first acquired by a committed Effect appears in `DbClient.dehydrate()` after the first enter event. A separate same-hash transition from a concrete query to an unbound descriptor query checks that the hook reports the missing client before reusing prior rows. The same React owner checks that a descriptor render suspended before commit starts no source work. Its finite 24-cell grammar crosses later reader intent, startSync true/false and eager/on-demand sources. Ordinary subscription admission also crosses no cleanup, loading callback cleanup, ready callback cleanup, and held ready cleanup. Preload and deferring readers retain no-cleanup controls. The shared independent judgment in `collection-subscription-lifecycle-grammar-oracle.ts` predicts adapter entries and the complete public status trace at admission return and cleanup settlement. A second ordinary subscriber reuses a live run or restarts a retired source. Public rows without cleanup distinguish on-demand source preload, which does not acquire rows, from ordinary subscriptions. The core lifecycle owner adds 24 cases crossing the four cleanup histories, no/unrequested/requested start gates and eager/on-demand modes. The erroneous release-before-request repair fails four core and four React cells at admission return. The final expanded React grammar also rejects the original no-release implementation. Historical calibration of a previously-requested-start mutant predates the final call reorder and is not evidence against that mutant on the current path. This does not establish arbitrary concurrent-render schedules, failed-provider histories, or Electric txid delivery. The [migration feedback review](oracle-reviews/2026-10-22-dbclient-migration-feedback.md) records the SSR admission repair. The maintainer chose a programming-error rejection when an ordinary server hook reads incidental rows or readiness that its first browser render cannot reproduce. Cold/loading SSR remains legal. `packages/db/tests/ssr-snapshot-admission-oracle.ts` owns the independent preparation judgment and history grammar. The descriptor owner drives React's ordinary and infinite hooks independently. The Svelte server driver is `packages/svelte-db/tests/ssr-snapshot-admission-oracle.svelte.test.ts`. Each compares rejection, projected rows and status before browser commit across no preparation, completed or pending query preload, and normalized source transport, including ready-empty and partial-loading sources. Render-time query captures carry their own readiness; normalized source rows alone remain provisional. React also runs real `hydrateRoot`, observes recoverable errors, and checks the committed browser result. Svelte's actual server-to-browser driver is `packages/svelte-db/tests/ssr-snapshot-handoff-oracle.svelte.test.ts`: it loads a server-compiled fixture and calls browser-compiled native `hydrate` or `mount`. Its first hook rows/status before effects and later authoritative browser view are compared with the shared judgment. Histories cross zero through three rows, same/different browser rows, zero through two earlier authoritative readers, first/late hydration, fresh mount and a child created after provider mount. Each independently hydrated root supplies `DbProvider hydrating`; nested same-client providers inherit that host fact unless explicitly overridden. An inherited marker must preserve the late reader's server view, while a fresh mount or later child must read live rows. Always using the server getter, keeping the marker after mount, and ignoring it each fail a receiving comparison. Both React and Svelte cross writes after server render and before browser hydration, including a completed same-query browser preload. The older Svelte server-only owner proves server reconstruction only; its second render is not browser evidence. `hydration.svelte.test.ts` separately receives normalized transport and normal warm-browser initialization through its native scheduler. The [React SSR diagnostic receiver](../../packages/react-db/tests/ssr-effects-oracle.test.ts) extends that preparation grammar and judgment with real matched React/ReactDOM 18.3.1 and 19.3.1 development server renderers. Separate paths cover provider and explicit-client ordinary hooks, completed non-streaming Suspense through both client forms, standalone builders and supplied Collections. A disabled input replays the same diagnostic comparison. Each checks return and the raw React client-layout diagnostic after server render and cleanup; ordinary descriptor paths also compare admission, selected rows and status, while prepared Suspense compares rows. Standalone/supplied paths make no hydration claim. Fixed/fresh campaigns retain per-runtime/path reach and direct replay; this does not establish streaming Suspense, actual browser hydration, arbitrary provider delivery or every React version. Client commit and abandonment remain with the window receiving owner. [SSR effect evidence](oracle-reviews/2026-10-30-react-ssr-effects.md) records pre-edit RED, repaired GREEN and mutant rejection. The shared admission owner also defines runtime ready/error outcomes, browser explicit preparation and defined/undefined causes. Its receiving drivers are `packages/react-db/tests/ssr-runtime-error-handoff-oracle.test.tsx` and `packages/svelte-db/tests/ssr-runtime-error-oracle.svelte.test.ts`. React drives ordinary and infinite hooks independently through `renderToString`, JSON and `hydrateRoot`; Svelte uses the server/browser compilation and native host above. Each checks every public lifecycle flag at the actual first hook view and the committed browser view: the transported initial error/ready view is reproduced, then browser error/ready becomes authoritative. The React driver also checks that an error snapshot cannot fulfill a later explicit data preload. Runtime `fail()` remains a returned error result; the explicit failed preload must reject. These empty-source histories do not establish arbitrary error-detail serialization, error identity or post-error row retention. Real React streaming checks cold and warm Suspense discovery, opaque keyed/unkeyed logic, and prepared non-streaming Suspense. Under the shared React identity law, unkeyed opaque queries reject with `UnhashableQueryIRError` during preparation, before stream admission. Both cold and warm receiving cases check that class; keyed controls still render and transport their rows. Infinite identity checks callback-returned Collections and explicit keys with matching and unbounded windows across builder, direct Collection and callback-returned Collection inputs. The latter callback path is JavaScript runtime coverage; it has no TypeScript overload. The React mixed-reader streaming owner crosses zero through three rows and microtask source publications before preload settlement. Histories place an ordinary hook before or after a Suspense sibling, or omit it, with source readiness synchronous or held until the ordinary server read. Held histories distinguish Suspense registration before the ordinary loading capture from ordinary-first discovery. An empty-source failure outcome makes that later stream reject after the ordinary loading view was rendered; rejected Suspense supplies a fallback, not a successful hook view. Real React hydration receives JSON-copied snapshots and streamed promises from the real Router adapter under its controlled SSR callback. It compares each hook's first browser view with its own server view, even when local browser rows differ. `packages/db/tests/ssr-stream-view-oracle.ts` owns this shared metamorphic comparison over independently recorded ordered row names and status; a missing browser observation fails. Mandatory reach distinguishes both reader orders, Suspense alone, same/different browser rows, synchronous/held readiness and held source failure. It crosses async hydration with a synchronous React act cut that permits ordinary commit before Suspense hydration, while transported promises can still be pending. Both schedules must preserve each reader's first projected rows and readiness, including an ordinary loading view whose sibling stream later failed. Emitting an update without a newer transport revision and prioritizing that later error over the ordinary initial snapshot fail the respective first-view comparisons. The Router's focused receiving test separately checks replacement delivery after an initial loading record. `examples/react/start-ssr-e2e/e2e/router-stream-view.spec.ts` receives the same law through the real Router serializer and HTML transform (`attachRouterServerSsrUtils`/`renderRouterToStream`), manifest-driven `Scripts`, `RouterClient`/`hydrateRoot` and Chromium. Its mini HTTP host holds the first DB record and every later byte until a browser hook attempts hydration, preserving byte order after the async entry and completed shell. Thirteen finite cases cross initial-shell/later-boundary discovery, ordinary reader order, zero/one row, same/different browser rows, and delayed first-record arrival. A completed same-query browser preload with a newer local timestamp cannot replace the older server view owed to hydration. Missing-record normal close and transport failure report the exact Error Boundary cause without a successful browser substitution or new adapter work after termination. A known pending result remains pending across DB record-stream close and explicit local Collection preload until the held server provider is released. Original no-wait and close-known-pending designs fail these host comparisons. Waiting forbids a successful substituted view before the server record; it does not prohibit valid Suspense prefetch. The core receiving driver `packages/db/tests/ssr-stream-record-wait-oracle.test.ts` adds paired generated histories for missing, pending and explicitly preloaded local records, arrival, normal close, transport error or cleanup, unrelated peer records, first attempts after termination, and defined/undefined causes. The shared stream-view owner supplies its independent lifetime judgment. Promise settlement/identity and public observer retry cuts check that only the requested server record settles a wait, known pending results survive normal record-stream close, and terminal missing records cannot become local success or start new adapter work. This later dimension coverage follows the original host RED gate. Histories also cross public client cleanup, rematerialization and a new stream for the same hash. Old wait promises remain settled, a new stream obtains a fresh wait, and enabling the same open stream preserves its current pending demand. The sticky failure implementation and an unconditional reset each fail the corresponding checkpoint. Pending-result disposal during client cleanup and timestamp policy after record consumption are excluded from this grammar. The [SSR review audit](oracle-reviews/2026-10-23-ssr-review.md) records RED on unchanged production, GREEN, narrow mutants, and exact receiving replays. The consumer bundle owner `scripts/ssr-bundle-oracle.mjs` checks the maintainer's 2026-10-26 SSR isolation decision at the current DbClient import boundary. It enumerates ordinary, Suspense, and infinite React hook exports, with and without DbClient. Final production bundles must exclude the entire observer transport module and its admission/capture operations without DbClient; positive controls must retain them. `pnpm test:ssr-bundle` runs after built artifacts in the minified-DB CI lane. The original shared observer fails the absence assertion; `--calibrate` forces transport into a plain bundle and fails that same assertion. The package aliases and pre-bundle artifact freshness checks share one list: DB, DB IVM and React DB, including TypeScript and TSX source inputs. Stale React and IVM controls passed the former standalone command, then fail its named freshness guard after correction; current output still passes all six consumer programs. The inputs are built ESM; esbuild minifies the final consumer bundle. Freshness compares source/config timestamps with the package entry, not content-addressed provenance or manually falsified timestamps. This finite build oracle does not establish every bundler, framework entry, byte budget, or runtime hydration schedule. A client-only application that uses DbClient still ships its transport methods: isolating that case needs an explicit SSR API boundary and remains outside this import-level guarantee. The [isolation record](oracle-reviews/2026-10-26-ssr-bundle-isolation.md) records the size comparison, runtime checks, and calibration. The separate `live-query-observer-snapshot-oracle.property.test.ts` owner checks unchanged getter identity with and without a completed DbClient query. It runs ordered/single-result and attached/detached histories through ordinary and server getters. It does not model provisional hydration replacement or host scheduling. Its `live-query-observer.row-container-sharing` lane also checks the maintainer's 2026-11-01 metadata-sharing contract: loading-to-ready and health-only changes keep data/Map references, while value writes replace them and retained snapshots keep their old rows. Fixed and random histories cross subscribe/unsubscribe transitions in granular/wholesale mode, zero through three rows, and data-first/state-first reads. Equal-content source writes can replace virtual row wrappers without advancing the row revision. The lane crosses that refresh with attachment and metadata, and checks full-snapshot identity after actions that change no public fact. Each campaign runs 24 shared examples and 40 generated histories. Nonempty attach, detach, and reattach have declared reach in each mode, including reach from fixed examples. Each history begins with readiness before health reports; only writes change the independent key/version model. A failure-list model checks fresh metadata and counts health-only transitions independently. Readiness-only histories cannot satisfy that reach. The original fresh-container implementation, same-cardinality reuse, and unconditional entry replacement on attachment fail the shared comparison. Equal-revision wrapper comparison also fails; always cloning the full snapshot survives the old sharing lane but fails its added no-op assertion. The same owner's `live-query-observer.capture-paths` property uses modelRows and checkRead through an additional real-query driver. Versions and source ranks independently predict ordered projection/findOne rows. Each fixed/random campaign runs 16 shared examples and 40 generated histories, with two or three rows and up to twelve generated actions. Histories cross initial attachment, provisional hydration-seed handoff, equal writes, value writes, rank-only moves, metadata and ownership actions. Declared reach distinguishes both observer modes, both query shapes, initial attachment, both hydrated shapes, metadata for every shape/mode, and attached/detached layout-only moves in both modes. Discarded delivery deferrals add value and layout captures inside one or two nested holds, followed by a second committed change with no intervening read. Reach distinguishes each discarded change/mode/reattachment path and nesting. The row clock stays monotonic across discard. Restoring an unpublished layout clock advances that row clock, so its numeric reuse cannot retain stale rows. The observer constructor rejects absent or non-finite row/layout clocks before client binding, row enumeration, subscriptions, or sync activation. Ordinary invariant witnesses cover each invalid clock, while the real Collection and pooled owners retain positive receiving evidence. This is rejection of a contradictory collaborator, not cross-copy compatibility or per-value instance tracking. The prior synthetic clockless input had no supported Collection API authority; it is replaced by real initial attachment without lowering either 40-run campaign or its 16 fixed examples. The ordinary synthetic Collection test now uses an actual Collection and retains its freshness/retention assertions. Checks after queued query publication compare rows, container identity, full snapshot no-ops, layoutRevision, health freshness and retained seed/live views. A narrow repair that trusts only the row clock fails the order-only comparison. The same owner's `live-query-observer.record-shape` receiving lane enforces the maintainer's 2026-11-03 decision: equal-content plain/class/null-prototype record replacements publish updates; fresh equal values with the same prototype do not. A shape-name/number model is independent of production equality. Each campaign runs 16 shared examples plus 40 generated histories through both direct Collections and projected live queries. Records, arrays, Map values and Set members carry the nested record; granular and wholesale modes cross ownership, metadata, replacement and refresh actions. Every checkpoint checks data/state shape and values, a granular mirror when attached, container sharing, and retained snapshots. Each receiving path has declared reach. The utility equality owner agrees with this approved record-shape distinction; draft reconstruction keeps its separate class/plain equivalence, and built-in/typed-array comparison policies remain unchanged. Original equality fails both receiving comparisons. This lane does not cover arbitrary built-in subclasses, descriptors, cyclic payloads, optimistic draft assignments, or framework/provider scheduling. The guarded replay manifest selects each property's random campaign directly. Cleanup/reset may discard a row revision and is outside its sharing law. Existing hydration and observer/layout witnesses retain their scopes. These core-only lanes add no new framework scheduling promise. The independent Angular PR projects observer row-state identity before copying its Map; combined integration evidence is recorded separately from either branch's standalone validation. The [row-container evidence](oracle-reviews/2026-11-01-observer-row-containers.md) records RED/GREEN, declared reach, mutant rejection, size, and limits. Focused snapshot checks protect lazy state, one admission walk for an unchanged revision, explicit preload after a loading capture, JSON-compatible non-streaming transport, and pending-stream ownership. The observer history owner generates throwing releases followed by explicit retries, in both modes and with thrown undefined. This last premise is a controlled synchronous channel release; first-party event listeners report their failures asynchronously. Its hydration error-timing grammar also crosses error before attachment versus after subscribe returns, granular/wholesale mode, all three portable seed statuses, and defined/undefined causes. The first pre-attachment hydration read must retain its server view; an owned provider error after subscription must publish error and notify synchronously. Always deferring error handoff fails the latter cut; original local-error precedence fails the former. This distinguishes initial hydration from ordinary owned runtime publication. Limits: admission/runtime sources are synchronous and eager with zero through three rows; the mixed-reader driver additionally holds readiness/failure. Infinite receiving coverage uses a one-row initial page and its peek-ahead row. Arbitrary asynchronous providers, later page-shape changes during a pending hydration stream, persistence readiness, arbitrary concurrent-root hydration schedules and custom dehydration filters remain open for these receiving owners. The Router/Chromium witness covers its finite serializer/HTML/script path, not a deployed Start application, Electric delivery, every React renderer or every host schedule. The React mixed-reader owner still needs a partial nonempty loading snapshot followed by failure; its failed-source histories are empty. The Svelte owners do not cover a pending streamed boundary, deferred source throws, arbitrary asynchronous providers, error-detail identity or post-error row retention. Manual multiple hydration epochs remain unspecified: Core-SC04 asks whether an older record arriving after active-record consumption may replace a newer retained server record. The shared stream-view and DbClient owners need an explicit ordering contract before adding consumed/unconsumed and older/equal/newer record histories. Neither local-versus-transported version coverage nor normal Router byte order resolves that question. Transport deliberately discarding required state and rendering local Collection object identity are outside the portable snapshot law. The Date descriptor typing report remains an evidence gap. The reliable strict compiler probe accepts the reported Date forms. The receiving owners are `packages/db/tests/db-client.test-d.ts` and `packages/electric-db-collection/tests/electric.test-d.ts`; extending them needs the failing application assignment and its resolved dependency versions. Its no-client diagnostic also covers explicit `queryKey` and legacy dependency identity for both `useLiveQuery` and `useLiveSuspenseQuery` at first consumption. A local hook-first SSR stream over a concrete source rejects a later same-hash descriptor preload over a different source; the same source is accepted. A hydration-first stream has no server Collection objects in its payload. The first committed browser hook claims its local source objects for the hash before source readiness; a later conflicting preload rejects, and the public row changes from the server result to the browser result after readiness. Removing the hook's attach claim fails the conflict assertion while readiness is held. A pending hydrated stream also has a Suspense receiving cut: its uncommitted read preloads the first local source, so that source may start and claim the hash before React commits. A later same-source preload succeeds while a different same-hash source rejects. A mutant that skips the Suspense preload claim fails at the conflict assertion. This differs from an ordinary hook render with no explicit preload demand. This owner does not claim that a failed Svelte effect can recover in place after a reactive query replacement. `packages/db/tests/db-client.test.ts` supplies a focused nested-query preload witness across two clients, including equal query hashes and distinct dehydrated rows. `packages/db/tests/db-client-preload-identity.test.ts` (fixed tests; no oracle owner (tracked in #2264)) covers the bounded same-hash preload law within one DbClient: the second local preload reuses a result only when its source Collection objects are the same at each query position. Concrete then descriptor, descriptor then concrete, and two concrete same-ID sources must reject a conflicting second request without changing the first dehydrated row; a same-ID pair swapped between union branches also rejects. A descriptor and its own materialized Collection may reuse it. For a hydrated hash, the first local preload claims ordered source-object identity; a later conflicting preload rejects for settled and pending streams. A newer hydration chunk keeps that claim. If the earlier local stream instead fails, a newer settled or pending hydrated result starts without its source claim. A healthy observer using a different same-ID source then attaches and reads its own row. The old preload entry cannot claim the new stream. Different explicit query keys, concurrent first local claims, and other failure/hydration orders remain outside this finite history. Observer preload checks that an active settled graph or pooled stream, and a pending hydrated graph stream, reject a different same-hash source through the returned Promise without a synchronous throw. Same-source pooled preload is the neighboring success case. A controlled reentrant registration collision also checks that a discarded stream Promise's later rejection has an observer; it does not claim that an official adapter currently makes this reentrant call. An ordinary observer's first subscription also checks an active stream claim before retaining its listener. With equal hashes, same-source attachment and public row read succeed; a different-source attempt and its retry both reject while the first stream remains active. A failed first attach leaving a retained listener fails the retry assertion. After the first observer's live result becomes authoritative, public dehydration omits the consumed client stream. The next observer may then attach with the same or a different source object under the same hash and reads its own row; the earlier preload entry cannot extend the consumed stream's source claim. Other attach failures and concurrent subscription orders remain outside this control. An adapter observer over a pooled view crosses the same-source and different- source cases for an existing stream hash. The former completes its own preload and reads the first source; the latter rejects before borrowing the first stream. Pooled views have no query Collection config, so this receiving path needs a separate source-identity witness. Historical baseline at `858b174a6` (superseded by the chunk entry below): The local live-query cache option owner is `packages/db/tests/live-query-cache-options-oracle.ts`, with core DbClient and React receiving drivers in the adjacent `.test.ts` and `packages/react-db/tests/cache-options-oracle.test.tsx`. The maintainer-approved law rejects different getKey/schema references from independent same-identity callers while retaining inline options within a mounted binding. The finite core grammar crosses each/both options, same/different references, distinct-key controls, derived/keyed identities, pending/settled result reuse and explicit preload/observer preload/subscription admission (144 cases). React supplies 24 real-host initial-render cases. The existing source-ID owner continues to judge rerender retention. This option owner does not claim arbitrary SSR transport schedules, every framework or semantic equivalence of distinct functions. Hydration carries no function references; only local consumers claim them. The [RC oracle challenge](oracle-reviews/2026-10-28-pr-2171-oracle-challenge.md) demonstrates two open gaps in this option owner at `858b174a6`: a guard that rejects only when every configured option differs passes all 144 cases, as does a guard that overwrites the original claim immediately before rejecting. Temporary independent-option and repeated-admission comparisons reject those mutants with 12 and 24 assertion failures respectively; unchanged production passes both comparisons. The checked-in grammar still couples changed options when both are present and compares admission without subsequent reuse. Its pending-result cell does not hold provider delivery, and its first caller is always explicit preload. The same owner needs independent option presence and reference histories, post-rejection observations, and option-specific hydration/consumption/failure histories. The report assigns host receiving, release, type, and harness improvements separately. None of these proposals is new checked-in coverage. The follow-up [review coverage matrix](oracle-reviews/2026-10-28-pr-2171-review-coverage-matrix.md) records current failures at the same head. Cached `getServerSnapshot()` accepts conflicting options before subscription; the shared admission comparison fails three conflict histories in core and the same three through actual React `renderToString`, with compatible controls passing. A newer hydration that replaces a locally preloaded record loses its row-option claim; all three conflict histories fail after the replacement is positively observed. These are open product defects, not merely proposed coverage. This cache owner needs the SSR receiving path (O16) and replacement-claim histories (O04), followed by production repair and GREEN/calibration evidence. Portable transport must still carry no function references. Temporary probes are not checked-in coverage. The [chunk implementation record](oracle-reviews/2026-10-28-pr-2171-oracle-chunks.md) now records the reviewed option extension on unchanged production. The shared owner crosses independent reference/presence pairs with explicit/default keys; its core driver runs 1,440 histories over five admission paths and actual held write delivery. It checks two admissions, original reuse, every next callback, exact ordinary values/keys, and refused-listener silence. React receives 288 histories through real mounted hooks and server rendering; all 144 client histories also compare after React's cached-seed handoff. Independent key functions make lost original behavior observable. Declared reach distinguishes single-option/both conflicts, added/removed declarations and distinct keys per path. Core has 192 admission assertion failures (64 settled SSR, 128 newer hydration replacement), React has 64 SSR failures; neighboring histories and checker/cleanup calibrations pass. These remain open product defects: the maintainer explicitly defers production repair until all oracle chunks finish. This historical chunk left first-registrant variation, transport serialization, first local claim after hydration and failure/consumption retirement pending; the following entries supply their later evidence. Other applicable frameworks and schema transformations remain limited. This extension does not establish hydrateRoot or arbitrary concurrent rendering schedules. The same chunk record now adds `live-query-cache-lifecycle-oracle.test.ts`: 2,160 legal timelines through preload, observer preload and server-first local claims over actual JSON-round-tripped server data. Pending delivery, replacement before/after transport, exact rejection on initial failure, consumed results and fresh declaration reuse have phase/schedule-specific conflict reach. Equivalent server/local behavior has independent function refs. On unchanged production, 640 admission assertions fail and 1,526 tests pass, including six controls. Failures remain open until the deferred production repair. The shared immutable bound-options checker now receives Preact's six native histories as well as React's 12; six mutant in-place mutations are rejected. The Preact receiver now registers these six exhaustive cases as `preact.bound-options` through `oracleProperty`. It snapshots Collection/getKey/schema reference relations and keeps the shared binding judgment, three rerenders, source publication, replacement keys and all six in-place-replacement calibrations. Each case requires every original observation cut and its recorded reach states; the finite command also checks determinism and takes no seed/path coordinates. Svelte's actual client-backed effect receives all 144 cached-option histories. All three native selectors pass. Portable first claims/failure/consumption are no longer merely proposed coverage. Remaining cache limits at that chunk were first registration without an existing stream, arbitrary transport schedules, schema transforms and native partial-construction cleanup. Svelte SSR/hydrateRoot/continuing publications are not supplied by its browser admission receiver. Chunk 12 adds first registration without a transported query result. Core runs 4,320 histories: explicit preload, streaming observer preload and server read as first claimant, each received through all five admission paths with held or settled source delivery. Each of the 15 routes reaches 288 first registrations and 144 held deliveries. The actual React streaming server driver in `packages/react-db/tests/cache-first-registration-oracle.test.tsx` receives 1,152 histories through ordinary/Suspense first reads and preload/server second callers. It supplies no hydration seed or Router result. It checks every render error, repeated admission, compatible reuse, then core observer continuation. Core has 640 intended admission failures and 3,750 passes; the new React driver has 192 intended failures and 960 passes. Flat source rows are copied away from expected facts in all five cache drivers. A corruption mutant now fails the ordinary-row comparison, rather than changing both sides. Omitting observer registration options adds 448 core and 128 React assertion failures. Held conflicting preload admission is observed before source delivery at a host-task cut; a pending promise fails promptly and cleanup releases the provider. Independent reviews and exact evidence are in the chunk record. Production is unchanged. Schema transformations, Router transport, hydrateRoot, arbitrary concurrent schedules and other framework first-registration receivers remain outside this bounded evidence. Native partial-construction evidence is recorded separately in chunk 11. `packages/db/tests/live-query-deferred-acquisition-oracle.test.ts` also checks a two-source descriptor union when the first sync start fails: the second source still starts and reaches ready on direct preload, and a preparation error stays primary if a deferred source also throws during release. The controlled sources start synchronously. At the synchronous preload error cut, even a caller that opts to stream pending queries cannot dehydrate the failed query; a later same-hash preload over a healthy replacement publishes its own row. Asynchronous failure is also exercised with a later controlled `markError`: the pending stream rejects and disappears from dehydration, the peer source is ready, and a healthy same-hash replacement publishes its row. A mutant that dehydrates errored records fails at that cut. Other asynchronous schedules and larger source sets remain open. Retrying the same options after the source entered terminal error reports that source error instead of reusing the failed query's pending stream; it does not restart the source. A replacement observer subscribed after the controlled asynchronous failure can attach under the same hash and reads the healthy replacement row as ready, without a stale stream error, before a new client preload. The prior source-mismatch check fails that attachment assertion. The same history rejects a different-source preload while its original stream is still pending. A second fixed history crosses a synchronous source throw and then attaches a healthy replacement observer before a new client preload; its settled snapshot contains only the replacement row. Removing the failed-record source-claim guard fails that observer attachment, while ignoring every existing stream's claim fails the pending-stream rejection. The preload-identity owner also checks active streams. These histories do not enumerate concurrent replacement observers, other failure schedules, or later conflicting preloads while an observer has no reusable client stream. An observer preload over a config-free pooled view is also explicit demand: it starts an idle eager source once, does not restart a running source, and reaches a ready public snapshot in both cases, with or without an SSR cleanup client. This bounded witness does not claim the same path for on-demand or asynchronous sources. `packages/svelte-db/tests/descriptor-query-release.svelte.test.ts` (fixed tests; no oracle owner (tracked in #2264)) checks Svelte's two-source release after a first startup error and a direct reader after a second descriptor factory fails. It observes source start counts, ready status, and failed-hook subscription release. A fresh effect root after the failed root is retired consumes an independent healthy query and its row. A controlled Svelte runtime probe showed that an uncaught effect error does not rerun the same effect when its reactive query changes; in-place recovery after that error is not promised. This owner does not establish two-client Svelte provider binding or ordinary reactive query replacement. Concrete- config descriptors, on-demand acquisition, and those Svelte paths remain open for this binding law; a receiving oracle needs the relevant public observation for each. Vue, Solid, and Angular have no DbClient descriptor-binding contract in this work. Their query callers use concrete Collections. `packages/db/tests/live-query-options.test.ts` checks that a client-aware consumer binds nested, union-branch, and include-child descriptors during final preparation. Construction retains descriptor refs in those positions, including direct, nested, materialized, and conditional includes. A prepared builder is a bound snapshot; a later descriptor join remains unbound until another client-aware consumption. The focused core tests check source materialization and sync starts before and after release of a render deferral set, plus the missing-client error for direct consumption. The React descriptor oracle checks public rows after a committed hook consumes such a continuation and zero source starts when a render containing one never commits. These bounded checks do not compare union or include rows under separate clients, or concurrent render schedules. The original standalone Query remains the reusable two-client plan; rebinding a previously prepared snapshot to a different client is not claimed. `packages/db/tests/query/collection-ref-compatibility.test.ts` fixes the exported `IR.CollectionRef` shape for concrete Collections: `collection` is an enumerable, writable own field that a spread copies. It also checks that an unbound descriptor uses `IR.DescriptorRef` with no `collection` field. A bounded source-position matrix checks collection, nested query, union, join, and include IR traversal and conversion to concrete refs during placement cloning. This focused shape test does not establish public rows for those query forms or generic visitor behavior outside the named collectors. | Surface | Primary executable owners | Independent judgment and important limit | | ------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Ordered relations and BTree | [top-K relation checker](https://github.com/TanStack/db/blob/main/packages/db-ivm/tests/operators/topk-relation-oracle.ts) ([calibration](https://github.com/TanStack/db/blob/main/packages/db-ivm/tests/operators/topk-relation-calibration.test.ts)), [fractional-index window moves](https://github.com/TanStack/db/blob/main/packages/db-ivm/tests/operators/topKWithFractionalIndex-oracle.test.ts), [BTree/Map](https://github.com/TanStack/db/blob/main/packages/db/tests/btree-map-oracle.test.ts), [incrementalization laws](https://github.com/TanStack/db/blob/main/packages/db-ivm/tests/incrementalization-law-oracle.property.test.ts) | Independent ordered relations and cumulative signed output. Each generated incrementalization campaign sums the checker's delivery counts and requires one atomic delivery per checkpoint and more split deliveries than an unsplit run makes; a checker that stops splitting fails all six campaigns. Most ordered steps edit the previous world by one removal or insertion, and a reconstruction check counts promotions of retained rows over the executed fixed campaign (25 global and 21 per parity at 100 runs; independent worlds gave 2 and 2). A type test fixes `join(other, type)`'s nullable pair sides for every join type. Top-K consolidation compares same-key values without hashing, including cyclic replacements and fresh transient cancellation. The fractional-index test checks an empty output message for a window move after all rows retract; it does not prove downstream lazy acquisition. The [distinct incrementalization extension](../../packages/db-ivm/tests/distinct-incrementalization-oracle.property.test.ts) recomputes unique immutable `{id: string, value: integer}` selections across real hash collisions, with two unequal collision members and a constructively verified noncolliding anchor. Its shared [model and grammar](../../packages/db-ivm/tests/distinct-incrementalization-oracle.ts) vary collision-member order, atomic versus separate insertion, duplicate support, partial and last removal, replacement, cancellation, and reinsertion, with a noncolliding anchor. The existing incrementalization checker compares net weighted deltas and retained rows after every logical batch in atomic and legal unit-split D2 deliveries, for selected-value and default-tuple distinct. The [public receiving witness](../../packages/db/tests/query/distinct-collision-oracle.test.ts) checks the same law and histories after every applied source transaction through ordered and unordered live-query Collections; the [reported seeded pair](../../packages/db/tests/query/distinct-reported-collision.test.ts) replays that shared judgment. Each campaign declares and measures collision coexistence, duplicate support, partial removal, last removal, and reinsertion separately for its receiving path. The original hash-only operator, equality buckets with shared output keys, and counts capped at one all fail value comparisons. These checks do not promise representative choice for unselected fields, intermediate source-transaction publications, framework render scheduling, arbitrary payload types, or collision freedom of the digest. The [issue 2306 audit](oracle-reviews/2026-10-30-distinct-collisions.md) records RED, GREEN, mutants, bounds, and byte cost. The wider representative and includes receiving grammars are recorded under [Distinct collision review extension](#distinct-collision-review-extension-2026-10-30). Other hash-based operators remain outside this distinct repair; the Index structural-collision trace is recorded there with its owner. Algebra does not specify client readiness. The BTree/Map oracle checks point operations, neighbor pairs, and full, partial, boundary, exclusive-high, and empty range scans for integer keys and node sizes 4–8. It does not check balance or space, and it assumes consistent comparators ([code-weight BTree review](oracle-reviews/code-weight-btree-trim.md)). The generated groupBy law compares JSON values; a fixed contract test in `packages/db-ivm/tests/operators/groupBy.test.ts` records that after a delete, `min` and `max` return a value hash-equal to a remaining member, not necessarily the remaining instance (`-0` for `0`, an equal Date), which is why the query compiler keeps its own exact-value keys. It checks both insertion orders, reads the group's row by integrating output multiplicities, deletes the minimum and the maximum, and shows that an aggregate input that tells the rows apart returns the remaining instance, for -0/0 in both directions and for both `min` and `max`. The contract holds while every member has positive multiplicity. It records the current behavior separately: the delete's retraction is the last record a shared hash entry gets, so the deleted instance comes back in either insertion order, for -0/0 in either direction and for an equal Date. For -0/0 and equal Dates the contract assertions only show hash equality, which is all the contract promises. Open: the incrementalization law's value policy compares JSON and clones by `structuredClone`, so no generated history sees -0 or Date identity; a value-identity policy with -0/0 and equal-time Dates would generalize this fixed contract. | | Includes and publication | [cross-formulation](https://github.com/TanStack/db/blob/main/packages/db/tests/query/includes-cross-formulation-oracle.property.test.ts), [temporal](https://github.com/TanStack/db/blob/main/packages/db/tests/query/includes-temporal-oracle.test.ts), [Collection includes](https://github.com/TanStack/db/blob/main/packages/db/tests/query/includes-collection-oracle.property.test.ts), [architecture and complete suite map](https://github.com/TanStack/db/blob/main/packages/db/src/query/live/ARCHITECTURE.md#executable-contracts) | Per-parent/flat-join/partition relations, callback-time rows, nested values, and route histories. Fragmented lazy-demand consolidation covers delta growth and successful, rejected/retried, and obsolete replacements at the Collection request boundary; it observes exact key unions and abort checkpoints. A compiled-includes fixture makes adapter unload evict owned child rows and proves a rejected union cannot remove established public child rows. Retry after that terminal live-query failure remains covered at the acquisition boundary; no automatic in-place recovery is claimed. Observe raw promised order; fresh queries do not establish continuous publication safety. The temporal owner's source-readiness grammar enumerates every legal order of delivery, settlement, source readiness, and one later change for a source whose Collection readiness lags its settled subsets. It checks live-query readiness, preload settlement, and visible rows for direct, single-result, ordered-window, include-child, lazy-join, and eager-root sources; `queryOnce` results for the direct and eager-root shapes; `toArrayWhenReady()` and `stateWhenReady()` results for a read started after rows are visible but before readiness, over the direct, single-result, and eager-root shapes (and the lazy join for `toArrayWhenReady()`); and Effect `skipInitial` deltas for the direct, lazy-join, and eager-root shapes, and every on-demand cell of every consumer is crossed with a truncate or (join and include) a parent rekey before settlement. Each on-demand cell also compares its consumer with a metamorphic twin over a source that is ready from its start, which does not rely on the model's eager/on-demand rule. A live-query observer test checks that a hydration seed hands off at subset settlement, and an Electric test checks that a ready progressive query's rows update only at the full sync's swap. Effects over an ordered window or an include have no grammar. It rejects both a design that waits for every source's Collection readiness and one that ignores source readiness. Electric live-query tests are the receiving witnesses for a real progressive source and an on-demand source that is ready before its subset loads; a React Suspense test checks that Suspense and `isReady` release together. Other framework adapters have no Suspense witness. | | Collection lifecycle | [mutation startup](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-mutation-startup.test.ts) (fixed tests; no oracle owner (tracked in #2264)), [change-event history](https://github.com/TanStack/db/blob/main/packages/db/tests/change-event-history-oracle.test.ts), [sync publication reentrancy](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-sync-reentrancy-oracle.test.ts), [history](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-subscription-lifecycle-history-oracle.property.test.ts), [publication](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-subscription-lifecycle-publication-oracle.property.test.ts), [replay](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-subscription-replay-oracle.property.test.ts), [effect disposal](https://github.com/TanStack/db/blob/main/packages/db/tests/effect-disposal-oracle.test.ts), [GC and persisting transactions](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-gc-transaction-oracle.property.test.ts), [GC retention boundaries](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-gc-retention-oracle.property.test.ts), [shared GC model](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-gc-retention-oracle.ts), [GC mutation projection](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-gc-mutation-oracle.property.test.ts), [native idle receiver](https://github.com/TanStack/db/tree/main/packages/db/e2e/collection-gc), [initial GC review evidence](oracle-reviews/pr-2258-gc-retention.md), [second GC review and decisions](oracle-reviews/pr-2258-gc-retention-round2.md), [interaction and mutation receiving evidence](oracle-reviews/pr-2258-gc-retention-round3.md), [GC checker calibration](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-gc-retention-oracle.test.ts), [Electric confirmation receiver](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/e2e/collection-gc.e2e.test.ts), [PR #1902 review](oracle-reviews/pr-1902-change-event-history.md), [batch-order decision review](oracle-reviews/change-event-batch-order.md), [absent-key insert review](oracle-reviews/2026-10-02-insert-for-absent-key.md) | Core Collection `insert`/`update`/`delete` admission while `startSync:false` is idle; complete public-row/change-message agreement across bounded one- and two-key histories plus replayable four-key campaigns, where every message must be valid for a strict consumer (insert only for an absent key, update or delete only for a present one; [absent-key insert review](oracle-reviews/2026-10-02-insert-for-absent-key.md)); a two-key deferred sync history checks each key's causal insert/update/delete trace while allowing any cross-key interleaving. Reversing all deferred messages fails that check; reversing each sync transaction's distinct-key messages passes. Queued duplicate admission and cancellation, ownership and phase histories, exact caller/error/publication evidence, and late completion and restart have separate witnesses. Generated deferred histories with cancellation or reentrant callbacks need a witness in the change-event history owner before claiming general batch-shape coverage. Every bounded change-event history, and about half of each generated campaign, runs again on a local-only Collection that ends with `reload()`: it must resolve with the Collection `ready`, the change-message mirror of valid messages must equal the public rows, the public rows must equal the history's kept rows (maintainer decision: a local-only reload keeps the user's writes, and `initialData` loads only into a Collection that starts empty), and a later write must reach both. The adapter that re-inserted `initialData` in each run failed 210 histories (a crash when a kept row changed, or a mix of kept rows and `initialData`); a reset to `initialData` fails 344, and loading `initialData` whenever the Collection is empty fails 45 (a history that deleted every row). Query write utilities and effect self-dependent disposal remain separate contracts. During a truncate, a ready callback can write to any key after a prior optimistic request. Each subscriber, with or without initial state or a filter, must receive valid messages after the Collection is ready and end at the Collection's rows. A ready callback that throws while entering sync surfaces when the sync function returns, whether it calls markReady or commits a truncate ([round 3 follow-ups](oracle-reviews/2026-10-05-round-3-followups.md)). Callback rollbacks, non-optimistic callback writes, and several writing callbacks remain open ([ready-callback truncate review](oracle-reviews/2026-10-05-truncate-ready-callback-delete.md)). The GC property (`collection-lifecycle.gc-persisting-transaction`) checks on a fake clock that automatic garbage collection retires a Collection only after `gcTime` with no subscriber and no persisting transaction, that the delay restarts when the last transaction completes or fails, and that explicit `cleanup()` still retires it while a transaction persists. Its owned production is `lifecycle.ts` and the settlement restarts in `Transaction.commit`, `Transaction.rollback`, and `Transaction.touchCollection` (`transactions.ts`). Clock steps are 1, 20, 60, and 120 ms. Before `gcTime` no retirement is owed. From `gcTime` to `gcTime` + 20 ms either outcome is allowed, since exact cleanup latency is not promised. From `gcTime` + 20 ms retirement is owed. A retirement two milliseconds early is rejected; one millisecond early is not observed at the 99 ms checkpoint and survives as indistinguishable from `gcTime`. Histories run over two Collections, with inserts through one Collection's `onInsert` or through a manually committed transaction that touches both. After each subscribe, unsubscribe, insert, settlement, and clock step it compares each Collection's `cleaned-up` status and each persisting row's visibility with an independent deadline model. `main` before the fix, a hold that never restarts the delay, a restart only on completion, and a restart only for the first Collection a transaction touched each fail it. Seven constructed histories, one or more for each of its seven declared reach states, enter those states in every campaign, so its reach gate does not depend on the seed; half of each campaign's histories are constructed, and the reach counts include the constructed histories, so a floor of 1 does not show what the generated histories reach alone. GC that ignores subscribers fails the fixed-seed and random campaigns. The companion `collection-lifecycle.gc-retention-boundaries` property separates elapsed eligibility from host idle delivery. Its shared reference model checks the absolute 50ms startup/preload handoff, real last unsubscribe, pending versus persisting transactions, delayed commit, success/failure/rollback, surviving siblings, disabled GC, and old idle work after renewal. Generated configured delays are 1, 10, 49, 50, 51, and 100ms; observations include immediately before and at the independent deadline. Eager sync and write-started sync both run. A Chromium receiving driver uses the same model/checker with native idle delivery and cancellation and controlled elapsed timers. It records the actual budget core reads and checks public status at core delivery and a usable native observation opportunity. Exact wall-clock cleanup latency is not promised. Paced mutations, offline transaction restoration, live-query Collections, and actual Electric `awaitTxId` plus provider delivery are not generated by these GC owners. The boundary grammar now generates repeated warm preloads over queued idle and persisting holds, successful and failed cold preloads as first or last releases, both sibling settlement orders, and pending drafts held by subscriptions. Held adapter cleanup crosses settlement with surviving pending or persisting siblings, both before and after cleanup settlement. Exact key comparisons reject leftover settled rows and cleanup resurrection; tracked transaction identities still match unsettled transactions. The 250-history fixed and random campaigns require all 33 declared states. Alongside the 15 focused grammar, constructive interaction histories combine up to seven transactions and three subscribers, delayed commit, three persisting siblings, non-FIFO settlement and preload between releases. Automatic GC also starts held or rejecting adapter cleanup, checks synchronous row discard before adapter settlement, and rejects pending-sibling resurrection. The shared model additionally receives direct updates/deletes, shared update/delete and cancelled insert/delete ownership with a surviving peer update through `collection-lifecycle.gc-mutation-shapes`. Its independent source/intent projection checks exact keys and values across completion/failure/rollback, both Collection orientations and subscriber states; each 150-history campaign requires all 11 declared states. The maintainer chose first-usable-idle retirement as a fixture scheduling assumption, not a public liveness guarantee. The maintainer also chose caller-owned pending draft visibility: keep a subscription; restart after GC does not promise draft restoration. The boundary grammar therefore does not establish post-GC draft restoration, paced/offline restoration, or arbitrary cleanup/source-recovery histories. A real Electric/Postgres receiving driver now crosses gcTime 10/100ms with absent/last-unsubscribed owners, holds an assigned uncommitted txid across the unheld deadline, and observes pending caller, persisting phase, optimistic row, genuine confirmation, successful settlement, synced row, renewed GC and idle delivery. Its 12 paths retain four one-write cases and add eight two-write cases with separate real SQL transactions and both local settlement orders. A genuine acknowledgement releases only one hold; the other SQL transaction remains open beyond the first-release deadline. It shares the model/checker and rejects no-hold and first-release runtime mutants. Native host and real provider are witnessed separately; their combined browser/provider schedule, three-or-more provider writers, provider failure/recovery and persistence wrappers remain outside these bounded receiving histories. The Collection lifecycle GC owners still use fresh disjoint optimistic keys. Before claiming the combined same-key rollback-cascade or confirming-sync-queue law with GC, this owner needs a generated receiving history that crosses those semantic owners at retention and cleanup checkpoints. The history owner's demand-change grammar (`demandChangeLifecycleHistoryArbitrary`, a fixed seed and the random campaign `subscription-lifecycle.demand-change`) adds a third demand, a `replace` command (`replaceSnapshots`: a held replacement whose own load did not fail covers the owners it replaces, law 10), and a `change` command that retires several owners through one `releaseSnapshot(...wheres)` call; the model judges an open replay once after the whole change (law 9). Declared reach: a change during a replay, a replacement covering a failed owner, and a change whose verdict between releases would differ. Per-release judging, first-release-alone, and batching only two-owner changes each fail it. A covered owner's failed replay load reports `loadSubset:error` whatever its settlement order (the model's existing reporting rule; suppressing the last settler fails it), and a prompt cancellation of a covered owner settles the replay as any settlement does. An aborted held replacement covers nothing: the abort ended its load before it applied (maintainer decision: an abort ends the load; law 10), so its replaced owner's failure keeps the replay failed (two 30-times counterexamples, now `keeps a replay failed when a replacement aborted after its replaced owner failed` and its peer-loaded twin; RED on the first simplification, which counted the aborted replacement as covering; a mutant that drops the check fails both). The controller always aborts and releases a segment together, so it never makes that case. An abort ends the load (maintainer decision): the history model's `abort`, and a truncate that replaces an attempt, stop that attempt's gating at once in both `manual` and `reject` cancellation; an owner whose attempt the abort ended before it settled owes the replay nothing, and a rejection after the abort decides nothing (a failure settled before the abort stays). The publication model finishes a replacement at an abort, and the replay oracle's newer attempt drops the older attempts' pending loads. A synchronous throw from `loadSubset` is a rejection (maintainer decision): an acquisition that core releases, also in the acquisition-cell and replay witnesses. RED on 2bc79fc7c: 18 lifecycle tests, 1 refinement test. Mutants that fail: a replay that waits for an aborted load (14), an aborted rejection reported as `loadSubset:error` (19), an aborted load that still holds readiness (17). | | Paced mutations | [virtual-clock oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/paced-mutations-oracle.test.ts) | `createPacedMutations` with queue front/back options, bounded waiting capacity at zero and one, cleanup draining in FIFO/LIFO order after a held write, cleanup timing at the configured wait for immediate writes, admitted writes after separate Collection cleanup, debounce and throttle schedules with explicit and omitted options, and first-leading throttle execution at epoch zero. Finite histories compare optimistic rows, returned transaction identity and receipt outcome, execution order and virtual-clock time. Held writes verify queue serialization. Leading-only throttle and debounce witnesses reject skipped calls immediately with their named dropped-call errors, including omitted edges, both edges disabled, and same-row rollback while a prior write is held. Capacity witnesses cover overflow rejection, distinct-key optimistic rollback, same-key admitted-write survival, and in-flight versus waiting admission. Cleanup witnesses check repeated queue cleanup, eventual admitted receipt settlement, direct queue strategy rejection of new callbacks, public post-cleanup rollback with `QueueDisposedError`, pending debounce transactions that wait until the last call's quiet edge after separate Collection cleanup, and a trailing throttle timer that runs at its regular edge after separate Collection cleanup. Deferred custom queue and batch callbacks check compatibility with `void` and `false` execute results, respectively. Frozen options verify factory non-mutation; a mutable option witness checks that debounce uses its construction-time trailing setting. Throwing `onMutate` histories check leading-edge reuse before any row change, failed-row restoration when a pending transaction already has admitted work, eligible leading writes behind a held handler, and throttle pending merges at the throw, start, receipt, and later-timer cuts. New debounce/throttle admission after cleanup, manual commit of a strategy-owned transaction, longer throwing/reentrant bursts, failed persistence, broader capacities and schedules remain outside this owner. | | React paced-mutation render cuts | [render-cut oracle](https://github.com/TanStack/db/blob/main/packages/react-db/tests/usePacedMutations-render-cuts-oracle.test.tsx), [PR #2170 review](oracle-reviews/pr-2170-react-paced-render-cuts.md) | `usePacedMutations` publishes callbacks only from committed renders and does so before descendant layout effects, while callback-only commits preserve mutate identity. An independent committed-document model crosses ordinary and StrictMode schedules with mutation before or after a suspended candidate, mutation after the candidate commits, and delayed or immediate mutation from a descendant layout effect. It compares ordered callback traces and public rows at the mutation cut, the trace after persistence, and mutate identity at the commit cut. Render-time publication, layout-effect-only publication, and split insertion/layout publication mutants fail at the intended comparisons. A commit between transaction admission and persistence, arbitrary React schedules, server delivery, and other frameworks remain outside this receiving owner. | | Optimistic state | [same-key composition](https://github.com/TanStack/db/blob/main/packages/db/tests/optimistic-composition-oracle.test.ts), [history model](https://github.com/TanStack/db/blob/main/packages/db/tests/optimistic-history-oracle.ts), [core property](https://github.com/TanStack/db/blob/main/packages/db/tests/optimistic-history-oracle.property.test.ts) (`optimistic-history.core`), [generated histories](https://github.com/TanStack/db/blob/main/packages/db/tests/optimistic-transaction-oracle.property.test.ts), [outcomes](https://github.com/TanStack/db/blob/main/packages/db/tests/optimistic-history-outcomes-oracle.test.ts), [publication](https://github.com/TanStack/db/blob/main/packages/db/tests/optimistic-history-publication-oracle.test.ts) | `optimistic-history.core` runs the core grammar through `oracleProperty`: the history resolves to a plan of concrete actions, the driver records each checkpoint, and the model owes allowed cuts, rows, outcomes, receipts, and tracked transactions, judged as named laws; the former settlement-boundary regressions are its fixed histories, and the seven observation mutants are calibrations, each rejected by its named law. Its grammar does not yet generate pending manual edits, external completion, rejected handlers, reentrant drains, partial updates, ordered operations, or schema defaults; those dimensions are still covered only by fixed histories in the owners that drive `runOptimisticHistory` (open: move them into the grammar). Optimistic state drops at settlement and held sync transactions publish with it ([settlement-drop review](oracle-reviews/2026-10-03-settlement-drop.md)); whole-row active overlays, metadata and prior-value events. A raw subscriber without initial state checks that each truncate batch inserts a key once ([2026-10-02 review](oracle-reviews/2026-10-02-truncate-raw-subscriber.md)). Never rebase a pending snapshot merely to simplify the model. Generated histories also write source batches inside mutation handlers, before they return; the Collection must own the request by then ([handler source batch review](oracle-reviews/2026-10-01-handler-source-batch.md)). The same-key transaction grammar also authors a delete followed by a reinsert, which must be visible optimistically and net to the truth-table request ([state mutation round 2](oracle-reviews/2026-10-02-state-mutation-round-2.md)). Source rows are written as `insert` for a key the source lacks, and batches may delete keys the source holds ([state-stack mutation gaps](oracle-reviews/2026-10-02-state-stack-mutant-gaps.md)). Batches may also delete a key the source never held. That delete leaves an active request in place ([absent-key source delete review](oracle-reviews/2026-10-02-absent-key-source-delete.md)). A separate partial campaign keeps the default partial row update mode, where source updates may omit a field and merge into the source row, not into an optimistic row ([round 3 review](oracle-reviews/2026-10-05-state-mutation-round-3.md)). An aborted open batch restores the driver's own source rows as well as its keys, so a later partial update still omits the field ([aborted-batch review](oracle-reviews/2026-10-08-partial-update-aborted-batch.md)). A failed synchronous manual `mutate` callback is now checked after same-key update, distinct insert, and same-key delete, with and without earlier intent, plus two two-Collection cases, one with a restoration listener failure. The throw cut compares public rows and pending payload; the later commit checks only surviving intent. A restoration listener error retains the callback error as the aggregate cause and does not stop other Collection restoration. These witnesses allow transient notifications during the callback and do not cover nested throwing callbacks or async work after the synchronous scope. After every step the driver also checks, by transaction identity, that the Collection tracks exactly its unsettled transactions, so a failed or rolled-back transaction leaves the map ([failed transaction retention review](oracle-reviews/failed-transaction-retention.md)). The [transaction ownership oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/transaction-ownership-oracle.property.test.ts) owns release across two Collections: merged-away pairs, conflicting rollbacks with a throwing subscriber, asynchronous success and failure settlements with a throwing subscriber, rollbacks from a `truncate` listener during a sync commit, a reused transaction id, and a `mutate()` callback that throws, checked in the same call stack and after promises flush. It also checks the settlement error shape and that a settled transaction's set of tracking Collections is empty; its mutations still name their Collection, so neither owner claims the Collection is collectable. Focused [restoration ownership](https://github.com/TanStack/db/blob/main/packages/offline-transactions/tests/restoration-ownership.test.ts) witnesses check that repeated offline `mutate()` calls add to one transaction, that a completed restoration settles `when('settled')`, and that a restoration one Collection cannot track leaves no Collection tracking it. Its grammar also has direct writes (`insert`, `update` and `delete` outside a transaction), optionally with a throwing subscriber that may have been sent the rows first; it captures each direct write's own transaction and requires it to fail when the admission throws and to complete otherwise, counts handler calls (none for a rejected write), and keeps a mirror subscriber on each Collection that must match the rows after every step. A write whose admission throws rolls back only its own transaction and rethrows. The [change-event history oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/change-event-history-oracle.test.ts) generates local-only direct writes that meet a throwing subscriber, registered after the mirror, and requires the call to rethrow with its transaction completed and the rows following the model. Focused witnesses cover a local-only subscriber that writes the key it was told about, and a subscriber that throws a value that is not an Error; whether a throwing subscriber may stop a later subscriber is not decided. Open (approved limits): a direct write made inside another write's change subscriber reports its subscriber failure to the outer write; on a local-only Collection a direct write whose subscriber throws completes on the fast path but rolls back on the transaction path, and the change-event oracle generates only the fast path; a direct write admitted from inside a sync-commit listener, where the rollback's recompute is deferred, is not generated; the generated ownership histories read every receipt themselves, so only a focused witness (rolling back an empty manual transaction) checks that an unread receipt reaches no `unhandledrejection`; two Collection instances with one id, a Collection cleaned up before its transaction settles, and offline restoration have focused witnesses only; no generated history combines a held completed row with a second Collection. | | oracleProperty framework | [self-oracle](https://github.com/TanStack/oracles/blob/98a9610465f802707b4ca95cbe75ca7f1bbbce2f/packages/oracles/tests/oracle-property-self-oracle.test.ts) (`self-oracle.framework`), [synthetic properties](https://github.com/TanStack/oracles/blob/98a9610465f802707b4ca95cbe75ca7f1bbbce2f/packages/oracles/tests/oracle-property-self-oracle-fixture.ts), both in TanStack/oracles at the pinned commit | The framework lives in `@tanstack/oracles` (TanStack/oracles); `packages/db/tests/oracle-property.ts` only re-exports it after loading TanStack DB's `oracle-config.ts`, so its self-oracle runs in TanStack/oracles, not in this repository. `oracleProperty` promises its authors registration, verdicts, shrinking, membership, reach, calibration, determinism, timeouts, replay, and rerun commands. The self-oracle writes synthetic properties (histories of one to three integers), runs them under real Vitest in a child process, and compares each test's state and failure with an independent model that reads only the synthetic driver's log of the histories each test ran. It probes a replay of every failing campaign (other tests must stand aside, the replay must start from the counterexample and reproduce it) and a rerun of each property's first violating fixed history or history (the printed `-t` command must run exactly that test). Eighteen fixed histories replay the framework's regressions and witness each state its laws are about; campaigns count those states. Maintainer decisions of 2026-11-03: a calibration skips a candidate whose clean trace fails; within one history a driver error decides first, then a law violation, then a missed constructed-history state; a generated property's determinism test also runs three generated histories. Seventeen framework mutants, including every survivor class from the three reviews, are rejected. The `clock` law (maintainer decision, 2026-11-06): a driver on `useOracleClock` whose clock fires more than its bound fails that history under law `bounded clock`, ranked as a driver error is; three fixed histories witness it, and a spin that always decides is rejected. Generated campaigns rarely combine a clock property with a spinning item, so the fixed histories carry that law. Limits: one rerun probe per property; the model relies on fast-check running a grammar's constructed histories first; `forwardCut`, `withinTurns`, `resolve` errors, and the gap report's observation hook have no law here; a run takes about two minutes. | | Drafts and native values | [proxy](https://github.com/TanStack/db/blob/main/packages/db/tests/proxy-oracle.test.ts), [detachment](https://github.com/TanStack/db/blob/main/packages/db/tests/proxy-detachment-contract-oracle.test.ts), [iteration](https://github.com/TanStack/db/blob/main/packages/db/tests/proxy-iteration-contract-oracle.test.ts), [revert](https://github.com/TanStack/db/blob/main/packages/db/tests/proxy-revert-oracle.property.test.ts), [native methods](https://github.com/TanStack/db/blob/main/packages/db/tests/proxy-native-methods-oracle.property.test.ts) | Native-operation controls, exact patches and actual stored rows; alias/cycle/adversarial keys-key histories. Set and Map reorder histories check draft patches and stored iteration order after replacement and clear-and-readd; RegExp replacement/reversion histories check `lastIndex`. General native-mutator and symbol-write support is not established by a plain-object oracle. The revert owner generates assignment, revert, delete, nested, symbol-key, and `for...of` histories and checks `getChanges()` and the draft against an independent draft-equality model: ordered Map and Set contents (including Sets inside Map values), RegExp `lastIndex`, array holes, and symbol keys inside nested values. Map and Set mutators and top-level symbol writes are outside its grammar; array mutators appear only in the mixed block below. Its round-trip grammar also replaces a field with a new object and restores the original value through a nested write. The law requires every changed key, and permits a written key whose final value equals its original to be reported with that value: a false positive repeats the stored value, and a false negative loses a write ([review](oracle-reviews/proxy-revert-replaced-object.md)). A further revert block mixes array `push`, `pop`, and `reverse` with assignments, a nested object replacement, and a retained handle, and checks that a mutator through a replaced handle changes nothing; fixed histories require a native write through a Map or Set value, a typed-array view, or a frozen draft to be reported, and a nested revert inside a Map or Set to keep the container's other write; Map and Set mutators are not mixed with assignments, and an equal-valued assignment keeps a retained handle attached (declared). The proxy owner's stored-function law checks, against a native row, that a function stored as data reads back as stored by every read path and that a stored method sees the draft as `this`, so its writes are tracked. The detachment owner fixes which key classes a draft copies: enumerable string keys and every symbol key. The revert owner also generates typed arrays (including a subclass that does not forward its constructor argument), URLs, and a class with only private state as written values, with a property that writes two of them over one field. The native-methods owner generates rows (holes, `undefined`, duplicates, nested arrays, empty rows, typed `-0` and `NaN`) and calls every method of `Array.prototype` and `TypedArray.prototype`, in fixed and random campaigns with replay; it compares the result, whether the method returned the array itself, the identity of each original object, and the published row with native values, and a new built-in method fails until it has arguments. The proxy owner's `defineProperty`, stored-function, and frozen-draft laws are bounded tables against native rows. Its `defineProperty` law compares result, value, descriptor, and changes, for values and accessors. The iteration owner checks that array iterators see a push, removal, index write, or length cut made while they are open. Open: [#2349](https://github.com/TanStack/db/issues/2349) reproduces an optimistic nested sibling edit converting an untouched class/null-prototype leaf to a plain record, then restoring its shape at sync confirmation. The maintainer identified this as a bug and explicitly kept its repair outside #2346. The draft/revert owners must add generated sibling edits and pending/confirmed shape observations while preserving isolation. A draft also reads a class instance of the original row as a plain object, so private-field getters read `undefined`, and a built-in method called through `this` on a nested Map or Set draft rejects the Proxy receiver; a mutator that changes nothing publishes an equal value; writing back a keyless class instance of the original row is a change, and `DataView` setters are untracked ([draft proxy review](oracle-reviews/code-weight-draft-proxy.md)). | | Query DB and observer | [ownership](https://github.com/TanStack/db/blob/main/packages/query-db-collection/tests/ownership-lifecycle.oracle.test.ts), [persisted direct-write window](https://github.com/TanStack/db/blob/main/packages/query-db-collection/tests/persisted-direct-write-window.oracle.test.ts) ([review](oracle-reviews/issue-2029-direct-write-lock-window.md)), [load lifecycle](https://github.com/TanStack/db/blob/main/packages/query-db-collection/tests/load-subset-lifecycle.test.ts) (fixed tests; no oracle owner (tracked in #2264)), [observer histories](https://github.com/TanStack/db/blob/main/packages/db/tests/live-query-observer-history-oracle.property.test.ts), [retained snapshots](https://github.com/TanStack/db/blob/main/packages/db/tests/live-query-observer-snapshot-oracle.property.test.ts) ([review](oracle-reviews/pr-2043-retained-observer-snapshots.md)) | Real QueryClient boundary, applied-settlement barriers for existing and cached demand, mutation-handler Collection identity, terminal fetch-record lifecycle, and a per-listener eligibility ledger, not a duplicate dispatch queue. The bounded handler grammar crosses insert, update, and delete through handler parameter and mutation-alias access. All calls explicitly refetch; former `refetch`/`clearError` coordinates remain only as historical replay labels, preserving all 12 identity and 12 mutation-overlap executions. The ordinary [health scenarios](https://github.com/TanStack/db/blob/main/packages/query-db-collection/tests/ownership-lifecycle.test.ts) observe exact public causes and settlement. A held refetch retains the current public error. A failed initial load, including a failed initial Collection application, remains a loading error for that sync run regardless of later fetch results. After readiness, a pending retry retains the prior failure reason; failure reports the later cause, and successful result application clears it. Query retry attempts and an older held success are crossed with newer failures, including reuse of one Error value in one clock tick. These scenarios supplement the oracle; they do not claim removed utility fields or error counts. Native SQLite persistence, concurrent retries across multiple tracked Queries, mutation-handler fetch-boundary settlement, and deferred result application remain outside this witness. The mutation overlap grammar crosses both start orders. Check reentry, peer survival, FIFO and disposal independently of final rows. A retained observer snapshot shows its capture-time rows on a later first read of `data` or `state`. Direct-write witnesses now distinguish an idle pending eager cache seed (success with no new freshness timestamp) from an in-flight pending request, and require update, delete, and upsert to reach both eager Collections through their shared physical Query, in both acquisition orders. They check both public Collections and the Query cache immediately after each write. A held older shared fetch also crosses B's release and reacquisition, then compares both public rows at refetch and load settlement; mixed select wrappers and three or more co-owners remain outside this witness. The load-lifecycle tests also restore an intermediate checkpoint that keeps an explicit subset refetch pending until a post-write request applies, and rejects a no-cancel mutant at the replacement-request assertion. . Two sync-metadata session witnesses fail on `30175be48`: a claim that inserts a row keeps applied non-owner metadata, and a claim during a held retention cleanup publishes the cleaned owner (see Sync metadata session) | | Observer hydration under terminal statuses | `packages/db/tests/live-query-observer-hydration-oracle.property.test.ts` | ARCHITECTURE.md law 16 and the glossary "crash": while a hydration seed is active, a Collection `error` or `crashed` shows in the snapshot, attached or detached, and is announced; an attached observer that sees the failure ends the seed, so cleanup then shows `cleaned-up` and live rows, not the stale failure or the seed. Decision (not a law-16 claim): `cleaned-up` and restart under an active seed keep the seed as `ready`, because cleanup is not a failure and the next sync run's readiness hands off. After the seed ends (readiness or a failure), cleanup and restart show the live Collection: `cleaned-up` with no rows, then every row the new sync run writes or reacquires, including a row equal to one shown before cleanup. That restart claim adds no rule: its authority is the header's law 2 (an observer whose seed ended behaves like one without a seed and shows the live Collection) with the glossary's "cleanup" (it ends the sync run; the Collection remains available for restart) and "crash" (cleanup discards all state, so a later start is a fresh start); the ARCHITECTURE sentence on the observer's subscription documents the mechanism, not the authority. The `live-query-observer.hydration-terminal` property (`oracleProperty`, in the path-replay registry) generates histories of up to 10 steps that cross both modes, an eager or an on-demand source (whose loader re-delivers the provider's rows, which survive cleanup), a seed of 0..3 rows or none (an observer without a DbClient, the reference case of law 2), attach order, live writes, `markReady()`, `fail()`, `crash()`, cleanup, and restart. Its 13 declared states are model states (a status while the seed is active, attached or detached; attach to a failure; cleanup after a failure ended the seed; restart under the seed; a row from before cleanup back after restart once the seed ended; the same through an unseeded granular observer's own on-demand subset demand). Eleven constructed histories enter them, so every fixed and random campaign reaches every state, and half of each grammar's histories start with a constructed history; each grammar prints its reach counts. Fixed histories replay the crash, fail-then-cleanup, and crash-before-attach traces and the two restart-rewrite traces in both modes and against both source kinds, and the restart-rewrite traces also without a seed. The check judges laws `view` (status, flags, claimed rows) and `announcement` (last-read snapshot, granular rebuilt rows). The migration from the hand-built campaign kept every mutant kill and every gap-report outcome on `src/live-query-observer.ts` (seed 42); the old prefixed histories ran up to 13 steps. Limits: rows under a failure status are not claimed; the source is a plain controlled Collection, not a live-query graph; on-demand loads settle at once, with no predicate, window, or pending load across cleanup; streamed client errors, handoff timing, and framework adapters stay with the focused observer and adapter tests. Closed cleanup/restart witness [#2334](https://github.com/TanStack/db/issues/2334) (also the random campaign's seed 1779366423, path 30:6:8:8:8:8): attach; ready; write `a=1`; cleanup; restart; write `a=1` again. The observer reset its rows at `cleaned-up`, but its Collection subscription kept them as its last publication (ARCHITECTURE "Cleanup, restart, and detached waiters"), so it dropped the equal rewrite as already shown; an on-demand restart's replay and sent-key filter dropped reacquired rows the same way. The observer's subscription now discards its published rows and sent keys at cleanup (`discardsRowsOnCleanup`). RED on `a17c8e468`: 19 of 38 tests fail with law `view`, rows [] where the model owes the row, also at a ready checkpoint when only ready checkpoints are judged. Mutants that drop the option, take the stale copy before the discard, discard only in granular mode, keep the sent keys, or keep the published rows each fail; an observer that keeps rows under `cleaned-up` fails at the cleanup checkpoint. The fix's production half is in `CollectionSubscription.handleCollectionCleanup`, so the oracle's owns name it (the gap report follows only `#function` entries into other files, and no Collection subscription owner subscribes with the option). Gap-report limit: on `@tanstack/oracles` b937148 the gap report refuses to run on `src/collection/subscription.ts`: its statement-deletion mutant rewrites the constructor's `super()` as `m(n) \|\| super()`, which breaks a derived class with parameter properties (`ReferenceError: Must call super constructor`), so every oracle that builds a subscription fails with no mutant active. Until TanStack/oracles fixes it, the hydration oracle's kills there are shown by direct runs: the authored mutants above and operator mutant M92 (`if-false` on the option) fail it with law `view`; M91 (`if-true`, every subscriber discards) and M88 (`if-true` on `!reload`) survive it, as they change only direct subscribers and reloads, which this grammar does not draw. | | Query DB SSR dehydration | `packages/query-db-collection/tests/ssr-dehydration-oracle.test.ts`, [review record](oracle-reviews/issue-1950-ssr-dehydration.md) | A plain Query cache control, a live on-demand compound predicate, a signal-only request, and an ordered cursor with a custom comparator all retain their row through QueryClient dehydration, reconstruction of Seroval's emitted stream payload, and Query Core hydration from that payload. The on-demand query functions still receive the original IR, comparator, and signal; serialized metadata retains enumerable user metadata but excludes request options. The original implementation fails the compound and signal cases at the stream checkpoint. A serializable stream-only request-options leak passes the former chunk-count check but fails the current payload assertion. This owner covers successful Query cache entries at the installed Query Core 5.90.20 and Seroval 1.5.0 versions. A TanStack Start integration owner still needs the reporter's Router 1.171.33 and Seroval 1.6.8 path, browser Collection resume/refetch, and request cancellation across SSR. Query subset and pagination oracles remain owners of predicate/order/cursor meaning and supported value types. The issue's `shouldDehydrateQuery` workaround replaces Query Core's success-only default and admits pending/error queries; any documented workaround must preserve that default filter. | | Query DB ordered refetch | `packages/query-db-collection/tests/refetch-ordered-prefix-oracle.test.ts` | Issue #2136: after preload, and after `utils.refetch()` or a Query invalidation settles, an on-demand Query Collection behind a LEFT-joined, ordered, limited live query must show the window over the current backend rows. The design under test: query-db reports `invalidateLoadedSubsets()` when an ordered page ends earlier in the order than before, including when its keys stay the same, or when its keys change and it has a later page. Each ordered loader runs its bounded prefix repair. A persisting optimistic update or delete can hide the visible order change that otherwise starts repair. The `query-db.refetch-held-page-end` property constructs that same-key earlier-end overlap through the real QueryClient and core receiver, with 24 fixed and 24 random histories (reach minimum 24 each), numeric finite cursor pages, static/function keys, one/two order terms, limits 1–3, offsets 0–1, varied row IDs, and explicit refetch/Query invalidation. Each history requires the same-key earlier end on the deleted held boundary, a fresh gap between the two answers, a delivered report, and a subsequent real core repair acquisition. Forty-eight structural histories cross widths/offsets with delete/update/unrelated-delete/no hold and earlier/later ends. Six delete-gap width/offset states each require structural reach. Label-only edits are negative report controls. The [nine-item review](oracle-reviews/2026-11-02-query-refetch-nine-item-review.md) records the strengthened classifier, experiments, portable commands, and finite limits. The exact failing CI history replays the shared model and comparison. Both the original implementation and the restored equal-key guard fail the public source-prefix comparison after release. See [the held-page-end review](oracle-reviews/2026-11-02-query-refetch-held-page-end.md) for exact source bindings, evidence, and limits. Its model is a pure top-k of marked backend rows. A fixed and a random campaign generate rounds of marker flips (which serve continuation pages), backend changes while the provider lags, a second live query (`observe`) whose own demand can load a page's new row first, optional Query invalidation with further changes, and a refetch, across one or two order terms, a numeric or locale-collated string order, limits 1–3, offsets 0–1, and a static or function Query key. With an unchanged backend, a repeated refetch must serve no more rows, start at most one first-page request, and report nothing. A refetch or invalidation must never start a new full-source request. A coverage law runs at the same checkpoints: every backend row from the start of the order through the window's last row (every row, when the window is short) must be in the source Collection with its current values, so a latent gap fails before a marker exposes it; a named fixed history of the issue trace with the moved row unmarked passes the window law and fails only the coverage law when Query DB never reports. The grammar can hold an optimistic update across a refetch, with the checkpoint moved to its release, and a premise-directed campaign under a hold (other rows observed, a row moved ahead of the page's end, a new row further ahead, a write to the last-sorting observed row) requires a report during a hold in every case and fails a skip that reads rows held back behind the transaction; the general campaigns did not. The general grammar holds optimistic deletes as well as updates. The generated campaigns declare reach (minimum 3) for a lagging refetch after a continuation, one during a hold, and a refetch that reported while the window was full, where the loader decides between ignoring the report and repairing. A named fixed history of a refetch during a held delete left the window short after release, also with this PR's report and overlap changes reverted, until the fix that resumes a continuation after a synchronous answer; no window is checked during a hold, where #2148 and #2169 remain open. Reports (`loadedSubsets:invalidated`) are bounded: a step reports at most once, and only when an ordered reanswer changes key membership or moves its end earlier, so unrelated value changes do not justify reports; named fixed histories require no report when a one-page window, or a window's last page, only loses a row, and a sync-boundary replay requires a report when a page ending on a row without an order value has its end move earlier (on the earlier gate, which read that page as empty, it reported nothing), and another requires a report when the provider returns a one-page window's rows in reverse order (the earlier gate took the last array row as the page's end). When a page's end moves earlier, Query DB reports. A loader whose window lies inside its own first page skips the repair only while its page read past the window or it read the tie of the current end; after an insert into a top-N list moves the end, a named fixed history requires the loader to prove the window again with bounded reads, no full-source read, and an unchanged Query count. A filtered one-page window whose page end moves past an unseen row must still repair (found by the random campaign; a loader that always skips fails it, the f9 tie replay, and the ordered-work oracle's signalling replays). The skip also refuses while the source holds accepted sync rows back: a replay refetches while an optimistic update persists, so the report arrives before the refetched rows are visible, and a skip that reads those older rows fails it. The ordered loader state oracle checks that a prefix read issued before an ordering invalidation, which settles after the bounded repair, does not retire the repair's prefix; the repair-first order failed before that fix. A `loadSubset` call that acquires a released, invalidated page can report, because Query then refetches that page on its own. A failed repair shows only the last window or the right one. Named replays cover the issue trace after a refetch and after an invalidation, with a page-capping provider, with another live query loading the page's new row first, with an empty later page, with a page whose end moves earlier while a tie request holds its old last row, a second refetch after an invalidation, a repair failure, and a provider that honors neither cursor nor offset. Never signalling, the old overlap-to-full-source rule, ignoring empty later pages, reporting on any page change, removing the repair loop guard, and reporting once per page each fail it by assertion. A replay makes a page's application fail and checks the window shows its last result or the right one, then the next refetch restores it; recording a page before its rows are accepted cannot be distinguished, because the failed attempt reports on its own. Open: the report laws bound reports but do not require each one; a page whose end moves earlier reports even with unique order values, where no row can be missing; it does not check whether a repair waits for in-flight work; the generated campaigns use an uncapped cursor provider only (an offset-only provider and a page-capping provider each hit a loader defect that reproduces on main: #2182, #2183); the generated campaigns do not check the window after a marker flip (a named fixed history checks the trace where the loader stopped refilling after a joined-side removal, which the repair-retirement fix below closed); a failed repair still recovers through the loader's full-source retry; interval, focus, and reconnect refetches share the invalidation path but are not driven; NaN order values have no executable witness; overlapping `refetch: true` acquisitions on one Query hash are counted, so the first to finish does not clear the loop guard for the other, but no witness separates that from a plain set; a Query refetch that joins a running `refetch: true` acquisition on the same hash does not report, and no witness reaches it (#2185); follower tabs of a multi-tab persisted collection never receive the report (#2174). The offset-only and page-capping loader defects have `it.fails` witnesses in the oracle. A finished bounded repair used to discard its boundary when its retirement made Query DB remove a row the loader had sent; the loader then restarted paging with a smaller first page that could not retire the repair's prefix, so every later refetch read both. A named fixed history found by the random campaign (at four times the run count) and an ordered loader state witness fail on that, and the fix also closed the joined-side refill defect. At four times the run count, the random campaign found a short window that stopped paging before the last row of the order: a report's repair released continuation Queries, and Query DB answered their reacquisition synchronously from its cache, so the graph turn inside each request asked for more while the loader was still requesting and nothing resumed the staged continuation. Only the coverage law failed. A named fixed history and an ordered loader state witness (a synchronous answer whose writes the graph already processed must continue the chain) fail on that, and pass with the fix. The loader side of the report also has a second owner: the ordered-work oracle's `refetch-signal` provider re-runs each served request alone and reports when any answer changed, across that oracle's generated plans, and a signalling refetch must start no full-source request unless a bounded page in that step ended on a null or NaN rank, which takes the documented full-source fallback (a random seed found that case). Never signalling and the old overlap-to-full-source rule each fail it. It excludes a peer live query, which can keep a short window after a refetch (#2155). The persisted-collection oracle checks that a source's report reaches the Collection through the managed cache-generation wrapper and that a retired source session's report is dropped. Remaining work for this class is tracked in #2186. | | Ordered acquisition | [pagination](https://github.com/TanStack/db/blob/main/packages/db/tests/query/pagination-oracle.property.test.ts), [ordered work](https://github.com/TanStack/db/blob/main/packages/db/tests/query/ordered-work-oracle.property.test.ts), [ordered lifecycle](https://github.com/TanStack/db/blob/main/packages/db/tests/query/ordered-lifecycle-oracle.property.test.ts), [ordered loader state](https://github.com/TanStack/db/blob/main/packages/db/tests/query/ordered-source-loader-state-oracle.test.ts), [graph scheduler](https://github.com/TanStack/db/blob/main/packages/db/tests/query/scheduler.test.ts), [issue #1880 ordered-repair review](oracle-reviews/issue-1880-ordered-repair.md), [issue #1882 custom local collation review](oracle-reviews/issue-1882-custom-local-collation.md), [issue #1898 relation-filter review](oracle-reviews/issue-1898-relation-filter.md), [PR #1909 external review](oracle-reviews/pr-1909-external-review.md), [eager ordered-window repair review](oracle-reviews/perf-ordered-window-repair.md), [reversed index reads](https://github.com/TanStack/db/blob/main/packages/db/tests/reverse-index-oracle.property.test.ts) | Complete finite provider results, inherited locale and bounded/unbounded custom collation with exact request options, query-level inheritance across source aliases, real lexical/numeric disagreement, custom comparator ties, scan/index paths, pending windows, ties/nulls, lease ownership, Effect callback gates, including an indexed source update during Effect startup, and documented repair timing. Direct LEFT-joined filters cover local finite prefixes, pending child demand, child removal, and anti-join publication with custom full-source and unindexed fallback loading; unrelated include demand cannot stall the root continuation, and an empty joined replay wakes held Effect callbacks; remote relation hints remain outside this owner. Graph scheduler checks coalescing, dependency order, synchronous loader input, and repeated-alias failure ownership. The ordered-work oracle checks that a synchronous root refill reaches D2 before joined publication; a mutant that omitted the post-loader graph step failed at the second child demand. Custom collation proves local full-source acquisition only; it does not establish provider cursor capability or backend collation fidelity. Sibling-source input during a synchronous ordered continuation returns to graph work before another ordered acquisition. Request completion is not proof of unrequested source extent. A window move during existing joined demand waits for its root continuation, including an independently held root request; current demand failure rejects the move, while retirement and an obsolete rejection do not. A bounded ordered repair resumes its refill after joined demand settles. The ordered-source-loader state test checks that an explicit failed-request retry blocked by joined demand retains its generation until it can issue a request. Multiple simultaneously pending joined plans during a window move and a public-query failed-retry overlap still need dedicated witnesses. The ordered-work oracle also checks an eager indexed window over generated upserts and deletes: the rows equal the filtered, sorted model, and each change delivers a bounded number of source rows; an unbounded or always-full repair read fails it. Its filter dimension adds a function filter and a LEFT-joined filter, and a campaign fixed to the joined premise checks that a window refilled past a distant row the query already received holds the first eligible rows. Joined filters also run as anti-joins, change eligibility through the marker or the root row's join key, and drive an Effect beside the Collection. A full-join filter keeps every root row and adds a null-ranked rootless row for each marker no root row matches; on main a bounded root prefix showed markers whose root rows were not yet loaded as unmatched rows, and restoring the old inner-or-right full-source rule fails eight tests. Null placement is a generated dimension, with the index built to match, and a query that ignores it fails six tests. A full-join campaign has few or no filler rows, a matched null-ranked root row and at least one orphan marker in every case, so its windows reach the null group where rootless rows and null-ranked root rows tie; a reconstruction check samples exactly the cases its fixed-seed run executes and requires such windows (19 rootless and 7 mixed null-group windows of 40 at one times the run count), and the Effect runs beside the Collection. Full joins read their full source, so only the rows law covers them; paging them under the old join rule fails the window law. Fixed cases cover a null-ranked root row past a prefix that ends in the null group. Paging a nulls-last full join passed this oracle but was not adopted: it cost more per delete when the window reached the null group, which no work law here measures, and #2130 tracks full-join paging. Joined filters can match a row through several markers, and the model keeps one result row per matched pair; a model that collapses them fails. The eager harness also runs an on-demand source whose provider follows the LoadSubsetOptions contract (offset only without a cursor, the applied receipt returned). Its test provider combines a sync adapter and its provider (glossary model alignment rule 2); a held request is a physical acquisition whose provider answer is delayed, a served range is the prefix and boundary one answer establishes (a model abstraction), and the peer is a second live-query Collection. The provider sorts by the requested order and keeps its own ledger of sent rows. A forwarding provider sends live changes only for rows it sent or rows that match a served subset, and its served rows obey the work bound; a loader that asks for 100 extra rows fails it. A refetching provider, like query-db-collection, sends nothing until a refetch. The refetch keeps every served ordered range whole, as the LoadSubset contract requires: it sends every row from the start of the order through the last order value a limited page returned, and rows in no range leave; the rows law over the model applies once no change is pending. After every step on either provider, the Collection must hold exactly the rows in the provider's ledger, and the query and the Effect must show their window over those rows; a mutant that drops marker removals fails this law at steps 0 and 1 of the fixed refetching campaigns, earlier than the model's rows law, and in one more campaign. A holding provider answers each load only at an `answer` step, from the rows at that moment, so live changes arrive while loads are in flight. While a load is in flight, the query and its peer either keep the window they showed at the previous checkpoint or show distinct ledger rows that pass the query, in its order; the Effect is not checked then. That is weaker than the architecture's barrier rule, under which a repair or window move keeps the last public snapshot until it settles: a barrier law fails today on on-demand joined plans, where a visible-delete repair and a held `setWindow` publish before they settle (#2131; the law and traces are kept for that fix). The provider records a request as served only once it answers it, and an abort (or an adapter unload) of a held request follows `LoadSubsetOptions.signal`: a cooperative provider installs none of its rows and its load fulfills at once, while a provider that cannot cancel in-flight work (`late` cancellation, generated) answers it anyway and its load fulfills after those rows become visible. A `release-peer` step cleans up the peer while its loads are held, which aborts them; each request counts once although its acquisition release both aborts and unloads it. The fixed held campaign reaches 5 aborted held requests and 1 late answer, and its reconstruction check requires at least 3 cooperative cancellations and 1 late answer. A held load rejects when its applied receipt rejects, and the step then fails, because no signal or cleanup rejects a receipt in these histories; that branch is unwitnessed. The held campaign fixes a forwarding provider, so `release-peer` never reaches a refetching provider; that branch is unwitnessed. A request whose signal is already aborted when the provider receives it is never reached; that branch is unwitnessed. The held campaign uses a forwarding provider and an indexed source filter or a joined filter, deletes three visible rows and then upserts an eligible row with an id no other command uses; its reconstruction check runs in the same test as the fixed-seed campaign and reads its per-case counts: 35 of 40 cases issue a held request, and every one of them changes rows while it is in flight. Loading must reach a fixed point: past a request budget the provider rejects and records it, and the initial load, every step and the end of each history assert the record is clear (a loader that re-requests a prefix it already holds can loop without reaching the provider, which this cannot see). A bounded step makes at most four provider requests, and each consumer's initial proven-prefix load is bounded separately, in total transfers (a repeated request for the same prefix counts) and in distinct rows (at most the source's size); a loader that asks for 100 extra rows on every page fails that bound and the initial-load work law. Loader mutants that never resume after a boundary request, or that ignore a load request while another load is pending, fail it; a mutant that drops a window move blocked behind a pending load still survives, even with the settlement check on held moves; whether it is equivalent is open. Open (#2148): on an on-demand source with a joined or anti-joined filter, an optimistic delete of the visible row leaves the window short until the delete persists, because the next row is never loaded. On an on-demand source with a source filter, and on an eager source with any filter, the same delete refills the window correctly; these are the contrast cases. Owner: this oracle. Needed witness: the optimistic-delete dimension (kept as a patch for #2148) in the grammar, plus a fixed histories of the anti-join trace. A refetch that re-runs each page alone, as query-db-collection does today, leaves a row that moved between two pages unloaded; random seeds found that trace, a named fixed history fails on it, and a query-db receiving witness reproduces it (#2136 tracks the provider fix). An Electric-style provider, which skips updates to rows it never sent, is not modeled; a mocked-stream witness shows a row moving into a served ordered range never arriving under the default replica mode (#2138). At one times the run count, the campaigns reach 87 refetch steps: 39 change the window, 6 remove a visible row, and 13 lead to a further provider request. A random seed found a refetch that empties a joined window, after which the loader refills it over several page requests and publishes `[]`, one row, then the final rows; a named fixed history keeps that trace for #2131. No incorrect final window has appeared on that path, and no loader mutant tried so far is caught only by it; the work law does not cover it. For an on-demand joined or anti-joined filter, the initial load must not request the whole source when the first window's worth of source rows in query order all pass the join and no boundary value is null or NaN; 35 executed cases meet that premise, and a compiler that reads the whole source for every joined filter fails eight tests on this law alone. The rows served by that initial load stay within the prefix, its boundary ties and a refill, for each consumer. Later steps of those plans have no work bound. An unindexed join filter over it left the window empty on main, until the plan counted the rows it still needs; restoring the old guard fails the campaigns and a fixed histories. A step that changes the visible rows must publish, and its subscriber starts with every visible key, so a removal-only change reaches it; mutants that drop update-only or removal-only publications fail. A step may publish one intermediate window per provider request it made, and only its last publication must show the final window, because a repair or refill can publish after each round trip (#2131); the content of those intermediate windows is unchecked. The model keeps its own copy of the markers, and full-join histories can insert the root rows of orphan markers. A premise-directed campaign inserts a fresh row and then changes an initial row's eligibility alone, so the row leaves the window only through the join; it and a named fixed history fail when a window row past the loader's settled boundary counts toward a full window. One case in four adds a second live query over the same sources with a larger window, and its rows law holds at every checkpoint; the work laws do not apply to those cases. #2155: a second live-query Collection over a refetching on-demand provider kept a short joined window after a refetch removed a tied row (the peer showed ranks `[0, 0]` where the model shows `[0, 0, 100]`). The loader fix that resumes a staged continuation after a synchronous answer the graph already processed closed that trace. The fixed histories of that indexed trace now expects the right window. Still open: an unindexed peer over a refetching provider keeps a short joined window (the peer shows `[100]` where the model shows `[100, 101]`), which also fails without that fix; each campaign therefore still excludes the peer and refetching pairing, as its last map. Owner: this oracle. Needed witness: a fixed histories of the unindexed trace flipped to pass, and the pairing restored to the grammar. Limits: Effects are checked for rows after each step, not for publication counts or positions. Histories move the first query's window with `setWindow` (150 moves at one times the run count, 56 on demand), and its rows law and ledger law then follow the moved window; the Effect and the peer keep theirs. On a holding provider every window-move promise must have fulfilled after the final drain. A refetching provider models query-db's unload: it drops the unloaded request and removes rows that no remaining request's last answer holds. The per-step work law applies only to forwarding, immediate, single-consumer cases: it skips refetching, holding and peer cases and move steps; a two-term indexed move scanned the source four times, which no law here bounds. Multi-term joined plans stay outside this harness, on both paths; on the on-demand path, the provider's transfer is bounded only for indexed single-term source-predicate plans. Joined windows compare order values, so a wrong row tied with the expected one passes; a window row tied with the boundary counts as proven before its tie request settles, which no witness exercises. A boundary that cannot advance past a window row would repeat one page per new key; reading the boundary's range locally should always reach that row, but no witness shows it. Joined ties are compared as any valid first rows; whether source-filter ties may be fixed to the source key is open. The same grammar includes NaN and null ranks and a second-order term, and bounds both rows read and rows delivered, including the initial load and index refills; a scan law limits each change to one pass over the source. A fixed case checks that an indexed descending window places nulls first, and a lifecycle witness checks that an eager full-source window is ready with its rows at creation when its source answers synchronously. The initial fallback cells check indexed and unindexed locale strings with distinct and tied values, plus a null boundary after a warm ordered request. The warm null-boundary case crosses preload-started and constructor-started live-query sync runs: the former completes at the synchronous cut, while the latter resumes deferred on-demand acquisition asynchronously and publishes after settlement. They require an unfiltered full-source request, no public row at fallback entry, and the expected row and status at the immediate readiness check. A Promise fallback stays loading at that checkpoint. A React receiving witness checks an eager locale-string `findOne()` at the first layout commit. A Query DB receiving witness checks warm cached subsets: both raw adapter calls return literal `true` with the source rows visible at each return, and the live query is immediately ready without a fetch. The same fallback cells observe subscriber changes from before the first source write: literal-true and Promise fallbacks each publish one nonempty final-window insert after the fallback settles, and the callback sees the complete row. Promise cells show no nonempty event at the immediate cut; a duplicate-event fault fails all eight cells. Other adapters and a real on-demand React first commit remain unwitnessed. Full-source work after initial publication and repair remain outside this synchronous guarantee. A separate post-publication oracle crosses marker deletion and retargeting with literal, Promise, and held-applied-receipt fallback responses. It also settles the child demand before holding the receipt, so the public live-query loading flag isolates the root fallback. The model checks final rows and net events, while event replay checks every callback snapshot; a retained or empty intermediate window is allowed. A loader fault that ignores the pending receipt fails at the held loading-flag check. Two literal-true cleanup-failure histories require that the replacement still publishes and the adapter error reaches the public query status without making the unrelated marker commit throw; the provider's applied receipts are recorded and compared outside provider callbacks. The Promise case checks eventual coherence on an asynchronous callback path, without claiming a separate timing cut. Four held-Promise histories apply fallback writes, change another join marker before provider settlement, and compare each callback and the final winner; an injected stale extra publication fails the event comparison. Other marker actions and overlapping root-source changes remain open; the provider has no later write or rejection, so this schedule does not establish when the loader claims full-source authority. The reversed-index oracle checks every reversed read's order and filter work for both null placements. The retirement-invalidation grammar (`ordered-loader.retirement-invalidation`) composes a constructive invalidation prefix, up to four settled answers that let the repair chain complete, and generated command suffixes with index availability, limit 1/2, joined deferral, needed rows, release errors, reentrant truncate and disposal, reentrant ordinary passes, retry timers, offset 0/1, and full-source plans. Its declared `completed-repair-release` reach counts only an invalidating release observed while a successful repair-chain answer settles and issues no further chain step; an instrumented run matched the production retirement path in 66 of 72 such histories, and the rest owed nothing more after a late disposal or full coverage; an ablation that invalidates only on other releases passes the older `release-invalidation` reach and fails this one. Only an on-demand source answers a release with an adapter unload, so neither this grammar nor the broad `ordered-loader.request-authority` arbitrary pairs `releaseInvalidates` with a synchronous repair answer, which reads an eager source whose releases bypass the adapter (`CollectionSyncManager.unloadSubset`). The broad arbitrary weights `releaseInvalidates` 5:1 like the other release reactions, because an invalidating release leaves the quiet report laws. The directed grammar also places the invalidation after the callback's disposal, reentrant pass, and truncate (`late-release-invalidation`). Broad overlap states require 20 histories each, and the rarer full-source-plan overlap requires 5. An invalidating unload also writes graph input, so the driver's drain runs one more loader pass before it judges progress, as the live-query Collection and Effect graph loops do; without that pass, a repair that finishes inside a loader pass after joined work clears was misjudged as owing no further read. Its independent request ledger records issue and invalidation events on one clock. It requires an authoritative start after the callback's invalidation for a live finite repair after retry/drain; complete full-source coverage absorbs invalidation, cursor reset transfers pre-reset work to replay, disposal ends ownership, and unanswered authoritative work retains its existing no-timeout limit. Each normal broad campaign measures callback overlap with release error, truncate, disposal, pass reentry, offset one, timer-enabled scenarios, full-source plans, and multiple successor chains. A separate `ordered-loader.retirement-receiver` property runs real live-query Collection and Effect consumers, and a live-query Collection whose `setWindow` to the other offset starts in the same turn as the ordering write. It varies indexed/unindexed sources, limit 1/2, offset 0/1, literal/Promise adapter answers, a held newer replacement answer, and the unload's change: moving the repaired prefix, deleting its rows before the boundary, deleting the boundary row, or deleting a prefix row that ties with it, each of which owes a replacement, or evicting a sent row past the repair's boundary, including a row that ties with the boundary but lies outside the prefix, which keeps that boundary and starts no read. A tie row sorts before or after the boundary row by key, as live-query Collections order ties. A same-turn window move may repair either window's prefix, so that kind keeps only the move and row 1's eviction; prefix deletes and ties run on the other kinds. Each consumer has separate declared adapter-unload and held-answer reach, and delete, boundary-row delete, tie delete, tie eviction, and eviction unloads have their own reach; each grammar runs 600 histories. A loader that skipped every retirement-time delete fails the delete histories at the progress relation, one that treated every sent-row delete as new information fails the eviction histories, one that treated every boundary tie as eviction fails the boundary-row and tie deletes, one that treated every boundary tie as new information fails the tie evictions, and one that kept only the boundary row's key fails the tie deletes. The loader keeps the keys of the settled prefix rows that tie with its boundary row. The focused `keeps a repair's boundary when its retirement removes a row the loader sent` test remains as a supplemental example. An instrumented run placed every invalidating receiver unload inside retirement (200 of 200 per campaign). Following Atomic window publication, the window move stays pending while the replacement is held and settles with its chosen window visible; a mutant whose subset loads stop joining the active window operation fails only those move comparisons. Held-answer reach is recorded only after the provider answer is blocked and the prior-window and no-publication comparisons pass. The provider moves its repaired prefix behind a still-uninstalled row during unload and supplies no later external graph input. The shared progress relation checks that an authoritative start follows the invalidation and precedes the first replacement publication. Independent full-provider sorting checks final rows; held answers retain the previous complete public window and publish no callbacks, and completion publishes one complete replacement. Fixed replay witnesses force the held-answer premise for each consumer. An executed public-method call probe observed reentrant `loadMore` inside every sampled unload for both consumers, with no production-state reads. Original debt-clearing and deliberately delayed-one-pass mutants fail the progress/publication judgments; start observations before the invalidation or at publication fail calibration. This evidence does not require recursive synchronous dispatch: deferred replacement remains legal while the public gate holds. The replay-continuation grammar (`ordered-loader.replay-continuation`) follows ARCHITECTURE.md, Ordered requests/continuation/recovery: a pre-reset request belongs to truncate replay and cannot revive its discarded cursor; a graph continuation survives bookkeeping until a graph pass consumes it or cursor reset discards it. `continuationOwed` is model-only classification provenance, not product completion state. The unchanged handoff/reset grammar and exact shared-model replay reject consuming that provenance during replay bookkeeping. This is a harness correction; it supplies no production resource-leak claim. Its `deferred-refill` state is reached only when a synchronous repair answer meets a release-triggered truncate (6 of 96 inputs). An eager source's release never reaches the adapter (`CollectionSubscription.createSubsetAcquisitionRecord`), so production cannot produce that pairing, and the grammar calibrates continuation provenance without a production-reach claim. The broad request-authority arbitrary pairs synchronous repair answers with release faults, truncates, disposals, and reentrant passes in the same over-approximating way; those histories pass and support no production-reach claim either. The random handoff campaign runs 400 histories so that state stays above its minimum. Limits: the real receiver uses distinct finite numeric ranks, ascending root order, one source and consumer, one qualifying callback invalidation, no failure/truncate/disposal inside the real unload callback, one window move per history and no failed replacement under a move, and no provider-specific network. Its on-demand source settles every repair answer asynchronously in the loader, even a literal adapter answer; the loader's synchronous repair settlement needs an eager source, which has no adapter unload to invalidate. The controlled grammar measures the combined lifecycle cases; it does not transfer all such combinations across the public receiver boundary. No claim about obsolete later cursor-demand retirement (#2223) or arbitrary callback composition follows. Existing run budgets remain unchanged. Random samples do not establish bounded exhaustiveness. The controlled and receiving grammars have distinct registered replay properties, so each seed and shrink path selects only its own driver. The no-leak calibration supplies a retained-lease observation to the same request-ledger comparison after an unmodified run of the same covering-repair history; it reads no private member names. | | Indexed predicate filtering | `packages/db/tests/query/index-path-collision-oracle.test.ts` | A bounded cross product of numeric values checks exact public keys before and after adding a nested-field BTree index. Direct predicates vary argument order, bound inclusivity, reversed operands, and bound field. Public Collection subscription and live-query callbacks run with and without the index. Selected-field ordering compares a direct JavaScript sort with a public `$selected` callback; restoring the dotted-key proxy cache made that comparison fail. The original compound grouping failed four indexed cases while scan controls passed. The original callback proxy caches also failed both unindexed public routes. A mutant cleanup control preserves the primary mismatch and secondary release error. Arbitrary path segments, nullish values, custom collation, and incremental publication need separate witnesses if claimed. | | Lazy target path identity | `packages/db/tests/query/compiler/lazy-targets.test.ts` | A focused same-source `UnionFrom`/`coalesce` witness requires both [`a.b`] and [`a`, `b`] demand targets. Restoring dotted-string deduplication drops the second target at the compiler boundary. A public on-demand adapter and row-publication history still need a separate witness. | | Correlated include path identity | `packages/db/tests/query/includes-context-transport-oracle.test.ts` | The fixed path witnesses live in `packages/db/tests/query/includes-context-transport.test.ts`. A flat parent field and nested parent field reach one-level and nested `toArray` results independently; dotted ancestor aliases remain distinct through a grandchild route. Initial results and parent updates have exact public-value checks. A conditional projection gives [`a.b`] and [`a`, `b`] different include results and checks parent-key changes plus later child inserts. Removing the compiler's unique route-key allocator loses a public child result; restoring dotted-string deduplication at either builder site loses a distinct parent value. These fixed witnesses do not establish arbitrary path segments, every recursive source form, or every materialization form. | | Alias scope identity | `packages/db/tests/query/includes-oracle.property.test.ts` (`includes alpha-renaming across lexical scopes`), `packages/db/tests/query/includes-scope-identity-oracle.ts`, `packages/db/tests/query/includes-alias-shadowing-oracle.test.ts`, `packages/db/tests/query/includes-outer-join-route-work-oracle.test.ts`, `packages/db/tests/query/validate-aliases.test.ts`, [issue #1975 review](oracle-reviews/issue-1975-scope-identity.md) | Four topologies place a source beside a same-named source: a `from()` subquery with an include, a joined `unionAll()` branch with an include, a collapsed top-level pure wrapper with a join subquery, and an include directly on a joined `unionAll()`, which may reuse a branch alias. The grammar crosses zero to two joins, LEFT or INNER, zero to two predicates, plain, ordered-and-limited, or DISTINCT bodies, include forms, and eager or on-demand finite providers, after preload and after source writes. Includes read their source directly, through a join, through a `unionAll()` with an anchor join, or through a `from()` subquery that reads the parent row. One in four scenarios draws any naming; same-scope and union-branch repeats are rejected while ancestor shadowing is admitted. Each checkpoint compares the canonical naming with plain recomputation, the generated naming with the canonical naming, and per-Collection `loadSubset` WHERE clauses. The exact-output companion independently recomputes parent-child rows for direct, QueryRef, union, and implicit-join forms across two equality operand orders, shadowed and renamed aliases, eager and on-demand children, initial publication and parent/child writes. The recursive forms keep a required outer lockId correlation and an independent captured lockName predicate; the union has a nonempty right branch and a later two-branch overlap. It checks enumerable user and virtual key names, user values, multiplicity, sibling helper reuse, a fresh parent/inner QueryRef declaration across a source update, direct, child union-branch, parent union-branch, parent QueryRef, and nested-include rejection of ancestor/descendant builder reuse, one nested grandparent capture, functional callback child input, grouping, captured whole-row and nested-path spreads across shadowed and renamed aliases, eager and on-demand children, and parent/child writes, and query identity. Focused follow-up cells check same-path group keys under shadowing and renaming through parent and child writes, alpha-renamed pure wrappers at public-row and optimized-identity cuts, and indexed lazy demand for direct or wrapped nested includes through anchor and user writes. Wrong-query controls that drop either inner predicate or substitute a parent-shaped callback value fail at the initial public-row comparison. A finite follow-up crosses direct includes and joined QueryRefs with shadowed or renamed aliases, eager or on-demand sources, and child IDs equal to or distinct from an outer filter literal; it checks public rows and on-demand child admission after preload. Another follow-up projects a captured parent rank through a child QueryRef and checks public rows after preload, a child-rank change, and a parent-rank change. The original compiler misrouted the outer filter in four cases, and the original optimizer lost the captured binding in two cases at their first public-row comparison. Every fixed histories and both campaigns fail on `18abceee4`; each of the four optimizer re-mint sites fails a witness when reverted. Arbitrary nested includes, include-inside-subquery forms beyond the checked LEFT joined QueryRef, other join-subquery topologies, `having`, outer joins beyond the bounded RIGHT/FULL matrix, publication events, unload, ordered windows, other lazy join targets, and temporal demand remain outside these owners; they need witnesses before an alias-scope closure claim covers them. Ancestor/descendant builder reuse is rejected before correlation extraction; one helper builder remains legal across a parent QueryRef, union branch, or joined QueryRef and a sibling include child. Six placement/source-mode cells check construction, exact rows after preload, and a source update; the joined placement includes an unmatched manager that would expose a missing helper join. The original source-tree guard rejects all six. A discarded enumeration of a captured proxy cannot change the selected query identity or rows before or after a child update; the retained-marker implementation fails that identity check. The [PR #2079 follow-up](oracle-reviews/issue-2072-alias-shadowing-followup.md) records its RED trace, the repaired spread and nested-QueryRef cells, and the remaining compiler and optimizer evidence gaps. The [ad5e0108 review](oracle-reviews/issue-2072-alias-shadowing-ad5e0108.md) adds a self-join with an inner alias matching the outer joined source, a joined child whose local source competes with inherited parent context in matched and unmatched LEFT joins, captured/local spreads, grandparent whole-row capture, and direct captured-alias selection. These finite cells compare public rows after preload and selected writes; an alias-only lazy-target mutant fails the eager self-join comparison. The reported on-demand failure did not reproduce with the controlled source. A further finite matrix crosses nested FROM or JOIN placement, field or whole-row capture of a shadowed outer joined alias, shadowed or renamed spelling, and eager or on-demand acquisition. It compares source-role rows after preload, child deletion and movement, joined-row update and movement, and parent update; on-demand cases compare nonempty request sets. Disabling projected binding lookup fails all eight cells at the initial public-row assertion; an alias-only lazy-target mutant survives this matrix, so it adds no broader lazy-target claim. A bounded outer-join extension crosses RIGHT and FULL joins, main- or joined-side correlation, direct and QueryRef joined sources, shadowed and renamed aliases, eager and on-demand sources, two parent routes, and seven initial or post-write cuts. Its independent source-role model checks exact public rows, including both absent sides; on-demand cells also require source acquisition. A join-operand extension crosses an ancestor term combined with a local main or joined term, or serving as the whole main key, with equality reversal, alias renaming, source mode, and five public-row cuts. The [outer-join follow-up](oracle-reviews/issue-2072-alias-shadowing-outer-joins.md) records RED and GREEN evidence. A foreign captured join operand must reject: a finite provenance matrix checks root and include placements, matching or different alias spelling, and eager or on-demand sources at construction or preload settlement; valid local and captured-ancestor operands remain controls. A two-LEFT-join history now checks that a later routed QueryRef or captured operand cannot restore an absent shadowed local source, across alias renaming, eager/on-demand mode, two parents, and local and second-joined arrival/removal. It also selects and updates a parent label while joins are matched, checking that the main route retains that ancestor value. A nested joined QueryRef control projects its join key from an inner tag source while the post alias shadows or renames an outer user alias; an independent plain-row model and installed on-demand post/tag rows are compared at preload, a user-key move, and a tag update. A wrong Collection/SourceId pair loads an irrelevant post at preload and fails the installed-row check. Other nested source shapes and real-provider request schedules remain outside this control. The route-work owner compares public rows and assembled parent-route work as irrelevant joined rows grow for direct main-correlated RIGHT/FULL joins in both source modes; an unconditional-route mutant grows from two to six pairs at preload. RIGHT joins correlated on main now join the outer-join row matrix, beside joined-side correlation and FULL controls. An include child rejects a bound join operand declared inside its parent QueryRef or union branch, across matching/renamed aliases and eager/on-demand sources; the original source-tree collector resolves preload instead of rejecting. A joined QueryRef rejects a captured source declared beside it in the enclosing query: the matrix crosses root/include placement, matching/renamed inner alias, and eager/on-demand sources; four true-ancestor controls assert rows, and the permissive sibling-scope mutant fails all eight invalid cells while those controls pass. The primary oracle now extends the hidden-source rejection through two QueryRef or union levels, with matching/renamed aliases and both source modes; a source-tree-binding mutant fails all eight added cells at the rejection cut. An unrelated bound reference is rejected in WHERE, GROUP BY, HAVING, ORDER BY, direct SELECT, and conditional SELECT across matching/renamed aliases; legal local controls and a grouped include with captured ancestor predicates, HAVING, ordering, shadowing, and parent/child writes prevent a blanket rejection. It also rejects foreign references moved into extracted include parent filters or into the removed correlation equality, each across alias spelling and source mode with valid parent controls. Disabling expression validation fails twelve non-join cells; omitting parent-filter or extracted-correlation validation fails four cells each. A separate plain relational model checks RIGHT-to-LEFT, RIGHT-to-RIGHT, FULL-to-FULL, and FULL-to-LEFT two-join chains under shadowing/renaming, both source modes, main/joined/tag correlation, and six source or ancestor writes; a later-FULL-as-LEFT mutant fails two initial public-row comparisons. The route-work owner now compares public rows and parent-route assembly counts at preload and four main-source writes while irrelevant joined rows grow. Other expression forms, arbitrary join-subquery and lazy-target shapes, deeper captures, other chained outer joins, real-provider schedules, and broader source-work bounds remain open under this owner. The alias-scope owner also checks outer grouping through a nested QueryRef and joined source with shadowed or renamed inner alias, eager or on-demand acquisition, and four source/tag writes at five public-row cuts. The tag insertion duplicates one joined source and the plain model counts both copies. A controlled rewrite probe reached an unbound pushed WHERE inside the QueryRef while the bound GROUP BY remained outside; an inner GROUP BY blocked that pushdown. A matcher mutant that ignored binding IDs failed two same-path group cells at the first public-row cut; a dropped-pushed-predicate mutant failed all four new cells by publishing an extra group. This refutes the reported WHERE-rewrite-to-GROUP-BY-matcher route in those shapes; another lost-provenance route needs a concrete fixture. Base/head work probes confirmed an extra pure-wrapper stage after #2079, but the same full-source outer-WHERE request and keyed lazy-join request on both revisions. No wrapper-stage work budget or safe binding remap is established. Bound root refs caused two route-metadata symbol checks per evaluation on the current head versus zero on base, while captured-ancestor rows remain protected by the primary oracle; a compile-time fast path needs a justified work budget and a preservation witness. The same function-form subquery placed twice compiled two results and invoked its callback four times for two source rows on both revisions. Cache comparison read more query properties on the current head, and a stateful callback produced placement-specific values. A callback identity or purity rule and work budget are needed before cache-equivalence changes. | | Join equality and cold acquisition | `packages/db/tests/query/cold-join-reconciliation-oracle.test.ts` | Independent recomputation for cold acquisition plus direct join/predicate equivalence across established equality domains. Binary/string and nullish classes, replacement histories, raw on-demand values, and both scan/auto-index paths are explicit; the compound grammar also covers tuple equality, term order, all four join types, controlled cold sources, and keyed histories. Positive acquisition witnesses require a satisfiable tuple. | | Aggregate selects | [aggregate select oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/query/aggregate-select-oracle.property.test.ts) | Generated select shapes of aggregate queries with and without `groupBy` by `c.k`, the pair `c.k`, `gt(c.v, 1)`, the triple that adds `gt(c.v, 2)`, `upper(c.k)`, `inArray(c.k, ['a', 'b'])`, a Date-valued `coalesce` or a `NaN`-valued `add`, rebuilt per use (literals, parent fields, the group key, the raw field `c.k`, source fields, `count`/`sum`/`max`, `add`, `caseWhen` with expression or object branches, nested objects, spreads, a nested include) and a HAVING condition that may compare an aggregate, selected as a field or not, at the top level, directly or through a `unionAll`, and in an include whose source may shadow the parent alias, through parent updates and source inserts, updates (including key changes that move a row to another group and route) and deletes. A shape throws `NonAggregateExpressionNotInGroupByError` exactly when a non-key source field appears outside an aggregate in its select or HAVING, or the shape spreads a row or holds a nested include; otherwise every published group equals the model and keeps the select's field order. The same grammar checks the opt-in operator laws: a grouped query whose select and HAVING hold no aggregate throws `GroupingOperatorRequiredError` when its keys are passed bare, and works through `groupKeys()`; a bare query builder throws `IncludeOperatorRequiredError` as a field, inside a nested object, or in a conditional branch; a wrapped include inside a nested object throws (a conditional branch may be an include; the includes-collection oracle publishes one, and a compiler that rejects one fails both that oracle and this one). When several errors apply, any one of them passes. Includes are wrapped in `toArray()`, `include()`, or `materialize()`. In three generated histories of six, the driver strips one kind of operator code, the grouping compiler, the include runtime, or the grouping compiler of the `orderBy` aggregate only, from the IR it built. One history in four is a forced history that strips the grouping compiler everywhere or from `orderBy` only, with no, one, or two group keys in turn, to sample each path through `new BaseQueryBuilder(ir)`; IR without its operator code must throw the coded error for the missing operator. A runtime-stripped history gives its include a child query that is valid on its own, so other errors cannot hide the missing runtime. Half the grouping-stripped histories give the top-level query a select of `count()` alone, with an aggregate HAVING when the generated shape has one, so a model error set of exactly `groupingRequired` witnesses the grouped, one-group, and HAVING paths. The top-level and include queries may order their groups with one or two `orderBy` calls, each on an aggregate or on a number or string select field through `$selected`, strings with the documented `en-US` collation: published rows and each parent's `kids` fall into blocks of equal values in that order. An `orderBy` aggregate that no top-level field selects throws `AggregateFunctionNotInSelectError` (now stated in the guide's "Ordering by SELECT Fields"), and a stripped `orderBy` aggregate compiles with the compiler that `groupKeys()` or a select or HAVING aggregate brings. One history in four takes ordered shapes from a grammar whose shapes compile, because generated ordered shapes compile in about one case in forty; the source starts with a key `A`, where locale and code-unit order differ. The property declares twenty-one operator states in `oracleProperty`'s `histories.states`. Each fixed and random campaign first executes twelve complete structural histories through the shared model, driver and comparison, then twelve seed-generated required histories and the unchanged 160 broad generated histories. One reach requires all twenty-one states in the structural set. This guarantee concerns initial publication or compilation only: these inputs have no mutation steps, shadowed alias, or union. A separate generated reach requires the generated histories themselves to enter all twenty-one states and seven additional checkpoints after parent updates, source inserts, updates, deletes, source route moves, a shadowed child alias comparison, and a union-source comparison. Those checkpoints count only after the public model comparison succeeds. The required grammar constructs one varied history per structural family, adding legal mutations and forcing shadowing and union on the string-ordered family. It guarantees the declared premises without relying on broad sampling; both reaches still fail on a miss and retain the selected seed and counts. The seven checkpoints do not require every operator state after every mutation or on every route; without the forced select, the one-group and HAVING states were never reached, and a mutant that throws the wrong error class only on the implicit path passed three campaigns. Fixed histories in `hand-built-ir-operators.test.ts` cover the old `IncludesSubquery` argument order, an aggregate only in `orderBy` without a select aggregate, and the mixed `orderBy` replay. The compiler before the order step took the query's grouping compiler fails the generated `orderBy` dimension (`top compiles`); an order step that ignores direction, keeps only the first `orderBy` call, or sorts strings by code unit, an include query that ignores direction, a group step that keeps only the first one or two keys, and a check that throws the wrong error class only beside HAVING each fail it (the last passed two of three campaigns before the alone states). A mutant without the include-runtime check, which publishes `kids: null`, and one without the grouping guard, which throws a `TypeError`, both fail it. A mutant that skips the grouping-operator check fails it with a `TypeError`, and one that treats a bare builder as an include fails it with the wrong error class. Open: an `orderBy` term on a raw expression other than an aggregate, and on boolean, Date, `NaN`, or object fields, whose order the docs do not state. The operator laws are generated only for aggregate and grouped selects; for plain selects, `includes.test.ts` checks a bare builder as a field, nested, and in a conditional, because this model publishes one row per group and needs a separate row-per-source model for them. The former seed-dependent string-order reach gap recurred in the main release run on 2026-11-02. The structural histories guarantee the initial premises. They cannot satisfy the separate generated reach. The model, comparisons, reach minimum, fixed seed 2094, and 160 generated runs per campaign remain unchanged. Generated history choices now use named fields rather than a positional tuple. Shared parameter helpers report each selected seed before execution, so a final reach failure after fast-check success has a reseeded campaign. Statistics use the exact value `TANSTACK_DB_ORACLE_STATISTICS=1` and survive comparison or reach failures. Removing the structural string history fails the fixed-reach check even when generated histories reach strings. Selecting code-unit order instead of the documented locale order fails the ordinary published-row comparison; seed 2094/path 11 replays that failure directly. The [original repair record](oracle-reviews/2026-11-02-aggregate-select-reach.md) preserves historical evidence. The [nine-item review record](oracle-reviews/2026-11-02-aggregate-select-review.md) records historical counts, generator ablations, replay diagnostics, reproducible commands, and remaining limits. The [release CI repair](oracle-reviews/2026-11-05-release-ci.md) records the recurrent sampled-reach failure, constructive generated-prefix repair, measured reach, and unchanged ordering mutant. | | Query optimizer semantics | `packages/db/tests/query/optimizer-semantics-oracle.test.ts`, [aggregate review](oracle-reviews/2026-09-28-optimizer-aggregate-pushdown.md), [QueryRef repair](oracle-reviews/2026-09-30-queryref-publication-repair.md), [residual review](oracle-reviews/2026-10-01-pr-1977-residual-convergence.md) | Independent sum recomputation and a materialized-Collection formulation check the first public snapshot of a nested aggregate under a left join. Direct, arithmetic-wrapped, and conditional aggregates distinguish safe from unsafe pushdown; a grouped-key control covers the grouped boundary. Matching and nonmatching global aggregates also cross a nested QueryRef inner join with absent, accepting, and rejecting outer predicates. The matching initial cases fail on the pre-repair revision and pass after the computed-projection lookup repair. A separate fixed residual-convergence grammar checks exact predicate and outer WHERE clause counts at `optimizeQuery` return and after re-optimization: LEFT, RIGHT, INNER, and FULL joins; equality, greater-than, nullable-field `isUndefined`, same-source OR, cross-source equality, clause order, separate/AND form, two active predicates, two residual sources, and an existing residual marker. Plain-array LEFT/RIGHT and three-source join models check first public rows, including unmatched rows. Arbitrary expressions, more complex join chains, and incremental optimizer/publication histories remain outside this owner. | | QueryRef operators and user-value boundaries | `packages/db/tests/query/subquery-user-value-oracle.test.ts`, shared `subquery-literal-value-oracle.ts`, supporting `subquery-literal-value-driver.ts`, correlated `subquery-literal-correlated-oracle.test.ts` / `subquery-literal-correlated-oracle.ts` with concrete factory/driver support, supplemental `subquery-user-value.test.ts` and `transactions.test.ts`, [repair record](oracle-reviews/2026-09-30-queryref-publication-repair.md), [chunk 19](oracle-reviews/2026-10-28-pr-2171-oracle-chunks.md) | The independent relational models own joined DISTINCT with outer WHERE, aggregate-source updates and joined findOne histories. Other fixed container/no-select/functional/predicate-literal examples are supplemental ordinary tests, not independent oracle scope. Chunk 19 adds one ordinary-JavaScript literal model with 17 forms × two positions × root/QueryRef receivers: 68 histories and three cuts each. It checks complete ordinary rows, event bags/current/previous values, event-time reads and immutable QueryRef callback inputs, with all 204 receiving and 102 callback states reached once. Strict exact-driver admission passes; unchanged production has eight undefined-to-null REDs (P11), ten empty-container-loss REDs (P12), 50 passing new histories and six passing relational neighbors. Twenty-four mutant and four lawful controls pass; partial selections still fail mandatory reach. Chunk 20 receives the same literal law through toArray, array/singleton materialize and Collection facades: 272 exact histories, all 3,264 path/cut states once, 200 main passes and 72 intended P11/P12 REDs; 33 checker controls and six independent facet controls pass. Legal QueryRef children have their own correlation WHERE and preserve the authored routeGroup input until actual projection removes it. Facade layouts are ordered, startup callbacks permit canonical empty values but owe complete ready inputs, and all 272 titles remain distinct for precise selection. Chunk 21 adds a separate source-public type judgment (`subquery-literal-types-oracle.ts` / `.test.ts`, supporting `subquery-literal-types-support.ts`) for those exact 340 authored receivers: 1,870 actual QueryResult, Collection-row, contextual-input, inline and facade/API markers. All consumers compile without diagnostics under TypeScript 5.9.3, and all 2,550 syntax/admission/marker states execute once. Unchanged production has 280 intended RED histories: 40 raw-nullish precision failures and 272 contextual-input or propagated-inline metadata failures, with 32 overlapping; 60 native histories and 55 checker/source controls pass. Independent review exposed erased call/construct signatures on records; the recorder now retains those declared capabilities and eight existing empty/nonempty × root/nested record controls reject invented signatures, after all eight failed under the original checker. Only the separate four virtual fields at named query-output or published/source Collection row roots are excluded from this ordinary-value judgment; callbacks and inline children remain strict. The full static callback metadata grammar remains open under existing `virtual-row-fields-types-oracle.test.ts`, with the literal sources as receiving witnesses of its accepted P10 law. Source-public inference does not establish declaration portability; an exported inferred factory currently gives TS4058 and is preserved for O22, including exported Collection and built/installed controls. Broader mixed-expression admission, sparse authored arrays, symbols, ordinary-record readonly modifiers, descriptor flags, arbitrary recursion and provider/framework schedules remain open with their sequential receiving owners. Metadata attribution stays with its separate owner; the four reserved fields are excluded only at each observed root row. No production repair or closure is claimed. | | Opaque backend pagination | [window oracle](https://github.com/TanStack/db/blob/main/packages/query-db-collection/tests/cursor-pagination.oracle.test.ts), [cache histories](https://github.com/TanStack/db/blob/main/packages/query-db-collection/tests/cursor-pagination.cache-oracle.test.ts), [cache publication](https://github.com/TanStack/db/blob/main/packages/query-db-collection/tests/cursor-pagination.publication-oracle.test.ts), [browser acquisition boundaries](https://github.com/TanStack/db/blob/main/packages/query-db-collection/tests/cursor-pagination.boundary-oracle.test.ts), [QueryCollection integration](https://github.com/TanStack/db/blob/main/packages/query-db-collection/tests/cursor-pagination-oracle.integration.test.ts) | Full filter/sort/slice reference, opaque token transport, actual Query cache expiry/invalidation/GC, forced refresh during growth, protocol failure publication/recovery, bounded slice work, nested cancellation/replacement, reader abort, browser retry defaults, manual-write cache isolation, and production window publications. Stable backend sequences; not snapshot guarantees for changing endpoints. Peek-ahead remains enabled. | | Experimental no-peek continuation | [test-only live-window probe](https://github.com/TanStack/db/blob/main/packages/query-db-collection/tests/cursor-pagination-oracle.no-peek.integration.test.ts) | The candidate uses an authoritative fact only for the same complete output prefix and otherwise requests the extra row. It remains test-only; the shipped opaque-pagination owner keeps peek-ahead. See [experiment limits](https://github.com/TanStack/db/blob/main/packages/query-db-collection/tests/cursor-pagination/NO-PEEK-RESULTS.md). | | Electric and TrailBase | [Electric histories](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/tests/electric-oracle.property.test.ts), [recovery histories](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/tests/electric-recovery-oracle.test.ts), [held resume snapshots](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/tests/electric-resume-snapshot-races.test.ts), [PostgreSQL semantics](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/e2e/sql-predicate-semantics-oracle.e2e.test.ts), [TrailBase contract](https://github.com/TanStack/db/blob/main/packages/trailbase-db-collection/tests/ORACLE.md) | Installed SDK delivery/framing, independent predicates, exact subscription arguments, restart/reset lineage, held certification and durability races, source-order publication before durability, and late errors. The queued-presence property runs identical fixed/random generators plus isolated seed-and-path replay across insert, update, delete, and truncate callbacks. The recovery fixtures use a mocked ShapeStream; they do not establish live Electric-service framing or native persistence-host behavior. The TrailBase lifecycle oracle's early-demand grammar checks that an on-demand load issued before the change listener runs does not fetch until the listener runs or cannot start, through a real live query and the subset boundary: 16 histories cross listen, subscribe rejection, reader failure, abort, and cleanup with a service change before the subscription; the adapter from before the wait fails all 16. Its page-event grammar checks that a page read before a concurrent change event neither reverts nor resurrects that row, and its stream-end grammar checks that the adapter does not resubscribe: 17 histories, 6 of which fail on the adapter before the page fence. A generated page grammar (`trailbase.page-event`) crosses two-page loads, cursor and offset paging, overlapping on-demand loads, and up to four changes among page releases. A held-commit grammar checks that a page never fails a load for an older event that core holds while a user mutation persists; deciding insert or update from visible rows fails it. After a generated history drains, the Collection holds exactly the rows a page returned or an event touched. Both page grammar deliver events for changes made before the list call at once, during the page, or after it applies, and check that the listener survives a late insert for a row a page already holds. The retry-decision property (`electric.retry-decision`) generates histories over full-log and progressive waits, with and without `onError`, crossing synchronous and asynchronous retries and give-ups, a throwing `onError`, a later error after a retry, an Electric client give-up, an external abort before or during a decision, new demands, the first up-to-date, a persisting optimistic transaction that holds the retried snapshot and later settles, and cleanup. The retry-decision grammar also crosses eager and changes-only sources, an external signal already aborted at sync start, and a status listener that cleans up inside the failure; it checks that a readiness wait rejects with the same cause as every waiting demand, and that such a cleanup leaves a rejected demand rejected. It also holds the acceptance of the first up-to-date commit across later errors, retries, give-ups, and aborts, and checks that the Collection becomes ready with the snapshot's rows when the commit is accepted, and fails with the acceptance's cause when it is not. The descriptor-isolation oracle holds that acceptance across a managed-cache rotation and checks that the retired session's acceptance settles nothing, whether it resolves or rejects, and that the replacement session's snapshot decides readiness. A progressive snapshot's truncate applies at once; a demand whose snapshot arrived before an external abort settles when its rows apply, and cleanup after the abort rejects it. An independent model checks the status, every demand's settlement and cause, and row visibility after each step: a source that still tries stays `loading`, and only a give-up fails its waits. `main` before #2127 and mutants that fail before the decision, skip the failure on a throw or give-up, or skip `markError` on a client give-up or an external abort each fail it at an assertion. An installed-client grammar in the SDK delivery oracle drives the same model (`electric-retry-decision-model.ts`) through the real Electric client and HTTP: a retried 503, a response without Electric headers, and an exhausted 50-retry budget, in eager, full-log, and progressive modes, with a synchronous or asynchronous retry (18 cells). Skipping `markError` on the client's give-up fails the 12 give-up cells; failing before the decision, or `main` before #2127, fails 15; the 3 survivors give up in the same continuation that decides, so an early failure is not observable there. A mutant that settles a held demand on acceptance instead of visibility fails the held replays. Excluded: stream steps while `onError` decides or after a final failure, which the client cannot produce. The source-release property (`electric.sdk-source-release`) checks that cleanup removes every `visibilitychange` listener that the installed client registered for a sync run's streams: one to three runs in eager, on-demand, and progressive modes, each answering up to three requests with row-only delivery, an up-to-date, an HTTP 409 reset, or a retried 503, then staying open, giving up, aborting the external signal, or holding an asynchronous retry/give-up decision through cleanup and later runs, with restarts through `preload()`. It declares separate cleanup reach for partial delivery, reset before a later up-to-date, and a pending error decision. The minimal partial/reset histories cross all five endings in every sync mode through the same driver. It compares the live listener count with the number of active runs after each step. The recorder tracks ordered callback/capture identities with duplicate-add semantics; all 8,421 add/remove histories of length zero to three over two callbacks and five capture spellings compare its count with native EventTarget dispatch before teardown. Recorder teardown independently removes retained registrations after the comparison; bounded callback-subset enumeration checks actual EventTarget dispatch and preservation of a primary failure. `main` before the fix, and mutants that release only while the stream is unaborted or only without a final initial failure, fail it at cleanup; the generated managed-rotation property (`electric.sdk-rotation-release`) checks the approved Electric deadline before replacement `ShapeStream` construction. It rotates one to three times in one on-demand sync run, so a replacement session is itself retired. Each old HTTP snapshot arrives during held rotation, before replacement snapshots, or after their settlement. It declares reach for all three delivery cuts, initial/replacement session retirement, and demands awaiting replacement source responses. A transparent constructor observer records zero retired listeners immediately before the real SDK constructor; both retained demands stay pending while rotation is held and before any replacement response, then fulfill after their source snapshots apply. Fresh public/current-generation durable rows, late old-response rejection, and final cleanup comparisons remain. Each round also remembers its retired storage target and checks that the late response's absent key reaches neither that target after delivery nor after replacement settlement. The seventh declared state requires this retired-target observation. This constrains the expired session's row; unrelated retained rows remain allowed, and a separate run with a valid claim can still use a retired generation. Assertion inputs copy mutable observations so cleanup cannot change their failure payload. The browser listener is observed in jsdom; React Native's AppState adapter and overlapping rotations are outside this generated grammar. | | PowerSync | [tests](https://github.com/TanStack/db/tree/main/packages/powersync-db-collection/tests), `tests/correctness.test.ts` (fixed tests; no oracle owner (tracked in #2264)) | Applied receipt positions crossed with held peers, native SQLite/SDK and cleanup evidence. A metadata-bearing `Collection.update` passes through an observed SDK watcher callback to the public and SQLite rows and an exact queued CRUD patch. Held callback ordering and synthetic zero-field cases remain controlled-only, and remote upload has no receiving fixture here. Run the focused owner with the package's `test:oracles` command. A timeout mutant proves a progress failure, not every value assertion. | | SQLite persistence and native hosts | [persisted histories](https://github.com/TanStack/db/blob/main/packages/db-sqlite-persistence-core/tests/persisted-oracle.test.ts), [reset/resume histories](https://github.com/TanStack/db/blob/main/packages/db-sqlite-persistence-core/tests/sqlite-core-adapter-oracle.test.ts), [setup reopen](https://github.com/TanStack/db/blob/main/packages/db-sqlite-persistence-core/tests/collection-setup-reopen-oracle.test.ts), [reload class](https://github.com/TanStack/db/blob/main/packages/db-sqlite-persistence-core/tests/reload-class-oracle.ts), [dual-adapter resume snapshots](https://github.com/TanStack/db/blob/main/packages/db-sqlite-persistence-core/tests/sqlite-resume-snapshot-oracle.test.ts), [Browser composed-owner histories](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/tests/per-collection-coordinator-oracle.test.ts), [Browser coordinator RPC](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/tests/browser-coordinator-oracle.test.ts) (fixed histories and the source-commit scheduler-order test live in `packages/browser-db-sqlite-persistence/tests/browser-coordinator.test.ts`), [shared-driver fairness](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/tests/shared-driver-fairness-oracle.test.ts), [driver contracts](https://github.com/TanStack/db/blob/main/packages/db-sqlite-persistence-core/tests/contracts/sqlite-driver-contract.ts), [Node shared-handle scheduling](https://github.com/TanStack/db/blob/main/packages/node-db-sqlite-persistence/tests/node-driver.test.ts), [OP-SQLite shared-handle scheduling](https://github.com/TanStack/db/blob/main/packages/react-native-db-sqlite-persistence/tests/op-sqlite-driver-oracle.test.ts), [browser OPFS lifecycle](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/tests/opfs-page-lifecycle-oracle.test.ts), [worker diagnostics](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/tests/opfs-worker-diagnostics-oracle.test.ts), [request order](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/tests/opfs-request-order-oracle.ts), [Electron IPC and composed owner](https://github.com/TanStack/db/blob/main/packages/electron-db-sqlite-persistence/tests/electron-ipc.test.ts), [113-law manifest](https://github.com/TanStack/db/blob/main/packages/db-collection-e2e/src/fixtures/persisted-conformance-manifest.ts), [persisted sync problems](https://github.com/TanStack/db/blob/main/packages/db-sqlite-persistence-core/tests/persisted-sync-problem-oracle.test.ts), [persisted reload replacement](https://github.com/TanStack/db/blob/main/packages/db-sqlite-persistence-core/tests/persisted-reload-replacement-oracle.test.ts) | Core cache/remote rejection/peer/reopen histories, atomic reset/resume lineage, key-set evidence, dual-adapter races, queued coordinator reload/gap notifications during startup, unscheduled startup/reset overlap, and exact driver results. The persisted sync-problem oracle (`packages/db-sqlite-persistence-core/tests/persisted-sync-problem-oracle.test.ts`) owns how the wrapper reports failures of its own remote work and to which sync run: a later successful remote request ends the wrapper's remote failures (maintainer decision: a coarse clear, by any remote request that succeeds, the same one repeated or another; 8 histories failed before it, and a wrapper without the clear fails 7); 35 histories over eight sites (coordinator release, the adapter's own `unloadSubset` throw or reject, scoped refresh ensure and release, rotated reacquisition through a routed or single-process coordinator, and a reload's cleanup release), each crossed with ready or loading and with the current run or a run that `reload()` retired before or after the new run's `markReady()`. A remote failure is a ready Collection's failure reason and never a crash; before the first ready it is only logged; an `unloadSubset` breach surfaces uncaught; a retired run's failures change nothing in the new run and never reject its cleanup. HEAD failed 29 histories; mutants that crash, remove the generation fence, or let a cleanup release reject each fail. Limits: controlled adapter and coordinator doubles; no Browser or Electron follower routing; no coordinator retry queue. The persisted reload-replacement oracle (`packages/db-sqlite-persistence-core/tests/persisted-reload-replacement-oracle.test.ts`) checks over 40 histories that the wrapper forwards `begin({ snapshot })` and `truncate({ markReady })`, that its restore and metadata commits replace nothing and do not complete a reload, and that durable rows equal visible rows after a replacement. HEAD's wrapper failed 15; a dropped snapshot, a non-durable snapshot, dropped truncate options, and a restore marked as a snapshot each fail. Limits: eager Collection only, in-memory adapter. The setup-reopen owner checks that a fresh adapter's first read repairs an interrupted setup, every subset of missing indexes, triggers, and bookkeeping rows, and a schema change to the fresh-install schema with rows kept or reset; complete setup costs at most one driver call over a cached read. It excludes cache-generation claims and concurrent adapters; the held-registration resume cases cover a collected generation at the setup DDL and at the registry read. The reload class owner keeps the reload law, model, histories, driver loop, and comparison in one module, with four production drivers: the Node Browser driver (real Browser persistence and coordinator, one connection per tab), the Node Electron driver (real renderers and main handler with an in-process `ipcMain` double), the real Chromium OPFS page, and a real Electron app (renderer over real IPC to a main process running the Node persistence over `node:sqlite`). Histories cover 1 to 4 eager or managed Collections with any subset of missing derived setup facts, a schema change, a database missing a migrated column or index, lock grants 1 to 5 tasks after the request, statement latency where the host controls it, a local write during another startup read (issued before or after its grant), a write held in flight at another Collection's grant, a follower write, a write from a third tab, takeover (also while a follower read is held after an earlier follower or third-tab write, and while a follower that knows the departed leader's route has a source commit queued behind a held subset read, which it flushes after the grant or which the departed leader received and never answered), restart, and a tab closed while its terms wait. It checks skipped and repaired Collection and database setup, that no term runs ahead of work queued on its tab at its grant unless a leader need is live in that election (a need that an earlier election served exempts none), that needs elect and settle, that a takeover's queued source commit settles within one RPC timeout (one timeout and a retry when the departed leader received it), and an exact per-reload budget: one registry read per adapter, one row scan per tab, two startup snapshots per eager Collection (metadata before the source starts, rows at the baseline hydrate, both required by the Electric resume laws), no rescan after a commit the tab already knows, and no database setup statement when it is complete. The implementation on origin/main fails every fixed history: the original 24 on all four drivers, and the 5 that cover per-election needs on the Node Browser driver. Production on this branch passes all 29 on all four drivers. The Node drivers reject 14 production mutants by assertion, including a lasting need latch, an earlier served need from this tab or another, a need still waiting at the grant that is ignored, and a grant that keeps the departed leader's route. The per-election cells in `browser-coordinator.test.ts` (fixed tests; no oracle owner (tracked in #2264)) also reject those latches and a delayed heartbeat from the departed leader that restores its route during an election. Real Chromium rejects the never-waiting barrier across its histories; the real Electron app rejects it in 10 of the 29 fixed histories; in the others, real IPC finishes the startup reads before any grant. Hold seams patch the adapter in the process that runs it. Not owned here: a barrier that skips queued but not yet running regular work, which driver transaction order and the writer lock hide in reload histories; the shared logical scheduling oracle owns it. The real Electron app uses `node:sqlite` because Electron's ABI cannot load better-sqlite3; a native better-sqlite3 build for Electron is not run. The shared core-adapter contract checks custom local comparator dispatch for ascending, descending, and comparator-equal public-key ordering at `loadSubset` completion. Host packages register this contract, but the local sqlite3 CLI run does not prove native host execution. Browser composes public source commits with per-collection elected-owner routing and covers the complete committed-transaction wire partition through deterministic Node transport seams. Remote-subset histories distinguish logical demand, physical acquisitions, exact acquisition leases, and released replay tombstones. Electron composes source commits with a per-collection renderer owner, IPC adapter, real SQLite, and reopen checks. The shared-driver fairness owner checks K=1 complete-logical-hydrate scheduling with identical fixed, random, and seed-plus-path campaigns. It records public rows, raw dequeue reach, and a persist-first FIFO mutant control. Its Chromium OPFS fixture refines the provider boundary but does not establish a browser matrix, elapsed-time latency, unbounded eventuality, or multi-process coordination. Same-handle Node and OP-SQLite tests cover transaction admission. Controlled OPFS page/worker histories cover ownership and diagnostic-cause retention. The reset/resume owners use sqlite3 CLI and in-memory node:sqlite seams; they do not prove multi-process WAL, mobile/Tauri, or other native-device execution. Distinct database handles rely on SQLite lock admission rather than one in-process queue. React Native hosts without async-context propagation must use the transaction driver supplied to the callback for nested work. Fake workers and synthetic page events do not prove native handle release or real bfcache admission. The Browser composed seams are not real multi-context/OPFS-worker execution; the Electron harness is not an actual Electron process unless its explicit runtime-bridge mode runs. An ownerless elected node suppresses core routing, while a follower may route demand to the elected owner. The follower generation-notice and rotated-reacquisition grammars state the rotation law: a rotated follower holds the new generation's commit notices until the owner has reacquired every active demand, then ends scoped recovery and applies them. Production does not yet end that recovery, so their cells that require it are fixed as failing under the known limit [#2139](https://github.com/TanStack/db/issues/2139); the random generation-notice campaign is omitted until the fix, because some of its histories pass today. Cells that still pass cover failed reacquisitions (scoped recovery stays and the failure is reported), a superseding rotation as leader, and a scoped recovery without rotation, with or without an active demand (untrusted durable rows stay hidden). Other cells cover a follower whose claim expires while its ensure is in flight and an owner reset (the follower requests its demand again). The follower remote-demand grammar checks that a follower's load, and a live query over its demand, settle only after the owner's broadcast applies here, for a broadcast that applies at once, one queued behind another subset's hydration, and one while the cache claim is expired; the claim-rotation placement is fixed under #2139. A failed apply rejects the load, errors the query, and fails the source. A renewal that fails transiently at the reply rejects the load but keeps and retries the demand, without releasing the owner's acquisition; a rotation during the reply wait is tracked under #2139. The flush-side expiry check and arrival-order queueing have no killing witness yet. Removing the follower's wait on either ensure path, its terminal check, or the queued flush's terminal marking each fails it. The Electron IPC readiness oracle checks a fresh or reopened renderer, a successful or failed IPC hydration, and an upstream load that succeeds, fails, or is released during hydration, against a model of the three readiness checkpoints; a renderer that replies before the main-process read or treats an IPC failure as empty fails it. The owner is a controlled coordinator double, not two real coordinators; host coordinators retry only classified transport or admission failures while demand remains retained. The manifest excludes progressive and move suites; registration and shim runs are not device execution. The per-collection coordinator oracle's real-tab grammar runs a follower and an owner tab with real Browser coordinators over Node's BroadcastChannel and Web Locks and one real SQLite file: 16 histories over the owner's source (custom or Query Collection), the broadcast's placement, the follower's apply outcome, and the consumer, plus a rotation cell. Main fails all 16 histories; an owner tab for a rotated follower generation is not reachable there. The Electron IPC readiness oracle adds a follower and an owner renderer with Electron coordinators: 4 histories over the apply outcome and the consumer, in process and through a real Electron main process; main fails all 4. | | SQLite expression-index planning | [Node expression-index oracle](https://github.com/TanStack/db/blob/main/packages/node-db-sqlite-persistence/tests/expression-index-oracle.test.ts) | RFC #1659 invariant 8 owns identical persisted-index and runtime-expression shapes. Independent expected keys are checked against direct captured SQL, adapter results, and named-index plans. Generated BigInts use SQLite's signed range; one fixed case checks legacy oversized-value reads. Other limits: bounded unqualified JSON paths/scalars, Node BetterSQLite, and no null, arbitrary raw SQL, or native-host planning. Run the package's `test:oracles` campaign. | | Offline execution | [scheduler](https://github.com/TanStack/db/blob/main/packages/offline-transactions/tests/KeyScheduler-oracle.property.test.ts), [leadership](https://github.com/TanStack/db/blob/main/packages/offline-transactions/tests/leadership-replay-oracle.property.test.ts), [settlement](https://github.com/TanStack/db/blob/main/packages/offline-transactions/tests/transaction-settlement-oracle.property.test.ts), [serialization](https://github.com/TanStack/db/blob/main/packages/offline-transactions/tests/transaction-serializer-oracle.property.test.ts), [web connectivity replay](https://github.com/TanStack/db/blob/main/packages/offline-transactions/tests/connectivity-replay-oracle.test.ts), [review record](oracle-reviews/pr-1879-visible-replay.md) | Declarative FIFO eligibility, per-transaction outcomes, durable state and typed wire trees. The web connectivity owner checks a persisted write under a false browser online hint, then visible replay by event or explicit retry, at provider-call, outbox, and caller-settlement cuts. It uses controlled browser globals and fake storage; it does not prove actual browser network detection, genuine offline retry timing, multi-tab leadership transfer, or React Native behavior. Issued work may finish after ownership loss, but new work must not start. Exactly-once network execution is not promised. | | Frameworks | [React conformance](https://github.com/TanStack/db/blob/main/packages/react-db/tests/conformance.test.tsx), [React pagination](https://github.com/TanStack/db/blob/main/packages/react-db/tests/infinite-query-conformance.test.tsx), [shared framework contracts](https://github.com/TanStack/db/tree/main/packages/db/tests/conformance), [Vue synchronous publication](https://github.com/TanStack/db/blob/main/packages/vue-db/tests/useLiveQuery-publication-oracle.test.ts), [Preact conformance](https://github.com/TanStack/db/blob/main/packages/preact-db/tests/conformance.test.ts), [Preact binding witnesses](https://github.com/TanStack/db/blob/main/packages/preact-db/tests/useLiveQuery.test.ts) | Exact exposed rows/pages and each framework's own lifecycle cuts. Vue's synchronous watcher checks insert, update, and nonterminal delete through supplied Collection and identity query inputs; it does not cover an empty final result, multiple changes in one transaction, or query recompilation. A React witness does not prove Preact/Vue/Solid/Angular/Svelte scheduling. Preserve their receiving registrations. The Preact driver observes each result at commit through a layout-effect probe under an error boundary, because Preact runs passive effects after paint and `act` drains only those it scheduled; it has no Suspense, server-snapshot, or DbClient witness. Its binding witnesses check that a write between render and subscription publishes and that an equal `queryKey` or structurally equal query keeps its live-query Collection. Subscribing in a passive effect instead of a layout effect survives both, as allowed scheduling freedom. The query-identity laws (1.0, maintainer decisions 2026-10-22 and 2026-10-23) run through every live-query driver and the React, Preact, Vue, and Svelte infinite drivers, branching on each driver's public `comparesQueryIdentity` policy. In a binding that compares identity (React and Preact), a query without a nonempty `queryKey` whose IR has no stable hash throws `UnhashableQueryIRError` at mount and at recompilation; an empty key counts as none, and a nonempty key runs the query. React no longer accepts dependency arrays. Such a binding claims each source Collection ID it compiled, so A(x) -> C(y) -> A(x) is legal while a later B(x) throws `SourceCollectionIdReuseError`. A pairwise model judges 32 enumerated histories over A(x), B(x), C(y), and a disabled step, with declared reach for a swap after an intervening query, a swap after a disabled step, and a revisit after an intervening query. Reach labels name the steps between the claim and its test, so a direct swap does not count; removing the C(y) step fails reach. Claims that keep only the latest query, or reset at a disabled step, fail it. React retains two shared-suite registrations, but both now call the same derived-identity API; the registration still named `react (dependency list)` does not establish a second production path. The earlier five failures from skipping a dependency-list check at first compile were evidence for the removed API. A nonempty `queryKey` skips the claim: React and Preact witnesses swap a same-ID source under a changed key, and a key reader that ignores keys fails both. One query over two same-ID objects uses overlapping but different rows; an engine mutant that resolves each source through the Collection-ID map, so the last object serves both join sides, fails the live and infinite scenarios. A Svelte hydration witness checks that a `DbClient`-backed query with a dependency list hydrates `queryKey: []` exactly as it hydrates an omitted key. The infinite suite runs the same pairwise grammar over A(x), B(x), and C(y), 18 histories with declared reach for a swap and a revisit after an intervening query; it has no disabled or page-shape step, because one infinite handle changes either its query or its page shape. A new binding starts unclaimed. The former React dependency-list/`DbClient` witness is historical; it does not establish current reuse or hydration behavior. The shared conformance rejection scenarios currently check that, after a rejected rerender, two reads each throw or hold no rows. Reactive drivers accept an unhashable query, as described below. React unmounts a tree whose render throws. Preact keeps such a component mounted, so its driver mounts the hook under an error boundary, which unmounts it; a Preact component with no boundary keeps its last committed rows and is not witnessed here. It guards a future driver whose binding stays mounted; the `DbClient`-backed Svelte binding, which stays mounted, is checked field by field in fixed [descriptor release tests](https://github.com/TanStack/db/blob/main/packages/svelte-db/tests/descriptor-query-release.svelte.test.ts) (no oracle owner; tracked in #2264). A reactive binding (Vue, Solid, Angular, Svelte without a `DbClient`) runs the same histories and must publish the current input's rows: the unhashable query runs and recompiles when a captured value changes, and B(x) shows B's rows, never A's. One query over two same-ID objects is likewise rejected by a comparing binding and read through an inner join by a reactive one. The same mount-and-recompile split is not yet generated for `DbClient`-backed Svelte or React hooks beyond the receiving witnesses below. The [React source ID reuse oracle](https://github.com/TanStack/db/blob/main/packages/react-db/tests/source-id-reuse-oracle.test.tsx) owns the release law for `DbClient` descriptors: a rejected query releases every sync start it deferred. React exercises applicable causes (source-ID collision, unhashable IR, a descriptor factory that throws, a query rejected during compilation, a single-result infinite query, and a render abandoned by a sibling throw or suspension) through live, infinite, and Suspense hooks with derived identity or changed explicit `queryKey`, plus ordinary-hook configurations that disable reclamation, at initial mounts or rerenders and through four readers. Explicit keys bypass source-ID and derived-IR rejection; single-result rejection applies only to infinite hooks, and abandoned-after-hook histories exclude Suspense because its preload already starts the sources. Svelte crosses collision, unhashable, factory, compile, and abandoned-setup causes with eager and lazy sources and three readers, and its collision history reads every public result field separately after the rejection; dropping the guard from one getter, such as `isLoadingError`, fails all six collision cells. The earlier dependency-list Suspense cache-claim failures are historical. Current ordinary [source-ID tests](https://github.com/TanStack/db/blob/main/packages/react-db/tests/source-id-reuse.test.tsx) check separate client-scoped Suspense hooks and an initial suspended retry with different same-ID sources; they use the current derived-identity API. These fixed histories are supplemental tests, not a dimension of the claim grammar: that grammar's disabled step has no Suspense form, because `useLiveSuspenseQuery` rejects a disabled query. React ordinary/infinite hooks and Svelte's compiled query release at their render boundaries. The current React Suspense rejection histories fail within its shared ordinary-hook preparation; removing only the outer Suspense wrapper's catch is an unreached mutant, not a demonstrated kill. The former dependency-array SSR history was removed because its API is absent from the RC; it had executed no cells in the preceding grammar. Routing Svelte's getters around the compiled query fails its collision cells; `preload()` overrides a deferral, so those cells pass without the release by design. Declared reach: each enumerated release history asserts that the rejected query ran the shared descriptor's factory once before the reader, and a history that binds the failing descriptor first fails that check. A render that never commits (React: a sibling throws after the hook returns, or the render suspends; Svelte: setup throws after the hook returns) releases its deferral when garbage collection reclaims the live query it built (maintainer decision 2026-10-23), or after the unsubscribed GC floor when the hook's config disables that reclaim (`gcTime` 0 or `Infinity`, or `startSync: false`); both release grammars add these causes, React adds the three config paths and Svelte a `gcTime: 0` setup, and waiting only for the reclaim fails those cells; removing the reclaim release fails exactly them, and releasing at the end of render instead fails the descriptor binding owner's no-work-before-commit law. Known limit, owner the maintainer: the reclaim follows the 50 ms unsubscribed GC floor, so a render whose commit React holds past that floor releases its deferral, and its source may start, before it commits; that render then subscribes to a cleaned-up live query, which restarts. No history holds a commit past the floor, which needs a controlled React scheduler or fake timers; this joins the existing held-commit open cell in the infinite-query publication row. A keyed step records no claim and checks none (maintainer decision 2026-10-23): for a comparing binding the claim grammar adds keyed steps AK and BK over the same-ID objects, 108 histories with declared reach for a claim that crosses a keyed step and a keyed step after a claim; a keyed step that claims, or that resets earlier claims, fails it for the current React derived-identity path and for Preact. Each controllable driver records a publication log (`publication-log.ts`) at the end of each synchronous turn, plus the value on screen at the first paint after each `setParam`, once the framework has flushed and before any later task (maintainer decision 2026-10-23). After a same-ID swap, a reactive binding's every logged value holds only the new source's rows or none: a binding that keeps the old rows published until a later task fails it in Vue and Svelte. A value replaced within one synchronous turn is not logged, because the browser never paints it; Solid and Svelte publish the previous query's rows once inside the swap's own turn, for any input change, and pass. Accepted design (maintainer decision 2026-10-23): React claims source IDs during render, so a concurrent render that is abandoned before commit keeps its claim, as the React oracle states for a render that suspends, because that render's live query may still own the source until cleanup. Same-ID source objects stay legal; the claim, not `createCollection`, rejects a swap. Trace: committed C(y); a transition render reads B(x) and is interrupted; an urgent render reads A(x) and throws `SourceCollectionIdReuseError`. The abandoned-transition history has no witness. Adapter-specific `queryKey` change semantics stay with each adapter's own tests; React's infinite hook also has a focused witness that a `queryKey` array changed in place recompiles, because only React hands the caller's array to the shared window binding. The shared lifecycle histories distinguish adapter-created projections from caller-owned retention: omitted and explicitly `undefined` `gcTime` use the 1 ms adapter policy; `gcTime: 0`, a positive 100 ms retention, and supplied Collections keep caller authority. They observe retirement after unmount, replacement, disabling, and positive expiry, plus survival before that expiry. The shared suite also checks initial-query readiness over a lagging on-demand source, for a list and a `findOne` query and for the infinite query (React, Preact, Vue, and Svelte): not ready before the subset settles, ready at settlement while the source is still `loading`, and still ready after the source becomes ready. Solid's Suspense over that source has its own witness. A Solid Suspense witness also checks that a source's `reportError()` and `fail()` after readiness keep the boundary's rows shown and the query `ready`; a hook whose status follows the health tree fails it. A resource that suspends again on a tree change is not observable at that cut, because its refetch over a ready query settles before a fallback renders. A separate Solid two-resource Suspense witness holds one ready projection past the 50 ms unsubscribed floor while its sibling remains pending, then checks both commit and boundary abandonment release the temporary preload owner and preserve ordinary 1 ms teardown. | | Backend Collection E2E | [shared provider suites](https://github.com/TanStack/db/tree/main/packages/db-collection-e2e/src/suites); [Electric registration](https://github.com/TanStack/db/blob/main/packages/electric-db-collection/e2e/electric.e2e.test.ts); [Query registration](https://github.com/TanStack/db/blob/main/packages/query-db-collection/e2e/query.e2e.test.ts); [TrailBase registration](https://github.com/TanStack/db/blob/main/packages/trailbase-db-collection/e2e/trailbase.e2e.test.ts) | Electric, Query, and TrailBase register reusable predicate, pagination, join, and live-update checks at their provider boundaries; Electric also registers the move suite. These are receiving paths for core query and Collection laws, not framework render cuts. Shared e2e suites follow-up: the suites and `notification-laws-oracle.ts` declare no `owns` (they have no production code in `db-collection-e2e`), and no consumer (`electric.e2e.test.ts`, `query.e2e.test.ts`, `trailbase.e2e.test.ts`, `persisted-collection-conformance-contract.ts`) declares one either, so the gap report counts none of their kills. Owner: this row. Needed: `owns` in each consumer for the adapter entries it judges, which the gap report can run only once a consumer is an oracle-named file under the package's Vitest config; the consumers run under separate e2e configs or host runtimes, not under it. | | Window-controller overlap | [shared infinite-query conformance](https://github.com/TanStack/db/blob/main/packages/db/tests/conformance/infinite-suite-oracle.ts), [React driver](https://github.com/TanStack/db/blob/main/packages/react-db/tests/infinite-query-conformance.test.tsx), [Vue driver](https://github.com/TanStack/db/blob/main/packages/vue-db/tests/infinite-query-conformance.test.ts), [Svelte driver](https://github.com/TanStack/db/blob/main/packages/svelte-db/tests/infinite-query-conformance.svelte.test.ts), [Preact driver](https://github.com/TanStack/db/blob/main/packages/preact-db/tests/infinite-query-conformance.test.ts), [review record](oracle-reviews/dec-03-window-overlap.md) | Four or five ordered source rows, two window-settlement orders, and public snapshots after each settlement, a subscribed observer update, a detached controller read, and explicit recovery. Insertion and removal of the fifth row distinguish both continuation directions while an earlier error remains visible. The detached read follows a source change with no controller subscriber; its preloaded Collection retains the five-row window. The exact overlap uses the exported DB controller in each package realm. Framework hooks expose no controller preload, so this cell does not establish a hook scheduling path; direct hook paging remains in the adjacent shared scenarios. An unsubscribed controller has no notification claim. | | Infinite-query publication | [shared publication laws](https://github.com/TanStack/db/blob/main/packages/db/tests/conformance/infinite-suite-oracle.ts), [React render cuts](https://github.com/TanStack/db/blob/main/packages/react-db/tests/infinite-query-render-cuts-oracle.test.tsx), [Svelte hook tests](https://github.com/TanStack/db/blob/main/packages/svelte-db/tests/useLiveInfiniteQuery.svelte.test.ts), [review record](oracle-reviews/2026-10-05-infinite-first-paint.md) | Each driver records every value its framework published: React layout commits, Vue pre-flushes, and the Svelte construction value plus pre-effect runs. The shared suite checks that a synchronous source shows its ready first page on the first value, for a query callback and for a supplied collection that has not started, that every ready value in a fixed-source, fixed-query scenario equals the source prefix for its own page count, including an equal dependency replacement that keeps page depth, and that a mount requests an on-demand first window once, for a query callback and for a supplied collection whose finite window is wider than or equal to the one the hook needs, judged by the rows the on-demand source holds after mount. Under deferred acquisition, an on-demand first value is either the ready first page or a value with no rows, by framework: React and Svelte publish before the hook subscribes, Vue after. `preloaded-collection-first-paint` checks the documented route-loader pattern: a limited live query preloaded before mount shows its ready first page on the first value in every framework and asks the source for nothing more; a preload that does not count as demand never settles there. Pre-commit work has no shared form, because Vue setup is its commit. The React driver owns renders that never commit, StrictMode double renders (one first-window request on React 19), retries after GC, a mounted replacement whose startup error must reach the error boundary, and a collection kept from an abandoned render that enters terminal error before its query is selected again, each as under `useLiveQuery`. The React source ID reuse oracle drives the infinite hook too. Svelte owns construction and superseded recomputes before the subscribing effect. In both, the hook acquires an on-demand source as often as `useLiveQuery` does under the same history, for either input form, direct or behind a live-query Collection. On-demand requests from renders that never commit are now owned by the live-query deferred acquisition oracle; the React render-cut oracle checks that an abandoned render makes no acquisition. Open cells, owned here: React 18 StrictMode, where neither hook keeps refs across the double render; a React commit held after the 50 ms unsubscribed GC floor, where a controlled-premise controller witness shows no non-ready value but no React scheduling witness exists; ready values in scenarios that write the source or replace the query, which need a per-step source model; a join of eager and on-demand sources, which needs a zero-acquisition check before commit; a supplied collection with no `.limit`, which sends one unbounded request on `main` too, because the controller cannot narrow it before the source request; and Svelte `state_unsafe_mutation` when a start inside `$derived.by` synchronously writes rows a peer is waiting for, shared with Svelte's `useLiveQuery`, which a two-component probe reproduces and the deferred-acquisition follow-up removes. | | Structural values and ordered primitives | [hash values](https://github.com/TanStack/db/blob/main/packages/db-ivm/tests/hash-oracle.property.test.ts), [hash identity](https://github.com/TanStack/db/blob/main/packages/db-ivm/tests/hash-identity-oracle.property.test.ts), [MultiSet consolidation](https://github.com/TanStack/db/blob/main/packages/db-ivm/tests/multiset-consolidate-oracle.property.test.ts), [hash graphs](https://github.com/TanStack/db/blob/main/packages/db-ivm/tests/hash-graph-oracle.property.test.ts), [mixed hash graphs](https://github.com/TanStack/db/blob/main/packages/db-ivm/tests/hash-mixed-graph-oracle.property.test.ts), [hash retry](https://github.com/TanStack/db/blob/main/packages/db-ivm/tests/hash-failure-retry-oracle.property.test.ts), [murmur stream](https://github.com/TanStack/db/blob/main/packages/db-ivm/tests/murmur-stream-oracle.property.test.ts), [comparison](https://github.com/TanStack/db/blob/main/packages/db/tests/comparison-oracle.property.test.ts), [deep equality](https://github.com/TanStack/db/blob/main/packages/db/tests/utils-oracle.property.test.ts), [cursor](https://github.com/TanStack/db/blob/main/packages/db/tests/cursor-oracle.property.test.ts), [indexes](https://github.com/TanStack/db/blob/main/packages/db/tests/index-update-oracle.property.test.ts), [BTree Map](https://github.com/TanStack/db/blob/main/packages/db/tests/btree-map-oracle.test.ts), [query identity](https://github.com/TanStack/db/blob/main/packages/db/tests/query/identity-output-shape-oracle.test.ts), [LIKE semantics](https://github.com/TanStack/db/blob/main/packages/db/tests/query/compiler/evaluators-oracle.test.ts) | Independent flat values, graph topology, algebraic laws, structural object keys in code-unit order (the flat-value, identity and consolidation grammars include keys that tie under locale collation), murmur byte framing against a byte-at-a-time reference (block mixing, the finalizer and symbol framing have no owner there), Map/group/sort recomputation, expression denotation, custom comparator dispatch/reference identity/index compatibility, LIKE wildcard refinement, compiled output bags, declared value-pair agreement between D2 equality keys and IR equality operands, and Collection collation with exact public scan/index order and one-index reuse across repeated reads. The auto-index cells cross BasicIndex and BTreeIndex; scan cells omit indexes. Both paths cover lexical and numeric `en-US` locale defaults plus an explicit ordinary locale override of a numeric default. An unindexed six-row work cell bounds Collection collation resolution to at most two reads per ordered scan: one index-path check and one scan clause. Other locales and ordered histories are outside this owner. The identity pair grammar covers primitives, signed zero, NaN/invalid Date, valid Date/timestamp, binary/Buffer, Temporal, nested references, symbols, and functions; fixed and sampled pairs do not prove every JavaScript value or hash collision freedom. Ref proxies are expressions rather than literal values in this grammar. The utility owner additionally generates widths 6–12 of ambiguous object-valued Sets. An independent count/capacity model judges equal reordered bags, late unmatched prototypes, multiplicity deficits, and a generic plain/class bridge that needs reassignment. Row comparison requires exact shape/value counts; generic equality permits keyed class/plain/null bridges. General and row comparison paths run in both directions, with acyclic members or links back to the Set. Separate cubic scalar-field-read and scoped native Map/Set-operation ceilings reject repeated-comparison and cached-candidate factorial searches without a timing assertion. Empty and singleton neighbors use the same model. Thirteen declared states each reach 200 histories. A paired-input lane adds widths 1,024–3,072, distinct/interchangeable members, and root-linked cycles. Its eight states each reach 20 histories; linear scalar-read and native-operation ceilings protect this equal corresponding-member family. Arbitrary unordered inputs retain the polynomial fallback; arbitrary graph topology and nested-value cost remain outside these bounded work laws. The deep-equality owner also checks that `deepEquals` ignores Map and Set insertion order, RegExp `lastIndex`, array holes, and typed-array class, the rules draft equality keeps. It also checks that `sameRowValue` preserves record prototypes (maintainer decision 2026-11-03), while exported `deepEquals` retains its established keyed-class/plain/null/cross-realm bridge, that a class instance without enumerable keys equals only itself, that URLs compare by `href`, and that typed-array elements compare like numbers. The hash-values owner checks equal-hash consequences for independently constructed flat values. Distinct type identities are checked by the hash-identity owner through `equalHashValues`, including forced digest collisions; distinct 32-bit digests are not promised. The hash-identity owner checks `hash` and `equalHashValues` against one spec-level identity model: primitives with signed zero, NaN, and bigint; reference leaves (functions, registered handles, `File`, binary over 128 bytes); Date, binary, Temporal, and RegExp headers; array length and holes; Map and Set insertion order; and object keys in any order, for acyclic values and for cycles through arrays, Map values, Sets, and plain objects. Map/Set order sensitivity is pinned current behavior, not a promise. Arrays from another realm, RegExps with a `NaN` `lastIndex`, getters, proxies, other cycle carriers, and pairs that differ only in a back-edge target are outside its grammar; fixed cases keep equality's cross-realm length check and strict RegExp field comparison. `hash-work.test.ts` fixes how visited values and array/RegExp headers count toward the structural work cap, and that equality copies a shared Map's entries once per distinct pair ([code-weight hash dispatch review](oracle-reviews/code-weight-hash-dispatch.md)). Custom string indexes do not optimize ordinary ranges, and custom cursors remain unsupported. The LIKE owner covers boolean string matching and bounded work, not nullish three-valued logic or a general Unicode collation contract. Unsupported composite cursors reject. The MultiSet consolidation owner checks keyed, single-type, and structural identity, signed zero and NaN in keyed and single-number data, the retained first record, zero-sum removal, and input record contents. It does not assert output order. Its keyed grammar includes cross-type key and value collisions, non-finite numeric keys, the `\|` delimiter, symbol and function identity, and a direct-object/object-tuple delimiter control from #1948. Eight named collision witnesses and both generated campaigns are RED on `c879ba6d` and GREEN with the repair ([#1948 review record](oracle-reviews/issue-1948-keyed-consolidation.md)); the [code-weight consolidation review](oracle-reviews/code-weight-multiset-consolidation.md) records the earlier exclusion. The keyed reference uses direct value/reference equality, including SameValueZero for numeric keys. The unkeyed fallback keeps its original key and value domains. The direct `MultiSet` owner does not prove which `@tanstack/db` query shapes produce primitive keyed values or mixed-type source keys; that needs a live-query production witness. The index owner enforces one invalid-comparator law across both BasicIndex and BTreeIndex: for each comparator, accepted numeric prefix (including the empty prefix), and probe operation (add, update, eq/range lookup, take, build), the operation throws exactly when it receives a `NaN` or non-number result and never when every comparison is valid. A `signed infinity` comparator is the valid control, and a custom collation `compare` supplied through `compareOptions` is checked the same way. Two BTree Map split histories check inserted-key reads, exact whole-range payloads/order, size, and extrema, proving split placement follows the insertion index without a post-mutation comparison. A rejected index add or remove leaves the index refining its accepted rows; update and build are not atomic. At the Collection boundary, both index types and both write paths (optimistic insert, sync commit) crash the collection: status becomes `error` and the next mutation throws, so a usable collection never holds rows its subscribers were not told about. Open: a sync source can still commit writes on a collection in `error` state, which stores unpublished rows; this is existing `markError` behavior and needs a lifecycle-owner witness. Comparator transitivity is outside this evidence. | | Mixed-kind ordered prefixes | [mixed-kind public-order oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/query/mixed-index-order-oracle.test.ts) | A separate unindexed ready Collection computes the public ordered two-row prefix for the same keyed rows as an eager BasicIndex or BTreeIndex Collection. Five histories cross number/bigint, boolean/number, object/string, and array/object values, with insert, update, and delete transitions into and out of mixed domains. Ascending and descending reads use one ascending physical index, so descending checks exercise ReverseIndex. After preload and after both source copies commit each step, exact direct and live-query IDs must match the scan. Same-kind checkpoints verify that safe indexes still serve ordered reads. The original type-name index order failed eight ascending public-prefix checks. A second numeric source Map models a finite on-demand provider: a bigint enters and leaves the visible prefix, deletion requires an uninstalled row, and an offset window reaches a cursor after the retained BTree index loses ordered-plan eligibility. Public IDs match the independent provider order at each settled window; controls withholding either requested row fail those assertions. This owner does not define a global precedence among unlike values, cover in-place value mutation or arbitrary mixed-kind pairs, or prove that every retained on-demand traversal is safe after its source domain changes. | | WHERE predicate publication | [WHERE predicate publication oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/query/where-predicate-publication-oracle.property.test.ts), [`in` evaluator](https://github.com/TanStack/db/blob/main/packages/db/tests/query/compiler/in-evaluator-oracle.property.test.ts) ([review](oracle-reviews/perf-in-constant-set.md)) | An independent Kleene evaluator judges `eq`/`not`/`and`/`or` predicates over strings, a normalization-prefixed string, booleans, numbers, `NaN`, a valid Date, `null`, a missing field, and virtual fields. Snapshot histories with pending optimistic inserts compare a live query, direct subscribers with and without initial state, and `currentStateAsChanges`; change histories apply multi-key sync transactions, including reinsertion of a key deleted earlier, and compare every consumer's key set after each commit, on scan and `BasicIndex` paths. Peer subscribers share one field with different literals, plus one on a virtual field, so every published change must reach exactly the subscribers whose predicate it can satisfy; routing mutants that ignored the previous value, ignored the field, delivered a change twice, or routed while stale published rows awaited reconciliation fail here. Fixed witnesses cover a layout-only publication reaching a filtered subscriber as one empty batch, a filtered subscriber's empty Collection-readiness batch, retraction of a vanished row after eager cleanup and restart, and the new row plus exact subscriber update payload when a same-key row stays TRUE. A stale-live-value mutant survives the generated membership checks but fails the payload witness. A focused [property-visibility test](https://github.com/TanStack/db/blob/main/packages/db/tests/query/where-prefilter-property-visibility.test.ts) compares the public unindexed snapshot with the enriched-row contract for inherited, non-enumerable, enumerable-own, and nested getter paths; the pre-fix stored-row shortcut failed three of its four controls. Other property-descriptor and stateful-getter histories remain outside those fixed controls. Mutant for FALSE-for-UNKNOWN `eq`, `or` or number-literal subscription prefilters, a prefilter that ignores the previous value, a skipped readiness batch, a skip while stale published rows await reconciliation, and an unindexed snapshot scan that reads only synced rows while an optimistic insert or delete changes visibility passed the prior `@tanstack/db` suite and fail here. Change routing withholds a dropped row from an `eq` subscription before its sent key could be recorded, so a mutant that records dropped rows as sent is equivalent for routed predicates in this oracle. A focused `collection-subscription.test.ts` witness checks that a dropped insert or update, alone or beside a matching change, cannot advance a limited subscription's page offset under a routed `eq` and an unrouted `or` predicate; the unrouted cases beside a matching change kill that mutant, and the unrouted `alone` case does not. A loose-equality prefilter is an equivalent mutant: it only skips less. Skipping during truncate replay also survives; the replay's baseline diff re-derives the same retraction, so the guard keeps the prior dataflow without its own witness. Generated cleanup and restart histories for filtered subscribers remain open for the lifecycle publication owner. No-op updates, other comparison operators, Temporal and binary operands, joins, ordering, optimistic updates, and truncate are outside this owner. It runs in `@tanstack/db`'s `test:oracles` campaign. The [2026-09-30 review](https://github.com/TanStack/db/blob/main/docs/contributing/oracle-reviews/2026-09-30-where-predicate-and-join-keys.md) records each ORC outcome. Change routing was later removed in favor of pooled live queries; the routing mutants above are historical, and the same peer laws now check plain subscription dispatch. The unindexed snapshot prefilter was restored for compiled queries as one stored-row `eq` test on a string or boolean literal. Its property-visibility test also covers the reverse direction: a stored row with an inherited or non-enumerable field must still match `isUndefined` on that field, which a scan that evaluated the full predicate on stored rows fails. The `in` evaluator owner checks `in` against an independent linear reference over Dates, `NaN`, `-0`, BigInt, bytes, Temporal values, objects and nullish items, for constant and row-supplied lists. | | Joined result keys | [Joined result key oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/query/join-result-key-oracle.property.test.ts) | A nested-loop model recomputes the pair set of an inner, left, or full join over source keys drawn from plain, comma-bearing, bracket-bearing, and quoted strings, numbers beside the strings that print the same, both infinities, and `NaN`. After preload and each synced group change, the published rows must equal the model's pairs and the result key count must equal the row count. The comma-joined key encoding fails its two fixed histories and both campaigns; plain `JSON.stringify`, which prints infinities as the missing-side `null`, fails the fixed infinity history and both campaigns. A fixed histories in which a `NaN`-keyed pair leaves and re-forms fails when the join index compares source-key prefixes with `===`. Joins over subqueries, more than two sources, custom `getKey`, and optimistic mutations are outside this owner. It runs in `@tanstack/db`'s `test:oracles` campaign. The [2026-09-30 review](https://github.com/TanStack/db/blob/main/docs/contributing/oracle-reviews/2026-09-30-where-predicate-and-join-keys.md) records each ORC outcome. | | D2 Index storage | [Index refinement oracle](https://github.com/TanStack/db/blob/main/packages/db-ivm/tests/index-refinement-oracle.property.test.ts) | A plain-`Map` model sums multiplicities under a type-and-value identity in which `NaN` equals `NaN` and `-0` equals `0`. Histories of up to twelve additions to two keys mix prefixed arrays with `NaN`, `0`, `-0`, `1`, `'1'`, `1n`, and `'a'` prefixes and unprefixed values, with cancellation and reappearance. After each addition, `get` and `has` must equal the model. Each step also checks that `get` returns what `getIterator` yields, in its order, since the two walk the storage separately. Comparing prefixes with `===`, which disagrees with the `Map` that holds them, fails three fixed histories and both campaigns; the `-0` control passes under both. Every history also runs with `prefixIdentity`, where values under one key with the same prefix are one value; mutants that merge unprefixed values or ignore the option in a prefix map fail. The [structural identity oracle](https://github.com/TanStack/db/blob/main/packages/db-ivm/tests/structural-identity-oracle.property.test.ts) checks that `structuralIdentity` agrees with D2 value identity for equal representations (array subclasses, class instances, null prototypes, key order, non-enumerable symbols) and independent values, including separator-bearing strings and keys, enumerable symbol keys, Dates, RegExps with numeric `lastIndex`, Maps and Sets with zero to two entries (the second Set member is a fresh tagged array, so primitive deduplication and unwrapped reordering are outside this grammar), arrays with an optional enumerable `note` field, binary values, holes, deep nesting, and a cyclic value; an independent normal-form model decides equality and is checked against `equalHashValues`. The model expands `deep` shorthand into nested arrays. A fixed equal `deep`/array pair and adjacent-depth control guard the model boundary exposed by seed 1158727847/path 255. The equal-pair grammar crosses same-spec values with explicit-array/`deep` equivalent specs; the independent-pair grammar uses two specs. Both run fixed and fresh campaigns with guarded one-case seed/path replay. Fixed same-description symbols and equal-body Map/Set/object pairs expose collisions that random independent pairs rarely reach. Mutants that stringify symbols, collapse those three object-kind tags, drop a string's or key's length or an array's length, or omit Date and RegExp headers fail it. A first-entry-only Map/Set mutant and an array-identity mutant that ignores enumerable non-index fields fail the fixed comparisons; lowering the depth cap is equivalent, because the cap only bounds work. Open: reference-valued RegExp `lastIndex` can give D2-unequal values one defined identity and merge `groupBy` contributions ([#2192](https://github.com/TanStack/db/issues/2192)); the structural-identity and incrementalization owners need a production repair and receiving witness. Temporal values, other opaque reference values, large binary values, getters/proxies, and mutation between observations are outside this generated grammar. groupBy's use of it is owned by the incrementalization law: its string-extrema grammar fails a string identity without a length prefix, and a focused groupBy witness fails when the group key is left out of the identity. Compaction, presence tracking, and structural payloads are outside this owner; a focused test checks that an index built without presence (as reduce builds its indexes) throws when presence is read; the [reduce fast-path oracle](https://github.com/TanStack/db/blob/main/packages/db-ivm/tests/operators/reduce-fast-path-oracle.property.test.ts) compares the fast path's emitted entries one by one with the general path's, over keys that move between the paths, hash-merged outputs, -0, and zero and negative multiplicities, while an unchanged `NaN` output is owned by a focused reduce test; the join operator tests and incrementalization law own operator behavior. | | Pooled live queries | [pooled live query oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/query/pooled-live-query-oracle.property.test.ts) | An independent `eq` model (nullish UNKNOWN, Date as timestamp, `NaN` equal to `NaN`, `-0` equal to `0`) gives membership; a live-query Collection compiled for the same query gives order, values, and status. Histories mix sync transactions, optimistic writes confirmed or rolled back, peer mounts and unmounts, and source cleanup and restart, including cleanup while a write is pending and a mount between cleanup and restart. Wholesale observers must match after every step, granular changes must match a reference observer by type, key, value, and previous value and replay to the model's rows, the layout revision must advance when keys reorder, and observing must never build the live-query Collection. Peers may add a residual `not(eq(...))` conjunct, which the model evaluates itself; a view that ignores it, reports an unfiltered `entries()`, or delivers a row entering or leaving it as an update fails it. Other residual operators use the same compiler evaluator but are not generated. Peers may also order their rows by `id` or by a `g` that can be null, with explicit `nulls`; order comes from the reference. A comparator that ignores direction or `nulls`, an order left out of the partition key, and key order instead of the query's order each fail the fixed reorder history and both campaigns. A partition that ignores a row's previous group, orders by arrival, skips normalization, skips the initial snapshot, follows the source's status after cleanup, or never terminates fails it. Two shared conformance scenarios (`eq-filter-rows`, `eq-filter-peers`) run the pooled path under React, Vue, Solid, Svelte, and Angular; a partition that ignores a row's previous group fails both under every adapter, and `eq-filter-peers` checks through `subscriberCount` that each adapter shares one source subscription per partition while mounted and releases every source subscription after the final framework unmount. The [resource-lifetime oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/query/pooled-live-query-gc-oracle.test.ts) compares when a pooled query and a live-query Collection release their sources across `gcTime` 1, 100, 0, and `Infinity`, with and without a subscriber, and with no `gcTime`, where both use the live-query Collection default, checks that a partition waits for its views' longest `gcTime`, checks that a view resubscribed after its partition released follows later source writes as its live-query Collection does, including a view with a residual conjunct, and checks that a partition that subscribes again still serves new mounts from one source subscription. A generated cleanup-admission grammar (`pooled-live-query.cleanup-admission`) crosses 2–3 views of one partition, observed or not, read by a subscribed live query or not, and view cleanups with or without `dependents`; it checks the model's rejection rule and rows and status against live-query Collections. A view that gives up its partition share when its cleanup rejects fails it. A view whose own cleanup fulfilled must show `cleaned-up` with no rows (law 14, maintainer decision), checked against the model and the live-query Collection; a view that keeps its source's status or its group's rows fails it. Further focused witnesses check that a partition keeps groups only for values that have rows or watchers, that a detached reader never sees a dropped group's revision reused, keep a pooled query's public Collection live while the view is observed, accept it as a query source, and check that a pooled query turns terminal when source cleanup starts while the adapter's cleanup is still pending, as a live-query Collection does. A detached wholesale reader of every view, kept after its peer unmounts, must match the live-query Collection at every checkpoint, and generated histories cross the dependents cascade with readers on watched and unwatched groups that hold rows (declared reach); a cleanup that empties groups without advancing their revisions, or advances only watched groups, fails it. Every view and its live-query Collection also carry an app status listener that throws; each listener gets its own call and the throw is reported uncaught, so a view that lets a listener's throw stop the others or reject the source's cleanup fails it. Generated callback-boundary histories also compare ordinary compiled and pooled core observers across return/throw, Error/undefined, zero through three healthy peers, callback position before/after peers, and `gcTime` 1–3. Failed granular bootstrap retains no unreturned ownership after grace; a held cascade cleanup (`cleanup({ dependents: true })`) gives every admitted wholesale observer one terminal `cleaned-up` snapshot/callback despite a sibling throw, and an ended partition stops following its source's health, and preserves the exact failure at settlement. Original production and independent rollback-only or all-peer-only repairs fail the respective ownership or cleanup-start comparisons. These controlled core receiving paths do not establish framework schedules, arbitrary callback programs or provider shutdown. A fixed oracle witness checks that an `eq` path whose getter throws excludes the row on both paths; a pooled path that rethrows fails it. The pooled oracle's grammar never releases a partition, so release and resubscribe histories rely on these fixed witnesses; a fixed delay, a missing unsubscribed floor, a last-`gcTime`-wins rule, and releasing at `gcTime` 0 each fail it. Removing the partition's final-listener release survives the mounted row checks but fails the shared framework unmount checkpoint and core release-timing owner. The [2026-10-01 review](oracle-reviews/2026-10-01-pooled-live-queries.md) records each ORC outcome. The shared adapter conformance suite checks the opt-in boundary in every framework: queries without `pool` keep a source subscription each in the function, config, and parameterized forms, and a pooled parameterized query follows its parameter between pool groups beside an unchanged peer. Pooling every query by default, a pooled identity that ignores literal values (React then reuses the old query), and an Angular `params` form that drops `pool` each fail it. `pooled-param-change` also reads each driver's publication log: every value published after a switch holds only the new group's rows. Each driver also logs its keyed `state` map at the same points, and the law applies to it. A pooled view that serves the previous view's rows until a later task replaces them passes every final-state check and fails only the log, in all six drivers. A view that sends the previous rows as its first change set fails the `state` log in Vue; Solid rebuilds its map from a snapshot within the same turn, and Angular builds its map from `entries()`, so that mutant cannot reach them. The `invalid-pool` scenario requires `InvalidPoolOptionError` for `true` and for `false` (the value adapters pass to say a hook cannot pool), alone, beside `gcTime`, beside `queryKey`, on a parameterized query, and on a disabled config or parameterized query, in all six drivers; a check in only one of the three readers of `pool` fails it in four of them, and Angular's `params` form failed the `false` and disabled cases until it checked its pool first. The shared `grouping-operator-switch` scenario re-renders a grouped query without `groupKeys()`, and `compile-error-after-rerender` re-renders to a select that mixes a source field with an aggregate; both require the error and no rows after it. A binding that keeps its last compiled query when compilation throws fails both in Solid, Svelte, and Angular; one that throws once and then serves that query fails the no-rows check in Solid and Svelte, and cannot occur in Angular, whose `computed` rethrows a cached error until an input changes. In `grouping-operator-switch`, React and Preact kept the grouped query before query identity held operator code, and Vue served the previous rows before its compile error stopped reaching readers through a throwing computed (also on `main` at `5649a07d4`). Its declared reach also requires successful wholesale, granular and detached observer comparisons on the same-copy pooled view, whose authoritative clocks do not require a separate layout subscription channel. | | Live-query deferred acquisition | [deferred acquisition oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/live-query-deferred-acquisition-oracle.test.ts), [React Suspense warm-cache witness](https://github.com/TanStack/db/blob/main/packages/react-db/tests/suspense-warm-cache.test.tsx) | An independent model of the law that a live-query Collection starts no provider work before a subscriber or a preload in its current sync run crosses seven source states (eager or on-demand, idle, already started or render-deferred, and an on-demand source that already holds the rows), an unordered query and an ordered window, one or two live-query levels, and eleven histories: start and read, subscribe or preload after a start, subscribe or preload without one, deferred subscription and resumption with or without a start, cleanup before a subscriber, peer start, source truncate, and restart after a run that had one. After every command it checks source sync-run starts, acquisition attempts, readiness when the call returns (the synchronous observation cut), settled readiness, and rows. A pooled block checks that building a pooled view starts no idle eager source until a view subscribes or preloads, and eight DbClient histories check that a preload answered by a pending or settled stream still resumes acquisition across eager/on-demand idle and render-deferred sources. The React streaming witness receives the on-demand render-deferral premise, starts local acquisition before the stream settles, and retains server rows until browser acquisition completes. Mutants that never defer, keep the subscriber-or-preload fact across cleanup, ignore preload, never resume a builder's subscriptions, let a deferring subscriber start a base source, build a pooled partition without deferral, never resume it, mark a preload one microtask late, or drop the stream's preload mark each fail it. The React witness checks that `useLiveSuspenseQuery` over a source that already holds the rows renders without the fallback, for eager and on-demand sources and both shapes; creating the Suspense collection started, or not preloading it in render, fails it. A later review added `peer` and `truncate` commands: a peer that starts an idle on-demand source, or a truncate on a running one, made the live query acquire before any subscriber, and both guards are killed separately. Fixed blocks check that a subscriber surviving cleanup is served after a restart while a surviving deferring subscriber is not, and that `toArrayWhenReady()` and `stateWhenReady()` count as a preload. A fixed block checks that a deferring live query is not counted in its source's `subscriberCount` or `subscribers:change` until its first subscriber, while still keeping the source from garbage collection; a Query Collection test checks that it causes no refetch. Another fixed block checks that a preload or subscriber requested by an inner live query's status handler, while the outer query creates its subscription to it, still resumes acquisition. Solid's Suspense receiving witnesses check that a resource whose preload settles first retains its live-query Collection while its sibling remains pending past the unsubscribed floor, then releases that temporary owner on both commit and abandonment, and that a preload settling after its owner unmounts cannot publish an error through the abandoned result. Open: source failure and asynchronous loads before resumption, which the subscription lifecycle oracle owns once acquisition resumes; a resume that throws, which leaves later sources unstarted only for a live query that is already in error; asynchronous sources; and arbitrary Suspense schedules with a `DbClient` beyond the bounded abandoned-render and streaming handoffs recorded above. | | Live-query notification algebra | [real-query and checker calibration](https://github.com/TanStack/db/blob/main/packages/db/tests/notification-laws-oracle.test.ts), [independent Map checker](https://github.com/TanStack/db/blob/main/packages/db-collection-e2e/src/utils/notification-laws-oracle.ts) | One-key synchronous source histories check exact live-query callback reconstruction and unsubscribe silence. Synthetic multi-key histories calibrate the checker; direct source Collection events remain with the change-event history owner. | | Flat-row change tracking | [flat change tracking oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/flat-change-tracking-oracle.property.test.ts) | Generated callbacks over flat rows, frozen or not and with or without a non-enumerable field (assignments of `0`, `-0`, `NaN`, `undefined`, functions, and fresh objects; reverts; deletions; added fields; data and accessor `defineProperty`; stored drafts; throws), run through the flat tracker, the draft proxy, and an independent model, which must report the same change sets, with `0` and `-0` distinct (maintainer decision, 2026-10-29: writing one over the other is a change), or throw the same error and leave the rows unchanged. Defining a field acts as assigning it, and a non-enumerable field is row data only once written; the proxy broke three of those laws on `main` and the flat tracker one. Diffs using `!==`, `Object.is` alone, or no deletions fail it. It found that the proxy dropped a field added as `undefined` when another field reverted; the fixed histories and both campaigns fail without that fix. Non-flat rows must fall back. The [2026-10-01 review](oracle-reviews/2026-10-01-pooled-live-queries.md) records each ORC outcome. | | Virtual props cache | [cache laws](https://github.com/TanStack/db/blob/main/packages/db/tests/virtual-props-cache.test.ts) | Focused laws for the per-key cache of rows read with virtual props: a change's published value is the row later `get` and `toArray` reads return, for every subscriber, after sync and local writes, and a key that is deleted or rolled back leaves the cache. Enriching the value before the previous value fails the first two; skipping the drop on delete events fails the third. Rows read with virtual props through other paths, such as joins, are outside these laws. | | LocalStorage Collection | [write order over every short history](../../packages/db/tests/local-storage-write-order-oracle.test.ts) (`local-storage.write-order`), [peers over every short history](../../packages/db/tests/local-storage-peers-oracle.test.ts) (`local-storage.peers`), [mutation order](../../packages/db/tests/local-storage-order-oracle.test.ts), [peer snapshots and ownership](../../packages/db/tests/local-storage-peer-history.test.ts) (fixed tests; no oracle owner (tracked in #2264)) | The `local-storage.write-order` property runs every history of one to three automatic updates and deletes of two stored rows (1,448 histories), every handler completion order, and every decision vector. After each handler finishes, no accepted write may have settled ahead of an undecided predecessor, and storage may hold only the author-order fold of part of the released prefix; a rejected write may settle as soon as its own handler fails (the two-write loops it replaced also held a rejected later receipt for two microtasks, which no law requires). At settlement, outcomes, durable rows, public rows, and a fresh restore equal the fold of the accepted writes. Against `src/local-storage.ts` mutants it detects every mutant that the finite two-write loops it replaced detected (63), plus one. Inserts are excluded: an insert after a rejected delete of the same key is undecided behaviour. The `local-storage.peers` property runs every history of up to three actions (19,289 histories) across Collections A and B in one tab and C in another tab over the same bytes. Actions are direct, manual-acceptance, handler, and custom-parser writes of string keys and the number key 7, a held update by A, `clearStorage()` from any Collection, `reload()` of C, and delivery of pending storage events. After each action, stored rows equal the model's read-modify-write fold. Every Collection in the writing tab shows the stored rows, because a write reads storage for its whole tab (maintainer decision D43, 2026-11-02, raised by three comparison gaps in the gap report). The holder's own pending row overlays only the holder, and while it is held the holder may show its earlier view of other keys (glossary, accepted sync transaction). The other tab shows a changed row once its event arrives or it reloads. A fresh Collection restores the stored rows. Against `src/local-storage.ts` mutants the LocalStorage oracles detect 201 of 320 with this property and 153 without it; detections in the peer and event functions rise from 36 to 70 of 131. Excluded: write races between tabs on one key, value-normalizing parsers, startup errors, storage faults, and cleanup. A nested fire-and-forget admission checks that the outer write reaches storage first; awaiting the nested receipt inside its earlier handler is an excluded dependency cycle. Handler-free direct insert, update, and delete are checked at the method-return boundary for synchronous Storage effects. A later handler failure is checked while its earlier handler remains held: its receipt rejects and its optimistic row rolls back promptly, while the durable predecessor remains pending. Only two fixed tests in `packages/db/tests/local-storage-order.test.ts` check this (same and disjoint key); no generated history does. Open: `local-storage.write-order` needs a checkpoint a macrotask after a rejected release that compares the rejected write's receipt and public row with the model. Fixed tests in `packages/db/tests/local-storage-order.test.ts` (no oracle owner (tracked in #2264)) cover the next two histories. An automatic insert followed by manual acceptance crosses same-key update versus disjoint insert and both earlier-handler decisions; manual settlement waits behind that handler, and public, durable, and fresh-restore rows match the authored fold. Un-awaited manual acceptance crosses direct and held-predecessor paths with success or Storage failure: both commit and persistence receipts wait for every registered write, report the exact fault on failure, and agree with durable and public rows at settlement. A two-Collection witness checks that one manual receipt waits for both un-awaited acceptances. Peer witnesses check serialized disjoint typed-key writes before delayed event delivery, equal-ID manual Collection ownership, construction-time rejection of direct or shallow-copy reuse before or after first preload with the first Collection still writable, a peer insert during pending local insert, listener release across cleanup/restart, malformed startup snapshots, transient startup read failures and restart, the null-versus-empty storage sentinel, local and peer clear publication with subsequent public/durable agreement and a pending optimistic mutation across clear, and storage/parser read failures during writes and event delivery. Reload witnesses let another tab (a second Storage object over the same bytes) update or delete a kept row and insert a row, or clear storage, while no event reaches the first tab, with and without a prior local edit of the kept row: `reload()` must resolve with the Collection `ready` and its public rows equal to the durable rows and a fresh restore, and the reloaded run must confirm a later write. The adapter that re-inserted stored rows in each run crashed on the update histories and kept the deleted row; a snapshot only for non-empty storage fails the clear histories. The [same-tab audit](oracle-reviews/2026-10-08-localstorage-same-tab.md) records witnesses that withhold events through each persistence receipt: disjoint typed keys, a manually accepted same-key update followed by automatic update and delete, clear, a rejected Storage write, a pending same-key optimistic insert, cleanup/restart, and a write started by a ready-status listener compare public snapshots with the authored durable fold. A default jsdom Storage witness receives a same-tab write. The old event-only adapter fails seven no-event checkpoints. The original adapter also fails the second-handler-first, delayed-peer, equal-ID, listener-release, read-failure, synchronous direct-write, prompt-failure, mixed manual/automatic order, un-awaited manual receipt, reused-options admission, malformed-startup, and clear-publication witnesses. A failed write read rejects without replacing durable rows; a failed event read retains the public snapshot until a later valid event. These checks do not establish simultaneous cross-tab read-modify-write atomicity, atomic acceptance across distinct storage keys, manual acceptance without a mutation Collection owner, arbitrary long histories, native browser scheduling, or synchronization across distinct custom Storage wrapper objects. Existing LocalStorage failure and CRUD tests remain supporting examples. | | LocalStorage value fidelity | [JSON value model](../../packages/db/tests/local-storage-value-fidelity-oracle.property.test.ts) | With the default JSON parser, an insert, update, manual insert, or manual update is accepted only if a fresh restore can return the row. A recursive value grammar labels each generated value, while it is built, with its expected JSON form or as lost. Lost: functions, symbols, enumerable symbol keys, `NaN` and infinities (also boxed), `undefined` and missing array entries, arrays with extra or symbol properties, a `toJSON` that returns `undefined` in an array, and Map, Set, WeakMap, Promise, RegExp, Uint8Array, and SharedArrayBuffer values. Normalized: `toJSON` values (Date, a plain object, and a function with its own `toJSON`), `undefined` properties and `toJSON` results, `-0`, boxed finite numbers, and non-enumerable symbol keys. Histories cross the four entry paths with and without an automatic handler. At `when('settled')` settlement, an accepted row must keep the authored writer value, store the model's form durably, and restore it in a fresh Collection; a lost row must reject with `SerializationError`, leave the writer's predecessor and storage bytes unchanged, and never call the handler. Fixed histories cover every lost kind and normalization on each path, with and without a handler; a fixed-seed and a random campaign of 300 histories run under `local-storage.value-fidelity`. A fixed histories per entry path uses a `toJSON` that changes after its first call: storage must hold the JSON the check accepted, and serializing the row again during the key check or the snapshot write each fails it. The stringify-only check on `main` fails 162 of 230 cells. The first walker in this PR failed 66 cells of the expanded grammar. Mutants that reject `undefined` properties, accept `undefined` array entries, skip boxed-number unwrapping, treat non-enumerable symbol keys as lost, skip the array-property check, or shrink the opaque-type list each fail at least six cells. Open: custom parsers, including a wrapper around `JSON` (accepted by design, documented); class instances (accepted by design; the guide states they restore as plain objects); cross-realm natives; getters; non-enumerable string data; update payloads whose shape the draft copy changes (array extra properties and symbol keys are dropped, and a hidden symbol key becomes enumerable, so an update of an object with a hidden symbol key rejects although its insert succeeds), which the proxy detachment owner must decide; peer or event delivery of a rejected write, which never reaches storage; and peer delivery of normalized values: the peer owner checks only `Date` at that boundary, so a peer receiving witness for the generated value grammar remains with the peer owner. IndexedDB clone rejection is owned by the IndexedDB settlement and values oracles, which require `SerializationError`; local-only rows keep values by reference, fixed in `local-only.test.ts`. | | Local-only direct writes | [direct write witnesses](https://github.com/TanStack/db/blob/main/packages/db/tests/local-only-direct-write-oracle.test.ts) | Focused witnesses fix when a local-only direct write skips the optimistic stage: a completed transaction and one publication per write, and the fallbacks for a pending, persisting, or ambient transaction and a user handler, for insert, update, and delete. Each history also runs on a local-only Collection whose handlers resolve, which must match its rows, change batches, errors, and transaction states, across mixed multi-key batches, a batch that fails midway, schema rejection, and handler rollback. Mutants that drop each guard, write only the first mutation, or never complete the transaction fail them. The change-event history oracle drives the direct path through generated histories (about two thousand writes per run); removing the guard, or guarding only persisting transactions, fails these witnesses. | | Reused sync row objects | [reused row witness](https://github.com/TanStack/db/blob/main/packages/db/tests/sync-reused-row.test.ts) | Focused witnesses for a sync source that changes a stored row object in place: in development, writing it again as an update without `previousValue` throws, while the same write with `previousValue`, or with a new object, moves the row out of an `eq` live query. Production skips the check. The check compares a shallow snapshot taken when the object was written, so it misses changes to nested fields; a write that names `previousValue` and a row whose fields throw on read are not checked. | | Index suggestions | [index suggestion oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/index-suggestion-oracle.test.ts) | A public filtered live-query Collection checks manual/default, eager, threshold, matching-index, and unrelated-index cases against the documented collection-size suggestion policy. A bounded ordered-query decision table separately classifies no field index, a null-placement mismatch, matching but order-ineligible indexes, and usable candidates in either registration order. It compares the development warning after preload; the matching-index selection owner below checks the chosen reader and ordered request. Two cyclic locale-options cells require the diagnostic to preserve valid query construction with or without a field index, and a custom-collation cell requires remediation to preserve comparator reference identity. The original manual-silence/eager-noise implementation failed two expected observations. The issue #2190 baseline failed four diagnostic cells, including a first-unusable/second-usable candidate order; the first formatter draft failed all three non-JSON-safe remediation cells. The owner does not judge repeated-query warning volume, slow-query timing, production-build suppression, every comparison-option mismatch, or every query shape. It runs in `@tanstack/db`'s `test:oracles` campaign. | | Minified DB public API | [consumer bundle check](https://github.com/TanStack/db/blob/main/scripts/test-minified-db.mjs) | CI builds `@tanstack/db`, then bundles its built `dist` entry with db-ivm inlined through esbuild `minify: true`. The build renames TypeScript-private members from `packages/db/mangle-cache.json`, so this grammar runs against the renamed output that consumers install. It rejects a `dist` that is older than `src`, the cache, or the package's build configuration. `pnpm --filter @tanstack/db test:dist` also runs five db test files against the built `dist`, chosen for coverage of the modules with the most renamed members. `pnpm check:mangle` fails when a cached name is used other than as a private member in db src, is read by another package, appears as a string, or has a short name that collides with a source identifier ([private-member mangling review](oracle-reviews/code-weight-private-member-mangling.md)). It checks every exported error class's current public `name`, the built-in `BasicIndex` resolver name in index metadata and its event, complete query rows (after removing the four documented virtual fields) against an independent array filter/sort/projection, and one live update. The `new.target.name`, public-member mangle, and extra-output-field calibration modes fail at the intended observations. This fixed slice does not replace the unminified generated oracles, exercise framework adapters, or establish stable names for custom index resolvers. | | Boundary refinements | [cleanup/restart](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-cleanup-restart-oracle.test.ts), [idle cleanup](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-idle-cleanup.test.ts), [issue #1891 async-cleanup review](oracle-reviews/issue-1891-async-cleanup.md), [issue #1891 cleanup-start follow-up](oracle-reviews/issue-1891-cleanup-start-followup.md), [metadata publication](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-metadata-publication-oracle.property.test.ts), [row metadata composition](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-row-metadata-composition-oracle.test.ts), [nested-begin metadata rebuild review](oracle-reviews/2026-10-06-nested-begin-metadata-rebuild.md), [state mutation round 4](oracle-reviews/2026-10-06-state-mutation-round-4.md), [state retention](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-state-retention-oracle.property.test.ts), [acquisition cells](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-subscription-lifecycle-cells.test.ts) (fixed tests; no oracle owner (tracked in #2264)), [D2 source reconciliation](https://github.com/TanStack/db/blob/main/packages/db/tests/d2-source-reconciliation-oracle.property.test.ts), [top-K support windows](https://github.com/TanStack/db/blob/main/packages/db-ivm/tests/operators/topk-support-window-oracle.test.ts), [nested Query work](https://github.com/TanStack/db/blob/main/packages/query-db-collection/tests/includes-work-counter-oracle.test.ts) | Explicit lifecycle products, independent source maps and weighted relations, exact publication cuts, support/multiplicity, and value-plus-work observations. These refine the larger subsystem models; they do not replace them. The cleanup/restart owner's failing-dependents product crosses every ordered pair of resolving, throwing, rejecting, held, and pooled-throwing dependent ends with synchronous, held, and rejecting adapter cleanup and both release orders, with declared reach; it rejects a cleanup that stops at a throwing dependent, settles with `Promise.all`, or waits only for its dependents. Effects and nested live-query chains with failing ends are not generated. | | Small structures and test mechanics | [SortedMap](https://github.com/TanStack/db/blob/main/packages/db/tests/SortedMap-oracle.test.ts), [cleanup queue](https://github.com/TanStack/db/blob/main/packages/db/tests/cleanup-queue-oracle.property.test.ts), [live-query GC clock](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-gc-clock.test.ts), [guarded replay](https://github.com/TanStack/db/blob/main/packages/db/tests/oracle-replay.test.ts) | Map/full-sort and elapsed appointment-list models with executed target/seed/path checks. SortedMap promises what Collection state uses, not full Map parity (maintainer decision). Keys are strings or numbers: `sync.write` and mutations throw `InvalidKeyError` or `UndefinedKeyError` for any other key, and grouped live queries key nullish, boolean, and bigint group values with strings (maintainer decision, 2026-10-27). The model is a Map of numbers plus a full sort; production stores row objects so the driver can change one in place. Keys include `NaN`, which a grouped live query uses for a `NaN` group; it is one key that key order places after every other number. Generated histories mix deferred and immediate sets and deletes, clear, deferred bursts of 17 to 41 keys, prunes that delete entries with deferOrder while iterating, and in-place changes of a deferred or a placed row. A prune must yield the order it began with. A row changed before restore sorts by its current value; once a placed row changes in place, comparator order downgrades to membership (each key once, current value) for the rest of the history, and a later write or delete affects only its own key. At each ordered read with a comparator, restoring k deferred keys among n others makes at most k * (ceil(log2 k) + ceil(log2 (n + 1)) + 2) comparator calls, and none with nothing deferred. Declared reach (minimum 5, per campaign of 100): burst restorations, an entry yielded after a prune deleted one, a placed `NaN` key written without deferral (7 to 16), a restore whose bound is below n (19 to 30), a changed placed row later written (11 to 20), and a deferred row changed before restore (11 to 19). Mutants that re-sort every key (108 calls against a bound of 7), re-sort the kept keys with the dirty keys appended (34 against 7), re-sort clean scans, drop the scan fallback for a changed row, match slots by `===` (a placed `NaN` key then removes the last key), keep dirty slots, apply deferred deletes immediately, or place a deferred row by its value at the write each fail. Supplemental examples in `SortedMap.test.ts` fix splice movement at scale, a key iterator opened before a deferred restore, scan reuse, and public single-transaction and queued-transaction Collection sync paths. Not promised: other mutation during iteration (immediate writes, clear), the order of rows once a placed row changed in place, keys outside the key type, `-0` keys, a comparator that throws, and the work of key order without a comparator, which the public API cannot observe. `forEach` was removed; SortedMap is not exported. Wall-clock steps do not move due times, and a focused public witness checks source subscription release. Callback-reentrant scheduling, OS suspend/resume, environments without `performance.now()`, and fake/real Performance clock replacement while GC is pending remain outside this coverage. Tests must drain or reset pending GC before switching timer providers. | The index-suggestion oracle's PR #2196 extension checks a matching local custom-collation index against the full-source request and retained warning, an ordinary unindexed on-demand prefix against its bounded request, virtual field advice, and direction-free comparison guidance. It observes first acquisitions and warning text, not later window moves or real-provider cost. ## Unit-test retirement transfers in PR #2116 The [direct index refinement oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/index-update-oracle.property.test.ts) owns the seven behaviors moved from index unit tests: an absent lower bound with an exclusive flag; exact membership through comparator-equal updates; `null` and `undefined` exact and `IN` membership, including repeated owners; undefined endpoint and cursor traversal; and explicit, omitted, and double-undefined range bounds. A source Map predicts exact key sets and ordered reads after bounded direct actions on BasicIndex and BTreeIndex. A full-build witness catches native `Array.sort` moving raw `undefined` last. The [round 1](oracle-reviews/index-unit-retirement-round-1.md), [round 2](oracle-reviews/index-unit-retirement-round-2.md), [round 3](oracle-reviews/index-unit-retirement-round-3.md), and [round 4](oracle-reviews/index-unit-retirement-round-4.md) ledgers retain each retired assertion. The [build review](oracle-reviews/basic-index-nullish-build.md) records the direct RED/GREEN repair. A separate mixed number/string grammar checks that full direct traversals and one indexed, bounded public Collection snapshot return each live source key once after deletion and after a direct delete/update/re-add history. Two more direct histories keep an ordinary string beside ordered ZonedDateTime or Duration keys and verify key conservation after one Temporal deletion. An en-US locale and a custom string-collation cell compare the first bounded public row through a scan and each index when an ordinary string begins the internal encoding prefix. An `origin/main` probe failed the default-locale public prefix case. The pre-classifier PR comparator failed all four public prefix cases and both BTree Temporal-deletion histories. This owner also compares complete forward and reverse reads through `IndexInterface`, without prescribing index buckets or a BTree representative. A fixed churn witness holds one live row while 16, 64, or 256 earlier distinct values are added and removed; its public `takeFromStart(1)` result and comparator-call growth reject retained empty buckets that add comparator work. This is a bounded read-work check, not a memory bound or a general complexity proof. A deliberate empty-bucket mutant failed at the intended comparator-count comparison. The invalid-comparator owner checks rejection exactly when a comparison returns a non-number or `NaN` and checks rejected removal atomicity; it does not require a comparison merely because one comparator-equal row is removed. The binary grammar checks fresh equal-content removal, re-addition, and replacement beside another byte value. It compares complete forward and reverse key reads to a source Map. Separate short and 8193-byte pairs check exact membership and complete forward and reverse key conservation when only the last byte differs. An intermediate PR BTree rewrite lost a surviving key after one equal-content owner left; the expanded grammar rejected that result. A separate two-value Date, Temporal.Instant, and Uint8Array callback grammar checks legacy scalar input kinds on direct add only. Arbitrary callbacks and update, build, and range paths are outside that grammar. This owner does not prescribe mixed-kind order or cover binary range ordering, all JavaScript value kinds, or general Collection publication histories. The [comparison oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/comparison-oracle.property.test.ts) uses the shared grammars and independent checks in `packages/db/tests/comparison-laws-oracle.ts` and owns the transferred same-realm NaN and invalid-Date default-order cases, plus ordinary PlainDate calendar and ZonedDateTime instant order. Its independent supplied values predict direct comparator signs and ties. The [round 5](oracle-reviews/comparison-unit-retirement-round-5.md) and [round 6](oracle-reviews/comparison-unit-retirement-round-6.md) ledgers name the retired examples. Mixed-kind order, cross-realm values, modified built-ins, and public indexed reads are outside this transfer. The [deep-equality oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/utils-oracle.property.test.ts) owns the transferred same-realm Date and RegExp equality boundaries: equal copies, changed values, and inequality with timestamp, ISO, or source text. The [round 7 ledger](oracle-reviews/utils-unit-retirement-round-7.md) retains the retired examples. Caller-modified built-ins and Collection publication are outside this direct-return owner. Its shared sparse-array value part (`sparse-array-value-oracle.ts`) generates lengths 1–5 with a guaranteed hole, other holes/undefined/numbers, a target position and a defined replacement. `utils.31` checks hole/undefined equality and hole/defined inequality through both APIs and directions, directly, in records, and in singleton Sets. Its seven states each reach 200 histories. The snapshot owner receives the same authored positional model through real source Collection/change mirrors and direct or projected observers, both modes, attached/detached, retaining earlier captures. Its fourteen states each reach 20 histories per fixed/fresh campaign. Before the indexed-array repair, source writes to a hole could change reads without an event or clock bump; these receiving comparisons were RED before production changed. The original hole-skipping mutant fails direct and receiving guarded replays. This law permits a hole to equal undefined; draft/persisted presence fidelity is separate. Framework/provider scheduling and arbitrary nested graph topology are not claimed. The native-operation work instrument closes the demonstrated cached DFS gap, but CPU implemented with other bookkeeping, allocations and array scans remain outside that deterministic measure. See the four-agent supplement in `oracle-reviews/2026-11-01-observer-row-containers.md`. Set performance work evaluated in PR #2301 is excluded by the maintainer's 2026-10-30 decision: "we've never had this perf problem ... let's remove it." The production matcher and the existing `utils.1`–`utils.40` campaigns and budgets remain unchanged. The synthetic duplicate-valued object-Set family exposes factorial assignment work, and an 8,192-member flat assignment chain exposes recursive stack depth. No application incident was established. The [versioned replay inputs](oracle-reviews/effect-startup-delta.md#deferred-set-replay-inputs) retain the descriptors, observations and limits. The primary owner remains `packages/db/tests/utils-oracle.property.test.ts`; resume optimization when the maintainer requests it or an application workload requires it. The new `utils.41`/`utils.42` work guards and dedicated receivers leave with that work. This records a scope decision, not closure of those performance limitations. The [Duration query equality oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/duration-query-equality-oracle.test.ts) uses ten public fields to predict direct BasicIndex/BTreeIndex exact lookups and public `eq` snapshots before and after indexing. The `in` evaluator owner also checks same-display Duration forms through constant and row-supplied lists. The deep-equality and Collection change-event history owners check a Duration field replacement and its subscriber mirror. These fixed histories do not establish arbitrary multirow Duration updates or live-query publication. The [Temporal index order tests](https://github.com/TanStack/db/blob/main/packages/db/tests/temporal-index-order.test.ts) (fixed tests; no oracle owner (tracked in #2264)) covers ZonedDateTime instant ordering and time-only Duration ordering for direct BasicIndex/BTreeIndex reads and bounded public first-row reads. It separates exact Duration fields from order ties, including exclusive cursor behavior. An extended-year PlainDate grammar checks calendar order under lexical string collation through ready scan and direct indexed snapshots, with eager live-query preload as parity evidence. The old indexed direct path chose the wrong year. An exception grammar requires ready scan, BasicIndex, and BTreeIndex direct reads and eager live-query preloads to reject mixed PlainDate/PlainDateTime values and distinct PlainMonthDays, as changelog #1519 specifies. The old indexed direct path returned a row instead. Calendar-unit Duration order, other extended-year histories, on-demand exception publication, arbitrary updates, and custom index callbacks remain outside this owner. The [custom-index selection oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/query/custom-index-order-selection-oracle.test.ts) checks that a reverse manual index cannot change an ascending limited public snapshot or live-query result. Eager and prepopulated on-demand sources with three distinct numeric ranks and a two-row window compare public IDs after preload. The reviewer withdrew a claimed wrong live-query result after fixing its scratch test's cross-checkout `@tanstack/db-ivm` resolution. The witness makes no claim about per-row custom callback order inside a comparator tie. A second on-demand witness registers an order-ineligible custom index before an eligible index on the same field and comparison options. It requires a bounded ordered request, a read through the eligible index, and no read through the ineligible index. The first-matching-index mutant fails at that reader check. Provider paging from an incomplete on-demand source and later updates remain outside this witness. The same owner now exhausts output-indexing configurations through `createLiveQueryCollection` and `createCollection(liveQueryCollectionOptions)`: omitted/off/eager modes, omitted/BasicIndex/BTreeIndex constructors, and eager admission without a constructor. It compares output config, constructor use, optimized snapshots, and independent sorted windows over two projected fields with both null placements, repeated consumers, and one source update. Each configuration requires distinct `rejected` or `output-read` reach; source settings remain unchanged. Admission/default policy comes from the shared indexing model. The ordered-index count derives from distinct requested specifications; calibration rejects extra indexes and inverted optimized-read availability. The [hook indexing handoff owner](https://github.com/TanStack/db/blob/main/packages/db/tests/conformance/indexing-config-oracle.ts) receives the nine configurations through the real React, Preact, Vue, Solid, Svelte, and Angular drivers after their settled flush cuts. It judges output config and downstream automatic/manual index creation. It does not judge rendering before flush or reactive adapters' option updates. Its [React Suspense receiver](https://github.com/TanStack/db/blob/main/packages/react-db/tests/suspense-indexing-config-oracle.test.tsx) exhausts two initial bindings across config pairs, derived/same/different keys, unscoped/client caches, and distinct same-name constructor references. It checks both admissions, each admitted output's settings, retained first settings, and independent output identity between two admitted bindings, including equal declarations (maintainer decision, 2026-11-03, superseding compatible sharing). Its 582 histories retain the original 534 cases and add 24 omitted/explicit- undefined cases and 24 pending-source cases. They check first-option retention on rerender (528 admitted-first histories) and application after an actual `queryKey` change (480 histories with two valid declarations). Invalid admissions have no output identity to compare. Constructor labels use grammar roles, and equal function names cannot collapse registration keys. This protects local cache qualification without changing portable query identity or mounted first-option retention. The [evidence record](oracle-reviews/2026-10-30-live-query-indexing.md) gives each receiving path's pre-repair RED, repaired GREEN, calibration, and finite bounds. The [PR #2314 high-effort review record](oracle-reviews/2026-10-30-pr-2314-high-effort-review.md) adds the maintainer's independent-caller local-options law to the existing `live-query-cache-options-oracle.ts` owner. Its `packages/react-db/tests/suspense-local-options-oracle.test.tsx` receiver exhausts 492 real Suspense histories: every non-indexing public Collection config field, independent absent/equal/different declarations, derived/same/different keys, and both client scopes. The public type inventory checks that new config fields cannot silently miss the driver. The shared indexing owner separately covers both indexing fields. Each history requires first output, second output and retained-first reach. Warm `cache-options-oracle.test.tsx` now receives 144 histories through Suspense in addition to ordinary mounted and server rendering; rejection must preserve the original caller's rows. These are initial-binding and cached-result claims, not arbitrary SSR/hydration timing or semantic equality of separately allocated option objects. The authored query owns list/single result shape; the local-sharing check does not promise that a config annotation rewrites the query's shape. The [Suspense oracle follow-up](oracle-reviews/2026-11-02-pr-2314-suspense-oracles.md) adds omitted versus explicit undefined in both caller orders: 120 local-option histories and the 24 indexing histories above, across all three identity relations and both scopes. A key that retains undefined properties passes the old 882 receiver histories but fails 88 of the extended 1,074 histories at output-identity comparisons. Each receiver also adds 24 pending histories. The local owner uses equal/different callback and scalar declarations; the indexing owner crosses mode and constructor equality. Both hold source writes, require two distinct visible Suspense fallbacks before release, then use their existing output comparisons after delivery. Per-scope aggregate reach requires both-suspended, equal and different option declarations, plus each representative option dimension. As of 2026-11-03, both cases require distinct outputs; the original sharing outcomes remain historical evidence only. A mutant that reuses and memoizes an unqualified pending entry passes the old 882 histories and fails 36 extended histories after the pending premise. These controlled eager-source schedules do not establish abandonment, rejection while pending, cleanup races, hydration, or arbitrary Suspense scheduling. The same decision requires eager/no-constructor admission to reject on every `DbClient.preloadLiveQuery` call, even when no new Collection is needed. `packages/db/tests/live-query-preload-indexing-oracle.test.ts` receives the shared indexing model across 459 histories: cold; eight prior valid configs with held or settled delivery; nine second declarations; and three key relations. Every history reaches admission; all 432 warm histories also check original-promise reuse. Original production accepts 32 invalid warm calls. This supersedes the construction-only limit in the earlier indexing record. Hydrated records, observer preload, SSR scheduling and malformed options outside the eager-constructor rule are not claimed by this receiver. The PR #2196 follow-up adds a direct `optimizedOnly` snapshot to the first-ineligible/second-eligible history. An eager-auto history starts with only an ineligible custom index and requires an eligible ordered reader after query compilation. These checks cover selection and creation at the initial read checkpoint; later index registration, mixed value domains, and provider paging from an incomplete source remain outside them. The existing mixed-kind public-order oracle checks the neighboring dynamic domain: a structurally sound index can temporarily lose ordered-read eligibility as row kinds change, without warranting a duplicate auto-index. The [PR #2116 confirmed-fixes review](oracle-reviews/pr-2116-confirmed-fixes.md) records baseline failures, mutant controls, and the bounded scope of these repairs. The [deferred findings record](oracle-reviews/pr-2116-deferred-findings.md) tracks remaining design and coverage questions, including valid Temporal kinds without public order and mixed-kind query order. Earlier PR-branch counterexamples do not by themselves establish an `origin/main` failure. Persisted startup replacement is owned by the shared [adapter persistence conformance oracle](#adapter-conformance-persisted-startup-2367). The Query ownership oracle retains its scope-local removal, peer ownership, mutation, and non-startup lifecycle laws. Its former startup dimension now runs as a receiving path of the shared owner, with the same histories and cuts. The Query DB ownership oracle also owns the explicit mutation-handler refresh contract ([evidence](oracle-reviews/pr-2171-explicit-query-refresh.md)). Its 18-history table crosses insert, update, and delete with no confirmation, explicit refetch, and direct writes, with and without discarded legacy return values. Each history requires optimistic and settled reach. At transaction settlement it checks exact Query fetch counts and public rows: no confirmation exposes the initial synced rows; either confirmation path exposes the server result. The old automatic-refetch implementation fails all nine cases at the fetch-count comparison (including a duplicate request after explicit refetch). This table uses a real QueryClient and Collection with controlled backend rows; polling, focus, reconnect, and external invalidation are outside its grammar. The [RC review coverage matrix](oracle-reviews/2026-10-28-pr-2171-review-coverage-matrix.md) records a missing documentation receiving witness for this owner at `858b174a6`. Executing the actual successful POST handler from `docs/guides/error-handling.md` leaves one server row and no Collection row at transaction settlement: the snippet omits explicit confirmation. The adapter correctly follows the law above; the authored guidance is wrong. O21/O17 in the challenge report assign extraction of real snippets and their confirmation histories to this owner. The guide and durable receiving witness remain open; the temporary probe is not a new oracle extension. The Query DB ownership oracle owns the direct-write no-automatic-refetch law ([review](oracle-reviews/issue-1935-direct-write-refetch.md)). The Query DB `optimistic-ordered-refetch-oracle.test.ts` receiver runs a real QueryClient and on-demand Query Collection. A held optimistic inbox-to-archive update must publish installed `[2]` immediately; its mutation handler changes the provider row and calls `utils.refetch()`, after which queued application publishes `[2,1]` to both rows and subscribers. It observes a useful bounded ordered request while held and rejects the old loader classification at the immediate cut. The separate `invalidateLoadedSubsets()` trigger belongs to the Query DB ordered-prefix owner introduced by open PR #2154 and still needs a during-hold observation. The load-lifecycle owner checks the bounded static-key full-source reuse law through live-query subscriptions: a settled full request serves a later filtered demand with no second provider call; after the full view releases, invalidation still updates the filtered view; an overlapping exact refetch keeps its own rows and owner; and final release removes them. A pending full request does not establish filtered coverage; the filtered demand may wait for its application or request its exact scope. The settled-full witness fails on the original implementation at the provider-call checkpoint. It checks that the initial full acquisition signal may abort while a later shared full fetch receives a live signal. Another held-fetch cut releases the final filtered owner during full Query revalidation, then checks transport abort and no late row publication. Query-cache success reentry checks that initial and replacement full results cannot settle a filtered acquisition before Collection application; the replacement cut rejects a gate based only on previous full-row ownership. An applied direct cache patch permits reuse or one exact filtered revalidation for a new demand, but cannot trigger a redundant full request. The bounded history has no retry, invalidation, or explicit refetch; a duplicate filtered provider-call mutant fails its full request-sequence assertion. Signal witnesses cover providers that ignore their signal and may finish into Query cache after final unload for full-source and equal filtered sharing; equal full-source and filtered peers after the first releases; and two Collections sharing a Query whose later fetch runs the released Collection's queryFn. Held initial and refetch histories acquire an equal filtered peer before or after fetch start, then release the first owner. They distinguish exact and custom abort reasons, a fresh provider AbortError, no remaining peer, and an unrelated ordinary error at provider-call, acquisition-settlement, public-row, cache-row, and error checkpoints. A recovery-specific ignored-signal witness rejects a guard that consumes Query Core's lazy signal before the replacement provider runs. The foreign closure witnesses verify the installed Query Core's option-selection path both before and during a shared fetch. A synchronous provider throw caused by reentrant peer acquisition has no separate witness. The ownership owner seeds a persisted `until-revalidated` subset owner, then applies a complete full-source result and acquires that subset. An omitted, unchanged, or moved source row must match public and durable rows at settlement, and the subset's retention marker must clear. A moved row must retain its full Query owner after its old subset owner retires. Reusing the full Query while leaving the subset owner unvalidated fails the row and marker observations; unconditional row deletion fails the moved-row control. Arbitrary predicate containment, function-built Query keys, TTL retention, native SQLite replay, and other persisted startup histories with a shared full-source lease still need distinct witnesses. These tests do not prove every provider returns a complete full source, arbitrary observer-option selection, or the policy for a new equal demand after failed revalidation. A fresh AbortError caused by the request signal and an unrelated fresh AbortError after that signal abort are indistinguishable to the adapter; the one-retry policy favors a surviving peer and may retry the latter. Real network providers and cross-Collection option selection beyond the installed Query Core version need receiving witnesses. The load-lifecycle owner also needs an external `queryClient.cancelQueries` history with a pending on-demand acquisition and a surviving peer; compare the public acquisition promise and status at cancellation and after release. A late-peer release history also needs a public live-query preload checkpoint for the retired creator, separate from the surviving peer's load. The raw internal `_sync.loadSubset` creator promise can fulfill in the current fixture; its settlement policy is unresolved at that boundary. Neither observation alone establishes a public cancellation bug. The load-lifecycle owner also needs a cleanup-fault calibration that preserves a primary row mismatch and reports secondary cleanup failure separately. Its real QueryClient witness loads ten disjoint on-demand subsets, then checks `writeUpsert`, `writeUpdate`, `writeDelete`, `writeInsert`, and a mixed `writeBatch`. After each accepted write it compares public live-query rows with an independent category filter and checks that no provider request started. The pre-repair implementation failed this request check with ten requests after one upsert. A held `deferDataRefresh` barrier adds a request checkpoint after release; the pre-review implementation made an unwanted request there. A derived-`select` witness checks that a direct write cannot replace an `edges` array with node objects. It permits a stale cache row while requiring a valid response envelope and the accepted public row. A direct-insert/unload witness keeps a manually written row after its queried peer retires; assigning every insert to the active subset fails that public-row checkpoint. Existing sibling cache witnesses reject retaining inactive entries under the Collection's base query-key prefix, including entries seeded before sync starts. The load-lifecycle oracle separately owns explicit refetch settlement; the ownership oracle checks that an explicit refetch after a direct write starts a post-write request when the initial fetch is still pending. A direct write alone starts no request. These bounded witnesses do not establish exact Query cache membership, ordering, or window replacement after a direct write. The ownership oracle owns future scoped-cache witnesses; the cursor-pagination oracle owns windowed receiving cases. The offline-transactions owner still needs a full reconnect-replay witness for its real `deferDataRefresh` premise. The ownership oracle also owns a later-remount witness after an inactive prefetched entry is evicted, and direct-insert retention across persisted restore remains with its persisted-owner histories. The ownership oracle also checks per-key precedence when a held on-demand refetch meets a later direct update, error and invalidation/freshness metadata across cache patches, one patch per physical Query under a colliding hash, and owner-bounded key extraction for ten disjoint 1,000-row subsets. An eager derived-`select` remount witness rejects replaying its stale envelope over a direct write; a foreign-observer witness permits an old inactive cache value while requiring the public row to survive remount and release of another owner. These controlled Query Core histories do not establish arbitrary `select` inverses, exact scoped membership or window replacement, every custom hash collision, or unbounded performance. The Query DB ownership oracle owns further direct-write cache histories; cursor pagination owns windowed receiving behavior. A caller using direct writes must accept the scoped-cache limits or request an explicit refetch. The ownership oracle also checks five later boundaries from PR #2065 review: a derived `select` still applies a held fetch's rows and settles eager readiness after a direct insert; overlapping explicit refetch callers follow the replacement request after a silent cancellation; a fetched result queued behind a persisted-baseline scan cannot overwrite a later accepted write; a zero-lease subset observer retained by a listener receives a direct cache patch before reacquisition; and eight retired on-demand subsets leave no fetch-start positions (removing the retirement call fails at eight retained entries). The Query error, invalidation, and staleness checks now cover both eager and on-demand modes. These are controlled Query Core and persistence seams. They do not establish every derived response shape, arbitrary overlapping refetch schedule, native SQLite timing for the queued-result cut, or unbounded cache-memory growth. This owner retains those boundaries; the persisted direct-write oracle owns native durable-order receiving cases. The retained-Query witness holds an empty-cache fetch across subset unload and reacquisition. A direct delete then requires an explicit refetch to start a post-write request and preserve the deleted public row at settlement; without a later write, the same refetch may reuse the in-flight request. A separate checkpoint keeps the detached fetch-start position until that request settles and retires it afterward. Two further shared-Query histories add A's sync restart after a direct insert/delete while B's pre-write request remains in flight. Without an explicit refetch, the old result must preserve the delete; with one, A must start a post-write request. Both were RED before physical fetch-start positions survived the restart and are GREEN afterward. These controlled histories do not establish every persisted adapter or Query cache-removal schedule. The [intermediate review at 74e399150](oracle-reviews/pr-2065-74e399-review.md) adds ordinary-unload and unobserved-fetch histories to that request-order law. The [final direct-write authority review](oracle-reviews/2026-10-12-query-direct-write-authority.md) records the later law decisions, RED/GREEN evidence, and ten-item audit. The [four-review follow-up](oracle-reviews/2026-10-12-query-authority-oracle-followup.md) audits legal subset predicates, cache-projection boundaries, scoped omissions, and the generated cursor manual-write campaign against its repaired commit. The ownership oracle also checks derived-select reacquisition and eager restart, explicit subset refetch, a derived result held behind `deferDataRefresh`, a provisional cache row awaiting persisted application, aliased physical Queries, and the boundary between an in-flight pending Query and an idle empty cache entry. The cursor-pagination integration oracle supplies the idle-entry control. Its shared-Query reset history holds B's acquisition after A's direct cache patch, resets the physical Query so the next fetch repeats the patch's numeric update count, and requires B's load to settle on the new provider row. It runs with a new response array and with the patch's exact array reference. This checks the authority boundary at fetch settlement, but does not model every Query Core reset schedule or custom-hash collision. An outside-prefix custom-hash collision remains in Query Core's cache after a direct write. The disabled reacquisition witness requires the load to wait for an explicit provider result, then checks that result and ownerless-row retirement. It covers one physical alias and an unbounded scope, not arbitrary hash functions or windowed scopes. The ordinary-unload, provisional-row, and alias tests reject their respective mutant classifiers at public-row or cache checkpoints. These finite histories do not establish every persistence schedule, every Query hash collision, or a full offline replay; those remain owned by the Query DB ownership and offline receiving oracles. Query Core 5.90.15 is the lowest version on which the full Query DB suite passed; 5.90.14 failed error-recovery witnesses, and 5.85.2 failed the post-write refetch witness. Older versions are excluded by the peer minimum. The ownership oracle now checks a direct row's ownership lifetime across one and two subset claims, with and without Collection row metadata. A direct update preserves those claims; a direct delete ends them; a later insert or upsert of the same key starts unowned; a later Query result can claim the new row. Its 20 bounded histories compare accepted public rows and exact persisted owner identities after each action and subset release. Removing the delete-retirement repair fails nine histories at those checkpoints. One real SQLite receiving history releases both former subsets, restarts the Collection from the same storage, and keeps the reinserted unowned row. A controlled persisted snapshot restart also retires two overlapping claims one at a time and compares durable owner identities and public rows after each empty result. This does not establish every persisted adapter, overlapping result schedule, or ownership of an inferred window replacement; the persisted direct-write owner retains the wider durable receiving boundary. Shared-Query cached-result authority across an unobserved Collection is now an accepted law: a newer physical fetch may replace and claim a direct row on later acquisition, while an older cached result or another Collection's local cache edit may not. The 24-history matrix crosses fetch/write order, a later same-key or unrelated write, a local cache edit, and another real refetch. It compares public rows at acquisition and subset release and checks that acquisition did not start an extra request. The pre-repair implementation failed the post-write and unrelated-write orders; removing fetched-data provenance fails two local-cache-edit histories. Two real SQLite receiving histories restart A as a fresh Collection instance while B retains the shared Query, with and without a later local cache edit. An ownerless stored row colliding with the cached result has unknown order, so acquisition refetches once and the new server row wins. Without that guarded revalidation the original receiving history kept the direct value. These finite histories do not establish every persisted adapter, a cached result without a colliding key, or a cross-process Query cache hydration order. Further controlled histories compare an accepted direct insert with a cached server row across cleanup and restart, so a discarded run's write position cannot suppress that row. The insert/delete neighbor distinguishes a stale position from intentional row deletion. An equivalent-predicate alias history coalesces two logical demands into one physical Query: a held pre-write fetch must preserve the accepted direct row, while a later fetch can replace it. A shared-Query history also checks A's direct insert while only B has loaded the Query; B's public row and cache stay on the server value until a newer fetch. The latter history rejects a cache patch that depends on A already owning a subset. A stable empty persisted result avoids repeated full-store scans on retained reacquisition, while a cold run still scans and retires a newly seeded durable owner. A nonempty provisional result still takes the baseline scan before applying. These checks use real Query Core observers and controlled persistence; they do not cover every custom hash collision or external durable writer. The overlap matrix below covers two requests and one shared row. The shared-Query authority histories now also vary peer acquisition timing: both Collections loaded at the write, B loaded while A is not, and B acquiring after A patched the cache. The latter rejects a local edit leaking into a late peer at a held-request public-row checkpoint, then admits the later server result. A real SQLite restart matrix distinguishes a persisted ownerless insert from an owned direct update against a shared pre-write cache row. It compares durable storage after cleanup and the fresh Collection's row after acquisition; an owned row cannot silently revert to the cached older value. Two alias schedules separately reject omitting the observer-attach fetch position and omitting propagation of a later physical fetch position to all logical observers. A directly selected response property checks the same late-peer rule as a raw array. A failed replacement fetch reaches the peer's public error state without publishing the other Collection's local edit. An outside Query observer retains A's own cache patch through cleanup; A's next sync run must request a new result rather than replay that old patch. A separate owned-row history checks that `queryClient.setQueryData` can update B but cannot replace A's later accepted direct value; a real post-write fetch may replace it. A held-fetch history checks the local edit before that provider result, and a sole-owner unload/reacquire history requires a new result before the manually edited cache can establish rows again. Eager shared-Query histories require compatible Collections to project the same representable cache patch. They cross active co-owners, a new direct key, a later or disabled peer, a cold cache seed, an older held fetch, and a later complete result. They compare A and B's public rows and the shared cache at write and fetch-settlement cuts. A held B application checks that disjoint writes alter only their own cache keys while preserving the peer's edit, for raw rows and a directly selected `{ items }` envelope whose unrelated metadata must survive. An eager writer's representable edit also reaches an already-acquired on-demand peer sharing its exact Query, while an unacquired peer waits for a server result. An eager peer with a derived visibility filter projects a direct-property writer's cache edit. A disabled eager peer projects a cached edit without a request; a disabled on-demand peer waits for an explicit refetch. A held persisted direct commit crossed with a refetch start compares public and durable rows before the provider responds, then after a newer response; eager and on-demand modes both reject replay of the old cached success. A complete matching on-demand refetch removes an omitted ownerless direct row, whether the result is empty or nonempty. A real SQLite restart witness confirms that the complete filtered fetch ran, retired the matching durable row, and preserved a disjoint durable sibling. Unload alone, disjoint, limited, offset, cursor, or failed results leave the row intact. Empty disjoint, offset, and cursor results and matching/disjoint compound predicates check the completeness and membership boundary at public-row settlement. A seven-history overlap model crosses prior ownership, both request settlement orders, equal-value responses, and direct writes between or after request starts. Its provider rows satisfy real `IR.PropRef` predicates; a fixture guard rejects literal-field comparisons that would make these histories illegal. It compares the public row after each result and after releasing both owners in either order. The older response may add an owner without replacing the later-started fetch's value while row ownership remains continuous. After full release, a receiving witness reacquires each retained Query with infinite `staleTime` and `gcTime`: each cache entry projects its own value without a new request. A complete response that omits an ownerless direct row settles that row for its matching scope; it does not tombstone older responses from other Query entries. A cross-scope omission-ordering guarantee would need a separate law and model. The original implementation fails three reverse-settlement histories. A separate real Query Core history writes inside an observer's success notification; a late on-demand peer must not mistake that cache edit for the fetch action's payload. The original implementation fails at the peer's held-request checkpoint. These finite histories leave same-run external durable writers, larger overlapping-fetch schedules, and direct-patch provenance after Query cache dehydration outside their proven scope. A fixed accepted-ownership history acquires three exact subset claims for one row, then accepts two complete empty results while an unrelated optimistic mutation delays publication. Its independent model stores the latest complete result per active Query and exposes their union: the third result keeps the row public until its own release, after which the union is empty. The ordered refetch owner's held-delete replay is the killing witness for trusting stale published owners over accepted ownership. A release/reacquisition history also holds publication, reacquires the same cached Query, then proves the older release cannot erase the new claim by releasing it and observing an empty public row set. That history uses infinite `staleTime`, so reacquisition starts no fetch. A sibling table crosses a stale reacquisition whose refetch fails, returns the same rows, or returns no rows; the refetch settles while publication is held or after the older release publishes; zero to two peer leases own the first row until after the refetch; and the reacquired result has one or two rows. Its independent model keeps each active observer lease's latest successful result and compares public rows while held, after publication, after the refetch, after every peer's release, and after the reacquired release. On `main` at `31dad2dd3` 20 of its 42 cells fail: the older release's empty ownership entry made the cached result look already applied, so the reacquired lease owned nothing. A row only it owned disappeared at publication; a row a peer also owned disappeared when the last peer left. The repair marks a released lease's entry and lets only an applied entry satisfy the already-applied guard and the on-demand direct-write skip. The empty-result cells reject keeping the row for every reacquired demand. Removing the guard fails the persisted direct-write histories that keep an accepted write through a refetch start, and their sibling with an empty current result and an inserted row rejects treating every empty entry as unapplied: in on-demand mode the insert disappears at its receipt, and in eager mode Manual survives the Newer result. A second table rejects deleting the entry at release: lease `b` claims the row while `a`'s release is held or after it publishes, with or without a peer `c`, and a server DbClient's dehydrated owners are hydrated into a fresh client. Deleting the entry copies `a` back from unpublished metadata, which adds an owner edge and, without a peer, leaks the row after the hydrated client releases `b`. Its `reacquired` histories reacquire `a` without cached data and fail its fetch before `b` claims the row; deleting the entry at reacquisition copies `a` back the same way. A reacquisition behind a refresh barrier (`deferDataRefresh`) followed by a direct upsert requires the reacquired Query's cache to show the upsert; reading the released entry as applied leaves the cache stale, and only the Query cache shows it. A release whose durable commit fails leaves the row public and stored, puts the Collection in `error`, rejects a later acquisition with the persistence error, and a `cleanup()` and `preload()` restart starts from clean ownership; a host that swallows the failure fails it. A sibling holds the release's durable commit, reacquires, and fails the reacquired application's commit: the row leaves with the durable release, the Collection enters `error`, and a restart serves and releases the row. Eager mode cannot reach the reacquisition premise: it has no subset release, and ending an eager sync run removes its Query from the cache. A cleanup that skips entries without an observer passes this owner but fails the explicit-cleanup retention test in `tests/query.test.ts`. A receiving probe on the Node SQLite adapter does not match the controlled failed-release premise: when a SQLite trigger aborts the release's delete, the Collection enters `error` and storage keeps the row, but the public Collection drops it. The SQLite persistence owner has no witness for that divergence ([#2210](https://github.com/TanStack/db/issues/2210)). Persisted retention (`persistedGcTime`) is outside these histories. The [review record](oracle-reviews/2026-10-20-stale-reacquired-ownership.md) lists the mutant outcomes and open cells. Larger overlap schedules, window ownership outside the ordered replay, and durable-adapter ordering remain open under the owners named above. A controlled cold persisted scan gives one Query two rows in both scan orders, then returns a current result that omits one row. Its independent replacement model requires the survivor to remain public with its owner and the controlled persistence boundary to receive a deletion for the omission. A row-by-row reconstruction that treats the first persisted edge as a resolved Query fails one order. A sibling DbClient hydration history supplies the same two rows in both orders, then compares the public Collection with the same complete current result and releases its demand. A row-by-row reconstruction fails both orders at the public-row checkpoint. These finite histories do not cover larger cold results or hydration interleaved with another active Query result. The alias-scope owner also has a compiler invariant witness for a malformed include plan: removing a captured ancestor's parent projection after the builder creates it must fail before child rows are read. Without that check, the plan compiled and a shadowed child could read its local row. The original Query-builder paths remain covered by the owner's public-row histories; this invariant witness does not claim arbitrary manually constructed IR is valid. The following related oracles own distinct production paths or observation cuts: - The [Collection lifecycle publication oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-subscription-lifecycle-publication-oracle.property.test.ts) owns exact public rows and change batches. The [replay oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-subscription-replay-oracle.property.test.ts) applies that law to competing replay schedules and same-key writes. Both models publish a replay's rows when its last owner is released and its current attempt has not failed, and keep a failed one private; the publication oracle's named histories cover a value written, rewritten or deleted during the replay, a row no demand names, a failed replay, a later request that updates a row still shown at an older value, and a row retained by a failed replay that the source deletes before a later replay retires. The replay oracle's named witnesses fail each synchronous failure site (a replay load, an old lease's unload, a new request) and then release the last owner; removing that site's sticky failure fails its witness. Limit: the generated grammars reach a failed retirement followed by another retired replay only rarely (the replay grammar releases one demand, on the last attempt), so the named histories own that sequence. The cleanup/restart equality crossing (`subscription-lifecycle.restart-publication`) retains equal rows actually restored into a direct subscriber's private replacement while deleting omitted retained rows. It runs the shared model, driver, and exact per-command batch/source/subscriber comparisons over two delivery paths (acquisition writes and independent source writes), six demand lifetimes (pending, settled, two live demands, aborted, released, absent), three prior-row relationships (absent, equal, changed), and resolve/reject commands for live acquisitions. Acquisition histories without a live attempt distinguish absent from retained rows and measure the settlement as a no-op; they do not claim restored equality. The single scenario grammar has 24 acquisition and 27 source cases. Each case reaches its measured owner lifetime, prior/delivered row relation, current outcome, and restarted acquisition count 12 times in each fixed/random campaign. Explicit generated row values and zero to three prior retired acquisitions remove the fixture-attempt-ID premise. Additional direct, filtered, ordered-snapshot and snapshot-before-source-events drivers each measure absent/equal/changed rows 12 times per campaign and reuse the owner's Map diff at held and settled publication cuts. The predicate excludes a real nonmatching row; ordered selection covers the complete bounded two-row replacement, not arbitrary windows. The exact issue #2310 history remains a shared replay. Original suppression fails every restart campaign; the earlier acquisition-only and retention-of-omitted-rows mutants remain recorded. [Evidence and limits](oracle-reviews/2026-10-30-pr-2313-review.md). This crossing concerns direct subscriptions under the controlled sync boundary. Eager sources follow a separate accepted first-public-batch reconciliation law in ARCHITECTURE's cleanup/restart section. The supplemental `collection-restart-publication-boundaries.test.ts` observes its before-ready deletion and later reinsertion, and checks actual compiled-query cleanup and restart in eager/on-demand modes. Public cleanup refuses active dependents; internal cleanup crashes them; restarting the query builds a fresh result. This evidence does not claim source-only restart revives a query, nor does it establish delegated includes, arbitrary ordered windows, or external providers. Bounded three-row histories now compare a subscription's selected keys with callback key/type batches across full, explicit, filtered, and empty snapshots, two later ordered selections, both initial-state modes, and callback reentry. A delete and reinsert checks that selection can reset. A 12-case callback matrix also crosses new insertion and delete/reinsert with filtered, full-state, and skip-filtering subscriptions, with and without a cursor. It checks callback batches after each source commit and checks retained-key count after deletion. Source-callback reentry also selects an unseen ordered row after publishing another key. A controlled three-row offset provider checks sparse callback and ordered callback-reentry histories in both initial-state modes: local selection does not establish a provider prefix. A second offset-only adapter checks cursors near the end of three- and seven-row sources: without an explicit offset, the request must be unbounded because no finite prefix derived from local keys can reach an arbitrary cursor value. A four-cell optimistic-overlay matrix submits a new ordered request after one or two pending deletes or predicate-removing updates. A plain remote array checks that the provider page reaches the first still visible remote rank. The source commit can remain queued behind the mutation, so this is a request-bound check, not an immediate-publication claim. The replay owner checks a filtered snapshot followed by an ordered selection during a pending direct truncate replay, including callback reentry before the target receives the source transaction. It also settles a repeated ordered replay and compares public batches before and after settlement. A sparse successful replacement checks that an adapter honoring a last-key cursor can still acquire lower-ranked rows. The [snapshot-selection review](oracle-reviews/2026-10-12-snapshot-selection-review.md) records the baseline and reservation-removal mutant kills at public-row, request-bound, and replay checkpoints. The controlled providers cover three and seven distinct ranks and the tested request schedules; arbitrary rankings, provider-specific pagination contracts, and compiled live-query windows remain outside these owners. - The [pagination oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/query/pagination-oracle.property.test.ts) owns general ordered-window rows and publication. Its optimistic overlay matrix crosses one and two pending source deletes or rank moves. It checks that a submitted provider page reaches the independently modeled window, then accepts the mutations through source sync and compares final public rows. A second matrix holds one or two optimistic inserts or rank moves while an indexed window widens. It crosses cursor-expression and offset-only providers, including windows opened from zero. The plain remote array checks the needed provider rank when a request can start before settlement; after source acceptance the public window must equal independent recomputation. The original six failing cells and narrow overlay, padded-boundary, and delayed continuation mutants reached these request or public-row comparisons. Settled ten-page traversals bound returned provider row volume and use only cursor-expression and offset transports. CollectionSubscription cannot emit `lastKey`; the [TrailBase adapter test](https://github.com/TanStack/db/blob/main/packages/trailbase-db-collection/tests/trailbase.test.ts) covers an external last-key caller and shows that core requests do not retain unused opaque cursors. Direct ordered subscription requests without an explicit offset may repeatedly load a growing prefix; with a cursor and no offset they may load the full source, because the adapter is permitted to ignore cursor expressions. The [ordered-work oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/query/ordered-work-oracle.property.test.ts) rechecks rows while bounding eager indexed and joined work. These finite matrices do not establish arbitrary overlapping optimistic histories, ties, or provider-specific cursor behavior. - The [IR identity oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/query/ir-stable-identity-oracle.test.ts) owns demand-key encoding in only two generated tests. The fixed demand-key cases live in [ir-stable-identity.test.ts](https://github.com/TanStack/db/blob/main/packages/db/tests/query/ir-stable-identity.test.ts), not in this owner. The [load-subset oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/query/load-subset-oracle.property.test.ts) owns runtime sharing and retry. The [transaction refinement oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/query/load-subset-transaction-refinement-oracle.test.ts) owns abort timing around sync acceptance and publication. The LocalStorage owners above also cover the [peer and materialization review](oracle-reviews/2026-10-08-localstorage-peer-review.md): a failing same-tab receiver cannot revoke a durable writer receipt or block later peers; a nested peer write remains authoritative through a later update; a DbClient Collection and its module-level manual utility share one write order, including before explicit preload; unrelated equal-ID Collections cannot borrow that utility even when they share the Storage object and key; startup validation fails before `begin`; and clear reads once per active receiver. The default JSON writer avoids a second full parse only when its saved bytes remain current. Custom parsers still read back. These finite witnesses do not establish recovery of an invalid writer key extractor or manual acceptance without a mutation Collection owner. The [follow-up oracle review](oracle-reviews/2026-10-08-localstorage-final-review.md) adds direct-owner idle, ready, and cleaned-up histories for module-level acceptance into a DbClient materialization. It checks the manual receipt, durable snapshot, active public snapshots, and fresh restore. A mutant subject that drops transaction commit work fails the held-receipt checkpoint. The peer owner checks a peer write admitted by a restore subscriber, custom-parser normalization of an authored insert and update without a version-token change, invalid events followed by same-token repair, and malformed stored row shape or key identity before startup opens a sync transaction. The order owner checks a handler-free direct write at method return immediately after a synchronous handler failure. These finite witnesses do not prove arbitrary reentrant subscriber histories or cross-tab atomicity. Default JSON intentionally keeps the writer's authored rich value until restore; a Date witness records the public/durable representation difference. The [second LocalStorage review](oracle-reviews/2026-10-08-localstorage-round-two.md) extends the peer owner across unchanged versus changed version tokens for an untouched parser-normalized row. At a fulfilled receipt it compares writer, peer, durable bytes, and fresh restore. It also checks duplicate decoded keys, serializable NaN-derived keys, nonfinite default-JSON row IDs, and prewrite versus postwrite read faults. The order owner holds an earlier handler while manual acceptance is followed by a `mutationFn` failure, then compares both receipt cuts and the eventual public, durable, and restored rows. A direct nested peer write replaces the unsupported manual-acceptance fixture. These finite histories do not establish arbitrary parser side effects, concurrent cross-tab writes, or every possible row serialization shape. The [boundary audit](oracle-reviews/2026-10-08-localstorage-boundary-audit.md) crosses default-JSON native-value retention with a disjoint same-tab peer write: the writer keeps its authored Date while receiving the peer's row, and a later same-key peer edit replaces that Date. Writer, peer, durable bytes, and fresh restore are observed at the peer receipt. A throwing writer subscriber after Storage acceptance does not revoke the receipt or prevent peer publication. The controlled host does not establish arbitrary native values or `toJSON` side effects, many-operation histories, or native browser scheduling. Those need a widened peer-owner value/history grammar and a receiving browser witness. The LocalStorage peer owner checks descriptor admission after three failed constructor boundaries: invalid index configuration before sync binding, controlled browser-listener registration failure during sync startup, and a missing on-demand `loadSubset` handler after a browser listener was acquired. A corrected retry must persist; a third construction and reuse after successful owner cleanup must reject. The original owner can restart and persist, while controlled browser-listener counts return to zero after failure and cleanup. Paired hosts compare the Storage reads caused by one later same-tab write; the failed-construction host has one extra read on `8b3debb3a`, exposing an abandoned same-tab callback. These checks cannot prove that a failed Collection is no longer retained by a private adapter closure or an inert callback in the same-tab registry; those resource-retention claims need a receiving lifecycle/GC witness in `packages/db/tests/local-storage-peer-history.test.ts` (fixed tests; no oracle owner (tracked in #2264)). Native browser listener failure and host scheduling remain outside the controlled history. The [React source ID reuse oracle](https://github.com/TanStack/db/blob/main/packages/react-db/tests/source-id-reuse-oracle.test.tsx) ([review](oracle-reviews/issue-1991-react-source-id.md)) checks that a mounted derived-identity hook rejects a different same-ID source Collection directly, after an intervening ID and predicate, within one query, and after source cleanup. Stable sources, new IDs, a fresh hook after cleanup, and independent client scopes remain usable. Returning to a prior client scope retains that scope's binding, including through `DbProvider`. A suspended render that starts a source query also claims the ID until unmount. An infinite-hook driver runs direct reuse, reuse after another ID, the same object and a new ID, reuse after a suspended render, and deferral release on rejection through `useLiveInfiniteQuery`, whose render-time collection cache is keyed by the same derived identity. Separate client-scoped Suspense hooks and an initial suspended retry keep their same-ID sources distinct. A rejected collision render releases sync-start deferral for a different shared client descriptor; a later direct reader reaches `ready` and observes its row. The public rerender error, status, or row is the observation cut. A second controlled history makes two deferred sync starts throw and checks that a later shared source still starts and publishes its row. This distinguishes releasing every pending source from stopping at the first startup error. The preparation rejection still reaches React's error boundary. The expanded release grammar has 344 histories plus four checker controls. It crosses applicable rejection causes, ordinary/infinite/Suspense hooks with derived or changed explicit identities, initial mounts or rerenders, and four readers. Rejection classes or authored error identities and after-hook execution are observed before declared `prepared` reach. A subscription reader now compares its callback replica, rather than Collection storage, after readiness and the next source publication. A mutant dropping update deliveries survived all 86 subscription cells before this recorder repair, and fails all 86 at the updated-row comparison afterward. Abandoned-render histories establish eventual release on the schedules encountered; they do not claim both orders of reclamation and independent demand. The shared [descriptor startup-release model](https://github.com/TanStack/db/blob/main/packages/db/tests/descriptor-start-release-oracle.ts) also has React and Svelte receiving drivers. Eighty-five finite prefix/mask/policy histories fail a descriptor factory before, or after one through three acquired sources, followed by an unvisited tail. Every acquired source's synchronous start-failure mask crosses every independent eager/lazy policy mask. React's three hook paths receive 255 histories; Svelte receives 85 at its native root boundary. Each observes the exact factory error, factory counts, independent starts, complete ordinary rows, Collection status and acquired healthy-resource cleanup counts at rejection, independent demand and client cleanup. Failed starts acquire no returned adapter resource. These controlled synchronous sources do not prove provider resource cleanup after a provider throws before returning its cleanup handle, arbitrary scheduling, or the outer Suspense catch path described above. The inline-options grammar additionally crosses live and Suspense config hooks, getKey/schema/both, and query/queryKey replacement (12 host histories). Repeated renders and an authoritative source update retain the Collection and configured option references; identity replacement applies the new references. Each history declares and reaches rerender, source-update and identity-change cuts. Schema is exercised at the JavaScript configuration boundary: the current public hook schema declaration is `never`; this test makes no typing claim. Infinite hooks accept no inline Collection options and remain covered by their source-identity and window owners. The old reference-based identity fails at Collection identity during rerender. Other framework receiving paths are not claimed by this React driver. This owner's source-ID law does not constrain explicit `queryKey` or direct Collection input, and it does not install a process-wide ID registry. React dependency arrays are removed; Svelte's supported dependency API is covered by its own receiving tests, not this React owner. Real persisted SQLite sources and DbClient SSR preload/streaming remain outside this controlled React driver. A space policy for a mounted hook that visits unbounded distinct source IDs remains open; this owner needs a bounded-navigation counter witness once that policy is chosen. The SQLite core binding-capacity oracle in `packages/db-sqlite-persistence-core/tests/sqlite-core-adapter-oracle.test.ts` is a bounded owner for issue #1993. The [review record](oracle-reviews/issue-1993-sqlite-binding-capacity.md) gives the exact executable revision and guide audit. It failed on the original 900-item chunking and passes with one JSON table binding per runtime `IN` list and a statement-total fallback. It compares independently filtered rows and typed values with `loadSubset` on real Node prepared SQLite statements. Node versions that expose the configured 999-parameter limit use that native cap. Older versions use a controlled driver that rejects over-cap bindings before SQLite preparation; the oracle tests that guard separately. Fixed and generated cases cover empty lists, 998/999/1000 single lists, 499+500 and 500+500 statement totals, mixed scalar/list and nested predicates, root and distinct transaction-driver routes (including an omitted transaction cap at the 100/101 driver boundary), signed-64-bit BigInt edges, escaped strings, an ordered two-hit list across the old 900-item chunk, both cursor SELECTs, and a 1,000-scalar fallback. Both index-definition `IN` contexts must remain literal SQL. The existing CLI large-list test substitutes values into SQL and cannot witness parameter capacity. This new owner does not establish behavior for null, nonfinite, container, or structured values; 50,582-ID stress; JSON-function availability; the cost of a full-table fallback; concurrent writers; or browser, mobile, Tauri, and native-host execution. The core owner needs typed equivalence and row-read work witnesses before claiming class closure. Each host driver owns a receiving capacity witness for its real SQLite engine. The Query ownership oracle checks that a direct-write promise stays pending while a controlled persisted adapter holds its sync commit and settles after the adapter stores the row. It also checks that all five direct-write methods reject after cleanup starts and that a restarted sync run can persist a new write. Focused Query tests check a synchronous batch callback returning another Collection's write without losing either write, while an async callback still rejects. They also check two serialized updates: after each awaited response write and mutation settlement, the public row shows the server revision. These witnesses cover an eager Query Collection after initial load with a controlled adapter, not a direct write already in flight when cleanup starts, native SQLite, or overlapping Query revalidation. The Query ownership and optimistic-history owners still need a joint generated witness for competing source writes around mutation settlement. The hash-identity owner also runs every law in a second module copy whose initialization draws are all equal, so every type marker has the same hash number in any declaration order. There it checks equality verdicts, equal hashes for equal identities, cycle rejection, and a `topKBatch` Map-to-Set replacement. No distinct-digest check is needed: a legal 32-bit collision cannot weaken the equality verdict. This closes the equality type-separation witness for every generated carrier. It does not prove hash collision freedom. Generated Map keys include numbers, symbols, references, and containers, and the model merges keys under SameValueZero. The [NaN ranked-window review](oracle-reviews/2026-09-30-nan-ranked-window.md) records an eager direct-source refinement in the pagination owner. It covers initial ascending and descending windows, two NaN tie values, an offset move, and equal, changed, and deleted source ranks. On-demand NaN rank acquisition, joined queries, and null/NaN order combinations still need public witnesses in the pagination owner before they support a broader claim. The [Angular conformance driver](https://github.com/TanStack/db/blob/main/packages/angular-db/tests/conformance.test.ts) checks a required signal input on a real TestBed component. Angular assigns the input after field initialization, then the driver checks rendered data and exact selected IDs after initial change detection and one input change. The driver supplies the AOT-equivalent signal-input flag because this suite uses Angular's JIT test environment. It does not exercise Angular's AOT compiler, older Angular runtimes, or every scheduler cut. The same driver checks that an explicitly disabled query reports `disabled` and ready before effects run. The query identity owner generates both equal and unequal primitive string pairs. Its fixed pairs also check public `groupBy` rows after initial publication. End-to-end subset-demand reuse is still unproven: the demand-key check observes internal identity only. The identity owner needs a subscription witness that compares public rows and acquisition counts after equivalent and distinct predicate demands settle. The subscription callback-reentry companion kills eleven guard-deletion mutants at the named request, resource, status, replay, or retention checkpoint on the reviewed production head. It also checks that releasing a direct snapshot during an unoptimized callback or snapshot evaluation prevents publication. A combined-predicate loader case checks release by the original request predicate before the loader returns. Three guards remain for a separate code-weight review (SUBS-09): M1's generation check after `loadSubset` is followed by demand-membership and generation checks after cleanup removes a starting demand; M6's replaced-state check before restart setup is followed by detached-demand and replay-state checks; M8's `releaseAttempted` true branch was unreached in 538 focused tests and its callers remove or detach ownership before invoking adapter unload. These are bounded equivalence arguments, not permission to delete the guards without a separate review. The companion does not establish arbitrary provider callback behavior. Row canonicalization before the result boundary now runs only for DISTINCT, which tracks visibility by selected value; removing it fails the functional projection oracle. Ordering already consolidates each key's batch before top-K state changes, and materialized relations reduce by public key. Removing the former parent-route, non-Collection source, join, grouping, ordering, and includes conditions passed the whole `@tanstack/db` suite and a `TANSTACK_DB_ORACLE_RUNS_MULTIPLIER=10` oracle campaign. Without the keyed reduction, `live-query-result-multiplicity.test.ts` witnesses the output boundary rejecting a flush that changes one key by more than one row. The Collection lifecycle publication owner checks 32 bounded histories in which cleanup interrupts nested publication deferrals and a restarted sync run later publishes or discards one or two source rows. It compares the next subscriber's exact batch when the new deferral closes, including an old handle closed before or during that deferral. The includes publication owner still needs a compiled includes witness for cleanup during a discarded source deferral, followed by a parent or child publication at its callback boundary. `packages/db/tests/query/group-by-work.test.ts` owns the work law for grouped aggregates: a change costs the same number of iterator steps at every group size, for a `groupBy` count and for an include count. `group-by.test.ts` checks which member supplies the value of a group whose members are equal under query equality but differ exactly, in both arrival orders. It also checks that `min` and `max` equal a remaining member's value after each delete, for signed zero and Dates and for stored and rebuilt arguments ([review](oracle-reviews/group-representative-exact-value.md)). Open: no law observes which parent supplies an include route's parent context, because a single-group include aggregate drops non-aggregate select fields; parents equal under query equality but different exactly share one route. The [Temporal group-key oracle](https://github.com/TanStack/db/blob/main/packages/db-ivm/tests/temporal-group-key-oracle.test.ts) owns the db-ivm `groupBy` value boundary for the eight Temporal kinds recognized by structural hashing. It compares public group counts with fixture-defined identity classes after one input batch, including distinct and matching fresh values and a plain object with its own spoofed Temporal tag. Nested serialization controls cover records, arrays, Maps, and Sets. Incremental retractions and unsupported symbols, cycles, and mutable RegExp state are outside this owner's bounded domain. The owner uses db-ivm's established kind-and-string Temporal key domain. Alternate representations remain separate: Durations such as `PT1H` and `PT60M` form different groups even when they compare equal. The supported inputs are ordinary native Temporal values or values from one polyfill copy. A custom prototype that impersonates Temporal can still merge a plain object with a genuine value. A genuine value with a replaced prototype can split from an equal value. Both altered-prototype cases and separately loaded polyfill copies are outside this contract. The oracle still protects a plain object's own spoofed tag without a custom prototype. The [includes publication oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/query/includes-publication-oracle.test.ts) now checks one held ordered repair with two public parent rows and one inline child. Its bounded history crosses a single-step row move, a private value change that returns to the prior value, and a final value change. It compares root Collection reads and subscriber callbacks with an independent sorted source Map, and checks Effect callbacks against the last callback-visible row. Its optimistic rollback histories also require the callback to be reached and compare the restored public rows and callback trace after rejection. This rejects a final-row-only check that misses a torn callback publication. The [DEC-02 review record](oracle-reviews/2026-09-28-retracted-value-retention.md) retains the RED and mutant evidence. The receiving Collection-valued owner (`packages/db/tests/query/includes-collection-oracle.property.test.ts`) now checks a held finite ordered child repair request with A→A, A→B→A, and B→C histories, facade identity, silence during the hold, final child order, and subscriber delivery. The optimistic owner (`packages/db/tests/query/includes-optimistic-oracle.property.test.ts`) checks a same-root-row optimistic update during held ordered repair, comparing exact public snapshots and change events before release, after release, and after rollback. Both use controlled provider timing; real-provider ordering remains a separate receiving handoff. The ordinary committed-transaction companion in the SQLite resume-snapshot owner checks durable rows, row and collection metadata, expected-key evidence, tombstones, applied position, idempotent reapply, and replay threshold behavior for bounded insert, partial-update, delete, metadata-only, and repeated-key histories. Its fixed and random generated campaigns cover a two-row seed, ordered action prefixes, seven required action/metadata suffixes, optional dependent updates, and late-bookkeeping rollback, comparing durable state after each settlement. The generated grammar is bounded to two writable string keys, one absent metadata key, up to 60 prefix mutations sampled in short, middle, and long bands, three row-metadata and two collection-metadata prefix actions, and up to three committed positions; it does not claim arbitrary histories or concurrent owners. Every generated seed, candidate, dependent update, and late rollback must enter exactly one SQLite transaction; counters are captured before durable snapshot reads. A separate fixed/random generated work grammar covers 0–60 distinct keys, six insert/update/delete/row and collection metadata shapes, and 100/999 parameter caps. It checks durable values before applying the same proposed chunk-bound work law; all repeated-key histories now check a distinct-key work bound after both committed and rolled-back candidates. A fixed 205-update single-key case drops from 824 to 8 query/run calls against a bound of 18. Truncate cases require overwritten invalid row and metadata values, including unbindable `undefined` collection metadata, to reject and roll back. Fixed 25/26 and 10,000-row cases separately witness the independent-key work boundary. Both fixed and generated independent-key work laws were RED on `ef1e6a4` and are GREEN with ordinary batching: the 10,000-row insert plus metadata takes 505 query/run calls instead of 50,005. A later 125-row-ceiling follow-up checks 124/125/126 rows under a 500-parameter host cap; the 10,000-row case now takes 405 calls. A temporary repeated-key classifier mutation fails the generated oracle at the candidate durable checkpoint, seed 1992, path `2:0:0:2:2:2:2`. A temporary chunk-limit mutation passes the Cloudflare 25-row case but fails at 26 rows under the 100-parameter guard. A collection-metadata classifier mutation that ignores repeated keys fails at the durable checkpoint for a set/delete history. All mutations were restored. The Cloudflare receiving driver also persists ordinary writes with row and collection metadata at 25, 26, and 205 rows within that guard. Its Node SQLite storage seam does not establish Cloudflare Worker execution. The synthetic node:sqlite seam does not establish OPFS worker scheduling, browser latency, or native-device performance. Tagged-value serialization, unavailable key evidence after raw loss, concurrent schema migration, WAL across processes, and arbitrary longer transaction histories remain with their existing owners or need explicit future witnesses. The same owner checks the optional source-progress bridge with an independent path-of-edges model. A discontinuity stays incompatible across matching and empty commits; a repeated endpoint is idempotent; a full replacement repairs continuity. Physical key integrity is checked separately after every transaction. The fixed/random `sqlite-resume.source-progress` campaigns use 80 runs each, seed 2281 and direct seed/path replay. Histories have 3–16 actions plus an initial replacement, opaque positions, stale predecessors, duplicates and optional old schema migration. Declared reaches require gaps, later matching commits, replacement after a gap, duplicate endpoints and migration. The primary Browser owner and real OPFS receiver supply source-head convergence evidence; the storage model alone does not establish provider framing or cross-host scheduling. The SQLite resume-snapshot owner also checks a cold, unique-key, non-delete full replacement with 205 rows. It compares exact durable rows, row metadata, key-set evidence, resume metadata, and applied position at transaction return; the driver query/run count is bounded, and a later-batch fault rolls back the whole transaction. Duplicate-key and delete histories keep their sequential semantics. This in-memory driver-call law does not measure Chromium OPFS latency, worker scheduling, or an end-to-end Electric snapshot. The Cloudflare Durable Object test applies 25-, 26-, and 205-row full replacements and ordinary writes with row and collection metadata through the actual Cloudflare driver. A storage seam enforces Cloudflare's documented 100-bound-parameter query limit and checks durable keys and metadata after each transaction. Its subset receiving witness compares exact rows for 100 and 101 equality or one-item `IN` clauses through both savepoint and native transaction drivers; the same seam rejects a statement above 100 bindings. The original transaction driver exceeded the cap at 101. This Node SQLite seam does not execute in Workers or prove native JSON-function support. The [worker diagnostics oracle](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/tests/opfs-worker-diagnostics-oracle.test.ts) drives the real worker module and also classifies a refused OPFS storage root, as in a private window or a browser without OPFS storage: the worker answers `PERSISTENCE_UNAVAILABLE` with the browser's error name and message before SQLite opens, and a `PersistenceUnavailableError` response carries only its details, which the opener prefixes once. The browser OPFS lifecycle owner also checks that a silent initialization rejects at the default or overridden open deadline, terminates its worker, ignores a late response, and releases the deadline and abort listener after a successful open. It also checks an abort during synchronous option evaluation, after the initial signal check but before listener registration. A Chromium fixture holds the VFS database Web Lock while a second tab times out. It checks that the queued request disappears, then reopens the database after releasing the lock. This controlled lock holder does not reproduce a frozen tab or establish behavior in other browsers. The [issue #1883 review record](oracle-reviews/issue-1883-opfs-open-deadline.md) preserves the exact-head unit and Chromium evidence and the queued-lock mutant. The jsdom open cases start after asset resolution. The [OPFS open outcome oracle](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/tests/opfs-open-outcome-oracle.ts) owns how an open settles across its four steps: the Vite asset lookup, worker start, WASM load, and initialization. One module holds the law, the history grammar, the model, and the comparison; neither driver states expected results. A history fixes each step (the lookup resolves, is held, or fails; the worker starts or is refused; the WASM loads or fails; initialization answers or stays silent; the worker script can also fail to load) and pairs every pending step with a deadline or an abort. The model predicts the settlement, started and terminated workers, the steps that production reached, and a later open after an interruption. The [jsdom driver](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/tests/opfs-open-outcome-oracle.test.ts) reaches worker start, initialization, and the worker's WASM failure response. The [Chromium driver](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/e2e/opfs-open-outcome-oracle.e2e.test.ts) reaches the lookup, the real worker's WASM fetch, and worker start against a Vite dev server that pre-bundles the built package, for Vite 7 and Vite 8 consumers. Under Vite 8 the copy's asset URLs point at the original install, so the lookup never reaches the dev server; the lookup states are declared for Vite 7 only (decision on TanStack/db#2371, 2026-11-08). Vite 8 histories still interrupt a held WASM fetch, which is the step a Vite 8 copy reaches. A held step that never reaches the dev server fails its history after a fixed 10 s bound, below the 120 s test timeout (liveness only; no observation depends on it). The srcdoc and cross-origin page shapes run under both Vite majors in wasm-package-consumer.e2e.test.ts. Mutant (production): clearing the open's deadline and abort wiring from the worker phase (the worker-phase openFailure replaced by a promise that never settles) fails the four held-WASM interrupt histories, two per major, and passes the other 13; the build was restored after. It holds back only the opener's deadline timer and fires it explicitly, interrupts only after the server holds a lookup or a WASM fetch, releases every held step, and reads the settlement and worker counts one task after each event, so no observation depends on elapsed time. Each driver checks that its history product covers the outcomes it declares; the `reached` observation is the production reach witness. Mutants that leave the lookup outside the deadline and abort, start a worker after a late lookup, report a WASM failure as an internal error, or let a refused Worker constructor's error escape each fail the driver that reaches that step, and a mutant that rejects before making the lookup fails only on `reached`. The grammar does not interrupt an open in the same turn as a failing step, because no law orders those causes yet. The [install-layout oracle](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/e2e/install-layout-oracle.e2e.test.ts) models which installs open in Vite development and production: direct, hoisted, pnpm, transitive, npm-alias, and two-copy installs, three cache directories, and exclusion by import name or package name. Vite 7 and Vite 8 each run all 36 rows. The Vite 8 model says the cache and the exclusion do not change a development install's outcome; the development rows for each cache and exclusion are the witnesses for that claim. Production rows use the default cache and no exclusion, because a production build does not pre-bundle, and they witness that each layout builds and opens (74 rows with the two coverage tests). Each major's coverage test reads its promised outcomes from the declared grammar. The Vite 8 rule has the maintainer decision on TanStack/db#2371 (2026-11-08) as its authority: under Vite 8 development, the pre-bundled copy loads its own worker and WASM and opens with the imported copy in every layout. Under Vite 7 the rules below apply. It reads the importer's specifier and the Node resolution of the package name from each installed tree rather than from a table per layout. A pre-bundled copy opens when the app root resolves the package name and otherwise reports `PersistenceUnavailableError`; with two copies it loads the copy that the root resolves, and when that copy is another version its worker refuses the opener and the open reports `PersistenceUnavailableError` after one worker starts. The two-version layout rewrites the nested copy's built version marker, so the opener and the root copy's worker really come from different builds. Excluding the specifier that the importer uses serves the copy in place with its own worker. The README states these rules. A mutant that always runs the lookup fails the three excluded transitive, alias, and two-copy cases. Its dev servers do not watch files, because a late watcher event reloaded pages during an open. The packaged-consumer [checks](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/e2e/wasm-package-consumer.e2e.test.ts) run the consumer production build, the nested-base development and production preview, and the `about:srcdoc` and cross-origin page shapes under both Vite 7 and Vite 8, each with its own build output. They also cover the build output and export map, a classic worker in development and production, an `about:srcdoc` frame, and a page on another origin than the Vite server, where the Worker constructor throws `SecurityError` and the open reports `PersistenceUnavailableError`. The [bundler consumer checks](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/e2e/bundler-consumers.e2e.test.ts) install the built workspace packages as published packages in a webpack 5 app (production and development builds) and a Next.js app (Turbopack and webpack, each under `next build` with `next start` and under `next dev`). Each opens and queries SQLite in Chromium, starts one classic worker, loads one `200 application/wasm` response, and makes no Vite lookup request. Each production build, and the Vite consumer's production build, ships none of the lookup's code. A module worker fails all six; a lookup that runs without a Vite client fails the four Next.js cases and is equivalent under webpack, which emits the worker and WASM in one directory. These owners do not cover webpack-dev-server, Rspack, Parcel, esbuild, an open from inside a worker, a Vite client injected without a script `src`, or browsers other than Chromium. The [PR #2103 review record](oracle-reviews/pr-2103-separate-wasm.md) classifies each calibration control and records every applicable requirement. The [browser OPFS lifecycle owner](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/tests/opfs-page-lifecycle-oracle.test.ts) also generates explicit close histories: zero to three pending executes, how many answer while close is in flight and in which order, a successful close and every worker error classification, a concurrent close, an execute submitted during close, and pagehide or a Worker terminal event before the close response, which then rejects close and pending siblings with its own failure. At close settlement, answered executes keep their rows and the rest reject with `AbortError`. Every close call shares the first close's outcome. The worker receives exactly one close request, and work submitted after close starts never reaches it. Rejecting at close start, posting a second close, admitting work during close, deferring rejection past close settlement, and the pre-fix hang each fail this grammar, as does ignoring pagehide or a Worker error while close is in flight. The controlled worker answers in any order, so these histories also cover a close response that overtakes pending work. The [OPFS request-order oracle](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/tests/opfs-request-order-oracle.ts) states that a connection settles requests in acceptance order with sequential results, settles close after them, refuses work after close starts, and keeps answered writes across a reopen. One module holds the law, the sequential replay model, the fixed examples, the public-connection driver loop, and the comparison. Two drivers run it. The [Node driver](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/tests/opfs-request-order-oracle.test.ts) runs the real worker module and wa-sqlite WASM build behind a bridge Worker, over an in-memory VFS with OPFSCoopSyncVFS's lock protocol, with fixed, random, and SEED/PATH campaigns. The [Chromium driver](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/e2e/opfs-request-order-oracle.opfs.spec.ts) runs every fixed example against real OPFS and takes the access handle through the VFS's own BroadcastChannel and Web Lock handoff. Histories vary one to three inserts and selects, which execute meets a taken handle, whether the handle returns before or after close reaches the worker, and an execute after close. The previous worker handled messages concurrently, so close ran while an execute waited for the handle and SQLite refused to close. That worker and a worker that queues executes but not close fail both drivers. Neither driver proves other browsers, frozen tabs, a crash between a write and close, or more than one other handle holder. The review record is `docs/contributing/oracle-reviews/pr-2213-opfs-close.md`. The ordered-work owner also checks that an Effect with `skipInitial` waits for joined demand before ending initial callback suppression. A deterministic work counter rejects an extra joined-filter graph schedule on root readiness while preserving the joined-source wake-up. Nonterminal per-demand failure recovery is outside this owner: `failDemand` enters terminal live-query error while its plan record remains unsettled until sync teardown. A future recovery contract must reconcile plan and subscription pending state before reopening publication. Its startup witness covers one synchronous rank update after an indexed page load and before the last source subscription returns. It does not cover every source ordering, multiple buffered mutations, or asynchronous startup changes. The [ordered Effect startup review](oracle-reviews/gap-06-ordered-effect-startup.md) records its baseline and mutant-mutant observations. The Collection lifecycle change-event history owner also checks eager auto-index equality buckets and fresh indexed `eq` live queries against its independent row Map. Its required same-turn delete/reinsert prefix reaches an already-built index for both BasicIndex and BTreeIndex. In the batched grammar, public rows and equality buckets are checked after each mutation returns, before any transaction is awaited; the batched final state and each sequential settled prefix are also checked. Fresh indexed queries are checked at the final checkpoint. Fixed and random tails check nearby legal histories. One temporary mutant that skipped index updates failed the fixed batched final count: one indexed key versus two model rows. Another fault that preserved the final keys failed the new returned-mutation check. The direct index refinement owner does not prove this Collection mutation path. Callback-time index agreement, the reported insert-seeded string-key setup, adapter cancellation, and non-local-only persistence remain outside this grammar. The [issue #1912 review record](oracle-reviews/issue-1912-eager-index-history.md) records the grammar controls, exact reviewed commit, and ORC audit. The [live Electric immediate-reload witness](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/e2e/electric-immediate-reload.opfs.spec.ts) checks one Chromium/OPFS history: an `onInsert` handler receives PostgreSQL transaction evidence, `awaitTxId` and the optimistic transaction settle while the source row's adapter write is held, and a hard page close is followed by an empty raw OPFS snapshot before the recovering Collection or Electric starts. After release, the witness checks the exact public and durable row from live Electric and records that the reopened page sent no user-insert request. Public rows are polled before durable snapshots to avoid a full OPFS read on every pre-publication tick. This bounded history does not prove Windows/Edge behavior, offline recovery, arbitrary later re-inserts, or a durable-acknowledgment contract for `awaitTxId`. The [optimistic-history oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/optimistic-history-oracle.ts) now owns the held-row law for sync transactions deferred behind a wrapping sync's durable step, and checks that every optimistic mutation is visible in the tick that makes it. Its [persisted production path](https://github.com/TanStack/db/blob/main/packages/db-sqlite-persistence-core/tests/persisted-optimistic-history-oracle.property.test.ts) runs the shared grammar through `persistedCollectionOptions` with `hold-store` and `release-store` steps and a handler that commits its own server row. It was RED before the wrapper reported deferred sync keys to core: when an earlier source transaction's store was held, a settled row dropped to an older synced row before its deferred server row applied (insert-then-update and insert-then-delete histories). It is green now, and mutants that drop deferred keys from the hold, drop the held row at a drain, or skip the held overlay after a drain each fail it. The grammar also aborts a deferred transaction before its turn, and ends every history with a source transaction on every key, so a stale hold or leaked local attribution shows. That step was RED on the first fix: the wrapper marked an aborted transaction as handed to the Collection, so its hold never ended, and a non-optimistic write kept local attribution for a dropped transaction. A campaign check requires each run to reach a hold across a drain and a hold released by an abort. Open: wrapper cleanup or source restart while a transaction is deferred has no grammar step, and a held-row release filtered as a recent sync echo was not reproduced. The production path uses an in-memory adapter. Several tabs on one durable store each run their own source and store every source transaction they receive. DB promises only eventual consistency between them: while their streams interleave, a lagging tab's copy of an older transaction can be stored and announced after a newer one, so a tab can briefly show an older server state. Every tab delivers the same log in order, so durable state and every tab converge once the streams catch up. No production path checks this yet. A counterexample bounds that convergence claim ([#2209](https://github.com/TanStack/db/issues/2209)). Two Browser tabs share one SQLite file through the real coordinator, with a controlled Electric stream per tab. Tab A's stream applies v1 then v2 at `30_0`. Tab B's lagging stream applies v1 at `20_0`, and tab B closes before it reaches v2. Tab A then shows v1, and the durable `electric:resume` offset is back at `20_0`. Nothing redelivers v2 to tab A while it stays open, because its stream is already past it. A tab that opens later resumes from `20_0` and repairs the cache in that history. Restart formerly failed when a later commit advanced the resume position over stale rows (#2281). The eager SQLite bridge now records source continuity atomically and requires a fresh snapshot on reopen after a gap; see the [repair evidence](oracle-reviews/issue-2281-investigation.md). This preserves temporary arrival-order regressions and leaves #2209 open. The multi-tab Electric oracle in `browser-db-sqlite-persistence` fixes this history with `it.fails` beside a passing control in which the lagging tab catches up. Ordering the copies would need a generic source position on sync commits; Electric already stores `{ handle, offset }` with each commit, PowerSync does not use this wrapper, and persisted Query collections have no log position. The [PR #1914 follow-up review record](oracle-reviews/pr-1914-immediate-reload-follow-up.md) preserves the held-checkpoint and extra-POST mutant results at the exact reviewed executable commit. The [PR #1902 review record](oracle-reviews/pr-1902-change-event-history.md) also covers one-pass queued-sync cancellation, partial-update dependencies on queued source rows, and focused late-hydration cases in `packages/db/tests/db-client.test.ts`. Those cases cross queued adapter insert and delete with a held local mutation. The [DbClient hydration authority oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/db-client-hydration-authority-oracle.test.ts) crosses applied adapter insert, update, delete, and truncate with hydration before and after the applied receipt. It includes delete/reinsert and truncate/reinsert controls. These owners do not establish arbitrary hydration stream order, a later authoritative hydration epoch, or unbounded retention. The [two-tab OPFS remote-subset oracle](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/e2e/remote-subset-two-tab.opfs.spec.ts) now exercises a real Chromium follower with a QueryClient-backed, filtered on-demand live query. It checks the function-bearing local request, clone-safe follower post, public row, and rejection of an invalid nested wire value before transport. A raw-options mutant fails with browser `DataCloneError`. The [review record](oracle-reviews/2026-09-27-remote-subset-two-tab.md) names the exact reviewed commit. The test does not run React, Firefox/Zen, or a live backend, and it does not settle exclusive OPFS ownership during leadership transfer. The [two-tab live Electric OPFS oracle](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/e2e/electric-resume-two-tab.opfs.spec.ts) crosses real Chromium tabs, Web Locks, OPFS workers, PostgreSQL, and the installed Electric SDK. It checks distinct per-Collection schema versions, unchanged public and durable rows when a follower opens, leadership transfer with later source rows, and recovery of partial-row loss or a fully empty pre-key-ledger baseline with a stale resume marker. A wrapped source-commit test in `packages/browser-db-sqlite-persistence/tests/browser-coordinator.test.ts` checks scheduler entry before the writer-lock request; the old bypass fails at that order assertion. The live recovery histories also guard the resulting progress. These bounded histories do not prove Firefox/Zen, React rendering, React Native, arbitrary large datasets, or an exclusive-OPFS ownership topology. Their [review record](oracle-reviews/issue-1589-live-electric-opfs.md) preserves the RED and GREEN host observations. The [issue #2085 review record](oracle-reviews/issue-2085-leader-close-red.md) preserves the baseline RED result and the subsequent repair audit. The source Collection law keeps an applied receipt pending after an indeterminate RPC. The replacement leader checks its exact transaction ID under the writer lock; an existing ID acknowledges the commit, while an absent ID permits application only against an unchanged durable anchor. The Collection and a dependent live query stay in one sync run. Direct mutating RPCs retain the #1845 `IndeterminateCommitError` contract. An absent ID after an intervening write, reset, or pruning remains indeterminate because applying it could regress a newer row or opaque source cursor. The persisted wrapper owner in `packages/db-sqlite-persistence-core/tests/persisted-oracle.test.ts` checks before/after durability, pending receipts, mounted live-query rows, queued hydration, later work, known durability failures, and an unchanged reconciliation reload. Its orphan row-metadata case fails on a shortcut that skips needed cleanup. Sparse-array, extra-array-property, and nested-prototype histories require a changed durable value to reload even when ordinary deep equality would skip it. The PR #2096 four-oracle review adds a mixed-demand reset route to the targeted/full-reload history. A previously public row outside the current filter is retained, refreshed, or deleted according to complete durable evidence; an unconfirmed DbClient seed remains source-owned. The controlled reset must publish no intermediate empty snapshot. Eighteen crossed histories compare every callback snapshot and final rows, including absent or older durable seed values. The original reset failed at the callback checkpoint. Targeted peer metadata set/delete now crosses active complete demand, an active filter, and retired demand with row update/delete/insert: an unconfirmed seed keeps both its row and its row metadata. The old receiver failed all eighteen seed-metadata histories. A protected-seed no-op reconciliation control reaches the same public event cut and emits none; its suspected redundant public event did not reproduce. Accepted same-key source transactions racing a targeted notice, paginated mixed demand, a peer write between complete and filtered reads, and atomic multi-subset reads remain unproved by these controlled histories. The [four-oracle review](oracle-reviews/2026-10-12-pr-2096-four-oracle-review.md) records the exact laws, witnesses, and dispositions. Direct persisted options and their spread copies can create only one Collection, both with and without a wrapped upstream sync source. The second creation rejects before it redirects the first owner's local or source writes. Selecting only the exposed wrapped `sync` config omits the descriptor claim; the runtime guard rejects that second Collection before changing control callbacks. A local-only write and an in-flight upstream source transaction remain with the first owner after the rejection. The ownership history now starts a selected-sync copy before the original lazy wrapped-source Collection as well as after it. A copy cannot bind first and steal the runtime from the successfully constructed options owner. The LocalStorage peer owner crosses those start orders for a selected `sync` copy and checks the owner's receipt, public rows, durable bytes, and listener count. Controlled listener and row observations do not establish that retained module options stop strongly referencing a cleaned-up restartable Collection. Whether cleanup promises collectability remains a separate resource-contract question. Cleanup does not release that claim. A selected `sync` config also cannot bind a second Collection after the first cleans up; the original Collection can restart and write through the same runtime in local-only and upstream-sync modes. Two DbClients materializing one descriptor receive independent runtimes. A no-demand on-demand full-reload notification reads collection metadata without fetching durable rows when no row is public. If a retired demand left public rows, the notification reads one durable snapshot and corrects only those rows. It retracts a peer-deleted row, updates a changed row, and removes obsolete row metadata without exposing unrelated stored rows. A later constrained demand does not need another validation read. An empty bounded page does not retract a row outside its scope. Eighteen source-precedence histories for that route preserve accepted source rows across insert/update/delete, truncate replay, and queued or serial reads. The original unbounded-read path and direct options reuse both failed these new witnesses before repair. The notice corrects already public rows even during the idle interval after demand retirement. With an active unpaginated filter, six further histories retain, update, or delete a previously public out-of-filter row across targeted and full-reload notices while another in-filter row changes. The original mixed-demand implementation failed three of six exact public comparisons; the repaired path validates previously visible out-of-filter keys from a complete durable snapshot. Paginated mixed demand, arbitrary overlapping retired subsets, a peer write between the full and filtered reads, and host scheduling remain outside these bounded controlled histories. A failed direct Collection constructor releases its options claim if the runtime never bound an owner; a corrected retry can then create the Collection. A successful owner still retains its claim through cleanup. The persisted owner also checks DbClient hydration seeds against absent, older, and equal durable rows through complete demand, zero-demand peer validation, and a bounded peer notice. The active-notice history combines a protected seed with ordinary row replacement, deletion, and insertion, then repeats the notice with an older durable seed. These controlled paths assert public rows and change batches; they do not prove every host-delivered peer schedule. Zero-demand validation clears orphan row metadata with zero or one public row, while an equal metadata-bearing row emits no change batch. The full durable snapshot used to validate visible keys remains O(table) per notice, including when a current filter leaves previously public keys outside its scope. There is no O(visible) read budget. A keyed atomic snapshot would need an adapter contract and receiving witness before that work bound can be claimed. The persisted wrapper owner models complete durable rows as exact values: field absence, including an own `undefined` field in the generic adapter, matters as much as scalar content. Eighteen bounded histories cross complete demand, retired-demand full-reload notice, and retired-demand reset with field removal, addition, and scalar change. They compare full public rows, event values, deleted and newly admitted keys, and a protected DbClient hydration seed at settled publication. Nine removal histories fail on the reviewed `8b3debb3a` implementation, while nine neighboring controls pass. The `undefined` arms are generic-adapter evidence; SQLite object encoding omits those fields. A captured-read source history checks submitted same-key and new-key writes after the held read releases, while eighteen complete-demand source-precedence histories extend the existing bounded matrix. These checks do not assert that a source write was accepted before the held read releases. Targeted `tx:committed` notices have separate bounded demand-scope and partial-patch histories. Six cases cross active `title = Keep` demand and retired demand with a row that stays in, enters, or leaves that predicate; five fail at exact public-row comparison and the leaving-active control passes. Nine more cases protect a DbClient hydration seed against durable replacement, partial update, or deletion under active complete, active filtered, or retired demand while an ordinary row changes; all nine fail. Two active-demand union controls keep a row that leaves `title = Keep` but enters `title = Other`, in both demand acquisition orders; both pass on the reviewed head. Temporary first-only and last-only evaluator mutants each fail one control at the public snapshot comparison. Ten source-confirmation histories apply a source insert, update, or delete to a DbClient hydration seed, await its applied receipt, then deliver a targeted or full-reload peer update, deletion, or insertion. A changing ordinary sibling ensures a perpetual-seed-protection mutant fails at exact public-row comparison rather than only timing out. Six same-key operation-order cases cross active complete and retired demand with delete-then-update, update-then-delete, and two partial updates; three fail and three pass. The independent models select authored complete durable rows, while notices carry legal source patches. Delete-then-update and update-then-delete produce the same separated `changedRows` and `deletedKeys` but opposite durable outcomes, so the receiver cannot infer the row from that envelope alone. The baseline failures and neighboring controls are recorded in the [PR #2096 law review](oracle-reviews/2026-10-12-pr-2096-oracle-laws.md); the repaired controlled paths pass. Further in-scope source transactions concurrent with targeted delivery need a same-key acceptance-order witness in this owner. Real SQLite delta creation and browser/Electron notification delivery need matching receiving witnesses in their existing adapter and host owners before this controlled result can be claimed across those boundaries. The Electric recovery owner has separate real SQLite restart histories. Its generated peer-publication history instead uses a Map-backed adapter and a manually delivered notice. It compares exact public rows, durable rows, and a committed metadata marker. A full-reload notice requires an authoritative durable row read in that active-demand history, through either adapter row-read route. A targeted notice for a previously unseen key may also read durable rows because its value has no completeness certificate. The oracle does not treat `requiresFullReload: false` as a no-read guarantee. The metadata of an unseen targeted row is not asserted to be demand-scoped: core permits explicit row metadata for an absent row, so this needs a separate product decision before changing that contract. The user chose demand-scoped schema-reset publication for on-demand Collections. With no active subset, reset validates only already public keys against durable rows; an empty public Collection remains empty, and a changed or deleted visible row is corrected. Eager reset still restores its full baseline. Eighteen source-precedence histories cross on-demand reset with insert/update/delete, source truncate replay, and queued or serial reads; three focused reset histories distinguish empty, changed, and deleted visible scopes. They do not establish host notification delivery or a keyed SQLite read budget. The visible-key validation may read the full durable table. A controlled term-jump history recovers a missed row; a position-only certification history shows that observing a durable version does not publish its rows. Reset continuations rebase the publicly applied row version, reject a delayed pre-reset notification in both orders relative to a newer election, and recover a row committed between the reset reload and the later position-only read. A controlled same-term reset continuation checks two new-epoch commits separated by a delayed old-epoch notice. The commit envelope has no reset epoch, so the wrapper rereads durable rows for all three ambiguous notices; a no-fence mutant publishes the old row. This establishes public-row safety and its three-reload work cost, not a bounded-work promise. The built-in coordinator currently has no `collection:reset` sender; a real-host same-term reset needs a Browser/OPFS receiving witness. A future epoch-aware fast path needs the persisted wrapper owner to distinguish old and new same-term notices at each public cut before that real-host receiving witness. The controlled wrapper compares public rows after each held cut; removing the old-term fence or treating the later position read as published rows fails those assertions. The SQLite adapter owner checks exact IDs, row versions, reset epochs, pruning, unchanged anchors, same-key peer writes, cursor metadata, durable no-write term reservation, and the exact-ID index plan against real SQLite transactions. It also checks that a live claim on a retired physical generation can proceed, that live claims cannot cross physical generations, that expiry fences reconciliation and term reservation before a durable write, and that a new claim remains usable. The Browser coordinator owner checks writer-lock stream advancement, changed routes, and invalid wire anchors. It delays a former owner's captured heartbeat past a no-write Web Lock takeover and checks both the new owner and a passive follower retain the newer route after the delayed heartbeat. Distinct durable terms protect the later routed source write. Its election witness checks that the registered physical storage ID and claim reach term reservation. The Electron IPC bridge runs the SQLite adapter contract through its renderer and main-process handlers, including exact-ID reconciliation and protocol-v5 claim-scoped term reservation. Its resolved-adapter witness checks that reconciliation carries each Collection's mode and schema version, and its absent-capability witness checks that an unknown result leaves durable state unchanged. The real-process witness runs the renderer adapter in Vitest and sends its envelope to an Electron main process. It does not execute the adapter inside an Electron renderer or check concurrent requests from multiple renderers. A reconciliation IPC reply delayed until after main applies is an untested transport history owned by the Electron receiving contract. The Chromium/OPFS host owner runs idle, before-durable, after-durable, peer-before-reconciliation, notification-before-lost-answer, and cold-successor histories across real tabs, Web Locks, BroadcastChannel, workers, and SQLite. It observes durable rows, cursor, and exact applied transaction IDs, public source/live-query rows, receipt settlement, one sync run, and passive-tab event counts. The peer history holds reconciliation before the writer lock until the peer write is durable. Removing the reconciliation reload marker leaves the passive source and live query without the original row at that public checkpoint. The real Electric receiver in `packages/browser-db-sqlite-persistence/e2e/electric-leader-close.opfs.spec.ts` streams a PostgreSQL row through the installed SDK, closes the first writer after SQLite applies that source transaction, and checks the surviving Collection, mounted live query, durable rows, exact applied ID, resume marker, and later PostgreSQL row. The original Electric applied receipt fulfills in one sync run. The crossing row's transaction and first durable snapshot agree on resume offset, handle, and shape ID. It supplies the SDK handoff for this one after-durable history. The wrapper's controlled term jump and the real OPFS cold-successor election are separate evidence cells. The persisted wrapper now has a controlled same-key peer-write continuation: X is durable at version 1, Y advances storage to version 2, exact-ID reconciliation acknowledges X's original position, the source receipt fulfills, and the wrapper's owned resume evidence fails closed against version 2. A temporary latest-position response makes that evidence assertion fail. The real SQLite exact-ID decision and this wrapper receiving history still have separate drivers; one real-adapter wrapper join remains with the persisted SQLite receiving owner. A single real-host history combining a missed original notice, an empty reserved term, and a passive follower's later public rows remains with the Chromium/OPFS owner. The controlled nested-prototype replacement reaches source and mounted live-query cuts; real SQLite serialization of that nested class in the same wrapper history remains with the Node SQLite receiving owner. The reset continuation uses a controlled snapshot with the same version-zero premise that the real SQLite adapter's schema-reset oracle proves. A combined real-adapter wrapper reset and later notification remains with the persisted SQLite receiving owner. The persisted wrapper owner also holds an on-demand resume certification across a newer, sequence-zero term while the row version and reset epoch stay fixed. It rejects the old exact-generation guard at key-set evidence. The Electric held-snapshot owner joins the real SQLite term reservation with the persisted wrapper and mocked Electric stream: the source retains its cursor and reaches ready with the original durable rows. Neighboring committed-write and schema- reset histories reject inheritance of the old baseline. The real Chromium/OPFS reopen history still owns the host election and restart schedule; this local join does not prove that schedule passes in CI. A bounded TLA+ design grammar and exact TLC receipts live in `review-evidence/issue-2085-tla/`. It explores one X, one same-key peer Y, one reset, delayed/lost notices, position-only observation, and ledger pruning; it checks the reference laws and kills wrong-design mutants but does not execute a production path. A separate challenge shows that an old commit notice can publish an old row after durable reset _before_ a passive peer receives any reset signal. The built-in coordinator has no reset sender, so this is an unresolved proposed cross-tab reset law, not a confirmed current receiving failure. A future sender needs a Browser/OPFS witness for that pre-signal order. This bounded owner assumes tabs run the same protocol version and one `txId` identifies one immutable payload. The Electric receiver does not cover before-durable loss, queued hydration, two Electric providers contending in both tabs, seven concurrent Collections, or a closing leader's active SQLite call; those need receiving schedules owned by the Browser Electric, hydration, and OPFS page-lifecycle suites. Arbitrary concurrent writes, physical crash durability, other browsers, and cross-version tabs are outside the established host evidence. These limits do not authorize a late apply after an intervening durable write. The persisted wrapper owner now also checks the no-`pullSince` row-version-gap fallback at every Collection change callback: a durable baseline, a missed commit, and a later notice may expose only the baseline or the complete durable replacement. The old truncate fallback exposed an empty intermediate snapshot. The Electric recovery owner drives ordinary peer notifications only after its adapter commits matching rows, metadata, and a contiguous row version; its bounded peer/stream histories retain exact public-row and publication-marker checks. The previous fixture announced version 101 while its durable position remained zero, so the new gap detector treated an ordinary notification as a missed history. These controlled owners do not prove real Electric delivery of a lost-notice gap; the Browser Electric/OPFS receiver owns that schedule. The Electric recovery fixture now distinguishes same-key insert replacement from partial update merge. Its generated peer-publication grammar varies that operation and a removable field, and requires a subscriber event carrying the authored callback-time snapshot when public rows change. A missing-event mutant fails at that event assertion. The generated same-key insert history found a receiver violation: targeted notices omit insert/update identity, so a public row must be checked against durable state before interpreting an omitted field. The primary persisted owner crosses insert replacement with two-update and delete/update controls under active and retired demand; removing the durable check fails both insert histories at exact public-row comparison. These Map-backed histories do not establish real SQLite notice construction or browser delivery; the relevant real-provider receiver remains needed. The [live Electric hydration-straddle oracle](https://github.com/TanStack/db/blob/main/packages/browser-db-sqlite-persistence/e2e/electric-hydration-straddle.opfs.spec.ts) owns one #1754 host history: an on-demand Collection has an initial durable row; an OPFS subset hydration is held after its local read; a PostgreSQL update begins an Electric source transaction during that hold; and the row-bearing commit is released only after the hydration scope exits. It checks the old row before release and the exact new public and durable row afterward, then after follower takeover and reopen. The fixture observes the on-demand run's claimed storage ID and claim at coordinator registration; PostgreSQL supplies the expected row independently. A late-buffer mutant leaves the old row in both observations. The [core persistence tests](https://github.com/TanStack/db/blob/main/packages/db-sqlite-persistence-core/tests/persisted-oracle.test.ts) own the adjacent during/straddling/after settlement, FIFO, abort, and failure histories. The live oracle does not prove eager-startup overlap, other mutation shapes, arbitrary Electric fetch schedules, Firefox/Zen, React rendering, or exclusive OPFS ownership. The [review record](oracle-reviews/issue-1754-live-electric-hydration-straddle.md) preserves the live-host and mutant evidence. ### Source durability inside a shared hydration scope The `hydration source durability routing` owner in `packages/db-sqlite-persistence-core/tests/persisted-oracle.test.ts` now runs 144 bounded histories: startup/subscription/after-ready × scoped/unscheduled × empty/shared-key baseline × twelve transaction templates. Its independent edit log covers full upsert, same-key order/delete, truncate/replacement, row and collection metadata set/delete, truly empty work, atomic multi-row batches, independent pre-abort, and first/second durability failure. It checks each acceptance and applied receipt separately, exact durable admission and prefixes, sequence allocation, current scoped-adapter identity/lifetime, ordinary next use, a second on-demand scope, and durable reopen. Four cleanup/restart histories and one early-receipt checker calibration supplement the matrix. Existing startup-read failure, request-local failed-read/retry, and optimistic causal replay witnesses preserve no-scope, same-adapter and distinct-adapter paths. Three callback-lifetime calibrations distinguish nested scopes and both overlap exit orders. Forwarding-wrapper and explicit-adapter controls cover coordinator composition and the ordinary registered fallback. The receiving fixed tests in `packages/browser-db-sqlite-persistence/e2e/hydration-commit.opfs.spec.ts` run 24 real Chromium OPFS histories plus one cleanup-failure calibration. They have no oracle owner: their expected rows come from a written table keyed by baseline and source history, not from a model. An oracle owner is tracked in #2264. It crosses the original phases/coordinators/baselines with single-insert and rich source histories, and checks three distinct Collection schemas, a cold peer, metadata, durable rows, and reopen. Sixteen startup/subscription histories require exact owning-scope exit; eight after-ready controls have no held scope and report that fact explicitly. The held cut waits for real peer hydration and ordinary-write scheduling admission. Peer hydrate/regular callback entry and C's commit SQL remain forbidden until the owning callback exits. Election stream-position reads are deliberately outside that regular-work law. The tail joins any truncate-triggered hydration, then must use the default coordinator's public apply or the browser coordinator's regular scope exactly once. Cycle detection ties the same transaction to the supplied live scope and its erroneous scheduled call; temporal overlap alone is insufficient. Captured primary evidence survives cleanup failures. The default coordinator now uses the supplied scoped adapter for that call, without caching it. The initial repair receipt on main at `a37e69ab` records 48 core routing assertion failures and eight real scheduler-cycle assertion failures for the original production code. The latest review follow-up passes 640 persisted-oracle checks (with one existing todo) and 25 Chromium OPFS checks. The original eight mutant repairs cover premature receipts, cached loans, omitted data, reverse FIFO and suppressed/misclassified failure. New calibration shows the old browser checks accepting cached loans and ordinary scheduling bypass; the strengthened receiver rejects them at tail routing and the complete scope boundary. A no-scope error-identity mutant is rejected by the restored failure paths. The [loss audit and exact content bindings](oracle-reviews/issue-2046-hydration-loss-audit.md) preserve all source recoveries, decisions, commands, calibration and limits; the [initial review](oracle-reviews/issue-2046-hydration-commit-deadlock.md) retains the original issue ledger. - [ ] **Scoped lifecycle compositions.** The persisted-history owner needs distinct-scope witnesses for dependent and post-publication aborts, buffered partial-update recovery, row metadata from different owning reads, arbitrary queued reloads, and late already-issued storage results after replacement. Existing semantic owners remain authoritative. The new queued-cleanup witness does not promise rollback of issued writes. - [ ] **Nested work under fairness backlog.** The shared-driver fairness owner (`tests/shared-driver-fairness-oracle.ts` in the browser package, with its OPFS receiver) needs a nested source commit inside a hydrate while both grammars retain a backlog that distinguishes K=1 from K=2. Finite peer progress here does not establish that composition. - [ ] **Elected-owner/host handoffs.** The per-Collection coordinator owner retains transfer/cross-tab RPC while nested durability is pending. The OPFS receiver owns provider-supplied physical failure and abort/cleanup witnesses; other browsers and native hosts need their own receivers. Distinct-schema isolation on this host is now checked. - [ ] **Historical attribution.** A package bisect is still needed for the earliest affected release; this work checks the stated `origin/main`. ### SQLite boolean predicate arity and row work `packages/db-sqlite-persistence-core/tests/sqlite-boolean-arity-oracle.test.ts` is the primary executable owner for bounded `and`/`or` predicate arity at `SQLiteCorePersistenceAdapter.loadSubset` return. Its independent three-valued model compares public keys while a `node:sqlite` driver records SQL and raw row work. The 960-case matrix and paired fixed and unseeded campaigns cover root arity 0–3, one nested operator, boolean and nonboolean operands, safe selective predicates, and sound candidate supersets for unsafe predicates. Eight direct cases challenge Unicode `ilike` and `like` patterns, tagged `NaN` comparison, lone-surrogate equality, and null-vs-missing under `not`. Paired- and lone-surrogate equality controls retain SQL row-work reduction. An empty-IN control and two-SELECT cursor composition check zero-row work. The original compiler was RED for unary and empty boolean work and multioperand under-selection. The first repair was RED for unsafe SQL prefilters: Unicode case folding, an emoji spanning two JavaScript code units, tagged `NaN`, and null-vs-missing under negation. A later lone-surrogate equality witness was RED for public rows and SQL work. The compiler now applies SQLite JSON extraction to the matching binding; paired and lone surrogates both keep indexed equality. The current compiler passes the bounded oracle. A removed-WHERE mutant fails the raw-row work law and a blind-unary mutant fails public rows. For this grammar, SQL pushdown admits every row that the in-memory evaluator could retain; a statically false AND may read zero rows even with an unsafe sibling. Mixed-AND witnesses retain a certified equality while an unsafe range, NOT, or OR sibling stays with the row evaluator. They cover child order and one nested AND, measure one raw row instead of twenty, and reject a removed-WHERE mutant. The unsafe OR mutant loses a public row. A fixed 80-level nested AND witness bounds compiler argument reads to linear work. It was RED on the prior quadratic compiler and is GREEN after removing the repeated subtree compilation; elapsed latency and arbitrary depth remain outside this owner. TimFL's 50,582-string-ID `AND(OR(IN, IN))` scope was RED for SQL row work: the adapter returned the right public row but read all 20 stored rows. A fixed real-SQLite witness now checks the public result, exact candidate count, two bound JSON arrays, and use of both named expression indexes. It includes lone-surrogate, NUL, and paired-surrogate string members. Mixed-type lists, other SQLite hosts, and elapsed-time gains remain outside this witness. The Node expression-index oracle checks the receiving SQLite query, raw candidate keys, public keys, and named-index plan. Its generated indexed grammar uses string equality, BigInt membership, numeric range, and string conjunction. Focused Date-epoch witnesses keep numeric equality and numeric membership on the JavaScript fallback path: a stored `Date(1)` matches numeric `1` in the row evaluator but is ISO text in the SQLite expression index. Fixed lower-wrapped BigInt membership and lone-surrogate coalesce witnesses also retain fallback: SQLite converts the former to text and encodes the latter's inline fallback differently from a JSON-extracted binding. Integer-bound range cases include adjacent fractional values and tagged or mixed scalars; this is bounded evidence, not a proof over every persisted representation. Large Number versus BigInt range cases check both operand directions, four inequalities, and unary boolean wrappers. Unsafe BigInt bounds admit a wider candidate range over the indexed expression for potentially rounded Numbers; JavaScript still decides the public result. Numeric-key object and array cases check public rows and named-index use through three digit segments, including mixed carriers. Deeper numeric paths use an unbounded candidate read. Unicode lowercase cases place NUL before and after a fold and keep the matching row through either equality direction and unary wrapper. The receiving Node plan uses the named index for the selective BigInt range orientation in both operand orders. The opposite orientation can scan because its candidate union also admits text and rounded Numbers; this oracle makes no constant-index-use claim for that branch. Fixed `strftime`, `add`, and Date-range witnesses also use full reads for mixed stored types; direct SQL would exclude a matching numeric timestamp or string concatenation. A typed-field contract or a separate indexed representation is needed before those forms can gain a generally sound selective candidate. The owner does not establish arbitrary depth or arity, every equality or LIKE pattern, limit/offset after filtering, all cursor shapes, order or value/metadata semantics, index-expression compilation, native hosts, OPFS, or multi-process execution. The existing SQLite owners above retain their separate reset/resume, order, driver, and host contracts. Broader class closure needs witnesses at those remaining paths. The optimistic history owner includes an external completion action. `optimistic-history-outcomes-oracle.test.ts` runs264 bounded completion histories: pending/persisting/completed/failed states,1–3 attempts, absent or independently pending/persisting same/other-key peers and target/unowned/peer/truncate source work. It preserves state, request outcome, public rows and waiter-time snapshots; a later source write checks continued use. Full owner287 passes on858b174a6. Deferred publication and missing admission guards fail at their intended checks. The real Offline settlement owner receives this law through60 serialized-outbox restoration histories:2/3 transactions, every outcome mask, shared/disjoint width1/2 and partial-overlap width2. A stateless prefix fold checks whole rows, pending metadata, eager waiter snapshots, core restoration states, per-ID outcome, provider calls and remaining outbox. It exposes14 unrepaired cleanup exceptions: a successful durable replay attempts to complete a snapshot a sibling rollback already failed. Known trace:shared or chain FT, FTF, TFT, FTT; shared also FFT. The independent outbox result is successful; the core snapshot must remain failed. 214/220 declared cuts reach; six later cuts remain blocked by earlier RED. Removing publication or deferring it fails public pending/waiter metadata even on all-success histories. See the RC chunk10 record for exact logs and limits. This is an open production class; repairs await completion of all oracle chunks. The receiving scope excludes deletes, retries, terminal outbox phases, multiple Collections, native durability and multi-owner timing. ## Acceptance map The post-merge review added three missing domains to existing owners: - [Top-K batch contracts](https://github.com/TanStack/db/blob/main/packages/db-ivm/tests/operators/topk-batch-contract-oracle.test.ts) cross sparse-array length/holes and RegExp source/flags/position with equal controls, replacement order, hash consolidation, and actual retained graph output. Ordinary replacements also run without the global `File` constructor. Its five `oracleProperty` campaigns preserve the original five fixed seeds and 25 generated inputs per relation/path cell, and add equal-budget random campaigns. Constructed histories measure replacement order, equal and unequal versions, transient cancellation, collisions, File availability, shared subtrees, unrelated getter reads, and long cancellation. The [conversion evidence](oracle-reviews/2026-11-10-topk-batch-property-conversion.md) records the same-seed mutation comparison and direct guarded replay. The unrelated-payload campaign compares each source key's exact signed contribution bag and source-row identity, as well as output length and zero getter reads. A multiple-key constructed history and duplicate-key/omitted-key calibration protect that distinction. - [Leadership replay](https://github.com/TanStack/db/blob/main/packages/offline-transactions/tests/leadership-replay-oracle.property.test.ts) holds real storage-read delivery across successful and permanently rejected durable removals, with bounded scans, concurrent loads, and unfinished peers. This is distinct from exactly-once execution across independent owners. - Settlement-time drop of optimistic state is owned by the [optimistic history model](https://github.com/TanStack/db/blob/main/packages/db/tests/optimistic-history-oracle.ts) and [state retention](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-state-retention-oracle.property.test.ts). A transaction's optimistic state drops when its mutation function settles. Sync transactions committed while it persisted are held and publish with that drop; `when('settled')` settles after that publication. Handler sync writes are generated at every cut, with and without awaiting their acceptance. Receipts stay pending until visible. With one persisting local mutation and no truncate, the first queued same-key source transaction consumes local attribution at settlement if that mutation succeeds. An absent-key delete consumes it without leaving a row. Repeated same-key writes in that first atomic source transaction keep its attribution. Later source transactions are `'remote'` without another local owner. A truncate can publish while the mutation remains active and label its same-key row `'local'` even if that mutation later fails. Attribution uses key and timing; `SyncConfig.write` has no causal client identity. A pending manual mutation does not hold source writes; a same-key source row can retain local attribution after rollback. A subscriber can commit a truncate and a later same-key transaction during another drain. The suffix truncate can use the still-active mutation's attribution. The later same-key transaction in that suffix drain is remote. An active mutation on a key the truncate does not write still attributes that key's first later transaction in the same drain. Bounded histories also cross two persisting same-key mutations, one or two source batches, both settlement orders, and success/failure combinations. The first source batch is local when at least one mutation succeeds; two failures leave it remote. A mutant failed-sibling mutant fails the one-success cases at settlement. The pending grammar rejects a mutant that ignores pending mutations at its source or settlement publication. Bounded manual histories now cross success, direct rollback, and handler rejection with both optimistic visibility settings. A later disjoint edit cannot supply the earlier manual request's handler outcome. The original harness left rejected manual requests pending; the new settlement check rejects that harness and a shared-handler variant. Six pending-peer histories distinguish same-key rollback cascades from secondary rollback and different-key controls, through public settlement and publication. Longer manual interleavings and larger same-key cascades remain outside these fixed histories. The original truncate implementation failed the reentrant history at failed-mutation settlement. The earlier accepted-snapshot retention law and its truncate-capture ownership refinement were retired with this contract. The [PR #1907 review record](oracle-reviews/pr-1907-accepted-delete-ownership.md) is historical. The [settlement-drop review record](oracle-reviews/2026-10-03-settlement-drop.md) holds the RED/GREEN and mutant evidence. A handler that awaits a visibility receipt held by its own transaction, such as an on-demand load of its own Collection, waits for itself; that history is outside the generated grammar. Issue #2071 adds two focused checks to this acceptance map: - The [issue #2071 review](oracle-reviews/issue-2071-refused-insert.md) checks a rejecting `onInsert` through the persisted wrapper. Four controlled histories cross source insert/delete with acceptance before/after rejection. They compare live rows, exposed base, durable rows, origin, and a held source receipt at mutation settlement and after source application. The [real SQLite receiver](https://github.com/TanStack/db/blob/main/packages/db-sqlite-persistence-core/tests/persisted-real-adapter-lifecycle.test.ts) checks two same-key continuations, including a real source `update` after reinsert. Each reopens the same file with a new Collection, adapter, and SQLite driver. Both the reported release and this review tree pass these bounded histories. The reporter's private bridge sequence is unavailable; these witnesses do not establish its behavior, other mutation kinds, on-demand sync, other SQLite hosts, or an OS process restart. The persisted wrapper owner needs the bridge callback and write sequence to reach that path. - The [optimistic publication owner](https://github.com/TanStack/db/blob/main/packages/db/tests/optimistic-history-publication-oracle.test.ts) distinguishes one and two queued same-key source transactions during a successful local mutation, two same-key writes inside one atomic transaction, an absent-key delete before a source insert, a delete and reinsert in one atomic source transaction, a truncate published before a mutation fails, pending manual mutations, two overlapping same-key mutations, a truncate followed by another same-key transaction, and a truncate followed by a different-key transaction with an active mutation in one reentrant drain. The persisted wrapper receives the one/two transaction pair. The source grammar can now preserve mixed write order inside one transaction; its atomic delete/reinsert witness is distinguished from a later same-key transaction. These histories establish bounded key-and-timing attribution; they do not establish every mixed operation sequence, causal authorship, or every overlapping mutation schedule. A causal `$origin` guarantee would require an explicit source signal and a new core-owner model and provider receiving witness. The [PR #2078 review](oracle-reviews/pr-2078-origin-attribution.md) records the original same-drain RED, the repair, and mutant controls. The optimistic history owner still needs controlled pending-plus-persisting same-key histories, truncate with two active owners, and longer reentrant or mixed source suffixes if those broader schedules are claimed. Such a witness must compare origin and complete publication cuts, not only the final row. The persisted wrapper owner still needs the private bridge callback and write sequence before claiming that reported path. | Issue obligation | Implemented evidence | Limit | | -------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- | | Metamorphic laws | Includes cross-formulation/partition, D2 independent-key commutation, DBSP incremental/full recomputation, pagination provider/UI boundaries, optimistic snapshot stability | Equivalence premises are explicit; not arbitrary query rewrites. | | Public observations | Reads, exact event payloads and reconstructed state, observer eligibility, downstream includes, lifecycle and ownership checks | Count/work budgets are separate from row truth and only fix established promises. | | Meaningful async histories | Applied receipts, truncate/replay, cleanup/restart, pending optimistic work, held provider completion, leadership loss | Control real causes; unsupported SDK traces receive no coverage credit. | | Checker sensitivity | Faulty output controls, missing/duplicate events, stale completion/ownership controls, forced collisions and pre-fix runtime witnesses | Setup failures and timeouts are recorded separately from assertion kills. | | Executed reach and replay | Named manifest with guarded replay, finite boundary products, fixed histories, fixed/random campaigns and explicit stress runs | Root `test:oracles` is a selected core/Query DB campaign, not all repository oracles. | | Contract and scope records | Guide, companion case notes, this map, suite-local law/domain comments and architecture | This is an executable testing method, not a completeness proof or new product specification. | ## Running and replaying Build workspace dependencies before testing consumers of package exports. Use the package's checked-in config; source aliases and native shims must be named when they replace that path. ```sh pnpm --filter @tanstack/db-ivm build pnpm --filter @tanstack/db build pnpm --filter @tanstack/db test:oracles pnpm --filter @tanstack/db-sqlite-persistence-core build pnpm --filter @tanstack/node-db-sqlite-persistence test:oracles # Service-dependent: requires Electric and PostgreSQL to be running. pnpm --filter @tanstack/electric-db-collection test:e2e pnpm run typecheck:tests pnpm exec tsc --noEmit -p packages/db/tsconfig.json pnpm --dir packages/db exec vitest run --coverage.enabled=false --maxWorkers=2 pnpm --dir packages/db-ivm exec vitest run --coverage.enabled=false --maxWorkers=2 pnpm --dir packages/offline-transactions exec vitest run --maxWorkers=2 ``` Core guarded replay is run from `packages/db`, for example: ```sh TANSTACK_DB_ORACLE_SEED=1813 TANSTACK_DB_ORACLE_PATH=0 \ TANSTACK_DB_ORACLE_PROPERTY=live-query-observer.granular-history \ node --import tsx tests/oracle-replay.ts \ tests/live-query-observer-history-oracle.property.test.ts \ -t 'granular listeners follow the eligibility ledger with a random or replayed seed' \ --coverage.enabled=false --typecheck.enabled=false ``` Use the failure's actual seed/path for a reproduction. The example establishes target execution, not reproduction of a particular bug. Local IVM and offline properties have separate environment variables; inspect their test headers. Do not assume the core multiplier reaches them. The adapter-window properties have named fixed history routes in `packages/db/tests/oracle-replay-manifest.ts`. Each shared history property includes its production driver: `framework..window-history`, `framework..pending-window-history`, or `framework..publication-window-history`. The drivers are `react`, `react-dependency-list`, `preact`, `vue`, `solid`, `angular`, and `svelte`. Each route selects its own conformance file and names the shared model module as its source. React and Preact render witnesses, all twelve React SSR runtime/path cells, and the IVM numeric-window grammar retain their own routes. Selectors choose only the fresh or random campaign. The earlier three shared `framework.*` names are retired because they lost the failing driver's identity. The [replay review](oracle-reviews/2026-10-30-adapter-page-window-replay.md) records the 21 driver/history witnesses and correction of the earlier canonical React routing claim in the preparation record. The Node expression-index oracle runs matching fixed-seed and seedless-random campaigns by default. A path replay of its property selects only the requested seed and shrink path: ```sh TANSTACK_DB_ORACLE_SEED=1659005 TANSTACK_DB_ORACLE_PATH=0 \ TANSTACK_DB_ORACLE_PROPERTY=sqlite-persistence.expression-index \ pnpm --filter @tanstack/node-db-sqlite-persistence test:oracles ``` Stress runs need an explicit file list, run budget, seed policy, runtime, exit status and cost. For long synchronous campaigns, yield **between complete histories**, never between an action and its synchronous observation. In this project, worker progress RPC starvation produced passing assertions with a nonzero process exit. Such a run is not green. Raising a test timeout alone does not let the worker process its progress messages. ## Action enforcement example `examples/react/action-enforcement/eslint-rules/no-direct-collection-mutations.test.js` (fixed tests; no oracle owner (tracked in #2264)) covers the example's file-local lint boundary. Its finite crossing covers 12 binding forms, six methods, six call forms, and two callback definition orders, plus lexical shadowing, sibling scopes, configurable imports/methods, and alias cycles. Each expected count is written: a table gives one diagnostic for each write method and none for each read, so the crossing is fixed tests, not a model (maintainer decision 2026-10-27: a table of written expected values selected by a test's parameters is not a model). The checkpoint is the complete diagnostic list from the real ESLint `Linter.verify` call. A receiving check runs the actual ESLint configuration on feature writes, feature reads, and action writes. The import-source dimension checks eight alias/relative/barrel spellings against four nearby unrelated paths, including the real configuration. Three TypeScript import-equals forms must preserve other diagnostics without crashing; static and escaped template members are paired with dynamic names. On `7d3a3e85b`, the expanded suite fails 21 of 32 groups: the parser-node witness throws while linting; the other failures are missing diagnostics. The repair passes all 32 groups. A path-prefix mutant that includes `collections-extra` fails three groups. A template-prefix mutant that treats interpolated names as static fails the dynamic-name assertion. Both failures reach diagnostic comparisons; neither is a setup failure. The original implementation (`3da274d8a`) failed 11 of the 18 test groups at that checkpoint: name-based scope pollution, declaration-order dependence, and missed destructuring. The repair passes all groups. The example README states the conservative rule for reassigned aliases. This oracle does not establish inter-module or type-based tracking, function argument/return propagation, new object/array containers, extracted mutation functions, or dynamic method names. Those are outside this example's declared static scope; expanding it requires new syntax witnesses here. Guide evidence: ORC-001–005 and ORC-009 are stated beside the finite grammar, model and driver. ORC-006 uses the original production rule as the rejected wrong design; failures are diagnostic assertion mismatches, not setup failures. ORC-013 pairs writes with reads and imported bindings with shadowing local values. ORC-007 does not apply to this bounded enumeration; ORC-008 has no stateful model, ORC-010 has no shrinking or resource cleanup, ORC-011 has no named shared semantic fault requiring a second formulation, and ORC-014 is witnessed at the real ESLint configuration boundary; no browser or backend-provider claim is made. These outcomes supply ORC-012 evidence; the executable suite contains the law and observations, rather than relying on this record for expected behavior. `examples/react/action-enforcement/tests/TodoApp.test.tsx` owns the example's application input and pending-write controls. Its focused component witnesses use real actions and the fake API with a virtual clock. They check unchanged, newer, and empty drafts after successful adds; unchanged and newer drafts after controlled create rejection; native form submission; and disabled toggles at 0, 40, and 119 ms during creation. A settled row remains enabled while another row is pending, and a newly settled row can toggle and persist its change. The original component fails the newer-draft, form, and three pending-row checks. The fixed component passes these nine cases. The lint oracle above cannot observe these application behaviors, and the shared framework owners do not own form state. The component suite also owns add admission: one add may be pending per mounted form, the input stays editable, and settlement permits the next submission. Four controlled-create histories cross fulfillment/rejection with repeated submits before/after a React render. They assert one action and provider call, reject submissions of a newer draft while pending, then admit that draft after settlement and check exact persisted counts. A fifth witness checks admission after synchronous validation rejection. The original handler fails all four pending-add histories. A guard based only on React state fails the same-render histories; a mutant that omits guard cleanup fails subsequent admission. A controlled-toggle history also checks failure and retry in both completion directions. It observes pending disablement, optimistic state, rollback, visible error, retry error clearing, and final provider state. The original component rolls back but fails the error-message assertion. This provider rejection is injected at the component boundary; it does not claim a real backend emits it. The same-path rejection probe found no unhandled rejection: Collection cleanup already catches the persistence promise. Toggle tests select buttons by accessible role. A hidden-toggle mutant passes the original tag selector but fails the scoped role query before interaction. This checks exposure in the accessibility tree; it does not establish keyboard focus or screen-reader behavior. These 15 focused cases do not establish arbitrary-length form histories, remount behavior during pending writes, or browser-native Enter dispatch. This component suite owns the first two extensions; a browser form witness is needed for native keyboard dispatch. ## Oracle tooling The converted TopK batch, OP-SQLite alias and Preact window-render owners check constructed-state observations in their shared comparisons as well as the framework's seeded checks. The pinned framework omits builder association for fresh generated constructions. Their [reach follow-up](oracle-reviews/2026-11-10-constructed-reach-followup.md) records generated-only omission controls, shared-check calibrations and the unchanged production paths and run budgets. The finite Preact bound-options owner already enforces its per-case cuts and reach directly. `scripts/run-budget-oracle.property.test.js` owns run-budget tracking (`scripts.run-budget`): every lowered budget, and every budget whose key is in no tracked oracle file at head, is reported. A budget belongs to the oracle file that uses it, including campaigns and constants in the test modules that it imports. The removal rule is the maintainer's decision of 2026-10-27; a move into an imported support module is not a removal. Its grammar varies where the count, key, and campaign are written at base and head, a base oracle file above 1 MiB, `.ts` and `.js` files, an untracked second oracle file, and a fixed seed shared with an unrelated campaign. Its driver fails on a crashed script. It does not establish that a lowered budget moved between two oracle files is compared when its fixed seed was already in the destination at base: a fixed seed is not unique, so the script cannot attribute it, and neither removal nor lowering is reported there. A budget moved into an ordinary test file whose seed another oracle file shares is therefore not reported. A budget that a helper computes at run time is not tracked either: the script reads the counts and keys written at a campaign's call, or in constants that the oracle file declares or imports. The op-sqlite alias campaigns in `packages/react-native-db-sqlite-persistence/tests/op-sqlite-driver-oracle.test.ts` (`op-sqlite.write-marker-aliases`, `op-sqlite.result-carrier-equivalence`, and `op-sqlite.columnar-sql-aliases`, 50 base runs each) now register directly through `oracleProperty`. Their base run budget still comes from `readAliasOracleRuns()` and the existing `TANSTACK_DB_OP_SQLITE_ORACLE_RUNS` override, so lowering that helper's runtime result is not reported. The framework applies the shared run multiplier once. The former 20-run checker shrink/replay calibration is unchanged in the ordinary `op-sqlite-driver.test.ts`; its move is reported as a removed oracle run budget, although normal package tests still execute all 20 attempts. On main the script instead counted the literal `oracleRandomParameters(50, …)` calls in a unit test of those parameters. That unit test now lives in `op-sqlite-driver.test.ts`, so the script reports both keys and the fixed seed 271828 as removed, although both campaigns still run in the oracle file. Owner: `scripts.run-budget`. Needed witness: a campaign whose budget a helper computes and passes in as parameters. A budget that a loop variable carries is not tracked for the same reason. `sync-metadata-session-persisted-oracle.test.ts` registers eleven persisted production paths (`persisted-flat` through `persisted-peers-on-demand`) in one `oracleProperty` loop over an array of `{ property, seed, runs }` entries. The call reads `id`, `fixedSeeds`, and `runs` from the loop's variables, so a lowered `runs` in an entry is not reported (checked on 2026-11-11 by lowering the `persisted-flat` entry from 50 to 49). The file's literal campaigns, such as `persisted-queued-metadata-repair`, are tracked. Owner: `scripts.run-budget`. Needed witness: a campaign whose id, seed, and count come from an array entry that a loop destructures. `scripts/strip-oracle-probes-oracle.property.test.js` owns the build-time removal of the oracle state probes from published builds (`scripts.strip-oracle-probes`, maintainer decision of 2026-11-09). Its grammar draws one-function programs with the guard in the placements that the probe-form rule admits (function top, blocks, switch cases, sibling declarators, parenthesized forms, unbraced and loop bodies, labels) and hostile or rule-rejected uses of `probing` and `__oracleProbe`. The rule decides admission, and the model must agree with it on every draw. The reference is esbuild with `process.env.NODE_ENV` defined as production. The production path is the plugin's transform, then esbuild's type stripping. Both outputs run with a recording probe that must never be called. Owner: `scripts.strip-oracle-probes`. Limits: one exported function per program, no imports, JSX, or bundler; the host `process` is a stub with one environment value. The stripper refuses a value read, a binding, a `for`-head guard, or a non-guard `probing` declaration, and every `__oracleProbe` that is left; a property name, label, or type position named `probing` is accepted. `scripts/check-dist-probes.mjs` also rejects a surviving `process.env.NODE_ENV` in a built package that wires the plugin; it is not an oracle. The gap report (`pnpm gap-report`) is the `oracle-gaps` CLI of `@tanstack/oracles`. Its own oracles (`oracle-gaps.report`, and the static and classify oracles) and their limits live in the TanStack/oracles repository, under `packages/oracles/oracle-gaps/`. TanStack DB passes its prefix with `--env-prefix TANSTACK_DB_ORACLE`. The report reads each oracle file's owned code from the `owns` list of its `oracleProperty` calls. A file with no inline `oracleProperty` call, such as one that registers through a production driver, keeps the list in `declareOracle({ owns })` until the oracles package removes that API. The report reads both. `scripts/lint-scope-oracle.property.test.js` owns lint selection after an edit (`scripts.lint-scope`): the changed scope, the named (pre-commit) scope, and the Claude edit and stop hooks. A generated construction in each campaign fixes a free-shaped program with a production hook target, an edited production file, and an oracle import of that production file. The declared `hook-production-boundary` intersection measures the full premise, so the production-boundary selection law cannot lose its required reach to random sampling. Another fixes a re-export chain with no configuration edit, so `re-export-dependent` is required, not only measured. The random run budget rose from 24 to 28 histories, because the install histories below lint nothing; the reach minimum of two is unchanged. Its model is a fixed-point closure over the drawn import graph, independent of the script's forward search. It covers oracle-to-oracle imports, untracked oracle files, and `.js` oracle files. It also covers the checkout rule from #2280. A session works in the launch checkout or in a worktree nested under its `.worktrees/`. The hooks run the launch checkout's script with the session checkout as the input's `cwd`. They must select that checkout's files, and they must report through that checkout's own installed copy of the rule. The rules come from `@tanstack/eslint-plugin-oracles` under `scripts/oracle-lint-settings.mjs`, so the lint configuration is the lockfile, which pins the plugin, and that settings module: an edit to either selects every oracle file. A plugin change is drawn as a lockfile edit together with a changed installed copy in the session checkout's `node_modules`, as an install leaves them; a settings edit is drawn as a change that alters no report. A plain scratch directory under `.worktrees/` must produce no report. The repository's `.gitignore` is part of the tested configuration. It also owns the missing-install rule (maintainer decision, 2026-11-10: the hook never crashes). The script loads its lint modules with dynamic imports. When the session checkout's ESLint, parser, or plugin cannot load because a module is missing, every form produces one line that names the checkout and says to run `pnpm install`. Any other load error produces `oracle lint failed: `. The command-line forms (the changed scope, the named scope, and `--all`) write the line to stderr and exit nonzero. The edit and stop hooks of all four harness formats exit 0 and hand the line to the agent as JSON on stdout: `additionalContext` after an edit, and a blocking `decision` with a `reason` at a stop, per each harness's hook output documentation. Constructions in each campaign draw a missing install (no `node_modules`) in a launch session and in a worktree session, whose hooks delegate through the launch checkout's script. They also draw a session checkout whose installed plugin lacks its entry file, lacks its subpath rule module, imports a package that is not installed, or has a cut-off entry file. It does not draw a broken ESLint or parser, a missing dependency deeper in the tree, or a stop hook input with `stop_hook_active`. The missing-install histories also run `pnpm lint:run-budgets` (`scripts/check-oracle-run-counts.mjs`), which loads the parser with a dynamic import and writes the same skip line with exit status 1. A broken plugin leaves that report clean. The same owner covers the remaining failure paths of review finding F26, under the same 2026-11-10 decision. An unknown `--format` or `--event`, a hook input that is not a JSON object, a checkout with no `main` branch for the merge-base, and an error that the rule throws while it lints each end with one `oracle lint failed: ` line. A hook format exits 0 and hands the line to the agent on its harness's channel; with an unknown event, that is the edit channel. Every other run writes the line to stderr and exits nonzero, and so does `pnpm lint:run-budgets` without `main`. A fault dimension draws each failure, and a construction in each campaign enters it (`unknown-format-fault`, `unknown-event-fault`, `invalid-input-fault`, `no-main-fault`, and `lint-error-fault`). The model predicts the line in each form that the failure reaches, and a clean run for a form that lints no file when the rule throws. A failure is drawn only with the session checkout's own full install. Without `main`, only the forms that always need the merge-base run: the changed scope, the four stop hooks, and the run-budget report. An edit hook or a named scope that names the lockfile also reads the merge-base; that is not drawn. The values are three unknown formats, three unknown events, two texts that are not JSON, and three JSON values that are not objects. The lint error is one that the rule throws on every file. A git failure other than a missing `main`, and an error in the delegated copy of the script, are not drawn. The outer-plugin rule closes a former open limit of `scripts.lint-scope` (maintainer decision, 2026-11-11: "using outer checkout's plugin seems fine"). A worktree under `.worktrees/` with no `node_modules` of its own, inside an installed launch checkout, resolves ESLint, the parser, and the plugin by walking up to the launch checkout's `node_modules`. It lints with the launch checkout's plugin, not the one its own lockfile pins, and every form says so in one line: `oracle lint used the plugin installed at , outside `. A command-line run writes the line to stderr and keeps its exit status. A hook puts the line before its report. With no report, an edit hook hands it to the agent and exits 0, as a skip does. The line never blocks a stop (coordinator decision, 2026-11-11): the lint ran, so only lint reports and a line that says the lint did not run may block one. With no report, the Claude Code, Codex, and Gemini CLI stop hooks show the line as `systemMessage`, which their hook documentation describes as a message to the user that does not block. Copilot's `agentStop` documents only `decision` and `reason`, so its stop is silent. A worktree-install dimension (own or none) draws this state under an installed launch checkout, and a construction in each campaign enters it (`worktree-outer-plugin`). Another construction gives such a worktree a stop with no report (`outer-plugin-quiet-stop`). The model predicts the launch checkout's unmarked rule for such a worktree, even when its branch changed the plugin, the line in every form, and, in each harness, whether the stop blocks and what it shows. A checkout whose own plugin loads must print no such line. It does not draw a launch checkout whose plugin is linked from outside every checkout. It does not draw `.js` support modules or drivers, although the rule now resolves a `.js` test module when no TypeScript source exists for it (the plugin's part-reach oracle, in TanStack/oracles, owns that resolution). It does not draw an edit to `package.json` without a lockfile change. It passes file names in their real-path spelling: a name given through a symlinked path is not covered. It does not generate a hook input without `cwd`, a worktree outside the launch checkout, or a worktree branch that has no copy of the script. In that last case the launch checkout's rule lints the worktree. The oracle lint rules (`oracle/no-disabled`, `oracle/no-unit-test`, `oracle/pure-model`, `oracle/replayable-seed`, and `oracle/probe-form`) are `@tanstack/eslint-plugin-oracles`, from the TanStack/oracles repository, and their self-tests moved there with them: the probe-form oracle (formerly `lint.probe-form`, which owns the state-probe form `probing && globalThis.__oracleProbe?.(name, condition)` under the function-local `probing` guard of the 2026-11-08 decision, option B), the part-reach oracle (formerly `lint.part-reach`), the replay-observation oracle, and the rules' example tests, under `packages/eslint-plugin-oracles/tests/`. Their ids left TanStack DB's property registry, and their limits are recorded with them. TanStack DB keeps its settings for the plugin in `scripts/oracle-lint-settings.mjs` (its environment prefix and its replay implementation and witness modules), which `eslint.config.js` and `scripts/agent-lint-feedback.mjs` both pass, and it keeps `scripts/agent-lint-feedback.mjs` and `scripts/check-oracle-run-counts.mjs`, whose oracles are `scripts.lint-scope` and `scripts.run-budget` above. The oracle framework's laws live in `@tanstack/oracles` in TanStack/oracles. `oracleProperty` is its only campaign API, and its declared reach (`histories.states`, each named by a constructed history, plus `measured`) replaces the removed `createOracleReach` and `runOracleCampaign`. DB vendored both helpers from commit `fe532f4` during its migration (`packages/db/tests/oracle-reach.ts` and `oracle-campaign.ts`, with their self-oracle `declared-reach-oracle.property.test.ts`, `oracle.declared-reach` and `oracle.declared-reach-examples`, and the examples in `legacy-reach.test.ts` and `legacy-campaign.test.ts`). Every caller now uses `oracleProperty`, so the helpers and their self-tests are deleted (maintainer decision, 2026-11-10). The framework's own self-oracle owns the declared-reach, replay and shrink-fidelity laws for every `oracleProperty`. The `legacyCampaigns` list in `scripts/oracle-lint-settings.mjs` is empty: no file keeps a raw or legacy campaign. `scripts/check-legacy-oracle-campaigns.mjs` still rejects any addition relative to the merge-base, so the empty list cannot regrow; the setting itself leaves with the framework's later removal of it. The last callers converted as follows. A per-history reach on an enumerated source (the documented-mutations receivers, the Query reload-housekeeping kinds in `packages/query-db-collection/tests/reload-housekeeping-oracle.test.ts` (`query-db.reload-housekeeping`), and the real Electric GC receiver `collection-lifecycle.gc-retention-boundaries.electric-postgres`) is a check law, `declared reach`, because an enumerated source runs every history. The one aggregate reach over an enumeration, the four model-derived states of the failing-Query histories, is a grammar calibration in `failing-queries-oracle.test.ts` that runs the model's reach classifier over the oracle's own enumeration without production, until `oracleProperty` declares states on enumerated sources. The SQLite sync-metadata session campaigns declare their states with constructed histories; the persisted nesting-and-seeds campaigns' "at least five random histories per state" became "at least one constructed history per state, plus the unchanged random runs", because a required state must not depend on the seed (maintainer decision, 2026-11-10). The `source-health.on-demand` and `source-health.lazy-demand` properties run each reach prefix, and each driver option that a declared state needs, as examples, so their reach does not depend on the seed (#2287). `source-health.history` gets the same guarantee from `source-health.required-history`, which runs every reach prefix in each campaign and shares its reach without fixed histories. Limits. The Electric GC receiver steps the shared GC model inside its driver, from the history's actions and the measured elapsed time only, and records the model's clock-free owed state beside each observation: the determinism test forbids clock readings in a trace. Its waits sit at least 20 ms clear of the model's deadline. It runs only where PostgreSQL and Electric run, in CI's E2E (browser) job. `packages/db/tests/oracle-replay.test.ts` checks every replay manifest owner: from its cwd, the command's files exist, its target is the owner, and a Vitest config applies. An enumerated `oracleProperty` has status `enumerated-campaign` and a direct Vitest command selecting its finite cases, calibrations and determinism check. The command clears inherited replay coordinates because the cases have no campaign seed or shrink path. The guarded seed/path runner rejects that status before starting a child and supplies the direct command. A two-case receiving fixture verifies that the advertised command runs the selected property, excludes a similarly named neighbor and rejects a wrong value through the finite comparison. This does not add guarded execution witnesses or seed/path semantics to enumerated histories. Generated properties retain their existing guarded replay contract. ## Reusable-law backlog RFC #1659 reviews found several green oracles whose stated laws remained valid but whose fixtures, grammars, or observations did not cover a neighboring boundary. Track the generalized repairs here instead of accumulating isolated regressions. Completion requires an executable owner, a production-path witness, a mutant wrong-answer control, and an explicit statement of remaining limits. - [ ] **Unchanged `NaN` keys at optimistic mutation admission.** With an eager Collection keyed by `row.id`, preload a row whose `id` is `NaN`, then call `update(NaN, row => { row.label = "held" })`. Admission throws `KeyUpdateNotAllowedError` because it compares the unchanged keys with `!==`. The November 5 joined-source grammar found the witness before its joined update checkpoint and retains `NaN` sync-key coverage separately. Owner: Collection lifecycle / mutation startup (`packages/db/tests/collection-mutation-startup.test.ts`; no independent admission oracle, tracked in #2264). Needed witness: unchanged-key mutation admission across numeric/string keys and SameValueZero `NaN`. This sibling remains open outside the joined-result identity repair. - [ ] **Offset-only providers under a joined ordered window.** A provider that honors `offset` and ignores `cursor` gets a wrong window at preload under a LEFT-joined filter: the ordered loader repeats a continuation `offset` capped at the window's `offset + limit` (`countAcquiredRows()`), so the provider serves the same page again. Witness: ranks 2, 1, 0 with only rank 0 marked and limit 1 leaves the window empty (an `it.fails` case in the Query DB ordered refetch oracle). Owner: the ordered-work oracle (`packages/db/tests/query/ordered-work-oracle.property.test.ts`) needs an offset-honoring provider; the Query DB ordered refetch owner then adds the offset encoding to its generated campaigns. - [ ] **Bounded recovery after a failed ordered request.** The maintainer decided that full-source reads should be avoided whenever a bounded read is available. A failed page, tie, or bounded repair, and an invalidation before any request has settled, still recover with a full-source read. A first attempt to make failures recover with a bounded prefix repair broke 48 fixed expectations and showed real regressions: a wrong window (`[1, 4]`, expected `[1, 2]`) after a failed tie request, changed lease release after a failed tie, and settlement mismatches in the pagination pending-history campaigns. Owner: the ordered-source-loader and pagination oracles; the change needs its own oracle work before production changes. - [ ] **A page-capping provider during an ordered repair.** A provider may return fewer rows than a request's `limit`. Under a joined, offset window, a row whose order changes can then drop out of the window after a refetch, through the loader's own repair; it reproduces on main. Witness: the capped-provider `it.fails` case in the Query DB ordered refetch oracle. Owner: the ordered-work oracle needs a page-capping provider; the Query DB ordered refetch owner then adds page caps to its generated campaigns. - [ ] **Refill after a joined-side removal when a continuation adds no rows.** With a current provider, unmarking a window row makes the loader request a continuation that returns only rows it already holds, then stop with an underfilled window instead of continuing from the new boundary. Witness: the `it.fails` case in the Query DB ordered refetch oracle (window `[5]`, expected `[5, 1]`); it reproduces on main. Owner: the ordered-work oracle; the Query DB ordered refetch owner then checks the window after marker flips while the provider is current. - [ ] **Accepted sync transactions across persistence reads (partial coverage).** The persistence-history owner retains the original 24 histories: insert/partial-update, one/two/three queued reads, unreserved/reserved commit turns, and an absent/present dependent successor. They check applied receipts, public/durable rows, metadata, cursor, and durable source order. Eight adjacent histories begin during an owning persistence read and commit after it finishes. They vary original key membership, commit-turn reservation, and one/two later reads. Captured row metadata ownership survives acceptance. The maintainer specified that persisted rows are an older baseline for newer sync-adapter changes; an internal read cannot revoke an accepted sync transaction. Ninety additional histories compare queued and completed reads against the same independent snapshot algebra. They cross insert/update/delete, no/before/after truncate replay, on-demand subset demand, and coordinator reset/full-reload notifications in eager and on-demand Collections. Exact settled rows, row metadata, opaque cursor metadata, status, applied receipts, loaded rows and durable completion order distinguish source precedence from truncate replay's ordered replacement. The old guard fails all 45 queued cells; serial controls pass. Omitting public truncate fails 60 cells; omitting public delete fails 10. Owner: `packages/db-sqlite-persistence-core/tests/persisted-oracle.test.ts`. The [original review](oracle-reviews/issue-2036-queued-hydration-publication.md) and [admission follow-up](oracle-reviews/issue-2036-admission-follow-up.md) preserve revision receipts, review dispositions and oracle-guide audits. Further witnesses must compose these schedules with cancellation, cleanup, or persistence-read failure. Existing rejection of still-open transactions across persistence reads remains a characterized admission restriction; its independent authority argument is not established by these tests. The notification fixtures assume a compatible persisted baseline. They do not establish behavior after schema changes or invalidated resume points, or each intermediate publication during a multi-transaction truncate replay. The same owner needs those histories before claiming those stronger laws. Reserved commits (#2226). The same driver and model also own the reserved-commit law: a persisted hydration that would start while a reserved sync transaction is open waits until it ends, and the commit is accepted. Authority: `reserveCommitTurn` in `packages/db/src/types.ts`, widened by maintainer decision on #2226 to every persisted hydration. Further maintainer decisions fix its edges. Readers keep the rows from before a hydration while it waits; a transaction opened after a hydration began straddles it. A notice that waited may be retried as gap recovery. A tab asks the leader only to fill a gap it has not already filled, and sends no added upstream request. Each reservation a notice waited for can open one gap, so the oracle checks at most one more pullSince request per wait (maintainer decision on PR #2265). A source that stops for good abandons its reservation. A second registration crosses the routes with the reserving timings, ending, and follow-up dimensions. The routes are subset, complete subset, a follower's routed subset, the source's own baseline, reset, full reload, sequence gap with or without pullSince, sequence gap whose pullSince deltas reload partway through (a targeted delta, then one past the targeted-invalidation limit), and a targeted change that starts no hydration. Gap recovery is a hydration cycle only from the point where it will change rows (maintainer decision on PR #2265): after pullSince answers, or at its reload without pullSince. A reservation opened after that point straddles it; one opened during pullSince makes it wait, and a transaction that did not reserve may commit during pullSince. A peer reset abandons a reserved transaction that began before it (maintainer decision on PR #2265): the commit rejects and the reset does not wait. The reserving timings are before a subset load's admission, during gap recovery's pullSince (with or without a reservation), across the mutex turn, across scope entry, during the read, in the route's first publication, and across startup. A load that waits for a reservation runs after it ends, whether it commits or is abandoned (maintainer decision on PR #2265); on `851e8d9da` the abandoned admission cells failed with a rejected load. The ending is commits, abandoned, cleanup, an aborted demand, or the source awaiting its own baseline. The follow-up is a reset then a pre-reset commit, or a reset, a new reservation, and then the pre-reset commit. A reservation that a reset abandoned cannot reserve again; on `7a6f32fd7` 8 re-reserve cells failed because a later hydration waited for the abandoned transaction. An aborted demand still waiting for its turn is no longer active demand. It receives the reset follow-up, or a peer's targeted change for a row no live demand covers; nothing reads or asks the leader for it. On `7a6f32fd7`, 12 of the 24 aborted-demand cells fail: the reset's reload read for it, and the peer change sent a pullSince past the bound. Filtering aborted demand only from reloads still fails the 4 peer-change cells that wait at the mutex turn or scope entry. Observations: receipts, final rows, row metadata, cursor, status, reads during the reservation, upstream requests, pullSince count, rows while waiting, and every read against the fold of the durable events before it. Every cell declares reach (ORC-015). | Evidence | Result | | --- | --- | | Row-algebra cross and reservation cross | 677 cells pass. | | Peer reset against an older reservation, on `2047f4281` | 53 cells fail: the reset waited and the stale commit landed in the new epoch. Abandoning only at the reset's turn fails 6 follow-up cells; abandoning only on arrival fails 40 route cells. | | Gap recovery's cycle start, on `2047f4281` | 12 pullSince cells fail: an unreserved commit during pullSince rejected, and a reservation opened then straddled. Dropping the reservation check after pullSince fails 8. | | Gap recovery that reloads partway through, on `851e8d9da` | 28 cells fail: recovery advanced the stream position and applied a targeted delta before it deferred, so its retry skipped the reload. A gate only at recovery start still fails 15 scope-entry cells; reloads that start their own cycle inside recovery fail 61. | | `5649a07d4` | The open cells fail with `a persisted sync transaction cannot cross a hydration cycle`. Three `after read` reset follow-up cells also fail, because `main` applied a pre-reset commit before the reset set its term fence. Queueing resets with notices fixes this pre-existing defect. | | Mutant | Each mutant fails its cells, and every failure is an assertion. Deferring every notice fails the targeted change. Dropping the follower reply's wait fails the routed subset. Reporting hydration start before the check fails the aborted demand. A reset reload that starts its own cycle fails the first-publication reset. Applying a reset outside the notice queue fails the reset follow-ups. Retrying a waited notice while the reservation is open fails the follow-up and routed cells (repeated pullSince). Checking only at the mutex turn fails every scope-entry cell. Gating subset hydration only fails every reset, reload, and gap cell. Requeueing a waited notice behind later notices fails 12 reset follow-up cells: the pre-reset commit is published before its reset, and a reload is lost. | A routed load also judges law 7 at its settlement: the owner's row is public when the load settles. A reservation that ends between the follower's flush and its wait check is a one-microtask window no timing reaches; a temporary hook that ended the reservation there showed the old wait loop settling early in 4 straddled cells and the current loop keeping the owner's row public. A new reservation that opens between the loop's wait and its flush defers the owner's broadcast again. The loop checks for a reservation after each flush; a temporary hook that opened one there showed the loop on `7a6f32fd7` settling the routed load in 2 cells before the owner's row was public. A third registration reaches it without a hook. The owner's reply is held while its broadcast waits; the source commits 0 to 8 microtasks after the reply and reserves an empty second transaction 0 to 12 microtasks later. On `7a6f32fd7` the 12 cells that commit 3 microtasks after the reply settle the routed load before the owner's row is public; all 117 cells pass on the current loop. A held write after the commit does not open the window, because a reservation lasts through its own durable write. A second reservation that opens 7 or more microtasks after the commit holds the broadcast twice, and the notice asks the leader once per wait, as the bound allows. A peer reset for a storage generation this Collection no longer uses abandons nothing. Known limit (maintainer decision on PR #2265): Electric publishes a transaction's txids as stream evidence before persistence accepts its commit, so `awaitTxId` can resolve for a commit that a peer reset or a terminal failure later rejects; the source then fails, and the Collection's health node records it. Known limit (maintainer decision on PR #2265): no fairness rule. A hydration released by a commit waits again for a reservation that opens before its next mutex turn, so a source that reserves back to back can delay it; Electric reserves across batches only during an initial sync or refetch. Not covered: `forceReloadSubset`, which only a sync-absent Collection has, and which therefore never meets a reservation; startup hydration, which source entry follows (an `open across startup` observation); and row visibility for on-demand Collections without demand beyond the source's own rows. Cleaned-up cells judge only cleanup. Real SQLite adapter: `packages/db-sqlite-persistence-core/tests/reserved-commit-sqlite-adapter-oracle.test.ts` crosses three routes (peer full reload, peer reset, and a subset admitted earlier) with two timings (a held write of this Collection, or the shared scheduler holding the scope after its turn) and two endings (commits, abandoned). It runs on `SQLiteCorePersistenceAdapter`. It also judges that a subset load that waited settles successfully. Its peer-reset cells judge that the reset abandons the reservation: the commit rejects and row-1 keeps its durable value (both committing peer-reset cells fail on `2047f4281`). A nesting dimension adds a second reserved transaction inside the first. A peer reset must abandon both, so both reject with the same abort; on `5ac5a8711` the inner one rejected with the cross-cycle error instead. Its 20 cells pass. Every committing single-transaction cell fails on `5649a07d4`. A mutant that rejects the waited load after the reservation fails the 4 subset cells; before the load's outcome was judged, it passed. A peer full reload behind this Collection's own held write cannot become durable through the single SQLite writer, so it is excluded here and left to the grammar's fixture leader. Browser host: the multi-tab Electric oracle in `browser-db-sqlite-persistence` crosses two or three tabs, eager or on-demand Collections, which tab finishes first, a storm or staggered arrival, the last tab's open reserved transaction (its refetch, or an ordinary batch after it resumed from the persisted position), how its source stops for good (an error that `onError` does not retry, the SDK giving up, a signal abort, cleanup, or resume invalidation), and how the application recovers it (restart in the page, or reload). It judges every tab's status once every source has delivered or stopped, and again after recovery. Eager cells also compare rows at both checkpoints, except a cleaned-up tab before recovery. It also judges the full-snapshot request after resume invalidation. A Collection in `error` keeps showing durable rows (maintainer decision on PR #2265), so the tab whose source resume invalidation failed must show its peers' refetch; it stays `ready` with an error on its health node. Its 290 storm cells pass. Every ordinary storm cell fails on `5649a07d4`. Removing Electric's abandon on the `onError`, give-up, or signal-abort path fails 12 cells each, and on the resume invalidation path 16 cells. Cleanup's abandon mutant survives here, because the persisted wrapper ends its transactions on cleanup; the Electric descriptor-isolation oracle kills it without persistence. On-demand cells judge receipts and status only. Generated histories in the same file interleave server changes, deploys, partial and complete deliveries, every stop except resume invalidation, restarts, and reloads across two or three eager tabs (fixed seed 952051961 and a random seed, 80 runs each; the shared `TANSTACK_DB_ORACLE_SEED`, `_PATH`, and `_PROPERTY= browser.multi-tab-reserved-history` replay one). The grammar constructs a 24-step prefix before its unchanged 8–24 arbitrary steps. Every stop kind occurs in a generated order: a source opens a transaction, stops, lets a distinct peer commit, then recovers and catches up. Source tab, initially absent key, and recovery method vary. Four membership toggles restore the original rows before the arbitrary tail. This makes stop/peer reach structural; an earlier CI random campaign missed the SDK-give-up boundary with the unconstrained shuffle. The model folds committed batches into the expected durable rows. After every step it judges the durable rows, every Collection status, and the rows of each tab with no open transaction; after every tab catches up it judges them again. A Collection status changes only through its own source (maintainer decision on PR #2265): a peer's commit leaves a `loading` or failed tab as it is. That law failed on `main` (a peer's truncate reload marked such a tab ready); the fixed seed fails without the repair. Removing the reservation gate, or the `onError`, give-up, or signal-abort abandon, fails both campaigns. Each declared premise, including a peer commit after each kind of stop mid-transaction, is reached in every campaign. Known limit #2267 is left out of the generated histories and fixed with `it.fails`: a resumed tab that lags behind a peer can receive an update for a row the peer already deleted, and Electric's resume check puts it in `error`. The published Electric resume-safety contract requires rejecting an unknown partial row. Whether composition must avoid that condition without failing the source remains a separate contract question; this repair does not remove the guard or resolve the fixed expectation. The histories also post a peer `collection:reset` on the tabs' coordinator channel; no shipped host sends one yet, so this premise is controlled. The reset abandons every open reserved transaction, and Electric's next commit then fails the source until the tab restarts (maintainer decision on PR #2265): a ready tab keeps `ready` with an error on its health node, which the histories judge, and a loading tab goes to `error` (#2168). A reset that waits and accepts the stale commit fails both campaigns. Electric's updates carry only changed columns by default, so an update for a row the tab does not hold applies nothing; the fold follows that rule (a CI random campaign found the history where a lagging tab's update follows a peer's delete). A delivery may also commit only a prefix of what a stream owes, as a server answering at an earlier moment does, so lagging commits are generated. The final checkpoint requires the server head (Law 2). Known limit #2209 is one history that breaks it: a lagging tab commits an older row and closes for good. Generated histories never close a tab for good, and an `it.fails` replay through the same driver and checks that history. The [#2281 repair record](oracle-reviews/issue-2281-investigation.md) retains the row-loss and resurrection counterexamples on `82c5f999b`. A lagging source changed rows; another source advanced the shared resume position over the missing change. The eager Electric/SQLite bridge now detects a discontinuous predecessor atomically with rows and metadata. Source continuity remains incompatible until an authoritative replacement; the physical key ledger stays independent, so cached rows remain visible. Reopening a missing, foreign, or discontinuous source token requests a fresh snapshot. The original row-loss replay and both six-step membership replays now pass. The generated `browser.electric-source-prefix` property runs 80 histories with seed 2281 and 80 without a seed, with direct seed/path replay. It crosses initial membership, one to three toggle pairs, swapped source roles, empty/disjoint advancement, drain/no-drain, tab reload or source failure followed by same-Collection restart, and current/missing/foreign progress. Caller positions vary between omitted, initial `-1`, handle-only, numeric offset with handle, and `now`. Declared reach requires all four divergent membership/advancement cells, a draining control, missing/foreign provenance, and divergent recovery through both actual lifecycle paths. It also requires divergent recovery with explicit numeric and `now` positions, plus initial-offset and handle-only controls. Both Browser random registrations and the SQLite source-progress registration stand aside during another property's path replay. The SQLite owner separately checks opaque predecessor paths, sticky gaps, duplicate endpoints, replacement repair, and additive schema migration (80 fixed/random histories each). Disabling gap retention fails both owners; rejecting duplicate endpoints fails the SQLite law. Bypassing startup provenance validation fails the Browser owner. The real installed SDK/HTTP/PostgreSQL/Chromium OPFS receiving driver `e2e/electric-source-prefix-oracle.opfs.spec.ts` shares the source-head judgment. The original ten cells cover both membership directions, empty/disjoint advancement and drain/no-drain, plus missing legacy provenance with disjoint advancement. Each declares held earlier response, stale commit, later advancement, and reopened source comparison. All ten pass; gap and legacy-validation mutants fail the matching real disjoint cells at that comparison. Ten more cells cross numeric and `now` caller positions with both membership directions and current/legacy provenance, plus initial offset and handle-only controls. Eight wrong-row comparisons were RED on `883b565ab` before the eager-only repair; all ten explicit cells now pass. Each explicit cell declares its caller-position reach. A mutant that requests recovery but preserves the caller position fails the final Node source-head comparison (seed 2281, path `1:0:0`). Explicit positions cannot bypass eager source-progress recovery. Other sync modes and explicit malformed/tag/shape regimes retain their earlier behavior and are outside this added evidence. Real foreign-token provenance and arbitrary changes of caller form still need separate receiving witnesses. Each of the source-prefix property's 80 generated inputs now runs both its original history and an interrupted-recovery neighbor (160 histories per campaign). The latter starts recovery without a caller cursor, stops before any source delivery, and reopens with the generated caller form. Actual persisted reset markers before divergent numeric/`now` recovery are required reaches: fixed/random counts are 10/6 and 7/8. Both campaigns fail on `623c59955` before the eager-only reset fix, and pass afterward. The real matrix adds ten interrupted histories across both membership directions and all five caller forms. A held first SDK response prevents replacement publication; the driver observes the durable reset before closing that run. Numeric/`now` give four wrong-row RED comparisons; six neighboring controls pass. All thirty real cells pass after the fix. The reset marker now requires eager recovery and clears the effective caller position. No expectation, model rule, or comparison is relaxed. This is bounded same-version eager Browser evidence, not arbitrary scheduling, mixed client versions, native-device, Electron, on-demand, optimistic, or monotonic-live-write coverage. The final checkpoint now observes a reset-abandoned commit's source failure, restarts it, and only then judges catch-up. The original reset trace (seed `-1115798760`, path `1:4:3:3:3:3:3:3:3:3:3`) and the later no-deploy reset trace (seed `-1371495859`, path `75:0:0:0:0:0:0:1:1:0:0`) pass on unchanged production with that repaired checkpoint. Both remain fixed inputs to the shared driver. A generated reach separately requires recovery first discovered during that final delivery, so an earlier reset failure cannot satisfy this premise. It reached 2 of 80 fixed-seed histories and 6 of 80 random histories. Removing the final restart makes both reset traces fail the final row comparison. The broader Node campaign can also log a leadership term write against a closed test database during teardown (pilot `PILOT/S02`, fixed seed `952051961`). This is distinct from injected stream errors; its user-facing effect is unverified. Owners: broadcast coordination and this host driver. Needed witness: hold the election term write across coordinator disposal and database close, then observe its settlement and resource release on controlled and real hosts. Passing convergence comparisons do not establish clean teardown. A generated cached-row regression also preserves intermediate observations during source-continuity repair. #2209's permanent-close case and #2267's resumed-update gap remain fixed expected failures under this owner. A claimed leftover-replay/reset failure still needs a concrete schedule; the bounded two-replay-then-reset probe drains replay before reset. Live Electric/browser OPFS delivery needs the matching schedule in `packages/browser-db-sqlite-persistence/e2e/electric-hydration-straddle.opfs.spec.ts`; its current ordering does not establish this handoff. These are bounded witnesses, not closure of arbitrary interleavings. - [ ] **Optimizer residual convergence beyond the checked paths.** The optimizer-semantics owner now checks `sourceWhereClauses`, source-free predicates, namespace-only predicates, later RIGHT/FULL join nullability, and an ordered QueryRef refusal at structural checkpoints. It still needs public-row witnesses for later RIGHT/FULL chains, residual checks for aggregate, functional, and projection-remapped QueryRef refusals, a separate UNION branch model, and incremental source/publication histories. Owner: `packages/db/tests/query/optimizer-semantics-oracle.test.ts` and its production compiler driver. Each extension needs a distinguishing wrong-plan control at the relevant checkpoint. - [x] **Real-provider conformance fixtures.** Frozen 15.2.7 React Native and Node receipts cover the supported peer version; 18.2.1 React Native, Node, and browser receipts cover the known forward shapes. Exact-row checks and a row-dropping mutant control prove the shim accepts those envelopes without mutating them. Owner: `packages/react-native-db-sqlite-persistence/tests/fixtures/op-sqlite-provider-results.ts` and `packages/react-native-db-sqlite-persistence/tests/op-sqlite-driver-oracle.test.ts`. Native device/host execution remains a separate runtime receipt. - [x] **Minimal ambiguity and name invariance.** Generate one-field and otherwise minimally distinguishable results. Renaming a selected column to a structural-looking alias must not turn a data row into a write envelope. Owner: `packages/react-native-db-sqlite-persistence/tests/op-sqlite-driver-oracle.test.ts`. Its three `oracleProperty` campaigns share the independent model and exact row/key-order comparison in `op-sqlite-alias-oracle.ts`. Randomized constructions reach every declared alias and all eight documented carrier paths; the SQL campaign retains both real columnar and real direct-row SQLite shim paths. The seed-165903 conversion reports contain the same 361 mutant keys and retain all 29 prior kills under named laws. The [conversion record](oracle-reviews/2026-11-10-op-sqlite-oracle-property.md) preserves the commands, reached states, and scope. - [x] **Carrier coexistence and representation symmetry.** Cross `rows`, `rawRows`, `columnNames`, and supported result containers, including legal coexistence. Equivalent array and object forms must agree on rows or on the documented rejection. Owner: `packages/react-native-db-sqlite-persistence/tests/op-sqlite-driver-oracle.test.ts` and the shared SQLite driver contract. - [x] **Shared-handle transaction admission.** Concurrent driver wrappers for one provider database handle serialize root transactions. Nested work must use the transaction driver supplied to the callback on hosts without async context propagation. Owners: `packages/node-db-sqlite-persistence/tests/node-driver.test.ts` and `packages/react-native-db-sqlite-persistence/tests/op-sqlite-driver-oracle.test.ts`. - [x] **Transitions at every relevant await.** Hold each coordination boundary, then change leadership, remote-subset ownership, abort state, cleanup, or restart generation before release. Owners: browser/electron coordinator, persisted-history, and collection cleanup/restart oracles. - [x] **Local-versus-transport refinement.** Compare local-leader and transported remote-subset behavior for immutable values. Separately prove that local `signal` and `subscription` references survive delivery and reach matching unload cleanup. Owners: browser/electron coordinator and persisted-history suites. - [x] **Partial-construction cleanup.** Fail database, driver, worker, and subscription construction after each acquired resource. Preserve the primary failure while proving all acquired resources are released exactly once. Owners: OP-SQLite driver-contract construction and OPFS page/worker lifecycle suites. - [x] **On-demand persistence after evidence changes.** Cross baseline versus on-demand hydration with consistent, unknown, and incompatible key-set evidence. A baseline certification failure must not silently erase valid on-demand rows. `loadSubset` checks baseline visibility and on-demand rows; the sync-absent `forceReloadSubset` route crosses the same startup evidence states but records baseline visibility as unobserved because that API does not expose baseline hydration. Owner: `packages/db-sqlite-persistence-core/tests/persisted-oracle.test.ts`. - [x] **Deterministic value-and-work laws.** Pair row correctness with stable statement, scan, trigger, or queue-cardinality observations where the subsystem promises bounded work. Owners: SQLite resume snapshots, Electric acquisition work, shared-driver scheduling suites, and the Node same-database-handle admission law. - [x] **Startup generation interleavings.** Hold persisted startup between its metadata and hydration snapshots, then cross no write, a managed mutation, and mutant raw loss. Compare public rows with the atomic durable snapshot, and require mutation persistence to wait until the prior stream position is known. Owners: SQLite resume snapshots and Electric resume snapshot races. - [x] **Schema-generation fences on cached adapters.** Cross a newer-schema reset with snapshot, row, metadata, delta, position, and index-lifecycle operations from the cached older adapter. Every stale operation rejects; the current adapter remains readable and its index registry remains intact. Owners: SQLite resume snapshots plus browser/electron coordinator routing. - [x] **Explicit omission records.** Add a short `Known omissions` section to each primary executable owner touched above and keep this map synchronized as laws land. An omission record narrows evidence; it does not waive a product obligation. - [ ] **Atomic active-subset full reload.** Load collection metadata and every active subset from one adapter generation, including filtered and paginated on-demand subsets. A sound implementation needs an atomic multi-subset API; loading all rows or accepting a metadata/row torn pair is not equivalent. RED evidence and the deferred executable placeholder live in `packages/db-sqlite-persistence-core/tests/persisted-oracle.test.ts` under R5-007. - [x] **Joined aggregate and `singleResult` subquery histories.** `packages/db/tests/query/subquery-user-value-oracle.test.ts` checks flat and nested aggregate source changes and joined `findOne()` QueryRefs at initial and later public checkpoints. The bounded histories and remaining forms are recorded in the QueryRef owner row above. ## Persisted readiness and network-first initial rendering The persisted-readiness oracle in `packages/db-sqlite-persistence-core/tests/persisted-readiness-oracle.test.ts` owns when a persisted Collection with network-first initial rendering opens from restored rows. A small model enumerates every ordering of the restore outcome (rows, empty, failed), the remote answer (ready, ready followed at once by `reportError()` or by `fail()`, fail, none), a later `reportError()` then `fail()` in one tick, and the deadline, each with quiet or throwing ready effects, 390 histories. After every event it compares Collection status, the node's `error` and `failureReason` messages, the visible rows while `ready`, uncaught errors, and the status of a live query over the Collection. The multi-call histories check that the wrapper delivers the adapter's calls to core in the order it made them; a throwing `onFirstReady` callback or `status:ready` listener surfaces as uncaught and the Collection stays `ready`. The laws: restored rows open the Collection once the deadline passes or the remote fails; an empty restore stays `loading`; a remote answer before the restore completes waits for it; a failed restore crashes. Fixed tests in `packages/db-sqlite-persistence-core/tests/persisted-readiness.test.ts` (fixed tests; no oracle owner (tracked in #2264)) check that a Collection without `initialRender` waits for the network, the three-second default deadline, configuration rejection, and that `reportError()` before ready still crashes; `markReady()` after a ready Collection's `fail()` is a no-op. Mutants that let an empty restore open, skip the deadline, skip the remote-failure opening, let `fail()` bypass the call queue, crash on a throwing ready effect, or report every `markReady()` throw on a ready Collection as uncaught each fail the oracle. This owner uses a controlled persistence adapter, not native SQLite or a real network provider. Restart, cross-tab coordination, a remote that stalls without an answer, and a Collection that synced to zero rows before (it waits like an empty restore) are outside it. Hooks read Collection status only, so the framework conformance suite's status scenarios cover the binding side. The persisted demand coverage oracle in `packages/db-sqlite-persistence-core/tests/persisted-demand-coverage-oracle.test.ts` owns the on-demand law: an opted-in wrapper may settle a demand's load from SQLite only when that exact demand has persisted demand coverage, after the configured wait or an upstream failure. Its bounded enumeration crosses twelve session-1 histories (not requested, failed, overlapping filter, same filter with another window, same filter with another order, rejected durable row write, settled empty, settled, settled then truncated, three in which a reset lands after the load's rows but before it settles (a source truncate, a completed scoped recovery that rotates the cache generation, and a scoped recovery still pending), and one in which the source deletes a row of D after D settles), two waits, and six session-2 upstream schedules (pending, early and late failure, early and late answer, late empty answer), over the real wrapper and `SQLiteCorePersistenceAdapter` on `node:sqlite`. Session 1 creates coverage only through real loads, and a positive witness checks whether it sent the session-2 demand key. A pure trace model predicts status, `preload()` state, and exact rows at five checkpoints. A fixed lifecycle history checks that each load measures its own wait and settles on its own restored rows, that release aborts the upstream load, and that coverage survives release. A joined history checks that a query over an eager and an on-demand source is ready only when the on-demand demand is covered, read directly and through an outer live query, with the joined row visible when ready. A third shape reaches the on-demand source through two live queries; covering only the inner query's demand must keep the query loading. Two fixed same-session histories check that a load of D after a cache rotation, and a `refetch: true` load of D, both wait for the network. Model-level calibration shows that eighteen wrong designs (fifteen single-demand, two lifecycle, one joined) each differ from the law at a named case. Before the implementation, every production case failed at setup because `initialRender` rejected `syncMode: 'on-demand'`; without the opt-in, that code matched every uncovered cell and diverged at the first checkpoint where the law applies for every covered cell except an early network answer. With the implementation, every case passes; the [implementation review](oracle-reviews/2026-10-21-persisted-demand-coverage-review.md) records RED, GREEN, and each mutant's outcome. Production mutants that ignore coverage, ignore or halve the wait, error a covered demand on upstream failure, write coverage before the load settles, measure the wait from the sync run, keep coverage across a truncate, let an on-demand opt-in permit fallback alone, or read the root query's demands instead of the owning inner query's each fail named cases. A review then found three more defects, and the in-flight histories and the two-reader shape reproduced each one on unchanged production: an obsolete load recorded coverage after a truncate or rotation (22 cells), a coverage record during pending recovery failed the session-1 load (12 cells), and the first live query reached on a source stood for every reader (one cell). After the repair, mutants that restore each defect, or that check only for a truncate, fail those cases. A third review round added the row-deletion history, the source-failure history, and the rotation and refetch histories; on the parent production code they failed 14 cases by assertion, and the Query DB witness failed its retention history. Mutants that drop the row count, require more rows than recorded, ignore the cache generation, let a refetch settle on coverage, or let a network failure bypass on-demand settlement each fail those cases; a gate that ignores the eager deadline fails the persisted-readiness oracle instead. The Electric progressive witness in `packages/electric-db-collection/tests/electric-progressive-offline-readiness-witness.test.ts` receives the law as a production driver for the shared model: it records Electric's own log at its `loadSubset` boundary, and session 2 reads either the subset session 1 loaded or one no query read. A subset-only session 1 settles the loaded subset offline and leaves the other waiting; after a completed progressive full sync, the never-loaded subset is ready too, because Electric settles every later load at once from its complete rows (model rule `full sync completes`). A mutant that drops the complete resume's full-snapshot resolution fails only that never-loaded history. The Query DB witness in `packages/query-db-collection/tests/persisted-on-demand-offline-witness.test.ts` receives it with a fresh QueryClient per session: a covered on-demand query stays loading until the wait and then shows its restored rows, a rejected `queryFn` settles it at once, and a never-loaded query keeps loading; a mutant that ignores coverage fails both covered histories. A fourth history lets Query DB retention delete the released rows after a 20 ms `gcTime`; session 2 must then keep loading. React and Solid Suspense once received a joined initial-render gate through capability fixtures. The source-health change (#2168) removed that gate: Suspense now releases at query readiness, and the React and Solid receiving witnesses below run the shared contract. A later round closed most open limits with enforced cases. The driver checks that the wrapper forwards a load only after its persisted subset restore is visible, so no upstream event can precede it. Session 2 reads answer on a later macrotask, so a load that fails at once reaches the coverage read, and removing the wrapper's early rejection handler raises unhandled rejections. Part 2b adds a schema reset over an empty covered demand, an optimistic write that rolls back on a demand settled from SQLite, and two cache-claim expiry histories: one before the coverage record and one before the coverage check. Part 4 covers ordered windows: a row deleted, moved out, or moved in after the window settled keeps it loading, a swap keeps it covered, and with an index a page move settles offline only when session 1 loaded that page with a cursor. The Electric witness adds on-demand must-refetch and checks that Electric writes nothing from a snapshot that answers after release. React (`useLiveSuspenseQuery-persisted-on-demand.test.tsx`) and Solid (`useLiveQuery-persisted-on-demand.test.tsx`) Suspense render a covered demand from a real persisted on-demand Collection on `node:sqlite`. Vue (`useLiveQuery-persisted-on-demand.test.ts`), Svelte (`useLiveQuery-persisted-on-demand.svelte.test.ts`), and Angular (`injectLiveQuery-persisted-on-demand.test.ts`) witnesses observe `isReady`, `isLoading`, and rows. All five run the shared receiving contract described below. Mutants that drop the early rejection handler, keep collection metadata across a schema reset, key coverage without cursor and offset, ignore coverage, or let a coverage read under an expired claim fail the load each fail these cases. A fifth round added Part 2c and five more histories. Part 2c checks that a failed coverage read, after the load or during the check, keeps the load's own outcome; that a synchronous answer's coverage counts its rows, so a later deletion ends it; and that a release during the coverage check stops the source Collection loading. Part 3 then added a source failure before a covered demand's wait ends; after the source-health change (#2168) replaced the initial-render gate with Collection status, those histories belong to `packages/db/tests/source-health-oracle.test.ts`. Part 4 adds a row replaced below the window boundary and a row gained by an under-full window, which keep the tie-boundary key. Each failed on the parent production code. A window check that accepts a superset of the recorded keys, and a builder that drops its error-state check without notifying settlement, each fail named cases. A sixth round (the 2026-10-28 review) closed three more holes, each RED on the parent production code. The campaign adds a `snapshot` command (a snapshot transaction ends coverage, as a truncate does) and a source that stops and resolves an aborted load (a load that core aborted records nothing); Part 2b adds a load after scoped recovery reloaded the demand (no load settles or records during the rest of that sync run). The shared model now judges demand identity from the request data itself instead of core's demand key. The storage sweep also checks that a failed coverage write crashes the Collection. Remaining limits: coverage relies on the source committing a load's rows before it settles that load (law 7); an unordered demand that loses one row and gains another keeps its row count and stays covered, so a row that retention removed can be missing from a covered restore (maintainer decision, 2026-10-26; a fixed history covers the rule); and multi-tab coordinators, outside the law by maintainer decision (2026-10-26). Part 4 now covers a tie at the window boundary, modelled as a limited demand plus an unordered tie-boundary demand, and page moves with and without an index. The generated campaign in `packages/db-sqlite-persistence-core/tests/persisted-demand-coverage-campaign-oracle.test.ts` shares the fixed oracle's driver (`tests/helpers/demand-coverage-driver.ts`). Its model replays the source's own log of row writes, deletes, truncates, and settled loads, so it does not predict when the wrapper reacquires a demand. A fixed and a random campaign of 40 histories each interleave two unordered demands with load starts, answers, failures, releases, live writes and deletes, truncates, snapshot transactions, and a source that rejects, ignores, or stops and resolves an aborted load; declared reach covers an obsolete load that settles, an aborted load that settles, a demand settled only by an aborted load, coverage ended by a snapshot, coverage recorded twice, a row moved between demands, and a covered demand short of rows. Each campaign also runs two generated packs of nine required histories, with varied row keys, unordered demands, and ranks. Every pack must reach all 15 declared states through the same real driver and shared judgment; an unrelated random history cannot supply a missing pack witness. This preserves all 40 unrestricted histories. The separate `persisted-demand-coverage.required` seed/path coordinate replays a failing pack directly; `persisted-demand-coverage.history` retains its original history grammar and coordinates. A seed without a path still checks the full campaign's reach, and failures report the actual seed. Part 2 fails each adapter call of a covered history once, before or after its effect, in either session: safety holds for every call, a failed coverage read keeps the load ready, and a failed coverage check waits. Part 3 releases the demand after each step of a load: the source Collection stops loading, and every load left behind was aborted. Mutants that ignore the row count, let an obsolete load record coverage, keep coverage across a truncate, let a failed coverage read fail the load, or keep a released load's wait each fail it. The campaign also reads the window `group = 'a' orderBy rank limit 2` over generated ranks with ties: a query is ready offline exactly when every load it sent in session 2 is covered, which judges the tie-boundary load without predicting when core sends it. Mutants that ignore window keys, compare them in order, or record keys for every demand each fail it. Its limits: real timers in session 1, one process, `node:sqlite`, and no cursor or offset loads. A scripted mutation sweep (63 mutants, recorded in the review record) then added five fixed histories: an empty covered demand after a rotation, a truncate during an empty load's coverage read, a synchronous answer whose durable write lands late, claim recovery after an expired claim during the check, and a coverage read that outlasts the wait. A sixth history holds the load's cache-claim renewal past the wait and kills the last survivor, a wait measured from after that renewal. No survivor of the sweep remains open in this owner. Every receiving witness is a production driver for the same judgment (ORC-014). The shared contract, `packages/db-sqlite-persistence-core/tests/contracts/persisted-demand-coverage-receiving-contract.ts`, holds six histories as data (session-1 steps and session-2 premises only): covered, never loaded, covered then a source delete, a covered window, a window with a row replaced below the boundary, and a covered demand whose upstream fails at once. Each host records the source log, the session-2 loads, and two checkpoint observations, and the shared model in `tests/persisted-demand-coverage-model-oracle.ts` judges them; no witness states an expected result. The histories module imports nothing, so the Playwright spec can load it. The hosts run all six through their own entry point: Node (better-sqlite3 through `createNodeSQLitePersistence`), Chromium OPFS (wa-sqlite in two page loads, in `playwright.opfs.config.ts`, which the browser E2E job runs), Electron (a renderer over IPC to a `node:sqlite` main process, two app launches, in the desktop E2E job), Cloudflare Durable Objects (`wrangler dev` restarted over one persist directory, in the cloud-mobile job), React Native (an op-sqlite-shaped driver, in the cloud-mobile job), Expo (an expo-sqlite shim), and Tauri and Capacitor (their unit-suite SQLite stand-ins). The React, Solid, Vue, Svelte, and Angular witnesses run the covered, never-loaded, and failure histories through their own hook or primitive. With the contract's session-2 source forced to a 60 s wait and an upstream that never answers, every host and framework reports violations on its covered histories. The OPFS witness also checks the guide's statement that a multi-tab coordinator waits for the network; that run is recorded, not judged, because it fixes the guide rather than the law. Limits: no CI job runs the Expo, Capacitor, or Tauri e2e suites, and no host runs on its native runtime here. The Capacitor device e2e needs an iOS simulator or Android emulator, and `adb` is not installed here; its Node e2e fails at file load (`SqliteError: cannot start a transaction within a transaction` at `tests/helpers/capacitor-sqlite-test-db.ts:22`). The Tauri native e2e needs `cargo`. React Suspense reveals a covered failure about 300 ms late (its fallback throttle), so the contract's before-wait checkpoint sits at 450 ms. The readiness fixture does not retain writes. The [shared adapter startup owner](../../packages/db-adapter-conformance/tests/persisted-startup-oracle.ts) receives the network-first contract on all six eager adapters. It compares saved rows and durable state while the source is held past the deadline, then the first complete source result and its durability before refresh, plus reopen. It also generates enabled-option responses before the deadline. Exact deadline, empty/failed restore, and remote-failure timing remain with this readiness owner. ## Sync metadata session [Issue #2220](https://github.com/TanStack/db/issues/2220) reports that a sync-side metadata read misses an earlier accepted transaction's write while a persisting optimistic transaction holds it. The law is borrowed from standard theory (maintainer decisions of 2026-10-22 and 2026-10-23, recorded in [the review record](oracle-reviews/2026-10-22-sync-metadata-session.md)): one sync run is a session with read-your-writes, own reads, and monotonic writes in commit order. Every sync transaction is independent, including one begun inside another; accepted transactions apply in commit order, and a hold cannot change that order. An outer insert that lands on a different source row in commit order makes its transaction invalid, and an insert written over such a row is rejected as a duplicate, whatever holds or seeds there are. Consumers see whole transactions. Hydration seeds and persisted cache rows are older than every source write, and a later seed replaces either until the source writes the row or its metadata; an equal re-insert keeps metadata without writing it. In the persisted wrapper an insert replaces whatever row it lands on. A peer's notice of a write in this run counts as a source write, and writes during a storage read follow the same rules, the last write for a key winning. When a stored row's author is unknown, a DbClient seed this tab holds stays, and other differing stored rows count as source writes (decisions 13 and 15). Reloads keep metadata of a missing row (decision 16), a write over a seed stores the row this tab shows (decision 17), and a reload after a named notice keeps a seed's metadata (decision 18). | Owner | Production paths | Observations and checkpoint | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | [sync metadata session oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/sync-metadata-session-oracle.ts) (`flat`, `nested`, `seeds`, `nested-seeds`, `seeds-full`, `nested-conflicts` grammars) | `DbClient` Collection, core hold, `DbClient.hydrate` seeds | `metadata.row.get`, `metadata.collection.get`, `list()`, `list(prefix)`, `collection.base`, each commit receipt's state, thrown errors; after every action and after settlement | | [persisted driver](https://github.com/TanStack/db/blob/main/packages/db-sqlite-persistence-core/tests/sync-metadata-session-persisted-driver.ts) and its [campaigns](https://github.com/TanStack/db/blob/main/packages/db-sqlite-persistence-core/tests/sync-metadata-session-persisted-oracle.test.ts) (`persisted-flat`, `persisted-nested`, `persisted-seeds`, `persisted-cached`, `persisted-conflicts`, `persisted-nested-seeds`, `persisted-reads`, `persisted-reads-seeds`, `persisted-peers`, `persisted-peers-full`, `persisted-peers-on-demand`) | `persistedCollectionOptions` over an in-memory adapter, store hold, core hold, and a storage read held in flight; seeds through a `DbClient`, alone and crossed with nesting and a row cached in storage at startup; a peer's notices, eager, under full row updates, and on demand | the same source reads after every action; `collection.base` and receipts after settlement; in the peer production paths, stored rows after settlement and stored row metadata at every completed durable action cut and after settlement | | [native SQLite/coordinator receiver](https://github.com/TanStack/db/blob/main/packages/db-sqlite-persistence-core/tests/sync-metadata-session-sqlite-driver.ts) and its [campaigns](https://github.com/TanStack/db/blob/main/packages/db-sqlite-persistence-core/tests/sync-metadata-session-sqlite-oracle.test.ts) | two real Collections and coordinators, node:sqlite, BroadcastChannel and Web Locks; partial/full/on-demand grammar | shared model and source reads after correlated commit/notice/recovery cuts; rows, metadata and applied receipts after settlement; direct durable metadata after each correlated action and durable rows after settlement | | [recovery schedules](https://github.com/TanStack/db/blob/main/packages/db/tests/sync-metadata-recovery-oracle.ts) using the same session model and native receiver | response delivery, storage reading and captured-row application held separately; bare/non-bare seeds, a second tab's source write, or cleanup during one recovery on demand | source metadata before application, after the interruption and after completion; stale source reads at cleanup start and after late work; direct durable metadata after completion | | paired properties and boundary witnesses in the core driver file | production against itself: holds removed, row 2's actions removed, or seeds performed first; stale run; write without a transaction; cleanup with a held seed | source reads (and row 1's view) at each shared checkpoint, or every observation after settlement for seed order; thrown errors; unhandled rejections | | [row metadata composition oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-row-metadata-composition-oracle.test.ts) held-window and nested grammar | Collection, core hold, a transaction begun inside an open one, `DbClient.hydrate` | implicit row-metadata rules during a hold, and for an outer transaction whose inserts are reclassified after an inner write applies first, with and without a hold | | [hydration authority oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/db-client-hydration-authority-oracle.test.ts) | `DbClient` initialData, hydration chunks, and an adapter sync transaction (inserts, updates, deletes, truncates, and metadata-only writes) in full and partial row modes | public rows, the synced store, and row metadata through `client.dehydrate()` after each action; D5 per object | | [Query ownership lifecycle](https://github.com/TanStack/db/blob/main/packages/query-db-collection/tests/ownership-lifecycle.oracle.test.ts) receiving witnesses | Query DB claims, releases, and retention cleanup over core and `persistedCollectionOptions` | published owners and non-owner row metadata | | receiving expectations in the [persisted oracle](https://github.com/TanStack/db/blob/main/packages/db-sqlite-persistence-core/tests/persisted-oracle.test.ts), the Electric oracle, the Browser coordinator oracle, and the Electron IPC tests | persisted source inserts over a hydrated baseline; the durable mutation a source insert writes | public and durable rows; persisted mutation types | On `30175be48`, 51 of 186 tests fail in the session, composition, and retention files: held reads, commit order and outer writes after a held inner commit, every seed rule, and the paired properties. The persisted production path fails the held reads through core, reads of an enclosing open transaction, an insert's implicit clear, equal re-inserts, inserts over seeds and cached rows under partial row updates, and late seeds beside a store-held transaction. Six Query witnesses fail, including two that only dropping Query's `??` metadata fallback repairs. The review record's evidence block lists reach counts, mutants, and GREEN runs. Two comparisons are narrowed on purpose, each recorded with its authority in the review record: - Under partial row updates the seed-order property drops `reinsert` from both runs: decision "b" lets a seed moved first change a partial update's merge base, so a re-insert planned from the arrival-order row is no longer equal. The named witnesses `partialUpdateThenLateSeed` and `seedUnderOpenReinsert` cover that interaction. - Key independence skips histories in which the model invalidates a transaction: invalidation removes the whole transaction, row 1's writes included (decision 7). The `persisted-peers` production path plays a second tab's source through the persistence coordinator: named row, metadata-only, delete, full-reload, and reset notices, crossed with seeds, the cached row, nesting, and holds. A reload that a notice causes is a storage read: its truncate replaces rows without truncating source authority or row metadata, an unchanged row keeps its status, and a seed's metadata survives a reload after a named notice (decisions 9, 11, and 15 to 18). A reset is a source truncate, and every later notice in its term reloads storage; on demand the reset keeps the seeds this tab holds (decisions 19 and 20). After settlement the stored rows must equal the model's, which a restart would read. `persisted-peers-full` repeats the production path under full row updates, where an update replaces its row in storage too; `persisted-peers-on-demand` repeats it on demand with a demand for every row. A reset over metadata of a missing row is too rare in generated histories to declare; a fixed history covers it. An equal source re-insert keeps metadata without writing it (decisions 9 and 14). As with an update, that keep neither makes a DbClient seed durable nor sends it to peers (decision 18). Direct durable metadata is compared separately from this tab's source reads. The constructive durability grammar includes all 36 update/equal-reinsert/inner-reinsert × bare/non-bare seed × implicit/explicit metadata × no-notice/named-notice/full-reload cases in each generated batch. Its partial/full/on-demand grammar run through both the controlled persisted adapter and the real SQLite/coordinator receiver, with 108 declared case/production path/notice states per host, each reached eight times in both fixed and random campaigns. Seed row shape, seed timing and repeat count vary; no campaign can omit the full reload. Explicit metadata writes are the neighboring control. The original seed/re-insert/reload grammar, fixed/random 40 budgets and its completed fixed-branch guards remain; the new constructive batch supplies guaranteed bare-key-1 implicit histories independently of seed. Both hosts share the 40-run sibling and 8-run durability campaign mechanics in `sync-metadata-session-campaign-oracle.ts`; production setup, recovery observations and direct replay selection remain in their receiving files. The campaign module and the files that host these campaigns carry `oracle` in their names, so `pnpm lint:run-budgets` tracks their budgets: the persisted driver's `sync-metadata-session-persisted-oracle.test.ts`, the native receiver's `sync-metadata-session-sqlite-oracle.test.ts`, `sync-metadata-recovery-oracle.test.ts`, and `sync-metadata-missing-row-oracle.test.ts` (review finding F28). The persisted flat property was two raw fast-check campaigns of 50 histories and a sample test of its fixed-seed reach. It is now an `oracleProperty` with the same seed (2220011), budget, model, driver, and comparison. Its four regimes (`read with two held transactions`, `open transaction over a held transaction`, `store hold`, and `core hold`) are required by constructed histories, whose prefixes are in the session oracle's `regimeConstructions` (maintainer decision, 2026-11-11, to remove every legacy campaign form). The native on-demand path can receive a successful recovery response that crosses an earlier cache version without transaction replay details. The shared model then applies the existing unknown-write rule (decision 15) to its own independent durable storage. The recorder withholds that transport input until its hydration task completes a storage read and application. A discarded response fails a guard instead of advancing the model. Setup inputs are consumed before authored actions. No expected metadata comes from a production reload classifier. A named current-run write still follows decision 11; a previous-run cached row initially remains a seed. The native driver finishes each source commit's correlated notice and recovery before admitting the next authored action. It compares source reads and durable metadata after that cut, and consumers, receipts and stored rows after settlement. The controlled driver waits for acceptance before comparing durable metadata; store/read holds postpone that cut until release. A later explicit write cannot hide an earlier wrong keep. The controlled adapter also records every completed durable metadata snapshot, so queued commits drained by one release cannot hide a wrong write. The comparison preserves the sequence of changes and permits repeated identical snapshots from empty commits. A constructive immediate/store-held × bare/metadata-bearing repair campaign declares all four regimes, eight times each. Native commits are individually awaited, so its action cuts already separate these writes. No claim covers intermediate SQL statements. The ordinary campaigns retain this serialized schedule. A separate fixed/random recovery campaign constructs all 18 response/read/application × seed/peer/cleanup × bare/non-bare states per batch. Every state reaches its held source comparison eight times in each normal campaign. The application hold captures the rows before returning them to the wrapper; it does not delay only an already-applied promise. Peer writes can complete before a held response is delivered; while a hydration scope owns SQLite admission they wait until that scope ends. Cleanup invalidates the sync run before the held work is released. The recorder discards its inputs, including a hydration task that finishes after invalidation. The shared model still derives every metadata expectation from its own storage. Expiry, persisted cache generation rotation, arbitrary overlapping recoveries, restart and the necessity of gap detection remain outside these schedules. Permanent [calibration controls](https://github.com/TanStack/db/blob/main/packages/db-sqlite-persistence-core/tests/sync-metadata-calibration.test.ts) feed wrong intermediate durable snapshots, reload-only wrong reads, temporary wrong reads at every held recovery cut and stale reads after cleanup through the same comparisons. Recorder controls cover failed tasks, missing reads, late responses and invalidation. A real fast-check obsolete-path control demonstrates zero-history GREEN and verifies the shared execution guard rejects it. These are checker and fixture evidence, not new product oracles or a production mutation score. The [instrument audit](oracle-reviews/2026-11-02-p6-instrument-calibration.md) connects each claim to authority, history, receiving path, checkpoint and control. The receiver serializes every root SQL call with transaction admission on its one physical connection, while scoped transaction calls stay inside that admission. Nested scopes use savepoints; same-transaction async root reentry uses that scope. Nested rollback/root-reentry and cross-adapter isolation witnesses reject missing savepoints and unqueued root calls. The reusable SQL fixture conformance suite checks both transaction entry points, caught inner rollback, successful inner scopes followed by outer rollback, deeper scopes, root reentry, unrelated-caller isolation, detached callbacks from completed transactions, and reuse after failure. A detached callback loses root reentry when its transaction ends, so it cannot read or join a later unrelated scope. The new witness failed before this fixture correction. The suite certifies this native fixture, without lending that result to every shipped SQL driver. The driver waits for actual correlated notices, remote ensure replies and accepted empty source commits through the wrapper's apply lock, rather than a quiet-time polling interval. It covers two real Browser coordinators over Node BroadcastChannel/Web Locks and native SQLite in one process. Chromium OPFS, Electron IPC, transport loss, leadership turnover, every partial-notice shape and every shared session grammar remain outside it. The constructive receiver uses core holds; broad controlled histories retain store/read holds. Owner: this sync metadata session oracle. A reset may rewrite its rows, which its reload then applies as source writes. The [kept-metadata review](oracle-reviews/2026-10-30-kept-metadata-durability.md) records the D9/D18 durable comparison, the D15 model-input correction, measured reach, calibration and combined-tree evidence. The [P6 current-main revalidation](oracle-reviews/2026-11-02-p6-metadata-closeout.md) keeps the withdrawn production diagnosis distinct from the replacement test/model patch. The source-facing metadata failure in [#2317](https://github.com/TanStack/db/issues/2317) was tracked separately under this owner, with P8 investigating. Its witness was recorded as property `sync-metadata-session.persisted-peers`, seed `346038028`, path `36:2:4:6:10:14:16:14:14:13:13:13` of the earlier raw campaign. The native campaign draws other histories for that seed (half of its budget is constructed), so that seed and path no longer replay it; the history itself is now the property's fixed history `#2317 P8 source-facing metadata witness`. #2303 (`b19094596`, "preserve run-only metadata on peer reloads") closed this witness: with only that commit's `src/persisted.ts` change reverted, the fixed history fails at step 11 under law `source reads its row metadata (metadata.row.get)`, row 2 `` where the model owes `{"s":3}` (RED); with the change restored it passes (GREEN, 2026-11-11). The issue itself awaits the maintainer's closure. P6's durability evidence does not close the broader #2281 persistence reports. Remaining observation work under this owner: the read-hold and abandonment production paths retain source-facing comparisons but do not provide the peer production paths' direct durable transaction trace. A receiving witness must stage a wrong durable write followed by repair while a read hold buffers a commit, including abandonment, and reject it at the appropriate durable boundary. These additions do not retire that obligation. Cross-host recovery schedules still need actual Chromium OPFS and Electron IPC receiving witnesses; their owner remains this session oracle with the broader receiving work tracked by #2272. Repaired counterexample, **META-CI-051-S001**: an enclosing update reads a cached row, an inner transaction deletes that row and sets its metadata while missing, then both commit. A named peer notice for another key drops the retained metadata in the on-demand receiver, with and without a core hold. Both the controlled adapter and native SQLite reproduce this source-read failure under D16 before the production repair. The model correction separates this run-only metadata from durable metadata when the outer update recreates the row; the old model's false durable expectation masks the later source failure. Owner: this session oracle. The generated `sync-metadata-session.{persisted,sqlite}-missing-row-metadata` campaigns cover twelve cases in all three peer production paths: implicit/explicit metadata, immediate/core-held application, a prior source truncate, same-key peer row or metadata replacement, unknown-write reloads, peer/source delete and source truncate. All 36 case/production path states reach eight times in each fixed/random campaign on both hosts. The wrapper distinguishes local metadata from a named peer replacement, preserving D16 without defeating D11 or D15. Three wrong retention policies fail the same source-read comparisons. The [CI investigation](oracle-reviews/2026-11-02-p6-ci-missing-row.md) records the pre-edit receiving RED, repaired GREEN, controls and bounded class claim. This does not determine that the separate #2317/P8 witness has the same cause or close its broader scope. `persisted-reads-seeds` crosses read holds with seeds and the cached row and aborts a buffered commit's signal, which abandons it at the read's end (decision 21); a seed that arrived after it stays judged against it (decision 22). Dependent suffixes of an abandoned transaction belong to the abort-graph oracle. The broad peer grammar uses a controlled coordinator. The new constructive seed/re-insert/reload receiver uses two real Collections and coordinators for the bounded metadata law above; it does not close the broader host and transport receiving scope of issue #2272. Missed notices and notices over the targeted key limit are not generated; the persisted oracle's grids cover them. Two held-cleanup Query retention witnesses race on CI; the maintainer deferred the race until a failure reports the timer trace these witnesses now print, and the review record's "Open" section holds the evidence. Restart and resume reads belong to the SQLite resume-snapshot and Electric resume owners; this oracle's claim ends with one sync run. ## Deferred contracts and evidence The maintainer assigned offline policy work to [RFC #1659](https://github.com/TanStack/db/issues/1659). It is not a merge blocker for this oracle repair. Keep these scenarios and decisions with that owner: - **A10 R7/R13:** the executor holds caller success until deletion is acknowledged, and a persisted `deletion-pending` phase prevents provider replay after a known deletion failure. Controlled restart and adapter-failure witnesses cover that boundary. A crash before the phase write, old readers of marked rows, physical power loss after adapter acknowledgement, and native browser restart or multi-owner handoff remain open. Provider idempotency is required to avoid a repeated effect in the first two cases. - **A10 R4:** [Issue #1939](https://github.com/TanStack/db/issues/1939) is owned by the leadership replay oracle. The action grammar crosses retained leadership, loss before invocation, and loss during or just after `onMutate` after offline selection; a manual transaction loses leadership after its optimistic mutation and before `commit()`. The original action path fulfilled with no outbox record or provider call. The repaired paths reject and roll back; retained-leader and before-invocation controls still fulfill. Later leadership changes and a held outbox write crossed with loss or regain remain for this leadership oracle, using controlled write settlement and caller checkpoints. The [IndexedDB write-settlement owner](https://github.com/TanStack/db/blob/main/packages/offline-transactions/tests/indexeddb-write-settlement.test.ts) still needs a browser-host composition with leadership loss across a write. These paths are outside this bounded repair. The [review record](oracle-reviews/issue-1939-offline-admission.md) preserves the RED/GREEN and checker-calibration evidence. - **A10 R5/R9:** manual removal/clear outside the active-provider witnesses and broader restored optimistic lifetimes remain open. The settlement owner checks the optional retry decision across AbortError, ordinary network, 400/401/403/ 422/404 message, and permanent errors. Each kind crosses true, false, undefined, and absent hook answers with 1–3 FIFO peers. The fixed examples each receive a campaign run before generated cases, with a reach assertion. A later failure checks the current retry count. Public `commit()` witnesses cover thrown, null, zero, and fulfilled or rejected Promise hook results; a rejected Promise must not escape as an unhandled process rejection. Primitive and status-bearing object provider rejections check Error conversion before the hook. A status-bearing Error from another JavaScript realm reaches the hook by identity, keeps its first retry record, and later settles after a successful attempt. A plain status-bearing object still takes the non-Error conversion path; spoofed Error tags are outside these witnesses. The first stored decision distinguishes terminal rejection from a retry record. A hook fault records a terminal rejection for only the failed row. The executor removes that row, rejects its caller with the hook failure, and continues queued work after acknowledged deletion. The public admission witness holds the terminal marker read, write, or deletion after a thrown or invalid hook: a new commit durably joins the queue at each cut but cannot run before head cleanup. The started-write witness crosses write acknowledgement before, during, or after the hook fault, including a row visible before acknowledgement and a write rejected before storage changes. It checks both public promises, outbox IDs, Collection rows, and same-executor peer progress. A visible but unacknowledged peer cannot run even after the head is removed. The controlled adapter does not cover a write that changes storage and then rejects its acknowledgement; fresh executor startup before a held write acknowledges remains outside this witness. Failed terminal marker or deletion storage still stops the executor: the head caller receives the hook error, the batch receives the storage error, and queued peers stay durable and unrun. If deletion fails after the terminal marker is written, restart removes the marked row without another named mutation function call or optimistic restoration. The settlement owner also checks terminal named mutation function rejection with failed deletion, a halted executor with queued peers held, and offline executor restart without a second named mutation function call or optimistic restore. The executor does not automatically retry a failed phase write or deletion. A failed terminal marker write followed by a crash remains an unmarked outbox replay window. The [row-local review](oracle-reviews/pr-1592-row-local-retry-hook.md), [retry-decision grammar review](oracle-reviews/pr-1592-retry-decision-grammar.md), [rejected-Promise review](oracle-reviews/pr-1592-rejected-hook-promise.md), and [error-boundary review](oracle-reviews/pr-1592-error-boundary-review.md) record the checker controls. The Node-hosted Promise witnesses do not establish browser `unhandledrejection`, third-party thenables, or rejection after executor disposal; this settlement owner needs a receiving witness for any broader claim. A held provider can reject after `removeFromOutbox` or `clearOutbox` acknowledges deletion. The default network retry and a hook's 401 retry both reject that caller with the provider Error, keep the outbox empty, and allow later same-executor work. Manual removal overlapping the read/write inside `outbox.update`, rather than finishing before provider settlement, still needs a controlled witness and an atomicity decision in this owner. Broader offline retry and recovery policy remains with RFC #1659. - **A10 R11/R12 and earlier R8:** metadata/native-value domain, old readers of new wire records, and unreadable/unknown-version outbox recovery. New readers accepting old records does not prove reverse compatibility. Do not delete unreadable work silently or invent exactly-once guarantees. Other explicit follow-up boundaries are owned by [issue #1820](https://github.com/TanStack/db/issues/1820), not silently claimed green: - **Effect disposal:** the existing external-disposal wait and synchronous in-handler cancellation are tested. Waiting for independent work returned by the initiating handler conflicts with supporting a handler that awaits its own disposal. The candidate implementation was removed pending a contract. - **Proxy native mutators and symbol writes:** retain supported standard Map/Set behavior. Decide additional support versus a clear error before generalizing expectations; do not silently drop native edits. - **Progressive/native execution:** eight progressive registrations lack valid phase/capability evidence. The progressive suite's expectation that a live query preloads before the full sync now matches the core initial-readiness law, but no run receipt shows that case executing against Electric. Electric's ready gate is after application, not a pre-swap source gate; TrailBase does not supply that capability. The 24 move cases and actual native hosts need separate execution receipts. A green registration helper or package job does not prove these cells ran. - **Optional mechanics/performance:** separating the expensive replay-process campaign, sharing native runner code only with both host builds verified, optional cancellation calibration and proxy construction-work budgets. An earlier suggestion to merge unnamed cleanup helpers still lacks exact targets; do not perform a blind consolidation. ## SQLite Temporal value preservation The implemented [v2 grammar and evidence](oracle-reviews/issue-2034-design/v2.md) cover native `Temporal.Instant` and `Temporal.PlainDate` through the shared SQLite adapter and local persisted wrapper. Global constructors must be registered; other Temporal kinds reject. Existing lifecycle, receipt and publication-before-durability laws remain with their current owners. - The [typed-value owner](https://github.com/TanStack/db/blob/main/packages/db-sqlite-persistence-core/tests/sqlite-temporal-value-oracle.test.ts) checks real file reopen, direct/nested rows, metadata, replay, equality/range, Boolean/IN, large IN, field comparisons, cursor ties/continuation and ordered windows. Its directly named rank/text companion supplies independent native observations across precision, signed-year, endpoint and calendar families. Constructor failures, invalid brands and marker-shaped records are included. - The [Node expression-index owner](https://github.com/TanStack/db/blob/main/packages/node-db-sqlite-persistence/tests/expression-index-oracle.test.ts) checks raw SQL before residual cleanup, final adapter keys and actual named index use. Wrapper-created coalesce indexes reach Collection metadata/native literals and distinguish adjacent-literal signatures. Small and large scalar membership indexes protect compatibility with SQLite's DDL restrictions. Numeric array/object native EQ and IN also inspect persisted expression values. Mixed-domain polarity checks retain NaN, null/missing and scalar controls. NUL strings cover both equality directions, membership and Boolean composition. Negated coalesce and scalar eq(in(...), true) keep #1997's full-read fallback. Exact replay excludes unrelated native cases; simultaneous semantic/cleanup failure retains both errors and still closes SQLite. - The [ordinary-work owner](https://github.com/TanStack/db/blob/main/packages/db-sqlite-persistence-core/tests/ordinary-transaction-work-oracle.ts) adds twelve native repeated-action success/rollback histories and invalid superseded actions. Its independent Map model retains immutable native values; kind/text observations reject the old structuredClone false-green boundary. - The [persisted wrapper owner](https://github.com/TanStack/db/blob/main/packages/db-sqlite-persistence-core/tests/persisted-oracle.test.ts) rejects native remote-subset literals before dispatch/retry, including an ownerless leader that becomes a follower while hydration waits or after local success followed by sequence-gap recovery. The latter uses the existing terminal error path before retry admission. String controls dispatch once; existing transient retry, receipt and FIFO histories still run. The [mixed-demand refinement](oracle-reviews/issue-2034-recovery-review.md) covers both demand orders, retained/aborted/released candidates, both native kinds and string controls. It observes valid-prefix dispatch, exact reentrant and later error identity, post-terminal replay/retry fencing, and exact release objects. Successful controls observe complete demand coverage after held transport settles. First-demand-only and replacement-error mutants distinguish these laws from the older singleton checks; successful pullSince recovery and real-host elections remain separate receiving paths. The [initial RED receipt](oracle-reviews/issue-2034-temporal-persistence.md) remains historical. The v2 receipt records failures against original production, a lexical-order mutant that retains native reconstruction, and intermediate paired-IN, nested-path, routing and membership-index counterexamples. Final results are green for the reached paths; this is not a universal proof or a latency guarantee. SQL cleanup alone cannot compensate for lost candidates. Remaining witnesses have explicit owners: engine-native/alternate constructors and old-byte/marker-shaped compatibility belong to the typed-value owner; native truncate/delete, crash and format-transition histories belong jointly with ordinary-work/resume owners; real mobile/browser roundtrips belong to each adapter's receiving contract; actual native multiprocess transport belongs to browser/Electron coordinator receiving owners. The persisted owner retains native release/abort/reset and wider ownership schedules. None of those receiving claims follows from this Node/shared-core result. Same-kind ordering is the supported domain; arbitrary Temporal arithmetic and other kinds are excluded. Applications may rebuild old damaged caches through existing schema/reset paths; no type can be recovered from an already-erased empty object. ### Law enforcement audit The [law audit](oracle-reviews/issue-2034-law-enforcement.md) strengthens the persisted and Browser owners after three demonstrated false greens. Captured pre-validation expectations protect mutable builtin state on acceptance and rejection. Rich output checks now enforce detachment and exact release-object identity; later projections must reflect changed input without altering earlier snapshots. Optional indexes cross both supported native kinds and missing-global cases, plus independent local/coordinator synchronous and held failures. The intermediate held cut checks that coordinator completion evidence cannot precede local settlement; settled cuts check warnings, exact calls, healthy siblings, readiness and ordinary reads. Mutants establish assertion sensitivity. Copy-work bounds remain explicitly limited to the measured buffer/record copy seams and full discarded projections; total allocations, latency, arbitrary third-party coordinator work, and real-host scheduling are not established by these checks. ### Remaining review investigations The [high-effort follow-up](oracle-reviews/issue-2034-high-effort-review.md) records measured work and upgrade behavior. Remaining questions are assigned to the following owners: - The boolean-arity compiler-work owner now counts discarded literal quoting for bound string IN at sizes 0, 1, 32 and 1,025. The old compiler performed two quotes per value; the repair performs none and retains exact rows and binding counts (BUG-007, HE-006). This is not a latency bound. - The [bounded follow-up](oracle-reviews/issue-2034-bounded-follow-up.md) closes repeated native literal encoding (HE-007): the typed-value work witness admits at most one encoding per literal occurrence for EQ and IN at sizes 1/3/1,025. Both native kinds are calibrated against the previous implementation; the surrounding expression-index and rank/text owners retain semantic coverage. - Discarded wire projections (HE-008) are closed for the three persisted admission guards by shared validation-only traversal. The [work follow-up](oracle-reviews/issue-2034-wire-validation-work.md) records an 18-case persisted matrix: follower/role transition/retry/recovery and abort/release during hydration at 0/1/33 bytes. Payload copies drop from two to one per successful attempt, four to two across a retry, and one to zero when demand retires during hydration. Independent Browser-owner rejection/path fixtures cover validation-only admission; frozen rich-value receiving histories retain cycles, aliases, detached snapshots, and local lifecycle identity. The original guards and no-admission/no-detachment mutants fail at intended assertions. Repeated validation traversal and runtime latency remain unmeasured; real-host scheduling remains with the browser/Electron receiving owners. - Optional index specification serialization now shares the existing best-effort persistence boundary. The [index-admission follow-up](oracle-reviews/issue-2034-index-admission.md) records startup/runtime histories with supported native controls, unsupported kinds, missing global constructors, and healthy siblings. The persisted owner asserts readiness, exact local/coordinator signatures, warning paths, rows, and subsequent ordinary reads. Original source and a local-only repair fail six cases each. This covers wrapper admission; real SQLite index execution and browser scheduling retain their separate receiving owners. - The resume owner now proves the selected explicit schema-reset route for obsolete indexes (HE-010) and ambiguous legacy marker bytes (HISTORY-002). It removes both registry entries and physical indexes before the first read, preserves an unrelated collection, and retains newly escaped data and rebuilt indexes on same-schema reopen. A registry-cleanup mutant fails this witness. Automatic reclamation without reset and lossless old-byte migration remain outside the selected policy; this test does not claim either. - The [Collection index-value owner](https://github.com/TanStack/db/blob/main/packages/db/tests/collection-index-value-oracle.test.ts) distinguishes native literals from ordinary tagged records, nested mixtures, and the escape envelope while preserving equivalent key orders (BOUNDARY-005). Plain and null-prototype own-tag records have isolated metadata snapshots (BOUNDARY-004/HISTORY-004). The old implementation fails these public metadata observations. Custom-prototype impersonators are outside this owner's native contract; the typed-value owner separately checks rejection and rollback of an invalid native brand at SQLite persistence. - The Node expression-index owner now covers ordinary/native-mixed NUL lists, four NUL/Unicode positions, positive and negated membership, exact stored index values, final keys and candidate containment (VERIFY-NUL-NOTE). The former SQL literal encoder fails at the public index-DDL boundary. Direct runtime mixed membership already passed; the defect was persisted expression construction. ## Final evidence record Verification receipts and follow-up issue links are recorded in the PR and the issue closeout comment. Keep their exact revision/runtime boundaries; historical counts in research notes do not certify later commits. Closing the bounded repair means the acceptance map has evidence and each remaining question has an owner—not that there can be no more bugs. ## IndexedDB Collection persistence Owner: [IndexedDB oracle portfolio](https://github.com/TanStack/db/blob/main/packages/db/tests/indexed-db/ORACLE.md). Settled histories compare independently authored scalar rows with public, subscription, peer, export, raw durable and fresh-restored snapshots. Imports check changed-value versions; detached driver inputs protect authored truth. Handler decisions are followed by an ordinary successful insert before a separate replacement suffix, so replacement cannot erase the observed leak. Wrong-version, input-mutation and suffix-leak controls calibrate those boundaries. The transport owner adds twelve histories: delayed clear/import followed by a later disjoint receiver insertion under FIFO/reverse/duplicate notifications; idle/cleaned-up clear/import; real manual acceptance after cleanup; and whole- database deletion with active sibling stores. Every affected public snapshot must match authored durable operation order after controlled delivery. A raw unseen row makes excluded-notification handling observable. These cases repair specific convergence laws; they do not establish arbitrary concurrent receivers. The [compatibility tests](https://github.com/TanStack/db/blob/main/packages/db/tests/indexed-db/compatibility.test.ts) (fixed tests; no oracle owner (tracked in #2264)) checks full versus getRandomValues-only crypto through write/broadcast, one reusable descriptor across independent DbClients and cleanup, and injected factories without ambient IndexedDB globals across typed-key multi-store restore/import/clear. Wrapper tests distinguish callback, request and native completion, including durable rows after late callback rejection. Store creation is additive; declared stores and actual native stores are distinct. Normal generated persistence tests retain fixed/random campaigns and direct seed/path replay. Blocked/unblocked open/delete cases check native terminal settlement and caller connection ownership through later native upgrade/delete. Native failed opens preserve durable rows/schema. A blocked administrative deletion retains public and durable snapshots. Its receipt has no row-publication authority; managed versionchange marks affected Collections errored while retaining rows. Failure to issue deletion preserves those snapshots. The controlled cases establish no timeout, cancellation, or automatic in-memory fallback. Native receiving cases below cover named blocker and release schedules; arbitrary browser lock scheduling remains open. The transport owner also crosses two/three independent managed descriptors with native upgrade/delete. Exact versionchange recipients and zero blocked events check automatic close. Deletion retains errored public snapshots while fresh storage is empty; upgrade preserves durable rows. Both require fresh descriptors for further persistence. The four original-source assertion failures and repaired cases distinguish this law from the earlier shared-descriptor fixtures. Raw unmanaged blockers keep the wrapper's pending-until-terminal law. These controlled cases do not prove browser scheduling. The concurrent extension adds independent per-Collection expectations, raw publication and Collection-status recording, native transaction gates and non-awaiting dispatch. It receives the whole-row omission law and rejects a full-to-partial application mutant. It also rejects a spurious Collection error, invalid delta semantics and a repaired partial publication. A serial delivery fixture fails the overlap reach control. Generated histories use fixed/fresh parity, original-failure-preserving reduction and checked direct replay. Executed coverage and remaining package-owned cells: - **Connection ownership, CR-02:** native managed versionchange with a held test-owned readwrite transaction and unmanaged deletion blocking, in all three engines. The retirement and deletion-queue owners now receive admitted writes, immediate error notification, obsolete reads, late startup, caller/publication obligations, and both native blocker-release orders. The retirement owner additionally receives abnormal native closure with ready, idle, loading and five admitted persistence operations. Chromium receives actual native close/abort through storage clearing; other engines lack that control. Raw close bypass and automatic restart remain outside the managed contract. - **Persistence, PC02:** all six manual acceptance orders for three distinct Collection identities, two stores, disjoint same-store keys, reused sibling keys, mixed deletes/inserts and unaffected versions. The compatibility owner also projects same-ID/disjoint-key payloads by Collection reference, in both acceptance orders before/after cleanup. Same-ID/same-key core payload merging remains outside that adapter witness. - **Settlement, PC04/PC06:** first/middle/last clone failure in a three-row batch for automatic/manual/import; multi-row held CRUD with both decisions and independent peer progress. Raw storage, caller, payload, versions, ordinary suffix and restore cuts remain distinct. - **Transport/settlement, PC08/PC10:** two to five independent descriptors, generated read windows across replacement/CRUD, one held whole-row local intent crossed with peer CRUD/clear/import, and downstream query cuts. Native import exposed transient union publication and ordered peer persistence exposed duplicate-insert confirmation; both have source repairs and receiving tests. The local-order owner now crosses three held local intents with ordered peer update/delete/replace and checks every decided prefix. Peer work interleaved between those acceptances, multi-intent intermediate local publications and reads straddling unordered writes still need receiving witnesses in the pending/transport owners; final local equality does not prove those cuts. - **Transport, PC12/CC09:** obsolete receiving read success/abort after cleanup and restart; native obsolete abort and later restore. Pending mutation caller outcome/confirmation into a restarted sync run remains a distinct policy and test obligation; callback invalidation does not specify it. - **Transport/core optimistic, PC16:** non-truncating omission via ordered delete/reinsert in controlled and native drivers; active intent, exposed base, public snapshot and one-use acknowledgement metadata at held/settled cuts. Nested values and several overlapping local intents remain with the core owner. - **Settlement, AUX01:** valid post-durability send/publication failure still needs a native premise and defined caller/source/public outcome. No retry or rollback-after-commit policy is inferred. - **Native/consumer, CC10:** Chromium, Firefox and WebKit receive overlapping callbacks, native read/write abort, startup subscriptions, blockers, versionchange, controlled page close/reload and restore. Raw evidence survives acknowledged page destruction with a held handler. A schedule-dependent mutant reproduces its original law/checkpoint in each engine. The controlled pending companion checks complete downstream live-query snapshots. Real suspension, lost-message recovery, quota/eviction, process-crash durability and evidence lost before runner acknowledgement remain open and require their own premises. Native evidence is per engine. Simulated reverse/duplicate messages do not prove browser delivery ordering. The package has no leader election, timeout or in-memory fallback. Same-key writers without explicit persistence order, untested mutable-value shapes and timing guarantees remain unresolved; separate Collection acceptance calls do not promise cross-Collection atomicity. **Typed-key payload identity (HC005):** the [optimistic transaction payload oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/optimistic-transaction-oracle.property.test.ts) now crosses four numeric/string pairs, both author orders, insert/update/delete/ repeat-update, and success/rejection. Exact handler payload multiplicity, order, types and final public keyed rows reject the original collision. The native host owner receives numeric 0 and string "0" in one insert, then peer update, import, clear and restore. Core global mutation identity now encodes Collection id, key type and key value as a tuple. This does not establish interoperability between distinct Collections that intentionally reuse the same id and key. **Failed mutation callback context:** the optimistic transaction payload owner checks that restoration publishes after the failed callback's ambient frame ends. A subscriber's new write is visible but does not enter the failed transaction payload. Nested success and failure witnesses retain the enclosing callback's context for subsequent writes. The reviewed implementation fails the subscriber payload cut; the frame-specific repair passes it and the adjacent nested histories. These finite histories do not establish arbitrary subscriber reentry or cross-scope restoration behavior. **Failed-callback snapshot work:** the same owner places 16 prior mutations in one transaction and counts array-entry visits across five no-write `mutate` callbacks. The eager snapshot on the reviewed code visits 80 entries; capturing only before the first real `applyMutations` visits none. The neighboring failed-write histories still check restoration of prior intent. This bound does not remove the existing linear merge traversal for each real write or establish elapsed-time performance. ## Public-container cleanup copies `packages/db/tests/query/public-container-copy-oracle.test.ts` owns array copy shape at resolver return, under the architecture's descriptor/prototype preservation law. Each fixed/fresh input exhausts 24 structural programs: shallow root cleanup, generic nested cleanup, compiled root cleanup and compiled include-path replacement; native, derived and null array prototypes; changed and unchanged values. Sparse sizes zero through eight, locked lengths, accessors, hidden properties and user symbols vary without weakening identity or descriptor comparisons. The original code loses derived/null prototypes in six changed cells; a shared-shell prototype mutant fails all eight changed derived/null cells. Every state reaches once per generated input. The ordinary `public-container-copy.test.ts` remains supplemental reference-key, cycle, sharing and record-descriptor coverage. This component owner does not establish framework/provider receiving behavior, arbitrary graph topology, or Collection publication descriptor policy. Opaque-payload scan work remains with the includes-work owner; Collection attribution remains with virtual-row-fields. ## Compound joins The high review extends the route-context owner with independent join source keys and matched fan-out: four join kinds, plain/QueryRef inputs on either side, and numeric/string/mixed keys (48 finite programs). Three parents share or separate routes. Initial rows, main departure/reentry and child departure use an independent flat join at all three include forms. All 576 declared path/cut states reach once, with 1,728 parent/form/cut comparisons. Original production and an unmatched-only key repair both fail in public-key reduction after legal admission. Pair identities repair projected join rows; the publication owner also preserves source keys for whole-source selections at matched/unmatched cuts. This extension uses eager synchronous sources and filters child-absent rows. It does not prove arbitrary full-join absence shapes, async loading, provider/framework timing or exact key serialization. See the [high-review evidence](oracle-reviews/2026-11-05-boundary-only-high-review.md). The route-context transport owner (`packages/db/tests/query/includes-context-transport-oracle.test.ts`) also crosses FROM/JOIN QueryRef placement, expression/direct functional return, and array/materialized inherited inputs. Each of eight cells checks three parents (disjoint and shared routes), all three outer materialization forms, and six cuts: initial, parent move, child move, grandchild update, empty grandchild result and reactivation. All 432 public comparison states reach once; the eight functional callback-group states reach at least once. The independent model recomputes child/grandchild membership from source arrays. Missing grandchildren remain observable as `undefined`, rather than being normalized to an empty array. Unchanged production fails six of 202 tests, with all 192 prior tests passing. Namespace-sidecar and joined-include-descriptor mutants fail the extended owner; repaired behavior also keeps callbacks free of private symbols. This covers eager synchronous source writes, not async demand, callback counts, ordering or metadata attribution. See the [prep-review evidence](oracle-reviews/2026-11-05-boundary-only-prep-review.md). [The replacement evidence record](oracle-reviews/2026-10-05-compound-joins.md) records RED admission on main, GREEN refinement, and mutant-mutant failures. The cold-join reconciliation owner now covers compound equality classes, nullish operands, two/three terms, order/reversal/nesting, all four join types, scan/index paths, controlled cold acquisition, and keyed replacement histories. The identity-output-shape owner checks complete predicates through direct, from-QueryRef and joined-QueryRef boundaries. The includes-context-transport owner checks parent values used only in a later equality across both operand sides and direct/joined-QueryRef sources, in all three materialization forms. The compiler demand oracle in `packages/db/tests/query/compiler/lazy-demand.test.ts` independently recomputes active first-key demand from satisfiable rows. Its finite histories cross LEFT/RIGHT, two/three fields, both term orders, shared primary keys, nullish components, and put/remove/restore. Nullish tuples contribute no keyed demand. The controlled cold provider now applies direct-field IN requests using the independent value-class labels. Four distinguishing numeric tuples reject wrong-field demand that the former whole-table provider missed. The bounded claim excludes arbitrary expression trees and wider tuples. Real provider acquisition, eviction/reentry, and exact lazy-demand minimality need receiving witnesses in the cold-join and adapter owners. Compound async, optimistic, paginated, and deeper nested include histories remain with the includes-temporal, includes-optimistic, pagination, and includes owners. This feature does not claim those cross-products are established by its finite matrix. Consumer hook caches require framework conformance witnesses; the identity owner proves the compiler identity boundary and fresh public rows. Review follow-ups remain bounded by the evidence above: - The cold-join owner must distinguish required acquisition from demand minimality. A nullish tuple contributes no keyed demand; a satisfiable tuple still needs a positive witness. Real-provider demand counts remain with the receiving adapter owner. - A deterministic 10,000-row-per-side probe measured the new operand-array cost and the repair: single equality 20,000 to zero arrays, two equalities 40,000 to 20,000. Whole-query runtime and heap impact remain unmeasured. The always-tuple alternative restores single-equality allocation, so its simplification remains a tradeoff for a future measured join benchmark. - Builder admission checks Boolean join syntax, while the compiler binds sources and also accepts direct IR. A single-parse representation would need a design for these separate entry points and measured compile-work benefit. No parser state or cached validation is added for an unmeasured saving. - The cold-join driver's cleanup callback unsubscribes before cleaning up its live query. No legal throwing-unsubscribe witness was found. The owner is `checkWithCleanup` in the cold-join oracle; any future cleanup change must demonstrate the throwing path and verify later cleanup plus primary-error preservation. This is an evidence gap, not a demonstrated production bug. ### Compound-join planning and identity follow-ups The second high-effort review at `5bb211519` distinguishes semantic identity from physical acquisition. A controlled React `useLiveQuery` rerender keeps its Collection and region-first demand when only the equality order changes. Freshly compiled controls use the supplied order. The guide now states that ordering selects a plan when the Collection is created. This React witness does not establish other frameworks' reuse behavior. - The compiler/lazy-targets and cold-acquisition owners retain the proposed first-eligible-equality optimization. A receiving witness must cross join direction, computed operands, direct and subquery sources, and index modes. - The identity owner retains join-specific unary/duplicate equality normalization. Public `and()` requires two operands; direct unary AND IR and `and(eq(...), eq(...))` with duplicate terms currently differ from bare EQ. A change must preserve general Boolean coercion and test actual Collection reuse in the receiving framework. Making loading order part of identity is a separate design choice; current identity remains semantic. - Exact compound acquisition needs a tuple-preserving demand model in the compiler/lazy-demand and cold-acquisition owners, plus adapter witnesses. Independent per-field IN sets admit cross-pairs from different parent tuples. Current first-field candidate supersets remain permitted by the architecture. ### IndexedDB review extension: local ordering and boundary admission The xhigh review at `6ad2edc42` receives its audit in [the versioned review record](oracle-reviews/2026-10-05-indexeddb-xhigh.md). `local-write-order-oracle.test.ts` owns the approved automatic-write ordering law for one Collection: three authored effects, every handler completion permutation, every accept/reject mask, held earlier handlers, and synchronous handler reentry. It checks caller outcomes, durable/public/peer snapshots and fresh restore. The native suite receives held insert followed by update in Chromium, Firefox and WebKit. Cross-Collection writers and explicit utility operations remain outside this ordering contract. The compatibility owner adds id changes at options/Collection construction, automatic/manual acceptance and acceptance after cleanup. Transport adds none/mixed/all version metadata, typed keys, duplicate delivery, invalid message exclusion with a valid neighboring read, old-connection error propagation, and native deletion completion separated from callback delivery and database recreation. Native multi-page tests receive the deletion/recreation premise in all three engines with the old success callback deliberately held. The wrapper owner observes native error causes. Settlement counts all native write requests admitted before the first success and retains its atomic abort matrix. This establishes request admission work, not an elapsed-time speedup. Runtime and type tests use source without built DB output. Published declarations have a separate build-consuming lane after concurrent CI runtime tests finish. The [law enforcement follow-up](oracle-reviews/2026-10-05-indexeddb-law-audit.md) records the subsequent calibration and closes the stored-field/type cleanup. - **Connection closure, XH-06:** implemented under the subsequent approved contract. Managed versionchange and explicit descriptor close immediately mark affected Collections errored. New reads lose publication authority; native- admitted writes finish and confirm without regaining readiness. Applications recreate Collections. The retirement owner, core readiness owner, and native receiving cases enforce these separate obligations. - **Deletion lifetime authority, XH-07:** closed under administrative deletion. The stale-receipt counterexample was retained before implementation. The Collection deletion utility and database-deleted message authority were removed; `deleteDatabase(name)` only reports the native administrative outcome. The deletion-queue owner checks old/new receipt cuts, retained errored snapshots, queued name targeting, and fresh empty storage. The browser owner receives both unmanaged/native transaction release orders. See the [TLA refinement audit](oracle-reviews/2026-10-06-indexeddb-tla-refinement.md) for exact bounds and provider limitations. No persisted identity or deferral. - **Stored metadata/public types, XH-14:** new version records omit `updatedAt`; legacy absent/past/future timestamps retain their row semantics. Persistence checks ordinary writes, untouched records, mixed-format restore and replacement. Utils now carry output and input types only; source assertions and published ESM/CJS consumers preserve the transformation distinction and Collection keys. - **Ownership, XH-02:** equal/distinct Collection IDs, both manual acceptance orders and live/cleaned-up sync runs retain only reference-owned effects. - **Transport, XH-03/XH-08:** absent metadata at the receiving read is independent of startup metadata. Typed keys, initial membership, duplicate delivery and a successful suffix are checked. Invalid envelopes cannot issue storage work. Native pages receive missing-metadata rows and duplicate notifications in all three engines; low-level writes still require their own invalidation. - **Settlement and diagnostics, XH-04/XH-09/XH-13:** transformed-key collisions and schema failures at first/middle/last input preserve rows and versions; exact cause identity survives each native admission branch. Request admission counters cover automatic insert/update/delete and import, with atomicity enforced by the existing abort matrix. ### IndexedDB connection closure: TLA+ refinement owners `packages/db/tests/indexed-db/retirement-oracle.test.ts` owns the finish policy's row, caller, admission, read-authority, accepted-work and error-status laws. `deletion-queue.test.ts` (fixed tests; no oracle owner (tracked in #2264)) holds administrative receipt authority across delete/recreate/delete. `packages/db/tests/truncate-readiness-oracle.test.ts` owns replacement publication with explicit readiness preservation. Their models remain structurally independent of production connection listeners and caches. See the [loss audit](oracle-reviews/2026-10-06-indexeddb-tla-refinement.md) for every formal transition/invariant, recovered distinctions, fault calibration and bounds. The browser receiving owner crosses five admitted mutation kinds × three closure origins × commit/abort in all three engines. It separately receives both releases of an old native transaction and unmanaged deletion blocker. This last receiving witness is required: fake-indexeddb 6.2.5 violates the transaction-only deletion hold. The model law remains normative; the faulty provider does not narrow it. The closed-connection finish policy is separate from cleanup/restart, physical crash, lost notifications, post-durability application listener failures and uncontrolled browser discard. Those existing owners/boundaries are unchanged. This bounded translation does not claim every formal graph path is executed by the TypeScript suite or that finite tests prove unconditional progress. ### IndexedDB wrapper observer composition `packages/db/tests/indexed-db/wrapper-settlement-oracle.test.ts` owns callback/native settlement independently of native event-observer registration. Its 20-case matrix crosses native complete/abort, none/additive/property/replaced/ cleared observers and immediate/held callbacks. It checks caller outcome at native terminal and callback-release cuts, durable rows and exact application observer events. Twelve cases failed against property-owned settlement; eight controls passed. Two adjacent native request-error cases distinguish prevented errors that permit commit from uncanceled errors that abort. The original wrapper owner keeps callback failure identity and late rejection after native commit. Provider scope is fake-IDB; no physical-crash or arbitrary event-suppression guarantee is added. ### IndexedDB donor coverage receiving extension The [sighted donor survey](oracle-reviews/2026-10-06-indexeddb-donor-survey.md) now has these receiving owners. The [port audit](oracle-reviews/2026-10-06-indexeddb-donor-port.md) records calibration, validation and the remaining limits. - DP08: `compatibility.test.ts` (fixed tests; no oracle owner (tracked in #2264)) starts two/three native opens against absent same/independent names, with identical complete declarations. It checks schema, held restore/readiness, disjoint writes, convergence, restore and a later upgrade with no orphan blocker. `packages/db/e2e/indexed-db/value-oracle.spec.ts` receives three-open histories in all engines. These histories settle all opens before writing; they do not impose an order on open callbacks or union conflicting declarations. - DP09: `persistence-values-oracle.test.ts` extends the persistence owner with independent tagged descriptions in `structured-clone-oracle.ts`. Seven value shapes cross scalar updates, peer delivery, export/import, first/middle/last nested clone rejection, metadata rollback and fresh descriptor restore. Type, offsets, backing bytes, dates and Blob content are observed inside the receiving realm. Native receiving is in `packages/db/e2e/indexed-db/value-oracle.spec.ts`. - DP10: the compatibility owner substitutes six legal database/store names into the same authored multi-store history. Prefix neighbors, typed keys in separate transactions, version values, peers and restore distinguish routing mistakes. `packages/db/e2e/indexed-db/host.spec.ts` (fixed tests; no oracle owner (tracked in #2264)) receives all six names through single-transaction typed-key insertion, peer update, import, clear, export and fresh restore. Prefix-neighbor and anchor snapshots must remain unchanged. - DP17: `packed-consumer.test.ts` supplements declaration tests with installed tarball ESM/CJS consumers and broken-export controls. The browser spec builds the same consumer without source aliases and executes it in all three engines. Tarball overrides fix the installed dependency closure; registry range selection, older Node/tool versions and every public export remain outside this smoke test. The ordinary local Playwright WebKit profile rejects Blob preparation with `UnknownError`; its two Blob-containing cells require exact rejection and a healthy suffix. The additional disposable persistent WebKit profile requires native acceptance and executes the full preservation/capture/rejection/restore histories. Chromium and Firefox receive the same full corpus. The provider rejection branch cannot certify success in the persistent profile. ### IndexedDB approved donor follow-up laws The [follow-up audit](oracle-reviews/2026-10-06-indexeddb-donor-followup.md) records the approved contracts and assertion-killed wrong implementations. - **DP02, abnormal closure:** the retirement owner adds idle/ready/loading and five admitted persistence phases. It compares actual native outcome, caller settlement, retained public rows, error status, rejected later admission and fresh restore. Its forced-close fixture compensates for fake-IDB's missing forced transaction abort by aborting those native transactions explicitly. Native Chromium storage clearing supplies seven actual close witnesses, including six with admitted work. This proves neither other-engine forced termination nor physical-crash durability. - **DP03, blocked diagnostics:** wrapper open/delete and managed opening expose the optional native event without settling the caller. Native old/new version, independent blocked reach, callback count and eventual terminal settlement are checked. No timeout, cancellation or fallback is added. - **DP12, value capture:** `persistence-values-oracle.test.ts` crosses six mutable kinds with update/import behind handler/storage gates. Authored descriptions compare writer, peer, export and durable rows after caller mutation. Native receiving includes the immediate update snapshot and held settlement cut. The core detachment owner checks buffer bytes, view range, aliases in both traversal orders, foreign realms and custom-constructor compatibility. Native iframe witnesses receive standard foreign ArrayBuffer/Uint8Array/DataView aliases in each engine. Shared-memory concurrency, detached/resizable buffers and arbitrary class private state are outside these copy laws. - **DP13, dedicated workers:** the native host owner uses real worker and page contexts for typed-key insert, peer update, import, managed close, retained error snapshot, late-write rejection and worker recreation/restore. Service workers, SharedWorkers and background delivery are unclaimed. Atomic cross-Collection read-modify-write remains a separate API proposal. Native durability remains the current receipt. These are accepted design limits, not deferred implementations of the approved follow-up. ## Electric recovery demand and scoped persisted restore [The cache-eviction design](oracle-reviews/issue-2056-cache-eviction-design.md) records the generation and expiry laws and their unresolved cuts. The [PR #2069 review at 51563046](oracle-reviews/issue-2069-review-51563046.md) records the Query startup handoff, index reverse-order challenge, all review dispositions, and the repair commit's ORC-012 audit. The [review of code head `7f1df5c82`](oracle-reviews/issue-2056-cache-generation-audit-7f1df5c82.md) records the ORC-012 outcomes, RED/GREEN witnesses, and evidence gaps. The [receiving-gap audit at `87aead1be`](oracle-reviews/issue-2069-receiving-gap-audit-87aead1be.md) records the native Electric, shared-QueryClient, and old-leader timeout histories, their mutant outcomes, and remaining cuts. The real-SQLite owner checks generation rotation, legacy-writer isolation, warm-run claims, rejection of moved or expired claims, uncertified key-set evidence after partial writes, and physical collection of a retired row table. A held registration test rejects a read after collection and removes its late DDL and metadata. Two further real-SQLite held-registration histories move one claim while a warm peer retains the physical generation. They require both an initial registry insert and a destructive schema reset to check that claim inside their SQLite transactions; the warm peer keeps its schema, rows, applied transaction, and resume metadata. The persisted owner checks demand-triggered and timer-triggered expiry recovery, queued old source commits, and an optimistic mutation held through the accepted truncate. It also holds hydration, row-scan, and replay results across claim expiry and checks publication or returned rows after recovery. A startup history holds private rotation during index bootstrap and checks that the source cannot enter until new storage is bound. The real-SQLite owner rejects an expired startup resume record and checks that a public index event from an expired Collection cannot remove a warm peer's persisted index. The persisted owner also holds cleanup across cache rotation and requires the late private claim to release. It holds a peer full-reload read across claim expiry, checking both returned old rows and SQLite-style rejection at its second claim check; a live-claim I/O failure remains terminal. The real-SQLite owner accepts a valid eager Collection ID with the internal cache prefix and rejects late managed registration that tries to recreate collected storage after the first claim check. Its explicit-storage-target history rejects bare IDs of both ordinary and cache-generated form. It checks all eleven adapter data operations after a managed generation is collected, compares every per-ID catalog and physical table after each rejection, reopens the adapter, and retries the old managed target after explicit eager reuse of the same ID. The contract is claim authority, not a reserved naming prefix: an application that explicitly declares an eager Collection with those bytes may create eager storage. The bare-ID fallback mutant fails at the first post-collection read. The [explicit-storage-target review](oracle-reviews/pr-2069-explicit-storage-targets-6b0192c19.md) records the checked paths, mutants, and remaining native-host limits. The persisted owner also keeps a subset demand through rotation from an old row version 10 to a new version 1 and requires the new peer notice to request source reacquisition. Four held-rotation histories cross old row versions 1 and 10 with an old physical cache's commit or reset before rotation binds. The new notice has row version 3 or 1, so the old notice can have a lower or higher version. A fixed and random bounded grammar also varies absent, commit, and reset old notices, both row versions, and absent or present new notices. The queued old callback cannot add a source request; the new notice must request source reacquisition. These use a controlled in-process coordinator whose recording adapter shares row storage across physical IDs. Exact durable row isolation, arbitrary interleavings, and native multi-tab delivery remain separate checks. The persisted owner varies whether a custom on-demand source has an active subset before claim loss. It requires one source cleanup and a new source entry after rotation, checks that a retained demand reaches the replacement, and invokes a late callback from the retired session. The callback cannot publish or persist its row. A real SQLite receiving history expires the first claim, then checks reentry, public rows, and the replacement physical cache through a claimed adapter read. Native-host delivery remains separate. The controlled owner also holds custom rotation until Collection cleanup; it requires one old-source cleanup and no replacement source entry after disposal. The same owner crosses cleanup before and after a held scoped refresh settles. Its raw coordinator release log requires exactly one release in both orders; the cleanup-first case rejected the prior double-release path at the late settlement checkpoint. A real multi-tab transport receiving cut remains open. The persisted owner also rejects a startup resume read after its claim expires, including two successive claim losses, then enters the source only after a live read under the replacement claim. A live-claim read error stays terminal. The real-SQLite owner now holds a resume transaction before its second claim check. Its fixed and generated histories cross clock cuts before, at, and after expiry; row inclusion; zero-to-three rows; and a later peer-claim time. An expired read makes no generation-specific durable access beyond claim validation; the live peer retains exact rows and metadata. Removing the transaction-local check and moving it after payload access fail at separate comparisons. The wrapper's response to that rejection remains a controlled adapter history, not a composed SQLite startup receiving history. The persisted owner holds resume certification across claim expiry: an old answer or a second claim-check rejection starts private recovery, while a live-claim I/O failure remains terminal. It also holds initial scoped rotation while aborting one demand and checks prompt rejection with a sibling still pending. The CLI owner writes a claimed physical ID through sqlite3, and its subset-failure cases seed the claimed storage while preserving their public and durable assertions. The Browser owner checks two concurrent runs: the recovering demand reaches its own source owner while the warm run keeps its source-backed row. Another controlled receiving test delivers a peer notification to an expired claimant before its renewal timer runs and checks subset reload. Both coordinator owners offer unload before a held source load settles. The persisted owner now holds claim renewal after wrapper admission and varies whether the demand retires before the claim check returns. At load settlement it requires zero coordinator acquisitions for retired demand and one for retained demand; the retired case rejected the former late-acquisition path. It also revokes a claim after a cache subset read, then holds the replacement acquisition. The active demand must request it once and remain pending until it settles. The old path made two coordinator requests at that cut. A separate pre-read expiry history and peer-notice histories cover their narrower cuts; these controlled paths do not prove every real-host scheduling interleaving. The Browser coordinator owner holds an acquisition across a failed release and varies whether the acquisition settles before or after release starts. A pending release retry survives both orders. Its unacquired-release case observes no outbound RPC. The overlapping case failed before the acquisition-success path stopped clearing release retry debt. These are controlled transport schedules; a real tab crash and an indefinitely unreachable leader remain outside them. The Browser coordinator owner also checks that a managed local mutation carries its exact claim into the coordinator-created transaction. Its recording-adapter law failed before the repair at the target-kind comparison. A follower-RPC claim-loss mutant fails at its success checkpoint. A real SQLite receiving history accepts that write and rejects a late local mutation after rotation without recreating the retired table or registry. Direct coordinator callers that omit a claim remain outside this adapter law; the coordinator interface still accepts eager Collection IDs. The Electron IPC receiving owner forwards claim, renewal, rotation, release, cache-claim read contexts, exact-ID reconciliation, and durable term reservation through protocol v6. Its in-process main adapter witness keeps the logical Collection ID for adapter selection while reads address the claimed physical storage ID. A direct shared-renderer-adapter claim/read/release history selects the authored logical ID, and a raw managed envelope without it fails before main-process selection. The shared SQLite adapter contract runs its claimed-cache cases over that bridge. A custom main-process adapter can explicitly disable managed cache generations and retain the full-shape fallback. The local Electron binary is unavailable, so an actual main/renderer process receiving cut remains with the Electron runtime-bridge owner. The Electric descriptor owner now holds an old SDK snapshot across claim expiry. The replacement provider session settles both demands from fresh snapshots, rejects a pending old txid wait, and excludes a late old row from public and durable state. A second delivery lands during rotation, before the replacement stream starts; it rejects old callback admission into the new cache. Initial scoped recovery also forgets imported old txid evidence, and retiring an incomplete old stream transaction releases its commit turn so a new demand can start. A progressive atomic swap that throws in `getKey` leaves its reserved transaction open; when the SDK then gives up, Electric must abandon it, and a subset load that waited runs. On `7a6f32fd7` the swap did not mark its transaction open, so no stop could abandon it and the load waited until its checkpoint timed out. The metadata-only commit shares the same begin and commit helpers but has no fallible step between them. These histories killed the one-phase restart, retained acknowledgement, and open-transaction designs at their named checkpoints. The Electric descriptor owner also holds rotation while aborting one old demand: that demand rejects promptly and a sibling later applies fresh source rows. Its overlapping-rotation history rejects a callback from the retired middle provider session, then requires the final provider session to apply a fresh subset demand after the second gate opens. The unabortable restart wait failed at this settlement checkpoint before the repair. The SQLite owner rejects coordinator stream-position, replay, and index work from a specific expired claim even while a peer claim is live. An expired run recovers privately while the healthy current cache remains claimable. The older Electric resume-race owner explicitly exercises adapters without managed generations; its unknown and missing on-demand evidence cases now require full-log replacement. The scoped reset settlement owner uses an abstract managed claim for that one applied-receipt law; the SQLite owner checks physical generation separation. The [bounded cache-authority design grammar](../../review-evidence/cache-authority-tla/README.md) also checks incompatible resume evidence followed by claim expiry. SQLite's transaction-time claim test makes that rotation private. The SQLite receiving owner now holds the real adapter's rotation after a controlled source starts scoped recovery, expires that run's claim while a peer remains live, then checks the peer's public and durable rows and unchanged resume metadata, an empty then fresh subset in the private generation, its reset marker, the recovering claim's storage ID, and a later claim of the unchanged head. A mutant that uses the expired claim's remembered storage ID advances the head and fails at that comparison. The controlled source supplies the recovery decision. The Electric resume-race owner now supplies an incompatible stored shape identity, reaches Electric's own scoped-recovery decision, expires its claim before SQLite's rotation transaction, and checks that a warm peer keeps its rows and resume metadata while the recovering run gets private storage. This witness failed before Electric stopped writing a reset marker into the shared generation. A second real-SQLite witness holds rotation after the storage transaction but before public truncate. It delivers a retired Electric callback and starts a distinct demand in that interval. The replacement session refetches the active empty subset and applies fresh rows for both explicit demands. Only those rows reach public and durable state. A deliberate wrong row in the rotated storage fails the held private-cache assertion. The grammar combines those actions; these fixed receiving cuts supply the missing implementation evidence. It does not model physical garbage collection or arbitrary callback schedules. The separate [receipt-settlement grammar](../../review-evidence/cache-receipt-tla/README.md) checks the accepted-versus-visible distinction during scoped recovery with a persisting optimistic transaction. It is bounded model evidence; the optimistic-history and Electric owners remain the production checks for those receipt laws. The installed-SDK delivery owner now holds an old HTTP subset response across managed rotation and observes fresh demand settlement, public rows, and the new cache's durable rows after that old response arrives. Its adapter is a controlled Map; real SQLite and native multi-tab delivery are separate cuts. The same owner uses real SQLite and the installed SDK for a cold restart after expiry rotation left a partial row and no reset marker. It observes the row absent before and after an empty source subset snapshot, including with an explicit Electric offset or handle. The explicit-cursor cases were RED at the pre-response public-row checkpoint before the cache-trust predicate changed. This rules out both early cache hydration and relying on source completion to delete that row. The descriptor owner also checks that cleanup during a held rotation fulfills after rotation settles. It does not establish a prompt cleanup bound while the adapter rotation remains held. The Query ownership owner now pairs a real QueryClient with managed Node SQLite. It advances a cache claim beyond expiry, uses a disjoint demand to trigger rotation, and requires an already active subset to reacquire its distinct row without another caller request. A later demand with stale QueryClient data waits for a new fetch; an old fetch and a public utility refetch cannot publish or return their retired result. A held real SQLite retention scan cannot delete a same-key row reacquired in the replacement generation. A released acquisition cannot launch another fetch after its held old result settles. These are fixed histories at public-row, request-count, and caller-settlement cuts. A paired-Collection real-SQLite history now gives two on-demand Query Collections one QueryClient and prefix-overlapping but distinct Query keys. Only the earlier claim expires; its rotation and fresh fetch must leave the warm peer's public row, Query cache entry, durable row, current storage ID, and fetch count intact. A broad prefix-eviction mutant failed at the peer cache-entry comparison. Shared exact-key cleanup follows the documented Query cache contract; arbitrary retention schedules and custom provider restart implementations remain outside these histories. The expiry and late-fetch histories also read the tested run's claimed physical SQLite generation after fresh settlement and after the retired fetch resolves; both cuts require the fresh rows and exclude old rows. A separate active-head claim would inspect a different generation when an expired run rotates privately. The same owner distinguishes a private startup rotation from a warm startup: only the rotated run must refetch a cached QueryClient success. It also holds a peer Query fetch that began before source entry through that rotation. Both its late success and late error require a new fetch before demand fulfillment. Two queued rotations have a separate held-second-rotation cut: the first recovery cannot reacquire an active Query subset or start a provider fetch. After the second rotation, that demand must fetch and apply a fresh row. The Query owner also checks new keys with and without a stale QueryClient value after claim rotation: one provider fetch satisfies the generation boundary in either case, with no extra cancelled fetch. A rejected SQLite rotation instead puts the Collection in public terminal error and rejects later demands with that same error; this is fail-stop, not a silent observer freeze. These are real SQLite/QueryClient cuts, not arbitrary provider failure schedules. The persisted owner also holds active rotation across index bootstrap and checks that an index added during the hold targets new storage. Its adapter call log does not prove native SQLite DDL completion. A virtual-clock history holds the provider restart after rotation and requires claim renewal once it resumes; index creation and renewal failures stay best-effort without changing public readiness. A held bootstrap lets index removal settle before the earlier creation completes; the wrapper reconciles the final durable index with the Collection's declaration. Re-adding that index during reconciliation has a separate fixed witness. The SQLite resume-snapshot owner now runs both reverse-order histories through the persisted wrapper and real `node:sqlite` DDL. It holds the first new-generation ensure until removal settles, then checks the Collection declaration, index registry, and `sqlite_master` after rotation. Its re-add history makes the replacement ensure finish before the held reconciliation removal, so a missed final re-ensure leaves the real index absent. Host-specific native DDL scheduling remains outside these Node cuts. The persisted Electric interleaving owner holds an uncancelable local cache read after demand abort. It requires the returned load to remain pending until the cached row is public, then reject with `AbortError`; both fixed and random campaigns were RED at the early-settlement checkpoint before the wrapper separated pre-hydration abort from in-flight baseline settlement. A separate composed Electric probe confirms prompt abort while a later source snapshot is held after local hydration. These cuts do not establish cancellation of an SDK request that has already delivered its rows through the shared stream. The persisted owner refuses a managed custom adapter that lacks rotation, renewal, or release, and refuses recovery from a managed source without a provider-session restart capability. The Browser owner holds the old leader's release message while the new generation starts its own source demand. Its host factory owner checks that configured claim lifetime and clock reach the SQLite adapter. A composed receiving history advances that clock past expiry and rejects a peer update before reloading the demanded subset. Cross-package Browser runs require freshly built core package artifacts because package exports otherwise resolve stale `dist` files. Reachable limits remain. A source that declares a restart capability must itself retire callbacks synchronously when recovery calls it. Claim expiry after core publication but before SQLite accepts the write rejects the receipt and leaves the Collection in terminal error; a real-SQLite adversarial probe confirmed the row can remain public without becoming durable. The ordinary durability-failure law permits that fail-stop, while automatic expiry reload covers admission before publication. The first new-format claim isolates but does not reclaim legacy storage. The Browser coordinator owner now drops an old leader's release reply after its adapter unload, transfers leadership, lets the real RPC timer expire, and checks that retry retires the outbound acquisition without replaying demand or unloading twice. A release-without-retirement mutant failed at the new owner's unexpected load. Claimless direct-adapter access to a physical ID after its catalog row is collected remains unproved and has a reproduced orphan-write probe; rejecting it while retaining arbitrary eager Collection IDs requires a durable distinction for former physical IDs. The Browser owner now has a combined receiving history over real wa-sqlite and the controlled Browser coordinator wire. Two runs hold distinct claims on one generation; only the earlier claim expires before its renewal timer. A real durable peer write precedes a matching, manually delivered notice. The expired run reloads into private storage while the warm peer retains its exact public and durable row, live claim, and source ownership for another demand. The current head remains unchanged. An always-rotate-head mutant failed at the head-ID comparison. Native coordinator emission, multi-tab or OPFS scheduling, and a composed SQLite-to-wrapper startup rejection were open at that review head. The SQLite owner now composes a real claim rejection during startup with the persisted wrapper: the expired run gets a private cache and a fresh demanded row, while a later live peer keeps its public row, durable row, and resume metadata under the unchanged head. Its separate three-generation reachability model varies release, expiry, renewal, zero or two rows, and collection checkpoints immediately before and at both renewed expiries. It compares retained row, tombstone, resume, and key contents; both physical tables; native indexes; every generation-scoped catalog; and claim identities. Wall-clock passage alone is not a sweep checkpoint. The persisted notice grammar now holds the fresh source receipt behind an optimistic transaction and checks a pending constrained demand, stale-row quarantine, the public publication trace, and release of the exact `(storage ID, options)` refresh acquisition. Its controlled coordinator supplies the receipt wait. The fixed Browser receiving cut below supplies that premise with a real coordinator on one schedule. The Browser OPFS owner now has a fixed two-context receiving history in which a real source commit makes the coordinator emit a physical-ID notice over native BroadcastChannel. One receiver callback is held until its claim expires; its private reload leaves the warm peer's public and durable rows and current head intact. An explicit demand stays pending until the fresh source receipt applies. The renewal timer lies beyond the fixed test window, and the receiver checks no refetch before releasing the delivered callback. The same fixed two-context history now also runs the installed Electric SDK in the expired tab against controlled HTTP source snapshots. It holds an old subset request and the new source response across the native notice, then checks pending demand, public and durable rows, and the warm peer. Dropping the held native callback fails at the refetch-entry checkpoint. Arbitrary native scheduling and a live Electric service rather than controlled HTTP remain separate unproved cuts; these fixed receivers do not close every cache-eviction interleaving. The [cache-generation oracle audit](oracle-reviews/issue-2069-cache-generation-oracle-audit-53ded62d8.md) records the generated grammar controls, killed mutants, direct replays, and the remaining handoff limits for code commit `53ded62d8ef70ccd63b75d0e6dbc0a964f14b17c`. The [cache-claim gap audit](oracle-reviews/issue-2069-cache-claim-gap-audit-575fb9473.md) records the added receiving witnesses, mutant checks, direct replay, and remaining limits for code commit `575fb9473dd7d8eccbe469d0831dc9f71cffddd4`. The [native SQLite index receiving audit](oracle-reviews/issue-2069-native-ddl-receiver-b4d57ced6.md) records the two reverse-order DDL witnesses, mutant checks, and remaining host-specific limit for code commit `b4d57ced63d513dd0dcb794b8e8bb2a840577758`. The [follow-up review audit](oracle-reviews/issue-2069-native-ddl-review-followup-b42b94b73.md) records the exact recovery-settlement and target-table assertion repairs for code commit `b42b94b73ddba79a6a87fa93e71787dd126ea1bd`. [Issue #2056 evaluation](oracle-reviews/issue-2056-full-mode-recovery.md) records the original RED and candidate comparisons on head `f43a16522c990134ae993235a312d2d5e433dc8a`. The later scoped design revises the Electric guide's on-demand cold-recovery contract. The earlier “Complete” literacy status is not a claim that every recovery law or provider assumption is enforced. Primary owner: `packages/electric-db-collection/tests/electric-descriptor-isolation-oracle.test.ts`. Its tag-history fixture has no managed cache claim, so an incompatible on-demand resume waits for a full source replacement while cached rows remain visible until the source transaction begins. The controlled ShapeStream rejects snapshot requests in full mode. Tagged cold, legacy, explicit reset, warm resume, interruption, partial replacement, and late demand have named cuts. Managed scoped recovery has separate descriptor and installed-SDK histories. The fixed/random tag campaigns share budget and grammar; a direct seed/path replay runs only the selected property. An unconstrained subset demand can fetch all rows because the caller requested all rows; it does not prove bounded network work. Receiver: `packages/electric-db-collection/tests/electric-sdk-delivery-oracle.property.test.ts`. A real installed SDK receives two launches through the Electric adapter and persistence wrapper with controlled HTTP and durable storage. Direct demand and public live-query preload settle through changes-only scoped snapshots in a managed fixture with separate durable stores for retired and current cache generations. The receiver verifies `id = 1` and its bound parameter on both launches. It permits one snapshot to satisfy the live query's active demand and checks its public and durable row after settlement. It does not require a second physical request for the same subset. Lost tags, changed shape, and malformed resume state keep stale B in the retired store without exposing it after an A snapshot or an empty B snapshot. The changed-shape case makes B's empty snapshot first. A third launch with no demand starts no full-shape transport or unrestricted local subset read. The fixture models generation routing, while real SQLite independently checks claim enforcement and physical tables. Another receiving witness rejects concurrent SDK snapshot invocation on the shared cursor. Compatible untagged resumes and the unmanaged full-log fallback remain separate controls. An installed-SDK abort witness holds subset HTTP across external stream retirement, then returns a valid row. The demand rejects, the row stays absent, and an identical demand is not certified as loaded. The dependency-compatibility extension checks the accepted SDK cursor after `requestSnapshot` fulfills and before its physical serialization turn ends. Successful demand settlement waits for both row application and the separate resume-metadata receipt; it does not certify a crash-atomic row/cursor commit. Twenty-eight lanes cross tags, direct/live-query consumers, an empty second response, and applied/held/rejected cursor writes; four held cursor-demand lanes add the second physical request while the first checkpoint stays held. Each lane runs eight fixed and eight random histories (448 total). Every applicable reach is enforced separately per lane. Cold cursor, advanced cursor, fresh-launch demand, held checkpoint, rejected checkpoint and next-request totals are 256, 320, 320, 192, 128 and 64 histories respectively. Tagged fresh launches retain scoped recovery's reset marker. The original missing checkpoint fails the intended metadata comparison; queue-await and scoped-reset mutants fail their progress and reset cuts. Removing the explicit receipt await survives the rejected-write fixture because the persistence wrapper independently rejects the demand; this fixture does not isolate that mechanism. Direct replay selects one property and path, but the local fast-check 3 traversal executed seven histories, so singleton execution is not claimed. See the [compatibility record](oracle-reviews/2026-11-09-dependency-compatibility.md) for commands, exact outcomes, grammar controls and remaining limits. The two-launch receiver also delivers a coordinator invalidation after a paginated scoped snapshot. The persistence owner crosses targeted, paginated, full-reload, and reset notifications after an active source row. Its post-invalidation public-row checks distinguish source authority from durable cache; the non-scoped paginated reload remains a neighboring control. The persistence owner also checks that a scoped cache clear preserves initial Collection loading until the source marks ready. A held optimistic handler checks that the same clear settles before the handler releases: core applies a truncate immediately, so the proposed accepted-versus-applied deadlock does not arise on this path. Its subset settlement law remains separate. The persistence owner now calls baseline hydration after starting scoped recovery with a stale durable row. It requires that no row enter the public Collection and that no full-row resume snapshot be read. This is a direct capability-ordering witness; ordinary Electric startup does not call baseline hydration after choosing scoped recovery. The buffered partial-update recovery read has a gated failed-local-load history: a partial source update may appear, but it cannot inherit stale durable fields. Removing the scoped read guard fails at that public-field checkpoint. `electric-resume-snapshot-races.test.ts` also holds a real SQLite metadata read across row loss or a committed replacement. Unknown and missing key-set evidence start changes-only without publishing the cached rows; a row-1 demand then applies only its source snapshot. This is a fixed Node SQLite receiving witness, not a generated-history claim or a native Expo result. Its two cache-generation receiving histories use Electric's real resume classifier and wrapper with real SQLite. An incompatible stored shape reaches private rotation after claim expiry without overwriting a warm peer's resume metadata. A later active-session claim expiry holds the boundary after SQLite rotation and before public truncate; a retired callback cannot write there, and a demand started in that interval settles after its replacement subset applies. The ShapeStream callback schedule is controlled. An installed-SDK HTTP delivery at this exact intermediate cut and native-host execution are not established. Applied-settlement owner: `packages/electric-db-collection/tests/electric-oracle.property.test.ts`. Held optimistic application distinguishes readiness from subset completion for demand both before and after readiness. A later same-run reset distinguishes a current replacement obligation from a permanently fulfilled startup gate. Concurrent initial-error and cleanup cuts observe settlement and lifecycle authority; cleanup quietly settles in-flight adapter loads. A sibling-demand abort cut requires one canceled demand to reject promptly while its sibling and a replacement of the canceled demand wait for the full source snapshot and succeed after its row applies. A separate external stream abort rejects its current full-log demand and never certifies an identical later demand as loaded. These full-log wait obligations still apply when scoped recovery is unavailable; the scoped path uses SDK snapshots and applied receipts. The changes-only path has the same refusal both when a subset transport returns after stream retirement and when an applied receipt is held across that retirement. The full-mode retry histories now reject their pre-error demand, then require a new demand to succeed after a same-run recovered snapshot, both with and without a held applied receipt. An installed-SDK controlled-HTTP receiver exhausts 503 backoff, invokes the user's retry handler, and acquires a new demand while the retry HTTP request is open. It requires that demand to wait, then succeed after the new full-log up-to-date. A missing-header response checks that the SDK's refusal to retry rejects later demands rather than leaving a renewed gate pending. The scoped reset history acquires a snapshot before must-refetch, then requires subset-end to apply its row before demand success without waiting for a full up-to-date. The neighboring full-mode reset retains that stronger wait. The Electric durable fixture has an adversarial keys insert check that rejects retained old columns or tag metadata; it is driver validation, not a new model owner. The Electric adapter owner now holds an asynchronous user retry decision and checks that a new full-recovery demand remains pending until source replacement, while the pre-error demand rejects. It also checks caller abort before subset transport settlement, while a request is queued behind the SDK cursor, and while an applied receipt is held. Each original behavior failed at the caller settlement cut; the fixed driver requires prompt `AbortError` without certifying that demand. The explicit-resume neighbor keeps malformed durable metadata untouched until source evidence arrives. The persistence owner now invokes a retired scoped-recovery capability after cleanup and restart; the original cleared the replacement Collection, and the lifecycle guard preserves its row. These fixed schedules do not prove arbitrary overlapping retry decisions or all failure paths through `startScopedRecovery`. A valid scoped-clear commit failure with an exact public sync-error observation still needs a witness; an attempted subscriber-throw fixture did not reach that callback during the local clear and supplies no evidence for the review's error-report claim. Remaining witnesses before broader closure: - Electric tag/history owners: unknown or missing key-set evidence combined with tagged scoped demand, multiple resets overlapping held application, and partial updates arriving before a scoped baseline. Repeated provider health, SDK retry-loop exhaustion, and a scoped reset overlapping a held applied receipt also need witnesses. The untagged SQLite metadata-read race is covered above. - Persistence/coordinator owners: native SQLite reads, browser/electron cross-tab transport delivering an invalidation during cache quarantine, and source versus local-only truncate durability. Controlled coordinator delivery and installed-SDK receipt cover the wrapper response, not the multiprocess transport premise. Scoped recovery also needs an explicit durable-cache eviction or certification policy: the current reset marker makes later uncertified starts repeat quarantine, and deleted durable rows can remain on disk. Neither a safe offline subset certificate nor bounded storage growth is proved here. - Installed-SDK delivery and Electric service E2E owners: actual subquery/tag emission, overlapping provider responses, and the scoped restart schedule against a live service. - Expo `expo-persisted-collection.e2e.test.ts` and emulator owners: the offered node:sqlite fixture, native storage, and actual process relaunch. - Descriptor/tag and SDK DNF owners, if durable tags are selected: complete selected membership and silent active-condition changes persisted atomically with rows and the resume certificate, including migration/reset admission. No individual maintainer assignment or approved deferral is implied by these executable ownership destinations. The bounded controlled-HTTP and Map-backed persistence witnesses do not establish class closure across those hosts. ## Paced persistence serialization Issue #2058's primary owner is `packages/db/tests/paced-mutations-oracle.test.ts`. Its held-write model crosses debounce/throttle, explicit leading/non-leading and omitted leading with trailing enabled, and successful release one tick before, at, one tick after, or ten ticks after the successor's timer edge. It observes handler concurrency, start times, transaction states, receipt settlement and identity, and optimistic rows at admission, timer edges, release, and drain. The original implementation fails 18 of 24 histories at the held edge; the six release-before-edge controls pass. The model's immediate handoff after both prerequisites hold is the chosen pacing policy. The original overlap violates the independent serialization promise regardless of that policy. Adjacent histories check renewed debounce quiet, throttle spacing from actual starts, leading-only admission isolation, same/distinct-key success or failure, pending cancellation, manual rollback of a persisting transaction, and synchronous nested admission. Manual-rollback witnesses cross all three serial strategies, including queue, and observe handler overlap after the public receipt has rejected. The wrong implementation fails at that intermediate cut; the repaired implementation waits for the handler itself to return. The owner also drives a leading debounce successor canceled while the first handler is held. A third admission after either direct rollback or same-key cascade must start after its own quiet edge and the held handler's release; the old callback cannot consume the third call's persistence obligation. The reviewed implementation fails at that handler-start cut, while the ownership repair passes both histories. A failed optimistic callback must not retain a newly created empty pending transaction: admitted debounce, dropped debounce, and queue paths now have scope-retention witnesses that fail on the reviewed implementation and pass after cleanup. The owner checks the chosen group-rejection law for a nested admitted call both with and without an earlier pending call. All receipts sharing the failed pending transaction reject with the callback error, no member reaches the backend, and a later independent call persists. The earlier-pending regime failed at the transaction-state cut before the group rollback repair; both factories now pass at the throw and scheduled edges. A separate held-handler matrix crosses debounce, throttle, and queue: manual `commit()` throws before changing a pending receipt, and the strategy still starts that write only after its timer edge and the prior handler's release. The owner also checks one strategy shared by two managers. Reentrant leading/trailing and ordinary trailing histories retain both separate transactions at one timing boundary. A renewed-quiet history moves another manager's eligible callback to the new quiet edge while the first handler is held. A held-handler rollback keeps the second manager's write behind the first handler. The reviewed code fails the second backend-start assertion for both debounce and throttle; the keyed pending-run repair passes. The owner does not yet cover provider echo, cleanup during a held handler, longer arbitrary bursts, held default/omitted-trailing combinations, or more than two managers. It owns those future source-level witnesses. Leading-only throttle admission-window timing while a write is held remains a separate policy question; the existing serialization and minimum actual-start spacing do not depend on its resolution. Real server ordering, framework unmount scheduling, and published npm behavior require receiving integration witnesses; the present evidence is controlled DB source execution. The revision-bound review record is `docs/contributing/oracle-reviews/issue-2058-paced-serialization.md`. ## Opt-in operator bundles Grouping, includes, and pooling ship only with the value that names them: an aggregate or `groupKeys`, an include function, or `pooledLiveQueries`. Joins are core. `packages/db/tests/opt-in-operator-bundle.test.ts` owns that law. It bundles small apps from source with esbuild and reads which modules reach the output. Each of the 10 operator values runs alone, and every one of the 8 combinations of operator families runs with rotating values. An operator's modules must be present exactly when the app imports one of its values. The join compiler and public-key reduction must be present in every app. The single-value runs are positive controls, so a renamed or moved module cannot pass the absence checks. A mutant that statically imports `BucketFacadeAdapter` into the live-query builder, and one that uses a `group-by.ts` helper from the live-query Collection builder, fail it. The owner checks module reachability only, not byte budgets; `pnpm size:compare` measures bytes. It bundles `@tanstack/db` alone, with other packages external, so it does not check db-ivm operators or framework adapters. Query results under the new API are owned by the existing query and includes oracles, which run with migrated queries; no oracle compares a query's old and new spellings on one input. Operator code is part of query identity. The [IR identity oracle](https://github.com/TanStack/db/blob/main/packages/db/tests/query/ir-stable-identity-oracle.test.ts) runs every combination of `groupBy` (none, bare keys, `groupKeys()`), a select aggregate (none, built, without its grouping compiler), and an include (none, built, without its runtime), checks each compile outcome against a small model, and requires distinct identities for any two combinations whose outcomes differ. Removing the identity mark for `groupKeys()`, for an aggregate without its compiler, or for an include without its runtime each fails it. A second check runs a wider product: `groupBy`, a select, HAVING, and `orderBy` aggregate each built or without its compiler, an include as a field, in a `caseWhen` branch, or with a child aggregate, each built or stripped, and an `eq`-filtered query without a select that a pool can serve. It takes each outcome from production compilation and requires one outcome per identity, for the IR identity and for the prepared identity with `pooledLiveQueries`. Each identity mark's removal fails it, and so does a pool shortcut that accepts a `groupBy` query. Bare and `groupKeys()` keys beside an aggregate may share an identity or not; the law leaves that open. Open counterexample, not fixed by this change: the ordered-window random campaign in `packages/db/tests/query/load-subset-replay-refinement-oracle.test.ts` fails with `TANSTACK_DB_ORACLE_SEED=1593300187` (path `121:1:2:3:2:2`) and with seed `-1005431615` (path `68:1:2`). Both shrink to one history: `hold`, `truncateMarkers`, `settle` with a load failure, over an ascending limit-one window on an on-demand marker source with includes. The convergence check sees a terminal error. Main at `65d9ada50` and the merge-base `5649a07d4` fail with the same counterexample, so the operator change did not introduce it. The campaign reaches this defect in ordinary runs, so CI can fail on it intermittently until the defect is fixed. Owner: the load-subset replay owner. Needed witness: a decision whether a truncate during a held, then failed, load may end the window in a terminal error, and the fix or model change that follows. Open counterexample on `main`, not caused by this change: the random campaign of `packages/db/tests/query/ordered-work-oracle.property.test.ts` (`eager indexed ordered windows > keeps rows and per-change work bounded`) fails with `TANSTACK_DB_ORACLE_SEED=1023848973` (path `34:3:3:3:3:4:3:3:4:4:4`). The history is an on-demand, refetch-signal, anti-joined, unindexed, ascending limit-one window with nulls first: upsert row 0 as ineligible, then delete the visible row. The check finds two full-source requests after a signalling refetch, where it expects none. `main` at `5649a07d4` fails the same way. Seed `-436579979` reaches the same check through a joined window (`filter: joined`, `via: link`), fails on `main` at `5649a07d4` too, and in CI timed out at 5 seconds while it shrank. The campaign can fail CI intermittently until the defect is fixed. Owner: the ordered-work owner. Needed witness: whether this unindexed window may use full-source recovery, which this map allows for unindexed underfilled continuations; if so the check is too strict for it, and if not production is wrong. The same comparison fails on main `6c1ca8f8f` and PR #2229 at `7fff3a7e0` with seed `1902868771`, path `19:2:2:4:4:4:5:9:18:15`. This joined-filter history changes eligibility through `link`, then touches another row. Both exact replays report two full-source requests where the check expects zero; neither reports type errors. The existing contract question remains open. Open observation without a trace: in one CI run of this change, the random campaign of `packages/query-db-collection/tests/refetch-ordered-prefix-oracle.test.ts` timed out at 120 seconds before it printed a seed. The previous CI run took 29 seconds, and twelve local runs with random seeds passed in 38 to 50 seconds each. Owner: the refetch ordered-prefix owner. Needed witness: a seed that reproduces the slow history, and whether it is a slow shrink of a real counterexample or a slow passing history. Open observation without a trace: during this change, one run of the random campaign in `packages/db/tests/query/includes-oracle.property.test.ts` failed on the branch. The run did not record its seed or counterexample. Thirteen later dedicated runs and two full-suite runs on the branch passed, and the campaign was not run on `main` at that time. Owner: the includes oracle owner. Needed witness: the failing seed and path from a later run. Until then, this entry cannot tell an operator regression from an older defect. A later failure of that campaign must record its seed here before anyone calls it pre-existing. ### Ordered joined dependency composition, October 30 October 30 receiving extension: the same ordered-work owner now checks joined dependency composition across direct, wrapped QueryRef and two-filter nested ordered plans. Its 128 finite histories cross actual Collection and Effect receivers, two directions, matched/anti-joined membership, widths one/two, joined answer order and which of two joined sources vetoes a new head row. Each history checks settled initial rows, then every recorded publication and public read at held, partial and settled cuts. All 256 declared held/settled states reach their minimum once. Unchanged `8464ec977` fails 24 publication comparisons (12 per receiver); the repair passes all 128 histories. Overwrite, last-only and first-only dependency mutants fail 24, eight and eight intended comparisons respectively. The original 424 owner tests and their budgets stay. This is a controlled adapter witness through real core receivers: one inserted head row, two joined sources, one QueryRef level and windows of one/two rows. Ordinary progressive Effect startup callbacks remain outside this new atomicity claim. No provider/framework, arbitrary nesting, rejection, cleanup or public window-promise integration claim follows. See the versioned [joined dependency review](oracle-reviews/callback-metadata.md#ordered-joined-dependency-review-2026-10-30) for the pre-edit gate, experiments, source binding and loss audit. ### Ordered signalling-refetch work scope, October 27 Owner: `packages/db/tests/query/ordered-work-oracle.property.test.ts`. The architecture's "Ordered requests, continuation, and recovery" law permits full-source fallback for an underfilled joined prefix without an order index. The signalling-refetch assertion therefore forbids extra full-source requests only when finite continuation is available, indexed joined windows and direct source-filter windows. Unindexed joined histories retain all public row, order, publication and other applicable work comparisons. They do not claim a bounded refetch transfer. The authority is the existing architecture contract, not a new behavior decision. Replay seed `-931507916`, path `21:3:3:3:4:3:4:4:4:5:4:4:4:4` reaches the permitted fallback after an ineligible upsert into an empty source and a joined-marker change. This was an overly broad oracle assertion, not a production repair. ### RC Effect explicit source metadata (2026-10-28) Owner: `packages/db/tests/query/virtual-row-fields-effect-oracle.test.ts`, sharing the small `virtual-row-fields-source-oracle.ts` source judgment with the root metadata owner. It recomputes explicitly selected ordinary metadata fields and full before/after deltas independently, then receives actual Effect onBatch and named callbacks across 200 finite single-source, LEFT-join and populated-union histories. It preserves previous values, multiplicity, field absence/undefined, typed source keys, and opaque event-key continuity only within active intervals. Held mutations, independent confirmations/outcomes, both settlement orders, remote updates, peer exit/reentry and next-use reach 5,512 production path/channel/cut cells exactly once. No implicit Effect-root metadata or output Collection ID is claimed. Original P09 evidence: all 64 LEFT-join histories emitted a startup update for a never-entered unmatched occurrence after its load finished. Those initial comparisons were RED on unchanged `858b174a6`; histories continued and all later comparisons passed. The other 136 native histories and 16 controls pass. Independent mutant overlays reject dispatch, previous-value, duplication, colliding-key and extra undefined defects; lawful key renaming, fresh reentry and empty partitions retain the baseline. Per-campaign omissions and seeded partial selections now fail reach. The finite owner explicitly disables the irrelevant shared replay exemption; O26 retains a broader campaign inventory for that harness class. See chunk 16 in the RC chunk record for exact fingerprints, evidence and review. Limits: eager controlled core sources, scalar rows, one mutation per source, and these named paths. No real provider/framework, arbitrary scheduling, ordered repair, same-source overlap, callback-input sanitization or exact internal graph-run callback-count guarantee follows. Historical initial P09 repair evidence for PR #2301: The exact owner and `test:oracles` entry were restored before production edits. On baseline `9b03e639f`, the fresh RED reproduced 64 startup failures with every reach cell at count 1. Repaired production passes all 216 owner tests and all 2,756 checkpoint comparisons. Restoring the original classifier reproduces the same 64 assertion failures; suppressing all unordered updates fails all 200 native histories. Each of the 5,512 reach cells remains at count 1 in both mutants and GREEN. All 1,690 neighboring tests pass before and after the edit. See [the Effect startup follow-up](oracle-reviews/effect-startup-delta.md) for commands, fingerprints and limits. Arbitrary scheduling, join multiplicity, ordered repair, same-source overlap and callback-input sanitization remain outside this bounded closure. Other deferred findings remain open. Subsequent checker calibration keeps both callback channels coherent when injecting a bad update key. The `key-collision` and `key-change` controls now reject deletion of the interval-continuity judgment itself: the full checker mutant passes 214 controls/histories and fails those two controls. Repaired production passed all 216 owner tests and the combined 619 targeted tests at that historical subject, including subsequently removed Set work. Native histories and all 5,512 reach cells are unchanged. See the follow-up's [calibration evidence](oracle-reviews/effect-startup-delta.md#key-interval-checker-calibration) for the new owner fingerprint and the limits of the continuity claim. The subsequent high-review repair extends the same owner with 24 finite histories crossing scalar/callable/private-field payloads, one source/LEFT join, initially absent/present membership, and separate/coalesced source transactions. The independent source snapshots still determine the full delta. Both callback channels preserve event multiplicity, previous readable payloads, and active key intervals across initial, sequence, absent, reentry and next-use cuts. All 120 new reach cells have count 1. On unchanged `d97c1aaf4`, 14 histories fail; retaining preceding result membership repairs them without relying on payload equality. The original classifier and a net-count-only classifier fail these comparisons. This finite extension does not claim exact rich-payload instance identity, arbitrary nondeterministic projections, changing join keys, provider schedules or framework behavior. The earlier scalar and ordered-repair limits remain. See the [Effect membership evidence](oracle-reviews/effect-startup-delta.md#membership-and-coalesced-source-writes). Current key-only repair: the metadata owner has **300 tests**, including 60 callback-profile histories from `query/effect-callback-oracle.ts`. The actual React driver `packages/react-db/tests/effect-callback-oracle.test.tsx` runs the same 60 histories, model and comparison. Six payload representations cross five callback profiles and `skipInitial`. Source-version updates, handler replacement, exit, reentry, next use and disposal reach 480 cells on each path, each at count 1. The original 5,512 cells and 120 membership cells remain. On unchanged `2b3dd8c2d`, 56 core and 40 React histories fail. The repair passes all **708 targeted tests**. The stale-value mutant survives the original 314 tests and fails the extended histories at exit; gross-count membership fails 79 comparisons. Unordered Effects now retain keys only and never compare projected values. Ordered repairs retain their preceding coherent values. The maintainer explicitly chose preservation of unordered update notifications, including equal projections, on 2026-10-30. The new histories cover eager core sources and actual React hook commits; other providers/frameworks, arbitrary schedules and ordered repair semantics retain their existing limits. See the [key-only review evidence](oracle-reviews/effect-startup-delta.md#review-of-2b3dd8c2d-key-only-unordered-results). Ordered callback histories (2026-11-02): the callback-profile grammar now crosses an unordered and an ordered query (`orderBy` with `limit`) and adds a `signed-zero` payload that alternates 0 and -0, distinct row values (maintainer decision 2026-10-29); 120 histories on each path. An ordered Effect delivers an update only when its projection changed. On unchanged `f06ee8fdd` the ordered `signed-zero` histories fail (an update that flips only a zero's sign was dropped); comparing with `sameRowValue` repairs them. That payload's source row also changes its `version`; the `source-zero` representation changes the source row only by a zero's sign, which the ordered query's top-K dropped before the 2026-11-02 decision (see the adapter conformance entry's signed-zero paragraph). An ordered Effect also dropped an update whose change is private or non-enumerable state, so the consumer kept a stale value (`private` and `prototype` payloads, 20 ordered histories, RED on `370e029db`). Maintainer decision 2026-11-02: the ordered comparison (`samePublishedValue`) treats a class instance as equal only to itself, so its update is delivered; an ordered repair may then deliver an update for an unchanged class instance. ### RC bound schema mutation receivers (2026-10-28) Owner: `packages/db/tests/live-query-bound-options-oracle.ts`; shared driver: `live-query-bound-options-support.ts`. React `bound-schema-options-oracle.test.tsx` and Preact `bound-schema-options-oracle.test.ts` receive the same model through real live hooks, plus ready-source React Suspense. All 216 finite native histories pass on unchanged `858b174a6`: nine ordered absent/trim/uppercase pairs, query/queryKey replacement, independent key proposals and two padded inputs. Held client updates use retained schemas until identity changes; synced rows remain raw. Immediate reads, committed hook data/state, handler original/modified/changes, settlement and later next-use are compared across 2,592 distinct reach cells. Extra own undefined fields and omitted followup mutations now fail; validation-bypass and source-input-corruption overlays fail the intended comparisons. See the RC chunk record, chunk 15, for frozen hashes and independent evidence. Limits: valid synchronous schemas, scalar rows, explicit string keys, settled mutations before replacement and ready-source Suspense. This JavaScript runtime receiver makes no typed-schema, initial suspension, SSR, concurrent-render or provider claim. Default-getKey absence and async/invalid schemas remain outside it. ### RC mutation confirmation expansion (2026-10-28) Shared rule: `packages/db/tests/mutation-confirmation-oracle.ts`; receivers: Query `ownership-lifecycle.oracle.test.ts`, Electric `electric-oracle.property.test.ts`. The finite grammar covers CRUD, absent/present peer, fulfilled void/legacy returns, rejection before/after a server write, no confirmation versus explicit Query refetch/direct write or Electric txid acknowledgement. Real utility waits are held before response delivery. Full ordinary rows, exact errors, terminal state, settlement-waiter snapshots and real fetch/provider-work counts are checked. 78 Query and 42 Electric histories pass on unchanged 858b174a6; 13 calibration controls reject wrong rows, outcomes, errors, early acknowledgement and extra work. O17 receiving expansion:24 ordered CRUD/outcome/invalidation histories and six post-handler durable-receipt histories now pass. The latter rejects an in-memory leaked-handler-count mutant in all six histories after a calibrated task-turn cut. Ordered observations cover a two-row numeric window and eventual fixed point; late application rejection, concurrent handlers, native SQLite and live provider timing remain outside these expanded witnesses. Adapter generated return-type admission now has the O14 source receiver below. Persistence wrappers, multiple concurrent handlers and live Electric providers remain separate paths. The [chunk 18 review](oracle-reviews/2026-10-28-pr-2171-oracle-chunks.md#chunk-18-actual-authored-mutation-handlers-reviewed) adds exact authored-handler receivers. `packages/db/tests/documented-mutations-oracle.ts` owns the finite guidance grammar and handler-Promise judgment; its support module extracts actual initializer ASTs. Query and Electric's `tests/documented-mutations-oracle.test.ts` use the shared mutation judgment with complete ordinary rows. Eighteen fences supply 30 current and three explicitly negative handlers. Their 190 histories distinguish transport rejection from a resolved HTTP 503, and server commit from handler confirmation and settlement. Query has 132 passing histories and two G01 settlement failures; Electric's 56 pass. G01's missing confirmation stages remain unreached and fail reach separately. Forty-three controls pass. The original instrumentation supplied a missing await through a handler-return gate; independent review demonstrated two false greens. The repaired receiver observes the actual handler Promise while genuine source delivery is held. Both identical omitted-await overlays now fail, while already accepted direct-write neighbors pass. Shared seeds preserve reach, and partial native selections cannot waive missing cells. G01 remains open for the later guidance-repair phase. This is exact-handler reception through controlled backend/SDK collaborators, not full factory, schema, component, concurrent-handler, persistence-wrapper or live-provider coverage. Broader authored guidance and diagnostic consistency remain O21 work. ### RC public mutation-handler type admission (2026-10-28) Owner: `packages/db/tests/mutation-handler-types-oracle.test.ts`. An independent output/transport rule checks generated Query/Electric consumers through Config, explicit factory and inferred factory entry points, with/without schema and Query rows/envelope select.36 consumers contain4,212 cells; all702 declared states reach six histories. Promise accepts void/undefined and rejection, including a synchronous never result; fulfilled values and synchronous void are rejected. It is the `oracleProperty` `adapter.handler-types`: each shape resolves to a generated consumer program, the TypeScript compiler is the driver, and six calibrations (missing, duplicate, setup-error, rejected-void, unrelated same-code, and body-local Promise diagnostics) must each fail their named law. Its enumerated reach is no longer asserted per state (open: enumerated sources declare no reach yet). All42 tests pass on unchanged858b174a6; the `oracleProperty` port registers 43 (it adds a determinism test). Independent compiler probes reject unrelated same-code and body-local Promise errors substituted for handler errors. Source imports do not establish packed declarations or npm consumers; O22 owns that receiving boundary. Full evidence is in the RC chunk record. ## Release notification selection `scripts/release-comments-oracle.property.test.js` owns exact per-package published-version selection, source PR identity, linked-issue aggregation and existing-comment suppression at the controlled `gh` command boundary. Its independent release ledger drives `scripts/comment-on-release.ts` and compares recipient URLs, source PR URLs, package/version/anchor unions and lookup stderr at script exit. Numeric recipients retain explicit `--repo`/`-R` overrides, and issue lookup fixtures belong to their requested source repository. All 161 finite histories pass, preserving all prior replay indexes. They cover stable/prerelease/build neighbors, both section orders, independent package versions/documents, duplicate PR references, source repositories, asymmetric contributions, shared/disjoint/absent issue edges, same-number foreign issues, lookup failures, document-wide heading collisions, foreign changelog references, misleading display labels, existing comments on early/later pages, missing versions, empty sections and no publications. Source PR identity comes from the URL, not its label; foreign changelog references do not create local recipients. Declared reach: stable 92, prerelease 77, build metadata 44, reversed sections 62, linked issues 122, no linked issues 32, no matching PRs 7, asymmetric contributions 82, disjoint edges 12, shared edges 54, foreign issues 54, same-number foreign issues 44, lookup failure 6, colliding heading anchor 13, alternate source repository 32, independent package versions 8, foreign changelog reference 12, label mismatch 4, existing release comment 24, release comment on later page 12, failed PR check 6, failed issue check 6, partial response before failure 8 and positive partial response before failure 4. All 24 states have failing minima. Linked reach now requires a selected expected issue notification; no-selected case 64 counts zero rather than its earlier false reach of one. Before production edits, the initial pinned script failed 64/67 comparisons; the first expanded owner rejected 27/105. A fresh reviewer demonstrated three more surviving mutants; the 121-history owner rejected them and narrow variants. The 149-history owner then rejected unchanged production in 20 intended reference/ comment-page comparisons, with 129 passes. That repair passed all 149 histories and 11 existing release tests. Sixteen final-source mutants fail intended value assertions across routing, unions, repository identity, per-package selection, anchors, warnings, reference identity and pagination. Earlier parser calibrations remain recorded. [Versioned evidence and replays](oracle-reviews/2026-11-06-release-comments.md) preserve all review stages, source identities, corrections and calibrated scope. The controlled comment API supplies per-page marker counts; raw GitHub comment body/JQ conformance and actual delivery are not established. Authentication, foreign-token permissions, linked-issue pagination beyond ten, retries, concurrent releases and alternative Markdown remain outside this claim. The maintainer chose attempt-posting after failed existing-comment checks on 2026-11-06 (R13), accepting possible duplicates. Eight single-recipient failure histories cover PR/issue targets, both source repositories and failures before or after a page response. The exit comparison requires the post, recipient/cause warning and explicit continuation message; successful neighboring checks still suppress existing comments. All eight direct replays rejected the old diagnostic before production edits. The 157-history campaign and all 11 existing tests pass; skip-on-failure and missing-cause mutants fail intended assertions. R13 is accepted-design with its diagnostic coverage complete. Actual delivery still needs an authorized host observation. R17 adds four positive-partial-response histories across both repositories and PR/issue recipients, preserving all previous indexes and budgets. A mutant that warns but trusts failed-command stdout passes all previous 157 histories, then fails all four added histories at the notification comparison. Unchanged production passes all 161 histories and 11 existing tests. This extends the accepted failed-check rule; it does not change production behavior. The release-history owner below continues to own version/publish planning. ## RC release histories and replay observations The shared independent release owner is `scripts/release-history-oracle.js`, received by `release-history-oracle.property.test.js` and `publish-history-oracle.property.test.js`. The [chunk 13 review record](oracle-reviews/2026-10-28-pr-2171-oracle-chunks.md#chunk-13-release-histories-actual-changesets-commands-and-finite-replay) records policy authority, grammar, reach, source fingerprints and calibrations. It checks 72 version timelines, 14 seed failure/retry timelines and 40 actual Changesets command histories, with six publish checker controls. Numeric 9/10 boundaries, strongest pending bumps, standalone stable work, dependency profiles, all three exit forms, exact consumption/changelog attribution, rollback and publish retries are exercised. Version/seed has 86 passes. Publish has 34 passes and 12 intended tag failures: with only prior RC registry history, real Changesets publishes candidates to latest instead of rc (P01). This remains unrepaired until the full oracle campaign completes. Strict local shims provide command metadata and retain raw requests; real npm HTTP, tarballs, installed consumers and Actions remain separate receiving work under O13/O22. Release receivers use native `oracleProperty` enumeration. The shared manifest marks `scripts.release-version`, `scripts.release-seed-failure`, `scripts.publish-command`, and `scripts.publish-http` as enumerated campaigns. Replay an exact case with its complete stable Vitest title, including the JSON history, under `scripts/oracle-scripts.vitest.config.mjs`; native enumeration replaces the earlier release-only PROPERTY/SEED/PATH index bridge. Every original finite case and comparison cut remains. Authored assertion failures retain their original error, while setup and cleanup failures remain driver errors. The older standalone `recordOracleReplay` comment promises never to throw, but a real RunDetails plus a directory channel throws EISDIR (P03). Its owner is the guarded replay/ standalone recorder checks in `packages/db/tests/oracle-replay.test.ts`; the needed witness is an explicit writer-failure policy comparison for that older API. The finite wrapper's guarantee does not settle that policy conflict. The lint observation owner was `scripts/eslint-plugin-oracle/replay-observation-oracle.test.js`; it moved with the lint rules to `packages/eslint-plugin-oracles/tests/` in TanStack/oracles, where its current limits are recorded. At that move, its independent source-intent model and actual ESLint receiver distinguish typed completed-run output from literal generated-run budgets. All 3,848 source programs and two checker controls pass; 1,924 states each reach twice. With ordinary rule/harness controls the final suite has 3,984 passes. Exported/aliased/budget uses, runtime JSON shadows and custom serialization hooks remain rejected; type-only uses are allowed. Broad flow and initializer mutants fail 520 and 200 comparisons. Only the known plain-data writer and unmodified standard JSON serializer are recognized; this is not dynamic whole-program flow analysis or a general serializer policy. Ordinary harness controls stay outside oracle definitions. The [chunk 14 review record](oracle-reviews/2026-10-28-pr-2171-oracle-chunks.md#chunk-14-actual-npmpnpm-http-publication) adds the same release judgment through actual npm 11.17.0, pnpm 11.1.0 and Changesets 2.29.8 over a loopback HTTP registry: `scripts/publish-http-oracle.property.test.js`. Fourteen histories cross stable, prior-RC, never-published and already-current metadata with both RC-only tag forms and legal failure phases. Raw attempts preserve duplicates; actual uploaded tarballs supply manifest identity and digest. Exact local bytes are checked before retry/settlement judgments. Eight histories and three origin controls pass; six histories fail intended assertions. Three confirm P01's wrong `latest` tag. Three expose P05: RC-only/no-latest metadata causes uploads of existing RC versions on retry or an already-current release. Both publisher defects remain unrepaired. Metadata/restoration reach14, failure/partial/retry reach8, packed-upload10, already-current1 and completed comparison8 distinguish earlier assertion failures from later unreached states. Eight ordinary fixture controls and three repeated overflow probes pass after test-tool repairs. This receiver establishes real HTTP/packed identity reception, not installed dependency/API capability, clean workspace setup, production authentication or Actions. O22/O25/O26 retain those boundaries. The fixture supplies local pack-time links without an install and requires POSIX process groups. The merged-main [chunk 22 extension](oracle-reviews/2026-10-28-pr-2171-oracle-chunks.md#chunk-22-publication-eligibility-without-dist-tags) preserves those 14 histories and adds 15 neighbors. Exact-version membership, not tag presence, determines upload eligibility. It covers current candidates with no tags or stale RC tags, the exact wrong-tag aftermath (`rc` points older, `latest` points current), absent targets without tags, reversed heterogeneous candidate versions, retained candidate success before a later failure, and stable packages whose current versions lack `latest`. Stable and candidate metadata reach are separate; a stable-phase duplicate failure receives no candidate-path credit. All 29 histories use the same independent ledger and raw-attempt comparison. Native results are 21 passes / 14 intended assertion REDs including six calibrations: seven P01 tag failures and seven P05 duplicate failures. The stable-path witness receives two actual 409 responses before any candidate GET. No production repair or class closure is claimed. The extension uses Vitest 4.1.12 with the existing actual npm/pnpm/Changesets tools and retains the earlier receiver's limits. Clean setup/build evidence and unresolved release gates are recorded [separately](oracle-reviews/2026-10-29-pr-2171-release-gates.md). The [Changesets 2.31 compatibility repair](oracle-reviews/2026-11-09-changesets-publish-compatibility.md) preserves those 29 HTTP histories and adds four private-version-policy neighbors. Temporarily hidden packages remain versionable for config validation while their private manifests still exclude them from uploads. Both receivers now capture original config/private-manifest bytes; HTTP archives additionally retain runtime and peer dependency edges, including bounded `workspace:*` expansion. The unchanged publisher gives 71 config-validation failures / 14 passes; the repair passes all 85 command/HTTP tests and 32 ordinary controls. Normal HTTP reach is 33 registry/restoration/comparison/public-dependent histories, 26 packed uploads, 12 failure/retry histories and seven already-current histories. Reformatting restoration and temporarily stripping packed edges each fail both selected histories at the intended assertion. Matching CLI 2.31.1/config 3.1.4 tagged sources were built together locally; published-distribution final-head CI remains a separate receiving gate. No publication ledger, tag law or budget was narrowed. The [chunk 23 SortedMap reach repair](oracle-reviews/2026-10-28-pr-2171-oracle-chunks.md#chunk-23-constructive-deferred-row-order-reach) constructively reaches changed-deferred order restoration before executing each original generated suffix from its original empty starting condition. The current-value sorting law, independent Map/full-sort model, four examples, both 100-run budgets and minimum five remain. Native and independent campaigns pass 48 tests; changed-deferred comparison reach is 96 per comparator campaign. Positive/negative premise controls reach 16/0. Exact one-history native and in-memory stale-placement mutant replays respectively pass and fail the shared ordering comparison. No production change or broader public receiving claim follows; the owner's other sampling and contract limits remain. ### Solid publication recorder receiving repair The [chunk 25 record](oracle-reviews/2026-10-28-pr-2171-oracle-chunks.md#chunk-25-native-solid-publication-recording-and-ci-import-census) closes the undefined-Accessor observation gap in the shared conformance owner. The shared `conformance/publication-laws-oracle.ts` requires complete modeled rows at the existing final cut while preserving permitted loading turns and earlier ID membership. All 32 source-ID histories per registration and both pooled a/b cuts run through actual affected framework drivers. Native Solid's 62 tests, whole-package typecheck and the affected React/Preact/Vue/Svelte/Angular selections pass. Independent reader mutants fail the intended comparison; failing-path mounts dispose exactly once. This is test-machinery coverage, with no library change or broader scheduler, status, backend or device claim. ### RC generated error catalog receiving boundary (2026-10-29) The existing Production error messages owner now compares the actual copied generator's stdout with its full frozen catalogs, independent of committed generated-page freshness. Every coded class requires its heading and real HTML ID; every coded site requires its source and target. Canonical text-message fences cannot supply HTML IDs. Independent R3 review retains valid alternate HTML syntax and rejects missing or fenced-only class IDs through the same check. The unchanged tooling run has 27 passes and 12 intended assertion failures; stdout reception reaches once and the completed catalog comparison remains zero because the old generator emits empty stdout. Ordinary CLI and root-command controls are separate files. The [chunk 26 record](oracle-reviews/2026-10-28-pr-2171-oracle-chunks.md#chunk-26-generated-error-catalog-observation-and-command-ownership) retains exact source/evidence hashes and all ORC outcomes. Actual production bundle erasure, Typedoc generation, tooling GREEN and restored-old-tooling mutants remain required receiving checks. Generated docs remain CI-owned. ### Replay successful-retirement ownership, October 30 The load-subset replay refinement owner scopes successful replacement to the same subscription as the failure. Its 96-history failure/success matrix reaches four sibling-success coverage histories and calibrates that another subscription's failure survives the account action. The original account fails that comparison; all 44 normal owner tests pass after repair, with existing budgets intact. No production change or new provider/framework claim follows. See the [versioned retirement review](oracle-reviews/callback-metadata.md#replay-retirement-scope-review-2026-10-30). ### Framework row snapshot isolation The **Frameworks** owner judges preservation of borrowed Collection values at actual framework boundaries. Authority is immutable updates, `PendingMutation.original`, `ChangeMessage.previousValue`, and the shared `packages/db/tests/conformance/contract.ts` result law. The shared executable owner is `packages/db/tests/conformance/row-snapshot-oracle.ts`. Core supplies admitted source facts before materialization. This relational comparison judges adapter preservation, not Core draft normalization or prototype policy. Nine common shapes cross one/two keys, callback/config/supplied Collection inputs, and sync/optimistic writes: 108 histories per common driver. Solid adds native stores for 120 histories, plus 60 real local-only histories. React has two registrations of its derived-identity API, labelled `react` and `react (dependency list)`; neither is a DbClient receiving driver. Two-key histories share initial containers and alternate updates. Actual mutable sharing is asserted before crediting cross-row alias reach: eight common histories and nine Solid histories per group. The later-object shape starts at null and gets no mutable-alias credit. Three updates per key distinguish initial and later admissions, alias split/merge, hidden string data, inherited-name shadows, and own-undefined/omission. The grammar contains 828 history slots across 45 group tests, including the duplicate React API registration. Every receiving group asserts its own reach. The shared comparison checks complete current framework and source values, retained initial `get()` and admitted `change.value` references, `previousValue`, and actual transaction `original` references at every existing cut. Optimistic handlers also have a held cut. Three isolated source-corruption controls reject damage limited to current, initial, or newly admitted values. A real Solid fault injection is rejected at the current-source comparison, even when its detached output is correct. The local-only driver returns actual mutation receipts. Alternative legal source-shape policy is accepted. Original-only corruption and cross-row caching mutants distinguish the extended owner from its predecessor. Solid's separate receiving owner, `packages/solid-db/tests/row-materialization-oracle.test.tsx`, judges nested identity, binding lifetime, current array membership, live nested getters, and bounded shared-graph work. Its original 85 finite histories include real `For` and effect consumers, native-store-only writes, reorder, growth/shrink/empty arrays, getter admission/replacement/omission/readmission, and crossed old/new graph sharing. The maintainer chose live getters and efficient shared acyclic graphs on 2026-10-30, with cyclic support decided separately. Work counts source and owned container enumerations against an unchanged 32-per-distinct-container budget. This is a bounded regression check, not a public SLO or a complexity proof. The native-store revision skips unchanged source rows and memoizes immutable, detached nested stores by source identity within each row. Solid setters update the ordinary stable root row and replace changed nested containers. Consumers must read the current nested path reactively: a captured old nested proxy does not follow replacement. Native stores supply getter tracking and notifications. Explicit root own-key admission handles inherited-name and own-undefined cases. The complete graph comparison checks mixed paths without imposing alias identity. Twelve additional controlled-helper histories vary descriptor visibility for undefined, null, scalar, object, array, and native-store payloads. They observe captured-root `Object.keys` consumers across unchanged, hidden, visible, and restored-visibility stages while retaining payload and root identity. The raw/proxy identity guard fails six container histories before repair. These histories test only the materializer's internal invariant. Core public row snapshots normalize root descriptors, so no public descriptor-admission claim follows. Valid derived array-wrapper prototypes retain source methods, and local-only original reach requires a nonempty actual receipt. See the [native revision review](oracle-reviews/2026-10-30-solid-native-store-review.md) and the historical [materialization](oracle-reviews/2026-10-30-solid-row-materialization-review.md) and [snapshot](oracle-reviews/2026-10-30-solid-row-snapshot-isolation.md) records. The Solid 1.9.18 compatibility extension replaces the reserved-name native-node seeding with a revision signal on detached owned data and a read facade; it does not alter Solid's guarded setters or native bookkeeping identities. Seventy-two finite reserved-field histories cross three public inputs, ordinary and `__proto__` names, three initial ownness states, and scalar/signed-zero/object/ array payloads. Each input has 24 histories enforcing all ten declared reaches, including tracked own keys, prototype integrity, retained sources and a quiet neighbor. The descriptor-visibility helper family now has 24 histories, crossing both field names with its original six payload kinds and two initial visibility states; all four reaches hold in every history. A get-only facade mutant passes all 72 public reserved-field histories but fails 12 of these helper visibility histories, preserving the distinction between normalized public rows and the helper's descriptor law. A signed-zero extension first fails six of eighteen selected histories, then all eighteen pass with Object.is-sensitive invalidation. The final upgraded-runtime Solid suite passes 426 tests. The original 32-per-distinct-container work budget and preceding limits remain. The [compatibility record](oracle-reviews/2026-11-09-dependency-compatibility.md) separates original-code RED, repaired GREEN, hostile controls, and host limits. **Core source-field and destination preservation:** the maintainer authorized fixing the sibling Core boundary in this PR. The existing context-transport owner now imports its public-field model/grammar from `packages/db/tests/conformance/public-field-oracle.ts`. Sixty histories cross six source keys, root/nested location, four selection forms, five stages, and ordinary/inherited nested destinations. Root Collection and three correlated forms supply 1,200 path/stage observations; the original 819 observations remain. The source admission check precedes result comparisons. Five restored wrong merge/destination designs fail intended own-field assertions. Real framework callback/config receivers reuse the same models and comparison for twelve new destination cells per input. Fourteen groups across seven registrations supply 168 histories / 840 comparisons. Core creates own enumerable data fields and own destination containers; unsafe authored alias paths retain rejection. The final [review record](oracle-reviews/2026-10-30-solid-native-store-review.md) records RED, GREEN, mutant classifications, reviewer outcomes, and exact code. The second independent review extends the same public-field owner with thirty overlap cells. Twenty-four legal expression cells reach every framework input; six functional controls supply a second Core formulation. A prior outer spread borrows the destination before a nested spread, literal field, or dotted alias writes it. Ordinary, inherited-name, and deeper destinations cross writable configurable/nonconfigurable source data. Authored nested objects replace their field; dotted aliases preserve siblings without writing through source objects. The four Core paths supply 120 path histories and 360 result cuts. Fourteen real framework groups supply another 336 histories and 1,008 result cuts. All compare current and retained source rows and require the actual source descriptor at all three stages. Existing 819 and 1,200 observations and the earlier receiving histories remain. Unkeyed functional projections are not legal derived-identity framework inputs, so they receive no framework handoff credit. Legal fresh-object expression controls provide those neighboring receiving comparisons instead. See the [second review record](oracle-reviews/2026-10-30-solid-oracle-review-round-two.md) for complete intake, RED gates, GREEN, mutant variants, and bounded closure. The same review adds six ordinary/subclass-array overlap cells. Dotted writes select lengths zero, one, and two while current and retained source arrays keep length three. Core now has 36 overlap cells / 144 path histories / 432 selected cuts. The fourteen real receiving groups each run thirty cells: 420 histories and 1,260 selected cuts. Each history independently requires all twelve declared checkpoints. Post-admission mount errors are recorded and later stages retry mounting; they cannot escape the shared comparison or supply false reach. Solid adds 93 actual receiving histories to its original 85: 24 native-parent identity transitions, 33 tracked callable data/getter histories, eighteen reserved-field histories, and eighteen inherited array-method histories. All three public inputs supply their own source admission and tracked consumers. The reorder comparison now checks complete current/rendered values and every element identity. A canonical backing-node memo preserves unchanged children across ordinary/native parent changes; a read facade retains live accessors and prototype methods while native nodes/setters supply updates. Original-code, missing-node, accessor/method, and reordered-tail mutants distinguish these repairs. No output alias topology or public elapsed-time budget is imposed. The callback integration adds eight signal-driven lifetime histories to the same Solid materialization owner: callback/config inputs cross one/two array levels and ordinary/native payloads. The original 48 input histories remain. The 32 identity/lifetime histories each enforce source-only-write reach; the eight added histories also enforce query-input-change reach and compare selected values plus rebinding. Application input preparation stays tracked, while initial compilation and Collection startup run untracked. The extended pre-production campaign rejects eight native lifetime cases on integration head `fa5df11a`; all 201 owner tests and 336 Solid runtime tests then pass locally. Restoring the old hook fails the source-only subscription comparison. Untracking query construction too fails all eight new signal-result comparisons. Existing comparisons and budgets remain. The [integration amendment](oracle-reviews/callback-metadata.md#solid-binding-lifetime-at-compilation-2026-11-02) records commands, runner differences, exact evidence, and limits. These finite settled-host cuts establish neither native-source-only value liveness nor other frameworks' dependency tracking. The local-only draft driver does not claim top-level symbol-write admission. Its shared preservation comparison still checks every field actually admitted, including nested symbols and all actual mutation originals. The proxy-revert owner excludes top-level symbol writes explicitly; **Drafts and native values** and [#1820](https://github.com/TanStack/db/issues/1820) own that support decision. The minimal trace assigns a fresh enumerable root symbol and nested symbol through `Collection.update`: the root is absent from the modified/source row, the nested symbol survives. Current and clean-main traces agree. Initial data admits both. No adapter or Core-selection claim extends through this missing source premise. Limits: the stated finite histories and real hosts' settled/held-handler cuts. Core normalization, arbitrary cycles, arbitrary getter/setter bodies, hidden symbols, all descriptor-visibility notification combinations, callback atomicity, other settlement schedules, and real browser rendering are not established. Core may evaluate root getters before the adapter receives them. The live getter claim covers nested accessors actually admitted to Solid. Cycle policy remains a separate maintainer decision, as explicitly requested. Existing framework, includes, and optimistic-history owners retain other responsibilities. The **Drafts and native values** owner retains an unresolved Core boundary: assigning a native Solid store through `Collection.update` can promote hidden host bookkeeping symbols during Core detachment. Support policy for that host-proxy assignment needs a maintainer decision before classification as a product-law violation. The needed receiving witness is actual `createStore` into `Collection.update`, distinguishing user keys from wrapper metadata in stored and retained values. Local-only histories use ordinary replacements after initial admission. Controlled sync histories admit native stores on every update and cover direct adapter input. ### Distinct collision review extension (2026-10-30) The existing distinct incrementalization owner now also generates four unequal native-collision members and an anchor, with independently varying unselected payloads. Its wider receiving driver is `packages/db-ivm/tests/distinct-representative-oracle.property.test.ts`. The full-row accumulated relation must have one positive unit representative per supported selected identity and no negative residue. Representative choice is unspecified. Atomic and unit-split deliveries each run fixed/random 100-history campaigns. Declared reaches are unequal unselected payloads, three colliding members, a later collision after removal, and empty output after unequal payloads. A last-input retraction mutant and a reused negative-key mutant fail the wider check while passing the prior two-member owner. `includes-oracle.property.test.ts` extends its existing full-tree recompute owner with colliding numeric-group route strings and the shared distinct support history grammar. Inline arrays and Collection facades each run fixed/random 100-history campaigns and compare public rows after each applied source transaction. The original operator fails Collection facade membership at checkpoint 2. Inline arrays pass: `createActiveBuckets` is used only for Collection-valued includes. This is a receiving witness for route coexistence, shared support, partial/last removal and reactivation, not a claim about every facade lifecycle observation. Four-member buckets are exercised at D2; the public includes witness has two colliding routes and one anchor. Neither production path claims mutable values, arbitrary payload kinds, framework scheduling or intermediate source-transaction publication cuts. Implicit distinct keys across separate builds remain unspecified (maintainer decision in the 2026-10-30 review); applications needing stable keys supply `getKey`. The existing top-level ordered/unordered receiving campaigns remain at their original budgets. See the append-only [review evidence](oracle-reviews/2026-10-30-distinct-collisions.md). A separate reachable Index defect remains open under the **D2 Index storage** owner (`index-refinement-oracle.property.test.ts`), whose current grammar omits structural payloads. With module hash initialization `Math.random = () => 0.5`, let `a = { id: 'item-51277', value: 51277 }` and `b = { id: 'item-90754', value: 90754 }`; both hash to `2650141082`. `index.addValue('k', [a, 1]); index.addValue('k', [b, 1])` returns only `[[b, 2]]`, whereas structural multiset identity requires `[[a, 1], [b, 1]]`. The direct `reduce(values => values)` path has the same wrong result. Direct `distinct(([, row]) => row)` on these rows preserves both, and does not use Index, so moving the distinct repair into Index cannot replace it. This is a sibling storage-boundary defect, outside this PR's distinct operator repair, not a regression excused by its age. The Index owner needs a structural collision dimension, per-addition multiplicity checks, storage repair, and reduce/join receiving witnesses before claiming collision-safe Index storage. The existing groupBy structural-identity bypass also means that repairing Index alone is not evidence for every groupBy path; #2192 remains open. ### Distinct provenance and fresh-identity challenge (2026-10-30) The wider distinct owner now realizes a fresh equal selection on every selector call, and owns separate scalar copies of source rows. Each atomic/split, fixed/random 100-history campaign declares and reaches **fresh equal selections** in 100 histories, alongside its four earlier reaches. This rejects a reference-only matcher that the earlier shared-reference driver accepted. The shared full-row checker also requires every retained representative's (member, variant) payload to have appeared in a positive input. It rejects fabricated unselected payloads without choosing first/last or requiring the representative's source slot to remain live. A permanent wrong-observation calibration protects that assertion. This is historical input provenance; it does not establish representative freshness across a zero-support boundary. Both motivating mutants passed all five earlier wider-owner tests and now fail at the contribution comparison. The four-member immutable selection domain, public receiving paths and transaction checkpoints retain their previous limits. Rich value-identity receiving histories through distinct (functions, opaque references, binary, RegExp, Map/Set and special primitives) remain a useful extension: the hash identity oracle owns those semantic distinctions, but its helper-level evidence does not by itself exercise distinct storage. The separate Index structural-collision obligation above remains open. See the appended [review evidence](oracle-reviews/2026-10-30-distinct-collisions.md). ### React Suspense initial-view lifecycle [The lifecycle oracle](../../packages/react-db/tests/suspense-lifecycle-oracle.test.tsx) owns the React boundary observation of current initial-view obligations. Its small model keeps only the current obligation, public pending/ready/error view, rows, boundary cause policy, and stopped-source health. It has no retry cache, observer, or source lifecycle implementation. Authority is the error-handling guide's Suspense contract, hook JSDoc, the shared conformance contract's retry progress and exclusive output laws, and the established cleanup/request recovery contract examples. Fixed and fresh campaigns generate source fail/crash/abandon, pending rerenders, boundary reset/root remount, retired rejection, successful peers, and source failure after readiness. Derived/keyed queries run without a client, with a provider, and with an explicit client. Supplied Collections receive query-only preload rejection before/after cleanup without a client or under a provider. After a late rejection, a forced render checks the replacement while it remains pending; readiness cannot hide a stale wrapper error. Four legal client request schedules cover observed failure, replacement in the old promise's rejection reaction, cleanup before rejection, and switching clients. A pending client record deduplicates work, so registration while it remains pending is not modeled as replacement. The co-mounted sibling grammar places both hooks before their first successful commit. Shared/separate boundaries, equal/different queries, staggered/same-pass readiness, and ready/lagging source Collections cross every client/key mode. The staggered path drains only the selected query's acquisitions until its hook returns successfully. The peer's hook has not returned and its demand stays held. Shared-boundary histories also require that neither layout effect commits. Each receiving mode declares this successful-candidate state separately from source-release ordering. Each generated family guarantees the reported shared-boundary shape. Every successful layout commit checks distinct output Collections. After both commit, a held private startup crosses a peer page move and an unchanged-input render; the copied ready rows stay on their own page until private startup settles. Render-time retry-cache eviction, an effect-only ownership fix, and copying a peer's moving rows all fail this receiver. These are finite React 19/jsdom histories with controlled on-demand requests, not arbitrary scheduler coverage. Copied ready rows do not establish the private output's initial-query readiness. The sibling grammar also rejects its held first acquisition before or after a peer page move, with Error, record and undefined provider causes. Each client/key mode declares and measures both rejection schedules. The existing initial-view model distinguishes a provisional seed from owned readiness: a first-load error ends the seed and reaches the real React ErrorBoundary; a source failure after owned readiness keeps data and appears in health. This receives the observer hydration owner's failure-ending-seed law. It reads the private Collection's public normalized failure as input and checks the boundary's cause; it does not reimplement core's provider-error normalization. Both the original hidden error and a repair that clears the seed without resetting readiness fail this receiver. The first error comparison runs before any application rerender, with declared reach before and after the peer move. A later reread checks the same error again. Suppressing only the private initial-error notification fails the first comparison; a forced host reread cannot supply the missing notification. The sibling grammar also discards candidates after their hook returns and lets a peer commit first under a separate boundary. The mounted replacement receiver admits a peer's pending target plan before the mounted binding changes to it, and crosses before/after-hook holds. Both receivers compare progress, exclusive outputs and subsequent retained page moves. Diagnostic acquisition counts expose finite retry work; no exact request budget or retention of uncommitted Collections is promised. While private startup remains held, source report/recovery histories compare committed health before and after a peer page move without a host rerender. A peer's page-request rejection then crosses an unchanged-input read. Its query-local problem must not appear on the seeded output or the unchanged source. The seed takes health from its own observer. Restoring peer health copying fails request isolation; freezing seed health fails source notification. These are query-local and source-health receiving laws, not provider transport or garbage-collection claims. Each receiving campaign declares reach and replays fixed examples through the same model/checker. Five hostile mutations fail at retry progress, successful peer ownership, replacement pending, restart pending, and late preload rejection. These laws previously depended on ordinary fixed recovery tests; the generated owner adds adjacent histories and direct seed/path replay. The core source-health and observer owners retain their status, health-tree, and transport contracts; the page owner retains page mutation and peer isolation. Limits: finite one-source queries, real React boundaries in jsdom, controlled subset work and a public query-preload seam. This does not establish native hydration, provider behavior, React 18 scheduling, arbitrary concurrent rendering, exact GC timing, or delayed failure-retirement timers. Error message text remains with the existing supplied query boundary examples; this owner checks Error identity or wrapped cause. The [review record](oracle-reviews/2026-11-03-client-suspense-page-ownership.md) contains per-mode reach, calibration, replay and grammar accounting. ### Adapter-owned page windows The framework owner includes [window-history-oracle.ts](../../packages/db/tests/conformance/window-history-oracle.ts), registered through the shared conformance suite in React, Preact, Vue, Solid, Angular and Svelte. Maintainer decision 2026-10-30 for #2291: changing only `.limit()`/`.offset()` moves the existing outer window; it adds no hook option. The independent sort/filter/slice model checks ordered selected rows and keyed-map values after each framework flush, Collection retention for page moves, replacement for source/filter/order/projection/nested-window changes, and retained upstream ownership. Direct and nested paths have separate reach, as do changing/stable/opaque keys where the driver supports keys. Keyed source swaps include distinct source objects under one Collection ID. Generated source updates check liveness after reuse. The bare-callback grammar also vary a Collection option together with a page change and check its applied value. The pending grammar observes a move during initial loading, oldest settlement while the latest remains pending, initial readiness, overlapping held acquisitions, final latest rows, and unmount before settlement. The publication-callback grammar changes offset, limit or both from a public change callback, then checks the retained Collection after the host settles. It controls demand settlement over already installed source rows; the core pagination owner continues to own source delivery, failures and ordered repair. The [React receiving witness](../../packages/react-db/tests/window-render-oracle.test.tsx) reuses this model/checker at suspended, cancelled and committed render cuts for eager and finite on-demand sources, with derived and explicit keys. It checks the captured committed Collection and provider acquisition count while a render is abandoned. The [Preact receiving witness](../../packages/preact-db/tests/window-render-oracle.test.tsx) checks an aborted render under a real error boundary while a public subscription keeps the committed Collection active. Its 12 `oracleProperty` registrations preserve eager/on-demand sources, derived/keyed identity and offset/limit/combined moves. Each keeps the fixed regression, fixed campaign seed 2291 and six generated histories per campaign. A construction retains the generated page parameters because every legal history commits one move and rejects the next; each declared state reached seven non-fixed histories per campaign in the conversion run. The recorder snapshots ordered selected rows and public Collection identity relations before cleanup, then the unchanged shared comparison judges all three cuts. Both run separate offset-only, limit-only and combined-move campaigns with declared reach per category. These do not establish arbitrary concurrent framework schedules. The retained-work observation checks continuous upstream ownership and every public subscription-count transition during a retained move; add-before-remove replacement fails, while retired Collections may complete GC. This is not a bound on CPU time or every possible internal compilation strategy. The page law now runs through client-backed React and Svelte drivers, and React Suspense both with and without a client (maintainer decision, 2026-11-03, issue #2345). DbClient is a driver mode, not a React exception; future client-backed adapters register the same histories and comparisons. Each mode receives direct/nested, applicable keyed/derived, pending, publication-callback, changed-plan and source-write histories. Every adapter also runs the independent-peer histories: equal queries yield distinct outputs; declarative and imperative moves preserve the peer page; source writes update both; retiring one leaves its peer usable. Before initial Suspense readiness, the pending comparison observes the actual fallback and absence of a successful result. It starts retention comparisons at the first successful return. The React render receiver crosses ordinary/Suspense hooks, provider/explicit-client/descriptor inputs, eager/on-demand sources, derived/keyed identities, and offset/limit/combined moves. A separate receiving schedule in that same file blocks a mounted replacement before its hook while a peer finishes the same preload, then resumes it. Its rows and identity use the shared page comparison; a missing exclusive-ownership check fails after the peer has rendered first. The [client page receiver](../../packages/react-db/tests/client-window-oracle.test.tsx) checks JSON-transported server preloads at the first browser hook render, a move before local readiness, local handoff, peer isolation, return to the first page, and replacement on a client switch over the same concrete source. Keyed preload identity includes the outer page. This receiver does not run hydrateRoot or a real Electric provider. Suspense retry work may remain unclaimed across discarded renders, but a successful binding takes exclusive ownership; returned query Collections are never shared implicitly. Supplied Collections, opaque-plan optimization, queries without an outer limit and findOne retain their existing contracts; no transported snapshot is retargeted. The generated retention guarantee covers finite bounds. An explicit Infinity limit can also move to a finite target under the resolver guard, but this evidence does not establish that additional domain or promise replacement outside the finite domain. The existing identity, deferred-acquisition, window-controller and includes owners remain authoritative for their neighboring laws. The React client page receiver also crosses the held-seed history with a speculative offset-only, limit-only, or combined move and cancellation. Each keyed/derived × ordinary/Suspense × provider/explicit-client campaign proves React ran the post-hook suspension, checks the original committed seed while suspended, then checks data, keyed state and Collection identity after the original page renders again. Local readiness remains held through both cuts. This distinguishes a wrong observer transport identity that correct local rows would conceal. All 48 fixed/fresh campaigns reject the original render-time observer mutation. The source remains a controlled finite Collection; native hydration and arbitrary React schedules remain outside this receiver. The mounted replacement/borrower receiver also generates both co-ready and borrower-first schedules. It moves the borrower after the original compiler retries, then moves the original binding and checks both pages. Reusing the compiler's resolver token fails borrower Collection retention. This adds the next-use direction the earlier receiver omitted; the initial successful Collections remain distinct in the reviewed implementation's co-ready lane. Before the original binding moves, every mode also checks its unchanged rows, keyed state and previously captured Collection's rows. Both bindings' keyed state is checked after each move. A wrong original page cannot disappear behind the original binding's next action before it is observed. Svelte client recovery histories cross a committed declarative move, an imperative move, a throwing key getter, repeated public rejection, the throwing native pre-effect, and recovery. Equal keys retain the authored input and its imperative page despite changed body/dependency proposals; changed keys admit the new plan. The existing independent window judgment compares data, keyed state and Collection retention after native settlement. Removing stable-key retention fails this receiver. This does not add disabled config fields to the typed API or promise in-place key mutation. The shared owner also crosses initially disabled inputs with stable keys through real ordinary React, Preact and client-backed Svelte bindings. A disabled input admits no plan; first enablement admits one, an enabled unchanged key retains it, and a changed key admits the changed plan. This distinguishes the enablement fix from deleting stable-key retention. Suspense has no disabled-input overload and does not receive this lane. The [Svelte client page receiver](../../packages/svelte-db/tests/client-window-oracle.svelte.test.ts) and React client receiver share [transported-page histories](../../packages/db/tests/conformance/client-window-history-oracle.ts) and the existing window judgment. Every keyed/derived receiving campaign mounts one or two fresh old-page readers after a move while local readiness is held. It compares their first seed and distinct Collection, then the moved binding and existing peer through local handoff and return. Svelte uses rune construction, native `flushSync` for held-readiness page changes, and a bounded settled cut for the asynchronous observer handoff; it does not claim native `hydrate`. React's client-switch subhistory now actually executes ordinary/Suspense × keyed/derived hooks, replacing its Collection for both same-page and moved-page switches through explicit clients. Those per-mode results are later evidence, not retroactive credit for the original pre-edit gate's ordinary unkeyed switch. Both transported-page receivers compare the existing peer's keyed state at every peer row comparison. Each receiving mode declares separate reach while the seed is held and after local handoff. A wrong keyed map fails even when the peer's data array and Collection identity remain correct. The ready-output/subset-settlement handoff found by this receiving extension is owned by the existing [observer hydration oracle](../../packages/db/tests/live-query-observer-hydration-oracle.property.test.ts). Its new fixed/fresh grammar holds subset work on a ready Collection before seeded observer attachment, then settles it without any row or status change. Both granular and wholesale consumers must keep the seed while held, then observe and receive the local snapshot, including empty local rows. The original missing subset notification and a premature handoff each fail their intended comparison. The Svelte page receiver supplies the same premise through retained live-query Collections. These controlled histories do not establish arbitrary provider schedules. The same shared window owner enforces immutable explicit-key values (maintainer decision, 2026-11-03). React, React DbClient, ordinary/client Suspense, Preact and Svelte DbClient receive equal-key retention and changed-key admission histories. Each fixed/fresh campaign declares separate reach for the same key object, a fresh outer array, fresh equal nested values, reordered record properties, independent record/array leaf replacements, equality after replacement and a return to an earlier key. Ordered data, keyed state and Collection identity are compared after native host settlement. Keys are frozen plain records/arrays with JSON scalar leaves. In-place mutation is unsupported; its behavior is unconstrained. Rich native keys, speculative cuts and transported seeds remain outside this lane. Reactive bindings that compare no query identity retain their reactive input contract. Future identity-comparing adapters register the same key histories through `mountKeyedControllable`. Evidence, per-path reach counts, reviewer reconciliation and mutation outcomes are recorded in [the page-window review](oracle-reviews/2026-10-30-adapter-page-windows.md) and the [client/Suspense extension](oracle-reviews/2026-11-03-client-suspense-page-ownership.md). The [fresh independent review](oracle-reviews/2026-10-30-adapter-page-windows-round-2.md) records observation and failure-fidelity repairs. Shared and receiving campaigns preserve the first violated law, checkpoint and input trace through shrinking. Later action and cleanup failures remain distinguishable; non-reproducing shrink candidates supply no successful product evidence. The original late-coverage process gap remains documented. The existing [top-K support-window owner](../../packages/db-ivm/tests/operators/topk-support-window-oracle.test.ts) also has a numeric-window grammar for safe-integer maximum offsets and widths, exact omitted-bound inheritance on partial moves, and required demand messages when installed ranges are empty. It permits additional messages. It observes one-group settled operator rows, size and demand signals; real framework source growth belongs to the shared receiving owner above. [Numeric evidence](oracle-reviews/2026-10-30-topk-numeric-windows.md) records RED, GREEN, reach, replay and mutants. ### Projection and negative-window gaps from removal review (2026-11-02) The shared framework owner now includes [result-shape-oracle.ts](../../packages/db/tests/conformance/result-shape-oracle.ts). One independent authored-source model and generated grammar run through React (both registrations), Preact, Vue, Solid, Svelte and Angular. List/findOne transitions, repeated modes, return transitions, empty/single/multiple source rows and both data-first/Collection-first reads are checked at each driver's native parameter cut, then after settlement. Finite singleton queries retain identical offset/limit across projection changes, including positive offsets. Native cuts require raw shape; settled cuts also compare selected values and keyed state. It is one `oracleProperty` definition, registered by each framework's conformance suite with that framework's driver as `framework..result-shape`; two constructed histories enter its twelve required states on every production path, the former fixed examples are fixed histories, and the previous-mode projection and stale rows are calibrations. Reintroducing the Angular defect below fails 32 of its tests, each at law `current query projection`. This does not promise synchronous row freshness or identical host scheduling. Disabled inputs, errors, supplied Collections, DbClient and broad host/AOT behavior remain outside this grammar. **Repaired receiving defect:** Angular previously returned the old query's raw projection at its synchronous Signal read before effects. Both directions failed even though the new input reached the callback and later settlement passed. It now reprojects captured rows through the current query while keeping the normal snapshot path and pooled-query laziness. All six frameworks complete their fixed/random campaigns; restoring the defect fails the native comparison. Generated guarded replay seed 2316, property `framework.angular.result-shape`, path `28` reproduces the defect; finite paths `1` and `25` preserve nonempty offset-0/offset-1 evidence. The existing top-K support-window owner adds a negative-offset grammar through direct array top-K, one-group top-K and public orderBy. Under the maintainer's 2026-11-02 absolute-rank decision, nonnegative widths select the installed ranks in `[offset, offset + limit)`, including intervals crossing zero. Generated histories reach wholly negative/zero-width/crossing-zero windows, negative source edits, partial moves, nonnegative returns and offsets below negative cardinality. Signed rows, order, values, multiplicity and size remain observed. The direct and orderBy size getters also count with an always-true predicate, which must equal the selected row count. Negative widths, fractional bounds, multiple groups, varying prefix predicates and downstream acquisition remain outside this grammar; existing support/numeric budgets and their prior evidence remain unchanged. The negative-width question has a maintainer decision (2026-11-02): public `.limit(negative)` and `utils.setWindow({ limit: negative })` must throw synchronously before changing the authored query or live window. The pagination owner's [limit admission companion](../../packages/db/tests/query/limit-admission-oracle.ts) checks that sign law, the documented RangeError class, and unchanged rows, bounds, status, request errors, publications, acquisitions, releases, aborts and prior operation outcome. Each generated history exercises limit-only and combined moves before startup, after readiness, during initial loading, during an unfinished move and during source replay; builder construction is a separate path. Rejected operations are followed by partial valid moves and source updates. Valid zero, -0, positive integer, Infinity and negative-offset neighbors use independent rank selection; every pending candidate has its own held fixture. The settlement recorder follows the admitted operation to fulfillment or rejection and compares its exact error at a named checkpoint. Each generated move-pending negative history also crosses successful and failed acquisitions; failure must retain the previous window and rows before a partial retry. Every pending campaign reaches successful settlement in 21 histories, and both negative move campaigns reach failed settlement in 21. A one-second diagnostic budget detects stalled controlled work without imposing a one-task product cut. Request-generation corruption fails the settlement comparison; corruption of the rollback window after a failed acquisition fails the partial-next-use check. This is a public admission contract for ordinary ordered list queries, not a negative-width result law for raw IVM operators. The original counterexample remains: `TopKArray(5, -2)`, installed values 0/4/6/8/10, then insertion of 2, emits moveIn 10/moveOut 6 while reporting size 0. It remains outside the raw operator's supported nonnegative-width law. NaN, positive fractional widths, raw authored IR, framework error timing and provider delivery are outside the new admission evidence. Existing findOne, order and reentrancy error precedence remains separate. All 24 fixed/random admission campaigns reach every declared state in 21 histories each; unchanged production fails all six negative receivers, and eight mutant mutations fail the intended comparisons. See the [admission evidence](oracle-reviews/2026-11-02-negative-limit-admission.md). **Repaired operator defects:** negative-window rows, size, source edits and return moves now agree with absolute ranks on all three paths. Each path's fixed/random campaign reaches all eight declared states in 101 histories (one example and 100 generated). Restoring relative slicing, the old size rule or the old leading-count start separately fails the corresponding observation. Each property `ivm.topk-negative-window-array`, `ivm.topk-negative-window-grouped` and `ivm.topk-negative-window-orderBy` has a guarded generated RED on the original code at seed 2316, path `1`, and a GREEN on the repair. This closes the recorded negative-window defects within the declared grammar, D2 paths and graph-drain cuts. Exact original/reduced traces, declared reach, receiving cuts, calibrations and independent review outcomes are in the [oracle extension record](oracle-reviews/2026-11-02-removal-oracle-gaps.md). Its [production repair entry](oracle-reviews/2026-11-02-removal-oracle-gaps.md#production-repairs-2026-11-02) records completed GREEN reach, isolated mutants and the rejected intermediate Angular pooling regression. The earlier page-window oracle-first qualification remains unchanged. **Open test-mechanics gap from the repair run:** the guarded replay owner (`packages/db/tests/oracle-replay.test.ts`, Small structures and test mechanics) does not enforce singleton execution for a successful shrink-chain path. With seed 2316 on the repaired code, `framework.angular.result-shape` at `28:0:0:0:0:0:0` reports one registration but two histories, and each `ivm.topk-negative-window-*` at `1:0:0:0` reports one registration but eight histories, although `randomParameters` requests `numRuns: 1`. Original one-segment paths and failing shrink paths report one history. Add a generated passing shrink-path receiving witness and constrain continuation before claiming one-history replay for that case. These extra GREEN executions are recorded accurately in the repair entry and are not used as singleton product evidence. ## Loading sibling replay and final catch-up reach (2026-10-30) The primary load-subset replay owner now constructs 48 finite histories where an include with no demand at truncate starts under its sibling's loading replay. It measures held failure (44 histories), failure retirement (33), and later own coverage (12), through the existing public retention and recovery comparisons. The original guard fails the quiet retention check. Subscription-scoped verdict and successful-coverage calibrations remain in that primary owner. The browser multi-tab Electric owner preserves its stop prefix and arbitrary tail and constructs an abandoned reservation immediately before final catch-up. This removes dependence on sampling that boundary without changing its model, 80-run budgets, comparisons or reach minima. See [the versioned experiment record](oracle-reviews/2026-10-30-release-replay-retention.md) for authority, RED, reach, mutant, grammar controls, historical gate limits and receiving-path limits. This is core Collection publication evidence and a Node SQLite/coordinator receiving witness with controlled Electric streams. It does not claim Effect, provider, framework, deeper include, or browser-process closure. ### Subscription-scoped request-error assertion (2026-10-30) The primary load-subset replay owner now retains subscription identity in its later-request and successful-coverage account. A sibling requesting overlapping source keys cannot exempt the failed demand's public health error. Its existing 96-history sibling-success grammar measures the actual owed-error assertion in four histories, alongside four successful-sibling-coverage histories. A targeted omitted-error observation passes the former source-wide account and fails the scoped health comparison. All existing comparisons, histories, budgets and reach minima remain. The controlled core, one-level include and peer limits remain those of this owner; no provider or framework claim follows. See the [versioned repair record](oracle-reviews/2026-10-30-release-replay-retention.md#subscription-scoped-request-error-checker-repair). ### First-demand admission and terminal regimes (2026-11-02) The load-subset replay owner adds 48 finite histories crossing sibling/include settlement order, direction, width, failure/success and a waiting window. A new parent remains eligible after sibling success. Before admission repair, all 48 fail the existing public-retention comparison. The repaired driver measures 24 late active include settlements and 12 retries while a sibling loads, directly from adapter receipts. The original sibling grammar's receipt reaches are now 44 failures, 9 same-truncate failed-demand unloads during commands and 12 own recoveries; its earlier model-derived retirement count 33 is historical. All existing semantic comparisons and required minima stay. The original-admission mutant fails retention. The earliest-error comparison was corrected from source-wide failure order to subscription-owned verdicts. Authority is the pre-existing maintainer decision in ARCHITECTURE **Atomic window publication**: a move rejects with *that replay's own* earliest still-deciding failure. Shared publication does not merge verdicts. This is an explicit account of the correction, not a claim that the assertion was unchanged. There is no source-wide race winner promise. The same-subscription latest-error mutant fails; the actual public owed-error check also rejects an error omitted after sibling coverage. Moves that resume into a different failed replay retain the owner's stated limit. A failed move is not promised success merely because a later retry recovers its demand. The multi-tab Electric owner now generates untouched arbitrary, reset-abandoned and stopped-source endings. Existing final comparisons, 80-run budgets, known gaps and minima stay; new reach separately measures final stopped-source restart and lagging-row rewrite. Old grammar reach was 0/46, so only the first was absent. Final-restart and final-commit omissions fail the real SQLite/coordinator public comparisons. These are Node-host controlled-stream receiving histories, not real provider or browser-process claims. The core and browser path limits are unchanged. See the [nine-item review amendment](oracle-reviews/2026-10-30-release-replay-retention.md#first-demand-admission-and-terminal-grammar-review-2026-11-02). ### Final-catch-up provenance and deferred sibling resumption (2026-11-02) The multi-tab Electric owner now separates durable/server divergence from an actual older same-key commit overwriting a newer peer commit. The old fixed campaign measured 58 divergence repairs, of which 57 lacked that overwrite premise and one had it (81 initiated/80 accepted histories). Earlier final "lagging rewrite" counts are historical divergence evidence. A fourth terminal regime constructs the actual overwrite. Original arbitrary/reset/stop regimes, 24-step prefix, 8–24-step arbitrary tail, models, comparisons, known limits, 80-run budgets and minima remain. New lagging suffix length is 12/15 for two/three tabs. Final commit omission fails the ordinary durable/public comparison. The deferred-acquisition owner adds 32 finite histories over a real same-source LEFT self-join, crossing subscriber/preload, one/two rows, literal/Promise acquisitions, and settlement order. Every history requires an actual deferred joined demand, checks zero acquisitions before its own reader, and checks readiness and independently projected rows after successful coverage. Existing production passes; retaining the parked participant makes all 32 fail readiness. No production cycle was confirmed. Both full owners pass 540 tests. Browser fixed/random actual overwrite reaches are repair 25/18 and callback 25/25. These boundaries retain their controlled core and Node-host SQLite/Electric limits. No HTTP, framework, browser-process, or arbitrary-shape closure follows. See the [versioned amendment](oracle-reviews/2026-10-30-release-replay-retention.md#final-catch-up-provenance-and-deferred-sibling-resumption-review-2026-11-02). ## Adapter conformance: persisted startup (#2367) The [shared persistence owner](../../packages/db-adapter-conformance/tests/persisted-startup-oracle.ts) judges complete source replacement across persisted restore. A collection-wide source replaces every row. A scoped source removes only its old ownership; an omitted row with a surviving peer stays. Authority: READY-3/PUB-7, the Query complete-result and scope-local omission contract, and persistence's durable acceptance contract. The maintainer selected this shared owner on 2026-11-09. The independent set model has no Query cache, source diff, or restore algorithm. [Query](../../packages/query-db-collection/tests/persisted-startup-conformance-oracle.test.ts), [Convex](../../packages/convex-db-collection/tests/persisted-startup-conformance-oracle.property.test.ts), [Electric](../../packages/electric-db-collection/tests/persisted-startup-conformance-oracle.property.test.ts), [TrailBase](../../packages/trailbase-db-collection/tests/persisted-startup-conformance-oracle.property.test.ts), [RxDB](../../packages/rxdb-db-collection/tests/persisted-startup-conformance-oracle.property.test.ts) and [PowerSync](../../packages/powersync-db-collection/tests/persisted-startup-conformance-oracle.property.test.ts) supply receiving paths. Query uses QueryClient; Convex uses its SDK and a controlled socket; Electric uses ShapeStream and controlled HTTP responses; TrailBase uses a controlled RecordApi and native stream; RxDB uses real memory storage; PowerSync uses real local SQLite through its Node and browser SDKs. Each uses the same [composition driver](../../packages/db-adapter-conformance/tests/persisted-startup-driver.ts), judgment, controlled storage, and real Node SQLite hosts. Per host, fixed and random campaigns each run 80 generated histories with separate enforced reach. Histories cross empty and nonempty prior subsets of three keys, any next subset weighted toward empty, changed overlap values, and response before/after persisted restore. A generated initial-render axis enables network-first and crosses source responses before the deadline with a source held past it. Every adapter, host and generated campaign enforces separate reach for both enabled paths. Query additionally crosses peer ownership and five response origins: fetch, initialData/cache with fetching disabled or held pending. Already available results precede restore; fetched and push results exercise both orders. With network-first fallback, the shared comparisons check saved public and durable rows after preload while the source is still held. After delivery, the source's `markReady()` and applied receipts identify its first complete result. Other histories retain the immediate post-preload comparison. Public and durable rows are checked before refresh can repair storage, then public rows inside refresh fulfillment, durable rows afterward, and rows after a local-only reopen. Scoped Query snapshots also check exact ownership at all four snapshot cuts. Startup checks the reload owner's one-full-row-read law before its own durable observation. Query's receiving driver preserves exact fetch-count and pending-fetch premises. The [Chromium OPFS receiver](../../packages/browser-db-sqlite-persistence/e2e/persisted-startup-conformance-oracle.opfs.spec.ts) runs 116 Query histories, 104 PowerSync histories, 32 RxDB histories and 26 complete-result histories for each of Convex, Electric and TrailBase through the same composition and check on real worker/OPFS. It repeats in the same browser profile, with file cleanup and separately enforced reach for network-first result/fallback, empty result/baseline, overlap, omission, mutation, and Query peers/ownerless baselines. Identical normalized histories are deduplicated; empty-baseline mutations still hold publication and remain distinct. Query crosses source-owned and ownerless saved provenance. Peer-only overlaps exercise every initial/cache origin. At fallback, ownerless rows retain their original absent source ownership. Complete results remove omitted ownerless rows and apply returned values even when a peer previously supplied the row. The independent [capability-admission owner](../../packages/db-adapter-conformance/tests/persisted-capability-oracle.ts) checks the cross-package SyncMetadataApi protocol. It enumerates nine required members with missing and false-valued corruptions, a missing capability field, and three legal forms (complete, explicit null, absent optional API). Real RxDB and PowerSync receive all 22 histories on controlled, Node SQLite and Chromium OPFS hosts. It checks invocation errors before source delivery and completes source startup for legal forms. It does not claim optional extension faults, on-demand acquisition results, or arbitrary malformed values. The shared startup calibration now fails on a bad clean candidate, counts injected persistence loss, and wraps hydration-scoped writes. RxDB/PowerSync must reach that scoped fault before restore release on real SQLite. See the [re-review evidence](oracle-reviews/2026-11-10-pr-2394-rereview.md). The original Query omission fails startup on both Node hosts and OPFS. Convex without its first-result truncate, a survivor in the bare eager-source grammar, now fails the same comparison on all three hosts. Current Convex passes; this migration confirms no new Convex defect. Electric also passes unchanged. The expanded network-first grammar passes on unchanged production across both Node hosts and OPFS. Per-adapter/host mutants that drop source persistence after fallback fail at `startupDurable`, before a refresh. Fallback checker controls also reject lost saved rows. The one-full-row-read law excludes only the observer's own durable reads. The receiving campaigns expose startup violations in RxDB, PowerSync and TrailBase before production edits, on both Node hosts and real OPFS. RxDB and PowerSync now keep ordinary first-startup source commits, await hydration, then delete only restored omissions. PowerSync commits source rows and omission deletes in batches bounded by `syncBatchSize`; RxDB keeps its existing single source commit. Both preserve atomic snapshots for retained nonempty reloads. TrailBase hydrates before its complete eager-list omission sweep and retains its event fence. Query's reconciliation stays at its adapter boundary while already available cache results retain immediate materialization. The old Query-only startup model/runner and OPFS files are retired after receiving parity; Query-specific ownership laws and the unrelated direct-write/failure-fidelity repairs remain. Limits: eager startup, three string keys and numeric values, one persistence instance, one source scope plus an optional persisted peer, and a disjoint optimistic insert held across the first source commit. Its settlement precedes the first complete-result comparison. Source commits and persisted restore can both be accepted while that transaction holds their application. Arbitrary mutation contents and overlapping optimistic transactions remain outside this grammar. No on-demand window, concurrent tab writer, arbitrary metadata namespace, failed-I/O, or every intermediate-publication claim. Electric's resumed delta-only streams belong to its recovery owner; a fresh full shape supplies this family's replacement premise. TrailBase has no deployed-server or SDK-wire claim, and the local RxDB and PowerSync sources supply no remote-replication claim. See [migration status](../../packages/db-adapter-conformance/MIGRATION.md), [original evidence](oracle-reviews/2026-11-09-issue-2367.md) and the [all-adapter amendment](oracle-reviews/2026-11-10-persisted-startup-adapters.md) and [network-first evidence](oracle-reviews/2026-11-10-network-first-startup.md), and [external-review amendment](oracle-reviews/2026-11-10-pr-2394-external-review.md). The additive startup work law bounds source writes by input rows and deletes by saved omissions. It rejects snapshot replacement and truncate at first startup. PowerSync crosses B=1/B=2, source sizes below/at/above B, omissions above B, and provider IDs transformed by deserialization. RxDB crosses source pagination and omissions above its read batch. The work comparison follows the existing public/durable/reopen judgments; correct rows cannot mask excess work. Both Node campaigns enforce randomized constructed reach. The actual Chromium receiver uses the same 104/32 histories and comparison. This is no latency or total-memory threshold. See the [batching evidence](oracle-reviews/2026-11-10-persisted-startup-batching.md). The independent [hydration lifecycle owner](../../packages/db-adapter-conformance/tests/persisted-baseline-lifecycle-oracle.ts) holds the adapter's hydration continuation across cleanup, reload and terminal source failure. RxDB and PowerSync receive its public/durable, error-identity and resource-release judgments on both Node hosts and actual Chromium OPFS. An acknowledgment rejected after real application does not erase accepted work. See the [receiving evidence](oracle-reviews/2026-11-10-persisted-baseline-lifecycle.md). The primary RxDB, PowerSync and TrailBase eager campaigns now use `oracleProperty`, preserving their models, states, budgets and prior mutant kills; see the [conversion record](oracle-reviews/2026-11-10-eager-source-primary-conversions.md). The [original diff-focused gap CLI audit](oracle-reviews/2026-11-10-startup-gap-cli.md) is historical; the [current audit](oracle-reviews/2026-11-10-startup-gap-current-head.md) records subsequent classification separately from startup conformance. The ownership oracle now shares its independent direct-write overlay judgment with [persisted precedence receivers](../../packages/query-db-collection/tests/persisted-precedence-oracle.test.ts). They cross raw/derived-select responses without an inverse cache mapping, four direct-write operations, before-result and before/after captured baseline reads, early insert/upsert before persisted restore, writes before the first physical fetch, cached results without a physical fetch, and a later fetch. Each Node host runs 104 fixed histories and fixed/fresh campaigns of 80 histories; the [Chromium receiving page](../../packages/browser-db-sqlite-persistence/e2e/eager-gap-conformance-oracle.opfs.spec.ts) runs the same 104 histories and judgment. Comparisons cover the accepted write when its baseline is already public, first-result public/durable/cache state, and public/durable state at later fetch settlement. The original derived-baseline survivor (`M1733`, now `M1748`) is rejected at first-result public and durable cuts when an omitted saved row survives. See the [precedence amendment](oracle-reviews/2026-11-10-persisted-precedence-gaps.md). The [retained-scope receiver](../../packages/query-db-collection/tests/retained-scoped-hydration-oracle.test.ts) judges on-demand demand restore and scope-local omission. It crosses two disjoint exact scopes, empty/nonempty responses, an ownerless saved row in either scope, and unbounded versus one-row ordered demand. Each controlled/Node SQLite host runs 48 fixed histories plus fixed/fresh campaigns of 60. Pending public rows, first demand public/durable rows, and second demand public/durable rows share one independent set-selection judgment. Always hydrating the full baseline (`M1481`) wrongly exposes unrequested rows; broadening ownerless reconciliation (`M558/M559`) wrongly deletes saved direct rows from a limited result. The comparison rejects each at its first affected cut. The same receiver adds a cached-peer first-claim judgment: a manual cache edit or an older fetched cache cannot replace a continuously owned row established by a later physical fetch. A new physical refetch can replace it. Two fixed histories and fixed/fresh campaigns of 60 per host compare public and durable values at claim and refetch. `M1376/M1377` fail at the claim cuts. Chromium receives both shared grammars and comparisons (50 histories). Exact mutant and clean replay coordinates are retained in the [scope/provenance report](oracle-reviews/2026-11-10-retained-scoped-hydration-gaps.md). This does not establish arbitrary overlapping predicates, concurrent writers, or failed I/O behavior. The core reload/snapshot law also receives unwrapped real RxDB and PowerSync through the shared [eager-reload judgment](../../packages/db-adapter-conformance/tests/eager-reload-oracle.ts), [RxDB receiver](../../packages/rxdb-db-collection/tests/eager-reload-conformance-oracle.property.test.ts) and [PowerSync receiver](../../packages/powersync-db-collection/tests/eager-reload-conformance-oracle.property.test.ts). They cross fresh and empty/nonempty retained reload, complete empty/change/omission results, and a disjoint persisting optimistic insert. Each adapter runs 24 fixed histories plus fixed/fresh campaigns of 80; Chromium receives the same 24. Fulfillment compares one coherent permitted source projection with the required optimistic overlay; readiness can precede application while a mutation persists. After mutation settlement and applied receipts, exact source rows are required. The exact historical snapshot-predicate negations (`M9`/`M164`) now fail retained-row-to-empty-result histories. See the [reload amendment](oracle-reviews/2026-11-10-adapter-reload-gaps.md). These unwrapped histories establish no persistence or remote-replication claim. TrailBase's [primary lifecycle owner](../../packages/trailbase-db-collection/tests/lifecycle-hydration-oracle.ts) now crosses cleanup while actual persisted hydration completion is held, old list completion/rejection, and replacement runs that are loading or ready. Controlled and real Node SQLite receive 24 fixed histories plus fixed/fresh campaigns of 50 per host; Chromium receives the same 24 histories. The comparisons check public/durable replacement rows, a later event and reader/error ownership. The exact old cancellation-guard removal (`M150`, now `M151`) reaches obsolete begin attempts but preserves these observations through existing wrapper/core fences: bounded equivalence for these histories, rather than a global claim that cancellation checks are unnecessary. See the [lifecycle amendment](oracle-reviews/2026-11-10-trailbase-hydration-gap.md). Query's non-retained hydration classification and redundant-call operators remain separate from the retained precedence receiver. Their physical-read budget belongs to the reload-work owner and shared startup comparisons. The current audit records 55 observed assertion rejections after additive receiving experiments, four bounded survivors, and two timeouts across the 61 changed-line operators. Timeouts supply no behavioral rejection evidence. Startup latency/memory are measured separately in the [performance report](oracle-reviews/2026-11-10-persisted-startup-measurements.md). These additions preserve the startup comparisons and their limits above. The [framework integration record](oracle-reviews/2026-11-10-startup-framework-integration.md) and the [startup conversion record](oracle-reviews/2026-11-10-startup-property-conversion.md) track conversion of the five added/shared campaign files to `oracleProperty`, including randomized constructed histories, per-builder missing-state controls, unchanged base run budgets and direct replay. The post-conversion Chromium receiver passes all 226 added histories through the same judgments. The [Query conversion record](oracle-reviews/2026-11-10-query-oracle-property-conversion.md) preserves seven exact source-operator rejections and updated replay coordinates. The later [retention supplement](oracle-reviews/2026-11-10-startup-property-gap-retention.md) keeps the original stable mutant keys and instrument failures separate from conversion results. It records the primary Query ownership and TrailBase lifecycle/eager conversions, unchanged campaign budgets, and the no-mutation reload observation projection. That projection removes only a meaningless release-order flag when no mutation exists; every mutation-present observation and raw judgment remains unchanged. The [Query startup receivers](oracle-reviews/2026-11-10-query-startup-receiving-gaps.md) add independent first-result value/ownership and synchronous creation-return comparisons. Controlled storage, native Node SQLite and actual Chromium/OPFS receive the same direct-write grammar. It crosses distinct and overlapping saved/direct keys, independent saved/direct/source values, insert/upsert, and writes before versus after the first physical fetch starts. A retained distinct saved baseline plus a direct insert before a later changed source response exposed a stale public/durable value on all three hosts before the source repair. The repaired diff uses accepted current rows when that saved baseline has no entry. The original value defect and the historical ownership mutant M563 fail at their intended first-result comparisons on every host. Immediate nonpersisted initialData/cache receivers reject M1468/M1469 at synchronous creation return; the persisted-startup receivers do not supply that different checkpoint. The same direct receiver also validates each raw Query sync-write operation against the public `SyncConfig.write` input contract before forwarding it. Its `fetched-row-write` reach observes a row-bearing write after fetch return, independently of the operation chosen. The exact M1334 field deletion fails `sync-write` / `declared sync-write operation` on all three hosts; clean same- history replays pass. The [protocol evidence](oracle-reviews/2026-11-10-query-sync-write-protocol.md) records the source span, fixed/fresh reach, full clean suites and exact replay. This added check requires no write count/order or own property and does not claim validation of all other sync-message fields. The [rejected-write cutoff receiver](oracle-reviews/2026-11-10-query-rejected-write-cutoff-gap.md) closes M1794 through an actual Query stale callback after a rejected missing-key write, followed by a new Infinity-stale peer acquisition. The independent model requires the fetched value/owners and one physical request. The exact mutant makes two requests and fails that comparison on controlled storage, native Node SQLite and actual Chromium/OPFS. The client timer premise uses jsdom for the Node wrapper; native persistence and browser host tasks remain real. The direct receiver runs 40 histories per fixed/fresh campaign plus twelve randomized constructions, with fourteen states enforced per receiving path. The immediate receiver runs 40 plus eight constructions; the cutoff receiver runs 20 plus nine. Fixed regressions do not receive generated reach credit. Their reports preserve per-path counts, generated-only missing-state controls, primary-versus-cleanup diagnostics, source hashes and assertion-mutant evidence. The full normal Query package command passes 1,623 tests with no type errors. These finite receivers do not establish arbitrary concurrent writers, failed I/O, every intermediate publication or a whole-PR readiness verdict. Query M1473 and TrailBase M151 remain open anchored optimization-guard gaps. The former adds redundant cached hydration work; the latter allows obsolete post-cancellation scanning and begin attempts that downstream fences reject. Keep both useful guards. Neither a bounded public/durable equivalence result nor this coverage entry supplies the maintainer allowance required by AGENTS.md. The [scope omission and reacquisition receiver](../../packages/query-db-collection/tests/scope-omission-reacquisition-oracle.ts) checks the ownership owner's next-use law. A complete scoped result can remove an ownerless direct-write row. A later acquisition can then project another scope's retained successful cache response under the usual cache rules. Generated histories cross raw and derived caches, cache completion before or after the direct write, insert/upsert, omission versus inclusion, source values, and empty/nonempty scoped results. Controlled storage, Node SQLite and actual Chromium/OPFS use the same model and public/durable comparisons at deletion and reacquisition. The stale direct-position mutations M1313/M1315/M1316/M1317 fail that later public-row comparison on both Node hosts; M1313 also fails on Chromium. This is additive evidence after the [changed-callback inventory](oracle-reviews/2026-11-10-query-changed-callback-gap-audit.md), not a change to that immutable run's 24-kill/11-survivor result. It does not establish precedence among multiple cache results from before a row's lifetime. ## Adapter conformance: eager live sources (#2118) `packages/db-adapter-conformance/src/eager-live-source-oracle.ts` owns the shared eager live-source laws from the adapter conformance law set (v18): READY-2/3/4, HEALTH-1, PUB-1/2/3/7, FID-4, LIFE-2/5/10, HEALTH-5, EVID-1/2/3 (`await-evidence`), HEALTH-2 and RETRY-1 for retried failures (`retry-policy`), RECON-1 (`transport-reconnect`), RENEW-1 (`capability-renewal`), READY-8/10 with PUB-5/9 for batches committed during the initial fetch (`listen-before-fetch`), FID-1 removal of an optional field, and FID-1 typed values per declared `valueKinds` on the initial load and live changes. Its reference driver is also the generated witness for core's synced commit change detection with `-0` and `0` (maintainer decision 2026-10-29: distinct row values; `sameRowValue`). The revert owner's numeric and floating typed-array tokens now retain the zero sign in both model and observations. Its additive sign-only assignment grammar generates root, nested and Float64Array paths, with six shared examples plus 100 generated histories in each fixed/fresh campaign. In the final gate, root/nested/Float64 reach is 43/26/37 fixed and 36/33/37 fresh. A ROW-removal mutant that the old encoding accepted now fails each path's required-change assertion; the flat owner already rejected it, so this repairs a stale owner equivalence, not a current production defect. Intermediate reads, integer conversion and Collection settlement are outside this added lane. The decision covers user writes too (2026-10-29): the draft proxy (`proxy-oracle`, `flat-change-tracking-oracle`), optimistic change detection (`optimistic-history-oracle`, with a `flipZeros` edit and `zeroSignEditsOverPending` reach), subscription truncate replay (`collection-subscription-replay-oracle`), and stale-row reconciliation (`collection-subscription-lifecycle-publication-oracle`) all compare row values with signed zeros. A source insert of a held key is an equal re-insert only for an equal row value: the state-retention oracle (`collection-state.retention`) generates zeros of both signs and a write of one zero followed by an insert of the other (reach `sign-only-reinsert`, 92 histories over its fixed and random campaigns); the deep-equality check accepted such an insert as an equal re-insert instead of throwing `DuplicateKeySyncError` (RED at `[update {0: 0}, insert {0: -0}]`). An ordered live query (`orderBy`, with or without `limit`) dropped a source update that changes only a zero's sign: its top-K batch merged a key's versions by D2 value identity, where -0 equals 0, while an unordered query delivered it. Maintainer decision 2026-11-02: live-query rows tell -0 from 0, so top-K compares a key's versions as row values (D2's structural comparison with `signedZero`, which tells -0 from 0 at a leaf); D2 value identity, which join, distinct, and grouping keys use, keeps -0 equal to 0. The Effect-callback oracle's `source-zero` representation stores the signed zero in the source row, so each update changes the row only by its sign (RED: all 10 ordered `source-zero` histories in the core and React drivers; unordered ones passed), and the top-K batch contract oracle's `signed zero` and nested relations now expect a replacement. Open: generated publication histories never write over a row a failed replay retained (the random grammar inserts source writes into green lifecycle histories), so the stale reconcile is reached only by pinned replays, including a `-0` one. A generated failed-replay history reached an open counterexample: after a failed, released replay, a write equal to the committed row leaves the subscriber at its older retained value while a direct read returns the new one, against the law that a subscriber equals a direct read. That contradicts ARCHITECTURE.md law 9's retention rule, so the generator is held back until the replay-convergence law is settled with #2294 (owner: the lifecycle publication oracle; witness needed: a generated failed-replay history; shrunk trace: source `a`=0, request, settle resolve, truncate, source `a`=5, settle reject, release, source `a`=5). Every driver is also checked for the rows at the moment status becomes `ready`. Its model is an independent row Map and sync-run phase; drivers supply only a controlled provider and declare whether they commit per batch or per change. PUB-1 checks every change publication during a step, not only the settled checkpoint. The reference push adapter (`tests/reference-adapter-oracle.property.test.ts`, `adapter-conformance.eager-live-source.reference`) runs fixed and random campaigns of 600 histories with declared reach, a per-change variant, an outage-threshold variant with client-created values, and ORC-004 reconstruction, exclusion, and ablation controls. The ordinary `tests/reference-adapter-calibration.test.ts` retains all 48 original hostile searches: seed 2118, a ceiling of 600 histories each, exact whole-law string or RegExp predicates, and each original driver configuration. Native property calibrations are supplemental; the fixed prompt-restart comparison remains. All eager live-source receivers register through `oracleProperty`: reference, RxDB, Electric, Convex, PowerSync, TrailBase, and the separately run Neon baseline. Their original fixed seed, run budgets, and shared comparisons stay. Electric's no-on-error path and Convex's React and wrapped-client paths also have named fixed/fresh campaigns and replay routes. Each declared state has five constructed histories with generated rows and suffixes inside the same capability-dependent language. The shared comparison checks every generated construction's declared states against independently recorded entries, including constructions absent from the pinned framework's seeded-example association. Date and `Float64Array` history values use tagged data until resolution; the shared model and strict comparison still receive native values. Named verdicts keep the original conformance law and step checkpoint. The Neon Realtime receiving driver (`adapter-conformance.eager-live-source.neon-realtime`, `test:neon`) runs `@neon/realtime-tanstack` 0.1.1 vendored at neon-pkgs `7ac55e3e` and is RED on READY-4 and HEALTH-1 until that adapter moves to `fail()`; probes show LIFE-10 (subscription kept open after an error state) behind them. Limits: no on-demand loading, mutation handlers, or reload; publications are observed through `subscribeChanges` only; EVID-3 does not distinguish a timed wait that rejects before its timeout; FID-1 covers eleven value kinds (with `Float64Array`), not Temporal, Map, Set, other typed arrays, class instances, or field identity; PUB-4 covers a complete delivery with two rows for one key, under each driver's `duplicateInsert` (TrailBase `replace`, reference `error`), not malformed keys, undecodable rows, or FID-3 out-of-domain values; the Neon and TrailBase claims cover controlled providers, not real clients. Owner: `packages/db-adapter-conformance`. Evidence: the package README. Migration goal (maintainer, 2026-10-29): every collection adapter gets a driver for each conformance family it declares; the plan and per-adapter status are in `packages/db-adapter-conformance/MIGRATION.md`. Existing adapter oracles keep their laws until a shared family checks the same law, history, path, and observation. TrailBase (eager mode, per-change commits, `adapter-conformance.eager-live-source.trailbase`) is GREEN; its lifecycle oracle keeps its laws, so eager startup failure and stream-end health have two owners until this entry moves them. RxDB (`adapter-conformance.eager-live-source.rxdb`, per-change commits, a controlled RxCollection with RxDB's own query matcher and sort comparator, `listen-before-fetch`) is GREEN after a fix for a buffered insert that the initial read already reflects; `rxdb.test.ts` holds a receiving witness for it on memory storage. PowerSync (`adapter-conformance.eager-live-source.powersync`, eager mode over a real local PowerSync database, per-batch commits, a database-side propagation step) is GREEN after a fix: a failed first load now releases the run's change watcher (LIFE-10). Its startup failures in on-demand mode, cleanup waiting on an unsettled `onLoad`, and post-ready change-handler errors are logged only; they belong to the on-demand and lifecycle families, which are not built. PowerSync also runs typed fields (string, integer, float, boolean as INTEGER 0/1, Date as ISO TEXT) through user deserialization and output schemas. Excluded by `excludesValue` (platform limit, not adapter behavior): numbers PowerSync's storage does not keep at full precision. Its table views keep 15 significant digits (9007199254740991 reads back as 9007199254740990, 0.30000000000000004 as 0.3) and reject Number.MAX_VALUE (`powersync_diff: number out of range`); owner: the PowerSync driver; evidence: a direct write and read through `@powersync/node` 0.20.0. Electric (`adapter-conformance.eager-live-source.electric`, eager mode over the installed `@electric-sql/client` and a controlled `fetchClient` that answers the HTTP protocol, per-batch commits, typed Postgres columns for nine kinds) is GREEN after fixes from two rounds. Maintainer decisions (2026-10-30) that the shared model and Electric's driver encode: only an extended outage reports, five shape-log attempts in a row for Electric (`retryReportAfter: 5`; a threshold is each adapter's choice: a connection-aware source can report at once), with the attempt that crossed it as the failure, any accepted response restarting the count, and an applied up-to-date clearing it at once; a sync run retires when it fails, so its pending waits reject then and later unmet waits reject; a retired run's evidence fulfills a wait once the current run is ready (revising law set v18 EVID-2, which said never); and a throwing `onError` gives up with its own error. Attempt kinds are generated (`transientVariants`: HTTP 503, HTTP 429 with `Retry-After`, a rejected fetch, an HTTP 400 that `onError` retries), and outages land anywhere in a history, also a second time in a run, after a live batch, and in a later run. Failure values are compared through the driver's `matchesFailure`: each failed response carries the injected failure's index in a header, and a thrown give-up is compared by identity. The on-demand subset lane of `electric-sdk-delivery-oracle` (`electric.sdk-snapshot-delivery`) adds retried subset attempts (0..7 per request), up to six live pauses, and a live outage after the first load, and checks that the source node shows a problem exactly when the live stream had an outage. Excluded by `excludesValue` (column domains, not adapter behavior): int4 values outside 32 bits, and a `-0` nested in an array or object for the float8 column. Updates carry only the changed columns, as Electric's default replica mode sends them, so the adapter's merge is exercised. An `empty-response` step (HTTP 204, accepted, with no change) restarts the attempt count. Give-ups come as an HTTP 400 or as the client's `maxRetries` bound (85), with `onError` returning nothing or throwing, and a second campaign runs the default configuration without an app `onError`, declaring the adapter's give-up log. The on-demand lane also restarts the Collection and checks that a retired run's snapshot-boundary evidence (txid 5 below `xmin` 10) and imported sync metadata (txid 25) stay pending until the restarted run is ready, then fulfill. Its live attempts after the first load are a generated sequence of 0..7 HTTP 503s and synchronous throws of the app's `fetchClient`, in any order; the expected outage and the message of the attempt that crossed the threshold (HEALTH-4) follow the attempts the provider recorded, with reach for an outage led by a throw and one crossed by a throw. A success between failed attempts is not generated in this lane; the eager lane's empty response covers the reset. At both cuts a fresh Collection imports the exported sync metadata, as hydration does, and must accept no txid the source does not accept then: the export carried the retired run's txids before the restarted run was ready (RED: txid 25 accepted after import), and a mutant that never exports them fails after ready. The metadata format carries txids only, so snapshot evidence is not exported, as on `main`. Maintainer decision 2026-11-02: a failed catch-up prefetch attempt counts toward the outage threshold, as any failed shape-log request does; no driver response spans several chunks, so no history prefetches. It declares reach for a subset request's five retried attempts, five live pauses, a live outage, and that restart. Each snapshot campaign now constructs a fresh randomized history that reaches all seven declared states, including outages led and crossed by a synchronous throw. Per-history checks enforce the construction obligations for generated outputs as well as campaign examples; seven missing-state calibrations reject an omitted reach observation. The 40-run budget, fixed seed, unconstrained arbitrary, and product comparisons remain. See [the reach repair evidence](oracle-reviews/2026-11-10-electric-snapshot-reach.md). The retry-decision model (`electric-retry-decision-model.ts`, shared by the controlled lane of `electric-oracle.property.test.ts` and the installed-client lane) now observes an `awaitTxId` and an `awaitMatch` that reject when the run fails or is cleaned up, and the source node's `error` while ready (READY-9: a give-up while the first snapshot's acceptance is pending is a post-ready failure once it is accepted). An external abort after ready is the source node's `error` too (maintainer decision 2026-11-02: deliberate or not, an aborted stream no longer syncs). Its controlled driver now reports a give-up decision to the subscriber, as the installed client does; before, a give-up after ready never reached the adapter's failure path in that lane. Both lanes also start a second pair of those waits at every checkpoint, after its step: a run that stopped rejects them too (EVID-2), except after cleanup. Reach (`electric.retry-decision`, fixed and random campaigns together): a loading failure 16, a give-up after ready 14, an external abort after ready 4, and an abort while READY-9 defers the failure 2, the last two from named examples. An abort retired the run before its failure was recorded, so a later wait waited for its timeout: RED at `[demand, hold, up-to-date, abort]` (late waits `pending`). Two mutants fail it: a retirement that advances the run's epoch again (abort after ready), and an abort that does not record the failure for the waits (`[demand, hold-acceptance, up-to-date, abort, accept]`). The other paths that abort before failing, a rejected applied receipt and a rejected or invalidated resume, share the repaired lifecycle rule; no generated history reaches them. Limits: no persisted resume or held commit receipt in the eager lane; no real Electric server; without an app `onError`, the driver detects a give-up from the adapter's log, so an adapter that stops logging times out rather than failing a law. The shared check refuses `retryReportAfter` above 1 with `transport-reconnect` or `capability-renewal`: no law fixes whether a reconnect or a renewal ends an outage a threshold is counting. Typed arrays (maintainer decision 2026-11-02): -0 and 0 are distinct inside them as row values too; the `float-array` value kind (a `Float64Array`) makes the reference driver the generated witness (RED on `370e029db`: PUB-2 after a retouch that flipped a zero inside one). A reload's give-up while its first commit's acceptance is pending fails at once when the Collection is already ready (maintainer decision 2026-11-02: READY-9's deferral applies to the first load); no generated history reloads with a held acceptance. Convex (`adapter-conformance.eager-live-source.convex`, eager mode over the real Convex JavaScript client and a controlled WebSocket that answers the sync protocol, complete results, per-batch commits, Convex value kinds as values and typed fields) is GREEN after a fix: a failed first load now releases the query subscription (LIFE-10). It declares `delivery-error` (a `QueryFailed` after ready, cleared by the next result) and reports a rejected delivery after ready (`rejectedDelivery: reported`, the law set's default `errorMapping`). Limits: no transport reconnect, no on-demand or paginated mode, no deployment; the truncate on a restarted run's first result is not distinguished, because an eager restart starts empty. While the client's result is a failure, the driver acknowledges a query removal only with its next transition, so a restart finds the failed query's cached error: maintainer decision 2026-11-02, a cached error does not fail a new subscription, which waits for the server (reach `restart-after-failure`, both clients). With `prompt-after-restart`, the new run's first transition can arrive before the client's replay of that cached error (reach `prompt-failure-after-failed-run`, 36 of 400 histories per client at seed 2118). Skipping the first error after a cached one lost a fresh failure there: RED `READY-4 (status)` at `[fail, prompt restart, fail]`, status `loading` and not `error`. The adapter now names the cached result by the identity of its log lines, read through the base client, because the `onUpdate` handle's `getQueryLogs` looks up the wrong query in Convex 1.47.0; a version that skips nothing fails `LIFE-2/LIFE-5 (status)` at `[fail, restart, changes]`. Behind an app's wrapper that exposes only `onUpdate` the accessor is missing, so the adapter falls back to the earlier rule (no current value until the server's first callback, and the first error taken for the replay); a fixed campaign over such a wrapper checks it (RED before the fallback: `[fail, restart]` ends in `error`). The wrapper does not declare `prompt-after-restart`: there a server answer that comes before the replay can still be taken for it (open limit). A cached valid result served to a restarted run is accepted client-cache behavior and is not generated, because the model starts a restarted run empty. A fixed-seed campaign runs the React client (`watchQuery`). ### Ordered-loader authority CI counterexample, 2026-11-03 Owner: `packages/db/tests/query/ordered-source-loader-state-oracle.test.ts`, property `ordered-loader.request-authority`. CI run `41699469835` on `5911d5e00` fails the no-leak check: requests `[2,3]` remain held after authoritative request 4 succeeds. Direct replay reproduces on the PR and an untouched archive of exact main `1443dc92e5417394acbdc98b782caa9802848ce6`: ```sh TANSTACK_DB_ORACLE_SEED=-416164704 TANSTACK_DB_ORACLE_PATH=2540:0:3:3:8:8:12:12:13 TANSTACK_DB_ORACLE_PROPERTY=ordered-loader.request-authority pnpm exec vitest run tests/query/ordered-source-loader-state-oracle.test.ts -t 'holds, retires, and recovers requests under generated settlement orders' --coverage.enabled=false --typecheck.enabled=false --maxWorkers=1 ``` Input: `indexed=false`, `limit=1`, `settledFirst=true`, `releaseFault=false`, `syncRepair=true`, `requiresFullSource=false`, `joined=true`, `snapshotRows=1`, `needsMore=true`, `retryTimer=false`, `releaseTruncates=false`, `offset=0`, `releaseReenters=true`, `releaseDisposes=false`, `releaseInvalidates=false`. History: `truncate; settle(0, success); invalidateThenFailOldest; move(-1); joinedBusy; settle(0, success)`. Status: confirmed baseline oracle failure, underlying repair location unresolved. Next witness: distinguish whether the final authoritative read covers the held requests while joined work defers a reentrant pass, then check the real subscription receiving path. This remains separate from PR #2346's observer metadata-sharing and discarded-publication scope. The test, grammar and run budget remain unchanged; a green later random campaign does not close it. ## Compiler group reduction boundary `packages/db/tests/query/compiler/group-by-pipeline-oracle.test.ts` retains the independent batch model formerly embedded in the ordinary `group-by-pipeline.test.ts`. Thirty finite histories cross explicit/implicit groups, no/plain/wrapped selection and five HAVING forms. Each compares keyed selected values after empty startup, population, a member move/value change, emptying and reentry: 150 comparison checkpoints, with each checkpoint declared and reached in every history. Checker calibrations reject a lost group, wrong key, wrong value and duplicate weight. Supplemental pending-state and admission examples remain in the ordinary file. Authority: the existing aggregate/group laws and the maintainer's 2026-11-05 boundary-only metadata decision. Group reduction has no source Collection attribution; Collection publication supplies that metadata. The retired reducer pending/origin/Collection-ID expectations are therefore removed from this component judgment. The primary `virtual-row-fields-oracle.test.ts` continues to own genuine published metadata; no public comparison is weakened. The component covers numeric keys/sums and synchronous D2 graph drains, without correlated routes, public events, provider schedules or general aggregate shapes. The public aggregate-select and grouped-result-key owners retain those wider value/key contracts and their stated limits. ## Legacy oracle campaign migration (2026-11-10) The commit-pinned `@tanstack/oracles` framework supplies `oracleProperty` as its only campaign API. DB retained the two removed helpers and their self-tests locally while the explicit `legacyCampaigns` baseline shrank. The baseline contained 199 files at adoption, including three restored compatibility test files. It is now empty, and the vendored helpers and their self-tests are deleted (2026-11-10). `node scripts/oracle-campaign-inventory.mjs` surveys the current files with the lint plugin's own legacy-use classifier; its shape and fixed-history flags are planning hints, not evidence of a completed conversion. `scripts/legacy-campaign-baseline-oracle.property.test.js` (`scripts.legacy-campaign-baseline`) owns the migration gate in `scripts/check-legacy-oracle-campaigns.mjs`. AGENTS.md's migration ratchet is its authority: an adopted baseline may only lose exact file identities. The model uses membership in a four-file universe. The driver commits base settings in a temporary Git repository, writes head settings, runs the actual CLI, and compares the full additions report and exit status after process completion. The grammar also varies the setting's presence and the gate's presence at base. Fixture histories cross inherited pre-commit/prepare-commit-msg hooks with plain or strict CRLF global configuration. A constructed no-hook history with strict CRLF settings requires fixture setup and the completed gate report to remain independent of developer global configuration. Only absence of both permits initial adoption; after the setting is removed, the gate's presence preserves an empty allowed set. Constructed histories cover an addition, an addition after an empty adopted baseline, an addition after the setting was removed, a removal, and initial adoption. Both 20-history campaigns run these same laws and constructions. A local association records each builder's declared states on every invocation. The shared check compares those declarations with actual state observations for seeded, generated, and shrunk constructed outputs; it does not depend on the pinned framework's seeded-only association. The checker rejects both an always-accept report and a trace that omits a required constructed state at the virtual `constructed states` checkpoint. This checkpoint is unrecorded, so an incomplete driver trace keeps its actual driver failure primary rather than inventing an earlier state omission. Actual gate-report mismatches still use `completed`. Production mutants that always accept or allow a removed baseline to restart fail the named `only shrinks` law at `completed`, including direct seed/path replay. Limits: valid settings with unique file names; the settings module exists at base and exports literal settings without imports. The external lint plugin owns malformed entries, stale entries in files that still exist, and the classification of legacy API uses. Deleted files have no lint invocation; remove their baseline entries when deleting them. The gate compares file identities and permits reason edits. No existing product law or campaign is converted by the repin. Each later conversion needs its own same-seed before/after gap comparison; this adoption does not supply that evidence. Gaps in changed functions close by a kill or an explicit maintainer allowance for their anchored gaps; a coverage-map entry alone does not close them. The reversed-index owner now registers generated reads through `reverse-index.reads` and its four existing large histories through the finite `reverse-index.large-reads` property. The independent order and filter-work judgments, 200-run fixed/random campaigns, and twelve declared states remain. Every fresh constructed history retains its reach obligations; incomplete traces preserve actual driver failures. The [conversion record](oracle-reviews/2026-11-10-reverse-index-property-conversion.md) binds the complete 49-site comparison and all 23 retained named order rejections. Its five survivors, fifteen unreached sites and six runtime crashes are unchanged gaps; this refactor claims no closure of them. The structural-hash graph and failed-getter-retry owners are now `ivm.hash-graph` and `ivm.hash-failure-retry` properties. Their arithmetic read-count and independent graph-topology/unfolding judgments retain the existing laws and 100/300-run budgets. Five retry states and nine graph states have constructed histories. Every builder invocation records its obligations; the shared check compares them with actual reach at a virtual completeness checkpoint that preserves interrupted driver errors. The [conversion record](oracle-reviews/2026-11-10-hash-property-conversion.md) and its companion JSON bind the final source blobs, all reach counts, generated failure replays, and late-error controls. A cold explicit-prefix seed-42 comparison preserves all 144 prior semantic kills among 234 baseline sites, checking 148 selected stable keys with zero cache reuse. Production is unchanged. The wider baseline's 54 survivors, 22 unowned sites, 12 crashes, and 2 unreached sites remain gaps; this refactor claims no closure of them.