Skip to main content

Scenarios

Every scenario is a script in packages/bench/src/harness/scenarios.ts: prepare and restore run outside the clock, run is timed, check demands the renders the script implies, and oracle replays the same script against the reference model. Each one has an audit card saying what application work it stands for, what property of a store decides it, which designs it favours by construction, and every bias found in it.

verdictmeaning
representativean application does this, at roughly this size, often enough to matter
narrowreal, but one corner of a larger behaviour; read beside its siblings
synthetican instrument — a floor, an isolation of one cost — not a workload
misleadingas written, it rewards something an application would not want

batch insert (batchInsert, bind)representativeaudited against the current code

One step: every row is inserted into an empty store in one batch. Both views go from empty to a full page and must each re-render exactly once.

A real, once-per-screen operation at a realistic size; it excludes construction and GC, so read it with coldStart and the memory pass.

Models: Initial hydration: the first fetch of a list screen writes the whole dataset into a store whose views are already mounted. Measures: Bulk-load throughput into an empty store with subscriptions standing, ending at both views' first full render.

Favours: Stores that ingest a batch in one pass and build their indexes once at the end (deferred index build, a bulk-load path) over stores that maintain an ordered index row by row as rows arrive. Stores that adopt the given objects rather than copying them into their own representation; the harness hands one cloned array (worker.ts:85) and copying is legitimately extra work.

  • Construction and subscription are outside the clock (`rebuild: true`, scenarios.ts:3085; `rebuild`, worker.ts:354-357, run from `settleForSample`, worker.ts:371-379, as the sample's untimed `setup`, measure.ts:73). Libraries expensive to construct and cheap to write look cheaper than at a real cold start; `coldStart` exists for that.
  • The empty render some libraries make on subscribe is discarded by `reset(forgetBetweenSamples)` before the clock (worker.ts:368-379; scenarios.md 'Two frames at a cold start'). Neutral here, but it hides a user-visible frame that `coldStart` shows.
  • One `write(rows)` call (scenarios.ts:3091-3094): every adapter may batch inside it, so eager and deferred stores are on equal terms. It is not wrapped in `frame`.
  • Five short columns per row (dataset.ts:29-35): stores whose load cost scales with field count (per-field observables, deep proxies) pay less than on application-width entities.
  • `repeatable: false` with a rebuild per sample (scenarios.ts:3085-3088; cells/runBatch.ts:55): one run per sample and a `collect` call before it (measure.ts:73-77), which forces a GC when `global.gc` is exposed (worker.ts:63-67), so GC triggered by the load's allocations is likely outside the timed region.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

insert into a populated store (insertIntoPopulated, bind)representativeaudited against the current code

One step: 100 new rows are inserted in one batch into a full store, with every group sorted and every visible row subscribed. They sort first, so they appear at the top of every group and both views must change. "batch insert" fills an empty store; this adds to one already in use.

A realistic feed-style insert into a populated store; its newest-first ranks fix the arrival position at the head.

Models: A page of new items arriving into a populated, newest-first list (a feed refresh, new orders, new messages) in one frame. Measures: Insert of genuinely new keys into a full store with fifty ordered groups and live subscriptions, and the re-derivation of every affected window.

Favours: Stores with an ordered per-group index that can place a new row by binary search, over stores that rescan or re-sort the group. For array-backed ordered buckets, arrival at position 0 is the most expensive splice position (all rows shift); for linked or tree-backed orders it is not special. The engine's ordered bucket inserts by `splice` (packages/core/src/engine/bucket/array/OIMBucketSlotsServiceArrayDriven.ts:154).

  • Every new row ranks below every stored row (`rank: -(i + 1)`, dataset.ts:909-915), so each arrives at the HEAD of its group's window (scenarios.ts:3900-3903). Realistic for newest-first lists; it never asks for a mid-order insert, and it guarantees every window changes.
  • 100 rows at the default point, two per group (`INSERT_COUNT`, dataset.ts:215). A modest page; a large page into a large store is asked by `growUnderSubscription`.
  • One `write(rows)` call (scenarios.ts:3932-3935): adapters can batch inside it; eager and deferred stores are on equal terms.
  • The untimed restore removes the rows (scenarios.ts:3928-3931), so the store never grows; a store whose removal leaves residue (tombstones, holes in arrays) is measured in its post-removal state on every sample after the first. Direction unverified.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

the population keeps growing (growUnderSubscription, bind)narrowaudited against the current code

8 steps. Each inserts a batch of new rows spread over every group and sorted first, and nothing is deleted, so the store ends forty per cent larger than it started. A store grown step by step is not the same as one loaded in one go: sorted lists and indexes can cost more as they grow. Every batch shows at the top of both views.

A real growth pattern asked at its most visible and heaviest (500-row prepends to every group, eight times), so it prices ordered-insert cost at the head rather than typical feed growth.

Models: A feed or log that keeps receiving new items while it is on screen, so each batch lands in a store earlier batches already grew. Measures: The cost of inserting a batch of new keys as a function of how much the store already holds, with both views re-derived after every batch.

Favours: Structures whose insert cost does not depend on where in the order the new key lands, or that sort lazily at derivation time. Against array-backed ordered buckets that insert by shifting: every batch is ranked below everything already stored (dataset.ts:919-938), so every new row lands at position 0 of its group. That is the worst case for a shifting insert and the best case for nothing. Direction asserted from the shape, not measured.

  • Every batch is visible: newest rows are ranked most negative (`rank: -(INSERT_COUNT + MOVER_COUNT + 1 + minted)`, dataset.ts:932), so each batch arrives at the head of all fifty windows and changes both views. An infinite list appends below the fold, where nothing re-derives; a chat or activity feed prepends a few rows per frame. This asks the prepend case at batch size.
  • Batch size is max(INSERT_COUNT, N/20) = 500 rows per frame at N = 10000 (dataset.ts:215, 248, 919-922), 10 per group per frame. Live feeds bring a handful per frame; 500 is a page load, eight times over.
  • Growth is bounded at 40 % over eight frames (GROWTH_FRAMES dataset.ts:235, GROWTH_FRACTION :248), as the description states (scenarios.ts:3973-3975). A cost that turns super-linear only at larger multiples is not reached.
  • The untimed `restore` drops and rebuilds the whole store every sample (scenarios.ts:3988-3993). Where the worker has `gc` exposed, `collect` runs it untimed before every timed sample (measure.ts:45-47, 73-74; worker.ts:63-67), so the discarded store is not collected inside the clock; without `gc` it may be. Whether a given run had `gc` is carried as `gcAvailable` in the result (worker.ts:64).

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

cold start to first render (coldStart, bind)narrowaudited against the current code

One step, timed from nothing: create the store and both views, subscribe them, insert every row, and render the first page of each view. The only scenario that times creating the store. Compare with "batch insert", the same work without creating the store: the difference is what setting up a store and its subscriptions costs.

The only row with construction in the clock, but construction is warmed by repetition, so it is a hot-construction cost rather than a page-load cold start.

Models: A screen opening from nothing: create the store and its two views, subscribe, load every row, and deliver the first frame. Measures: Construction plus subscription plus bulk load plus first delivery, all inside the clock; read against `batchInsert` for the construction share.

Favours: Libraries cheap to construct and to subscribe (no schema compilation, no per-view setup). Libraries that do not render an empty frame at subscribe time, but only in the counters: the render count is not judged (`finalStateOnly`, scenarios.ts:4052-4067).

  • It is not cold. The timing loop runs the whole construction at least once and up to `warmup` iterations before sampling (measure.ts:55-69; `planFor` warmup between 5 and 2000, capped at 5 s of warm-up, measure.ts:34-39, 118-138), so construction runs JIT-hot. A real cold start runs library code for the first time, interpreted or baseline-compiled, after parsing it. Tilts toward libraries whose construction is heavy but JIT-friendly; the label overstates what is measured.
  • Parse/evaluate of the library bundle is outside the clock (the module is loaded once per process, worker.ts:69); bundle size is measured elsewhere (src/bundle.ts) and not combined with this row.
  • Allocating the row objects is outside (`loadRows` built once, worker.ts:85) and the previous store is disposed untimed (`restore` calls `dropBinding`, scenarios.ts:4076-4078); where `gc` is exposed it is also collected untimed before every timed sample (measure.ts:45-47, 74; worker.ts:63-67).
  • Six libraries were recorded rendering an empty frame before the full one (scenarios.ts:4056-4061: mobx, legend-state, effector, nanostores, preact-signals, alien-signals, measured 2026-08-29); that cost is inside the clock for them, as it is for a user. Neutral. The record predates the 2026-10-17 upgrades of mobx (7.0.6) and nanostores (1.5.5) and was not re-checked.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

tear the screen down (tearDown, bind)narrowaudited against the current code

One step: the whole screen, a full store with both views and every subscription, is disposed. The teardown itself must render nothing. Afterwards, outside the timing, rows are written into the disposed screen and nothing may render, so a dispose that disposed nothing fails instead of looking fastest. A library that refuses that write also passes.

A real but uncommon event — the whole store disposed — whose measured cost excludes garbage collection; the everyday navigation case is an unmount against a surviving store, which this row does not ask.

Models: Disposing a whole store together with its views and every subscription — a per-route or per-widget store going away, a micro-frontend unmount, or test teardown. Measures: The synchronous cost of `dispose()` on a fully populated, fully subscribed binding.

Favours: Libraries whose teardown is dropping references and letting the collector reclaim them: the reclamation is not timed (see biases). Against libraries whose teardown walks every subscription and unlinks it from surviving structures (per-row effects, per-slot holds; the script's comment names `OIMEffect.detach` per per-slot effect, scenarios.ts:4105-4110).

  • The usual navigation in an application unmounts VIEWS while a global store survives; there each unsubscribe must unlink from live structures. This script disposes the store too, so a library can skip unlinking entirely. The surviving-store case is the churn family.
  • GC is excluded: when the worker runs with an exposed `gc`, a forced collection runs before each timed sample (measure.ts:72-74; worker.ts:63-67), so the garbage this teardown creates is collected before the NEXT sample, outside the clock. In an application that cost lands on the main thread soon after navigation. Tilts toward drop-the-reference teardowns.
  • `repeatable: false` (scenarios.ts:4218) means one run per sample (the repeat cap is 1, cells/runBatch.ts:55) of a region the script's comment puts at tens of microseconds (scenarios.ts:4111-4115), so timer resolution and noise are a large share; C3's spread ceiling is likelier to refuse a rank here, as the record says (scenarios.ts:4198-4202).
  • The proof frame cannot tell 'refused the write' from 'accepted and stayed silent' (scenarios.ts:4253-4255); both pass.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

teardown lower bound (tearDownFloor, bind, floor)syntheticaudited against the current code

Lower bound, no library: a hand-written screen (every row in a Map, two views and one subscriber per visible row) is discarded by dropping the single reference to it. No library can tear a screen down for less. Afterwards, outside the timing, rows are written into the discarded screen and nothing may render.

A lower bound that is, in practice, near the timer's resolution; use it to see which teardown rows are at clock noise, not to rank them.

Models: Nothing an application does: a hand-built screen given back by overwriting one reference, used as the lower bound of the `tearDown` table. Measures: The cost of one reference store — the least any teardown can cost.

Favours: No participant. As the divisor of the teardown table it makes every row's multiple a ratio against an operation of a few nanoseconds.

  • The timed region is one assignment (scenarios.ts:3688-3690) run once per sample (`repeatable: false`, scenarios.ts:3646; repeat cap 1, cells/runBatch.ts:55). The sample is bracketed by two `process.hrtime.bigint()` calls (measure.ts:75-77), so the measured minimum is likely of the order of the timer's own overhead rather than the assignment, and the teardown multiples are then ratios to clock overhead. Not measured by this card.
  • The garbage released by the drop is collected before the next sample, outside the clock (measure.ts:72-74), exactly as for `tearDown`; the floor shares that exclusion, so it bounds the synchronous part only.
  • The screen's subscribers are closures in an array attached to nothing (scenarios.ts:3661-3673); a teardown of subscriptions to a surviving store is not what this bounds.
  • Windows A and B are the same rows (scenarios.ts:3659-3660), declared irrelevant to the cost (:3648-3652); true for a reference drop.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

patch one column (patchColumn, bind)representativeaudited against the current code

32 steps. Each step changes the `label` of one row visible in view A. View A must re-render with the new text every step. View B shows a different group and must not change; how often it was woken anyway is counted.

The suite's baseline single-field edit: real and frequent, but the full-window string render per delivery makes much of every row the consumer's cost rather than the store's.

Models: An inline edit or a pushed update to one field of one row the user can see, repeated row by row, each change its own frame. Measures: Single-write latency from a keyed column write to a re-rendered window, plus whether an unrelated view (group B) is woken.

Favours: Stores that route a row write to the views containing that row (per-row or per-visible-slot subscriptions, signal graphs) over stores that re-derive or rescan a whole group or the whole population per frame. Nothing favours coalescing here: one write per settle and no `frame` call (scenarios.ts:465-468), so eager and deferred-flush stores do the same number of derivations.

  • Every delivery re-formats all 32 window lines and hashes them (render.ts:31-44 `deliver`, consumer.ts:108-148), so a store that knows exactly which row changed cannot show that advantage on the render side. Real per-row-component UIs re-render one row. Tilts toward list-level derivations and compresses every gap toward the consumer constant.
  • `label` is neither filtered nor sorted on (dataset.ts:22-24), so a write can never change membership or order. Tilts toward stores whose window bookkeeping is expensive only on shape changes (per-visible-row subscribers: oimdb, tinybase, per WHY-EACH-ROW.md:615-629).
  • Rows have five short columns (dataset.ts:29-35). Copy-on-write stores (immutable entity spread) and per-field-observable stores pay less per patch than they would on application-width entities.
  • Only 2 of the 50 groups are watched (dataset.ts:37-41). Stores maintaining an index on all 50 groups pay maintenance nobody reads (WHY-EACH-ROW.md:559-587); tilts against eagerly indexed stores.
  • Timed in Node on a JIT-warm loop and reported as the minimum of samples (measure.ts:41-97). Real edits arrive sporadically into colder code; tilts toward monomorphic, JIT-friendly write paths.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

patch a row off screen (patchOutsideWindow, bind)representativeaudited against the current code

32 steps. Each step changes the `label` of a row in view A's group that sits just below the visible page: in the group, but not on screen. Neither view may re-render. Measured: how often a library wakes a view for a change nobody can see.

A real and frequent case — edits to off-screen rows of a virtualised list — that prices subscription scope; it carries no floor multiple, which fits a script whose correct answer delivers nothing.

Models: An update to a row that belongs to the list on screen but is scrolled out of view (virtualised list, paginated table), one row per frame. Measures: Wake-up selectivity at sub-group granularity: whether a write to a watched-but-invisible row wakes the view, and what that wake costs.

Favours: Stores whose views subscribe to the VISIBLE rows (per-visible-slot subscriptions; the script's own comment says the design that benefited from every write landing inside the window is 'ours', scenarios.ts:485-491) — they hear nothing. Fine-grained computeds that track only the properties of the rows they returned (MobX-style), for the same reason. Against: stores whose view is a derivation over the whole group or the whole population; each write wakes it, it re-derives an unchanged window and delivers redundantly.

  • `label` is not a filter or sort column and the rows are the second window of group A (`outsideA`, dataset.ts:1030; documented at :478-484), so a write can never pull a row into view. The case where an off-screen row's SORT KEY moves it on screen — what makes visible-row-only subscription hard — is not asked here.
  • Redundant deliveries are timed with their full 32-line render (render.ts:31-44), so a waking store pays the consumer for nothing. That matches an application that re-renders on a wake, and makes the row's gaps partly consumer cost.
  • ADDRESSED: the window floor. The script sets `rendersNothing` (scenarios.ts:501), so `stepDeliveryOf` returns `nothing` (floor.ts:79), `floorKeyFor` returns no floor (floor.ts:91-100, 144-147), and the table prints `no floor` (floor.ts:191) with the reason from `UNBOUNDED_BECAUSE` (floor.ts:129-136).
  • With no floor, a row that wakes keeps its consumer share; the wake count is the subject, so that is the intended reading.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

patch an unread column (patchNote, bind)narrowaudited against the current code

32 steps. The same rows and the same calls as "patch one column", but the changed field is `note`, which no view displays. Neither view may re-render. The difference between the two scenarios is what tracking changes per field saves.

The isolation half of the patchColumn pair: it prices per-property versus per-row change tracking on a column nobody reads, and is meaningful only beside patchColumn and batchPatchNote.

Models: An update to a field of a visible row that this screen does not display (a timestamp, a sync flag, a hidden attribute), one row per frame. Measures: Column granularity of change tracking: whether 'the entity changed' is distinguished from 'something the view reads changed'.

Favours: Stores that track dependencies per property (MobX observables, per-field signals): the column has no observers, so nothing runs. Against: row-granular stores — a whole-row signal, a per-visible-row subscription, an immutable row replaced on write — which wake view A once per step to show identical text.

  • `note` is read by NOTHING anywhere (dataset.ts:25-27), an extreme. In applications an unread-here column is usually read by some other view; the script prices only the best case for per-property tracking.
  • The drop-the-write cheat is not caught by the digest (scenarios.ts:544-556 says so); it is caught only by the population audit after the run, which compares `note` on every row (worker.ts:462; oracle.ts:529-531). A failure there voids the row, so the bias is closed, but only by the audit.
  • Narrow rows (dataset.ts:29-35): a per-field-signal store pays its per-field setup at load, which is not timed here, so this row shows its benefit and hides its cost.
  • ADDRESSED: the window floor. `rendersNothing` is set (scenarios.ts:567), so `stepDeliveryOf` returns `nothing` (floor.ts:79), `floorKeyFor` finds no floor for it (floor.ts:91-100, 144-147), and the table prints `no floor` (floor.ts:191) with the reason from `UNBOUNDED_BECAUSE` (floor.ts:129-136).

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

batch patch (batchPatch, bind)representativeaudited against the current code

One step: the `label` of every tenth row in the whole store (at least four pages of rows, spread over every group) is changed inside one batch, and the changes are delivered once. This is a sync response or a bulk edit. Most changes land in groups no view shows. Both views must end showing the new text. How many times each re-renders is up to the library: one with a batch API renders once per view, one without renders once per changed visible row, so only the final screen is checked.

A bulk response in one frame, run inside each library's own batch scope; what remains tilted is the per-row call shape, which action-based stores cannot fold into one action.

Models: A sync response or bulk edit: about a tenth of the population changes one visible field, applied in one frame. Measures: Cost of many writes before one frame boundary — whether the store coalesces deliveries, and how much of a widely spread batch reaches the two watched views.

Favours: Stores whose delivery is deferred to `settle` (a dirty flag, a frame-scoped delivery list): one derivation and one render per view whatever the library's batching API. Libraries with a batching API, which `ctx.binding.frame` reaches (scenarios.ts:656-660; `TBinding.frame`, types.ts:24-26): `runInAction`, `batch` or `transaction` around the 1000 writes defers their reactions to the end of the scope, so they also derive once per view. Against libraries with no batching API: their `frame` is a plain call and they deliver once per visible write.

  • One `patchLabel` per row (scenarios.ts:656-660). A library whose bulk idiom is ONE action carrying many updates cannot use it: merging the calls would be the adapter holding values the library does not hold, which B3 forbids (scenarios.ts:135-139). Redux Toolkit's adapter defers listener notification to the end of the frame with autoBatch (adapters/redux-toolkit.ts:72-101, actions prepared with `prepareAutoBatched` at :193-261), so its listeners run once; what the row still charges it for is 1000 reducer passes where an application would dispatch one action.
  • A library with no batch API delivers per visible write, and every delivery re-derives and renders the full window synchronously (render.ts:31-43). An application under a UI scheduler would coalesce those renders; the consumer here has none.
  • The stride is stepped down to be coprime with the 50 groups so every group is reached (dataset.ts:813-814), and both windows are forced to be hit (dataset.ts:817-848). A handful of the ~1000 writes are visible. Realistic for a sync response.
  • `finalStateOnly` (scenarios.ts:636): the render count is reported, not judged, so the time column mixes one-render and many-render rows under one label. The counters column says which is which.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

batch patch an unread column (batchPatchNote, bind)syntheticaudited against the current code

One step: the same rows as "batch patch" are changed in one batch, but in `note`, a field no view displays. Neither view may show new text; any re-render is wasted work and is counted. Against "batch patch" it shows the cost of a batch nobody sees; against "patch an unread column" it shows what batching saves. The changes are checked in the store afterwards.

An isolation instrument bracketing patchNote and batchPatch; it prices coalescing against column routing, with each library's own batch scope and no false floor.

Models: A bulk sync that changes only fields this screen does not display, applied in one frame. Measures: Whether coalescing at the frame boundary recovers the wasted wake-ups a row-granular store pays on an unread column, versus per-property tracking that never wakes.

Favours: Per-property trackers (mobx-style): nothing observes `note`, so no reaction runs at all, batched or not. Row-granular stores that defer delivery to `settle`, and row-granular libraries whose batch API `frame` reaches (scenarios.ts:752-756): at most one redundant derivation per view per frame. Against row-granular libraries with no batching API: one redundant derivation and one full-window render per visible write in the batch.

  • The script sets `rendersNothing` (scenarios.ts:733), so `stepDeliveryOf` returns `nothing` (floor.ts:79) and no floor divides the table (`BOUND_BY` has no `nothing` entry, floor.ts:91-100); the reason is printed from `UNBOUNDED_BECAUSE` (floor.ts:129-136).
  • With no floor, the consumer's share of a row that does wake is not taken out of it (floor.ts:131-135 says so). Wakes are the subject here, so that is the intended reading, but B4's demand is not met in substance (see standing).
  • `note` is read by nothing (dataset.ts:25-27), an extreme that makes per-property tracking free; it says little about a column read by some views and not others.
  • One `patchNote` call per row (scenarios.ts:752-756): an action-based store cannot fold them into one action, as on `batchPatch`. Redux Toolkit's listener calls are deferred to the frame end by autoBatch (adapters/redux-toolkit.ts:72-101); its 1000 reducer passes are not.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

most rows change every frame (patchMostRows, bind)narrowaudited against the current code

2 steps. Each step changes the `label` of one row in 2 across the whole store, the same share of every group, and delivers once. Every other write scenario changes a handful of rows; this one checks the opposite end, where most of what is subscribed changes at once. Both views must end every step showing new text.

The dense end of the write dial, which the rest of the suite never reaches; real for refresh-style frames and run inside each adapter's `frame`, but two round-robin frames of per-row calls are one corner of that behaviour.

Models: A dense update: half of every group changes a visible field in each of two consecutive frames (a full refresh, a price tick across a whole book, a recompute of every row's status). Measures: Cost of a frame where the dirty set is a large fraction of the subscribed population, and what that frame leaves behind for the next.

Favours: Designs that scan subscribers or rebuild at the boundary rather than maintain a per-write dirty list; the script's comment predicts the engine's rejected stamp-and-scan arm ahead by about 1.18x at this fraction (scenarios.ts:780-785; dataset.ts:101-106) — an internal figure, not verified here. Deferred-flush stores and libraries whose batch API `frame` opens (scenarios.ts:844-848), over adapters whose `frame` is a direct call.

  • Each frame's 5000 writes run inside `ctx.binding.frame` (scenarios.ts:844-848; types.ts:24-26). Every adapter now supplies `frame`: a batch scope where it declares one (mobx `runInAction`, mobx.ts:40-42; legend-state `batch`, legend-state.ts:69-71; oimdb `openSubframe`/`closeSubframe`; tinybase transaction; signaldb `collection.batch`), and a direct `run()` in the anchors, lokijs (lokijs.ts:96), oimdb-legacy, nanostores (nanostores.ts:39-41) and effector (effector.ts:39-41). Whether each direct call is a library with no batch API or an adapter that skipped one is the participant cards' question.
  • 5000 separate `patchLabel` calls per frame (scenarios.ts:845-847). Refresh-style frames usually arrive as one array; an action-based store cannot fold the calls into one action, as on `batchPatch`.
  • Only two frames (DIRTY_FRAMES, dataset.ts:95). 'The frame after a large frame' is asked once; a steady state of dense frames is not.
  • A contiguous prefix of the population (dataset.ts:850-856; `TPlan.dirty`, :516-522) dealt round-robin: every group is half dirty. Real dense updates are clustered (one table, one feed); here every group's derivation is invalidated.
  • The labels are built with a template literal inside the timed loop (scenarios.ts:846): the allocation is paid alike by every row.
  • ADDRESSED: `check` now asks for at least DIRTY_FRAMES DISTINCT renders per view (scenarios.ts:871-872), not deliveries, so a store that re-delivered an unchanged window in frame 1 fails it. The comment above it still says 'delivered at least once per frame' (:852-859); the code asks the stronger thing.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

one frame, every kind of change (mixedFrame, bind)representativeaudited against the current code

One step with five kinds of change delivered together: 4 new rows inserted at the top of view A, its last 4 rows deleted, `label` changed on rows in between, 4 rows moved to group B, and a few rows re-sorted inside view A. Each kind touches different rows. This is what one message from a server can carry; every other scenario has one kind. Both views must end full and correct, with a new row at the top of view A.

A realistic mixed frame, small and concentrated on the visible window, whose correctness is pinned by the final-state comparison and the population audit rather than by `check` alone.

Models: One socket or sync frame that carries every kind of change at once: rows created, rows deleted, a visible field edited, rows moved to another list, and rows re-ranked inside the visible list. Measures: The cost of applying five different write kinds inside one frame and producing the final window of both views once, including whatever ordered structure the store keeps for the group.

Favours: Stores that defer derivation to the frame boundary, or libraries whose batching API is honoured by `frame` (scenarios.ts:933-943): they derive each view once over the finished frame. Designs that re-derive one window from scratch, because every one of the 19 row changes lands in view A's window or at the head of view B's, so incremental maintenance has no off-screen work to skip. Direction asserted from the shape of the sets, not measured. Against libraries with no batching API at all: their `frame` is a plain call, so each of the 13 binding calls can deliver on its own.

  • All five sets sit inside view A's window by construction (dataset.ts:940-965, 1092-1096): movers in slots 0-3, patched rows in slots 4-6 at the default window, sorters at slots 7, 9, 11, 13 (dataset.ts:779-793), the deleted set in slots 28-31. A real frame from a server touches mostly rows nobody is looking at; `batchPatch` asks that half.
  • Movers arrive in group B at their resting ranks 1-4, which are below every other row (dataset.ts:440-447, 630-637), so each arrival is at position 0 of view B, the cheapest insertion into an ordered bucket. `moveAndReorder` is the script meant to ask the mid-order arrival.
  • Small: 4 inserts, 4 deletes, 3 label patches, 4 group moves and 4 rank moves at the default point (MOVER_COUNT and SORTER_COUNT, dataset.ts:69-71; sorter count dataset.ts:779-782; patched slice dataset.ts:955). The row is dominated by per-frame overhead and two window derivations, not by write volume.
  • The inserted rows are cloned once in `prepare` (scenarios.ts:910-918) and the same objects are written in every sample, after the untimed restore removed them (scenarios.ts:919-930). A store that keeps the objects it is given sees the same identities each time; whether any participant has an identity-keyed cache this helps is not verified.
  • `finalStateOnly` (scenarios.ts:908): torn intermediate states produced by a library without a batch API cost time but are not judged. Sound for a frame whose render count is the store's answer.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

row moves between groups (moveGroup, bind)narrowaudited against the current code

8 steps. Each step moves one row from group A to group B or back. The moved rows sort first, so every move shows at the top of both views: view A loses a row and pulls in the next one from below, view B gains it.

A real board or status-change operation, measured at its cheapest arrival position; read it only beside moveAndReorder.

Models: A card moved between two columns of a board, or a row whose status changes so it leaves one filtered list and joins another, one move per frame. Measures: Re-selection: removing a row from one grouped view and inserting it into another, with both windows re-rendered every step.

Favours: Stores keeping an ordered bucket per group: every arrival is at POSITION 0 of the target order, the cheapest insertion such a bucket has; `TPlan.arrivalRanks` says so and that it was chosen to make the move visible rather than to be typical (dataset.ts:629-638). Stores with a group index over those that rescan the population per derivation.

  • Movers are the first MOVER_COUNT rows of group A by ordinal and are ranked 1..4, below every other row (dataset.ts:440-448), so they sit at the head of whichever group they are in. Arrival is always at position 0 and departure always from the head. Tilts toward ordered-bucket designs (oimdb among them) whose insertion cost grows with position; `moveAndReorder` (scenarios.ts:1012-1066) exists to counter this and must be read beside it.
  • One write per settle (scenarios.ts:987-995) and no `frame` call: coalescing is not exercised, which is neutral between eager and deferred stores.
  • Only four movers and eight steps (dataset.ts:69; scenarios.ts:977): a small sample of the operation, folded by `repeat` for resolution.
  • Both views change every step, so the selective-wake question is not asked here; a board with 50 columns would ask which other 48 are woken (that is `consumerPerGroup`, on rank moves rather than group moves).

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

a row arrives mid-order (moveAndReorder, bind)narrowaudited against the current code

4 steps. Each step changes one row's `group` and `rank` together, so it leaves the top of view A and lands in the middle of view B, not at its top. Compare with "row moves between groups", where the row always lands at position 0, the cheapest place to insert into a sorted list. Both views must change every step and stay full, and the final positions are checked.

The mid-order arrival is real, its end state is verified, and every timed run is a real move (`repeatable: false`, one run per sample after restore); narrow because four arrivals land in one gap of one window.

Models: A row changes list and position together: a task dragged into another column at a chosen place, a ticket re-assigned with a new priority. Measures: The cost of a group move combined with a rank change in one frame, where the arrival is in the middle of the target window rather than at its head: one run per sample, each after an untimed restore.

Favours: Stores whose ordered bucket inserts by search over stores that append and re-sort; the arrival point is mid-window, so a head-only fast path does not help. Direction not measured. Libraries whose batching API `frame` reaches: the two writes of a step become one state. Libraries with no batching API render the intermediate state (group changed, rank not yet) and pay an extra derivation per step.

  • Four movers, four steps (MOVER_COUNT, dataset.ts:69). Arrival ranks are adjacent integers in one gap of view B (dataset.ts:967-990, `inB[arrivalSlot].rank + 1 + j`), so every mover arrives at nearly the same slot.
  • The way back to group A is the untimed restore (scenarios.ts:1033-1040), so the timed half is only the mid-window arrival; the head-of-group departure it pairs with is `moveGroup`'s cost too.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

sort key moves (sortKeyMove, bind)representativeaudited against the current code

8 steps. Each step changes one row's `rank` so that it moves to another place inside view A. The same rows stay on screen; only their order changes. View B must not change.

The single-row reorder every sorted list performs; its window-internal moves exclude the membership change a real sort-key update often causes.

Models: A row's sort key changes so it moves within the visible list — a priority change, a re-ranked item, a drag within one column — one move per frame. Measures: Order maintenance for a single moved row inside a window whose membership does not change.

Favours: Stores with an incrementally maintained ordered index (insertion repair of one row) over stores that re-sort the group or rescan the population per derivation. Against stores that subscribe per visible row and re-point subscriptions whenever the window's shape changes (oimdb and tinybase per WHY-EACH-ROW.md:615-629): an order change is a shape change.

  • View A's sorters are the rows at slots lowAnchor+2, +4, +6, +8 of the window (slots 7, 9, 11, 13 at WINDOW 32), and their targets are one rank past the anchors at slots lowAnchor and highAnchor (5 and 25), plus j (dataset.ts:779-793). Both targets are inside the window and the mover is never an anchor, so membership never changes. This isolates reordering cleanly and excludes the common case where a rank change moves a row into or out of the window.
  • Unlike the per-group sorters (`sorterInWindow`, dataset.ts:692-742), view A's anchors are not searched for a strict rank increase; a rank tie at an anchor could make a step render the order it already had. That would fail `check` for every adapter alike rather than tilt the row; it does not occur at the shipped points as far as this card can tell, which is unverified.
  • Four sorters, eight steps (dataset.ts:71; scenarios.ts:1077): small and folded by `repeat`.
  • View B must not change (scenarios.ts:1097): selectivity against an unrelated group is asked; selectivity inside group A (rows outside the window) is not.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

the whole window re-sorted (resortWindow, bind)narrowaudited against the current code

8 steps. Each step changes the `rank` of all 32 rows of view A at once, so the whole page is reordered while the same rows stay on it. Compare with "sort key moves", which moves one row: together they show how the cost of keeping a list sorted grows with how much of the order changed. View B must not change.

The many-rows-reorder end of the sort dial, real for ticking ranked lists and run inside each adapter's `frame`, but with membership frozen and a structured permutation.

Models: Every visible row's sort key changes in the same frame — a live leaderboard or price list re-ordering on each tick — for eight ticks. Measures: Order maintenance as a function of how much of the order moved: a whole window re-ordered per frame, against `sortKeyMove`'s one row.

Favours: Stores that sort lazily at derivation time (sort the window's candidates once per frame) over stores that maintain an ordered index incrementally — the script's comment expects the incremental bucket to lose here (scenarios.ts:1113-1125). Deferred-flush stores and libraries whose batch API `frame` opens (scenarios.ts:1180-1184): 32 rank writes become one derivation. Adapters whose `frame` is a direct call re-derive per write if the library is eager.

  • The 32 writes of each frame run inside `ctx.binding.frame` (scenarios.ts:1180-1184; types.ts:24-26). Every adapter supplies `frame`; it is a direct `run()` in the anchors, lokijs, oimdb-legacy, nanostores and effector (see the patchMostRows card for the lines). Whether each is a library with no batch API is the participant cards' question.
  • Membership is constructed never to change: the rank pool is strictly below every rank outside the window (`TPlan.resortRanks`, dataset.ts:525-534; built at :1019-1026, 1066; scenarios.ts:1127-1131). A real tick re-orders rows into and out of the window as well; this asks only the permutation.
  • The pool is rotated by frame+1 places (scenarios.ts:1174-1187): a structured permutation, not a random one. An insertion-based repair sees the same displacement pattern every frame. Direction unverified.
  • The comment's mechanism names `settleBudget(n)` in `engine/bucket/array/OIMBucketSlotsServiceArrayDriven.ts` (scenarios.ts:1115-1120); no symbol of that name exists under packages/core/src. The mechanism exists under another name: the default `bucketFullSortGuard` is `fullSortGuardAboveLogBudget` (packages/core/src/engine/bucket/array/OIMBucketSlotsServiceArrayDriven.ts:37; utils/fullSortGuardAboveLogBudget.ts:1-7), which chooses `list.sort` when `2 * outOfPlace + arrived` exceeds twice the bit length of the bucket size (16 for a 200-row bucket), else insertion repair (OIMBucketSlotsServiceArrayDriven.ts:249-263). A whole window out of place is far above that budget, so the comment's prediction follows from current code; its symbol name is stale.
  • 32 separate `setRank` calls per frame (scenarios.ts:1181-1183): a tick usually arrives as one array, and an action-based store cannot fold the calls into one action, as on `batchPatch`.
  • ADDRESSED: `check` now asks for at least RESORT_FRAMES DISTINCT renders of view A (scenarios.ts:1204), not deliveries, so a store delivering an unchanged order on an intermediate frame fails it.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

a consumer per group (consumerPerGroup, bind)narrowaudited against the current code

50 steps, with one view per group (50 views) instead of two. Each step reorders rows inside one group's page, so exactly one view may re-render. Measured: how many of the other 49 views were woken anyway. A library that notifies only the affected group wakes 50 views in total; one that notifies everybody wakes 50 × 50, and each of those views re-renders its page.

The only many-views selectivity probe in the suite; real in kind (boards, dashboards) but oversized per view, so its gaps are dominated by consumer re-renders.

Models: A screen with one live view per group (fifty board columns or fifty dashboard widgets) where one group's order changes per frame. Measures: Wake-up selectivity across many standing views: how many of the 49 unaffected consumers are woken per write.

Favours: Stores with a per-group change signal (a bucket or index per group with its own subscribers): 50 deliveries for 50 steps. Against a single global change signal: 50 × 50 deliveries, each a full 32-line render (scenarios.ts:1241-1249). Stores that maintain all 50 group indexes are no longer charged for unread groups here (WHY-EACH-ROW.md:559-587).

  • The consumer is 50 times larger for a non-selective store: each redundant wake formats and hashes 32 lines (render.ts `deliver`; consumer.ts:108-147). The gap is mostly consumer cost multiplied by wake count, which WHY-EACH-ROW.md:589-600 states; the ratio is not a store-only ratio.
  • Fifty standing windows of 32 rows is 1600 rendered rows, larger than a typical screen. Real many-view screens (boards, dashboards) usually show fewer rows per view; the size inflates the non-selective penalty.
  • Each step is a rank move inside one window (scenarios.ts:1266-1276), a shape change; stores that re-point per-visible-row subscriptions on shape change (oimdb, tinybase) pay it 50 times per run, linear in the window (WHY-EACH-ROW.md:615-629). Tilts against them at the wide point, toward them at the default.
  • Bind-time cost of fifty views is outside the clock (`rebuild: false`, scenarios.ts:1253; WHY-EACH-ROW.md:610-614).

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

targeted column delivery (cellDelivery, bind)narrowaudited against the current code

16 steps over 8 rows that are looked up once before timing starts. View A shows their `label`, view B their `note`. The first half of the steps changes each `label`, the second half each `note`. A change must reach only the view showing that field: a library that tracks fields wakes one view per change, one that tracks whole rows wakes both, and one that tracks nothing re-reads everything.

An isolation of column-level delivery on pre-resolved rows; a real pattern for detail panes, but built around a handle some libraries do not have, so its times mix two properties.

Models: A detail pane, form or per-cell component bound to specific fields of specific rows that the code already holds a handle to, with one field written per frame. Measures: Delivery granularity by column on pre-resolved rows: whether a write to `label` wakes only the label view and a write to `note` only the note view.

Favours: Stores that route by column (per-property tracking, per-column identities): one view woken per write. Libraries that hand back a reusable handle for a key: the address is resolved untimed in `pin` (scenarios.ts:1627-1629) and every timed write goes through it; the script's comment says the pin exists to make oimdb's identity path measurable (scenarios.ts:1516-1522). Against row-granular stores: both views woken, one with identical text; against no-granularity stores: everything re-read.

  • The pin is a resolution outside the clock that only some libraries can use; libraries whose id is the handle pay a keyed lookup per write. The row therefore mixes column routing with handle availability; the comment states the pin is not isolated (scenarios.ts:1531-1533).
  • Eight rows, off screen, window views torn down (`PINNED_COUNT`, dataset.ts:79): a constructed situation with no window derivation at all, so the row isolates delivery and nothing else.
  • One write per settle (scenarios.ts:1647-1661): coalescing does not enter, and `frame` is not used.
  • The comment cites `packages/core/src/abstract/OIMCollection.ts:469` for the lookup cost (scenarios.ts:1518); that directory does not exist in the tree (`packages/core/src/abstract/` is absent, and no `OIMCollection.ts` is under packages/core/src). The 103-132 ns versus 36-51 ns figure is unverified.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

cell lower bound (cellFloor, bind, floor)syntheticaudited against the current code

Lower bound, no library: the steps of "targeted column delivery", each rendering one changed line of a 8-line view straight from an array of strings. A library that notifies only the view showing the changed field renders this much; one that notifies both views renders twice as much.

A delivery-only lower bound for the cell table; correct in shape, and its multiple is a delivery ratio, not a store ratio.

Models: Nothing an application does: the cell script with the store removed, used as the lower bound of the `cellDelivery` table. Measures: The cost of one 8-line cell delivery through `deliverCells` per step, from arrays of strings.

Favours: No participant; it is the scale for the cell table. It is tight for column-routing stores (one delivery per step) and half of a row-granular store's delivery work (scenarios.ts:3743-3747).

  • Delivers exactly one view per step (scenarios.ts:3847-3854); a correct row-granular store delivers two (one redundant). The floor therefore bounds both and separates them only through the counters.
  • The values are held in two prepared string arrays (scenarios.ts:3734-3735); no lookup by key and no pin is in the timed region, so it bounds the delivery and not the address.
  • Suffix alternation keeps every delivery distinct (scenarios.ts:3843-3844), so the digest fold is paid on every step as it is by the store rows.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

delete the visible window (deleteRows, bind)narrowaudited against the current code

One step: all 32 rows view A shows, the top of group A, are deleted in one batch. View A must re-render once, refilled with the rows that were below it. View B shows a different group and must not change.

A real bulk-delete with a refill, positioned at the head of the order; read beside `deleteOneRow`, which now measures the single-row case.

Models: Bulk removal of everything currently visible in one list (select-all-on-page and delete, or a server purge of those keys), refilled from the rows behind. Measures: Batch removal from an ordered group plus the window refill, in one frame.

Favours: Stores that remove a batch by one filter or rebuild pass over stores that remove element by element from a sorted array; the script was sized to stress the latter (scenarios.ts:1306-1315). Neutral on coalescing: `remove(ids)` is ONE binding call (scenarios.ts:1337-1340), so every adapter can wrap it in its library's batch.

  • The 32 removed rows are the lowest-ranked of group A, contiguous at the head of the sorted group (`plan.windowA`, scenarios.ts:1320, 1338; dataset.ts:794). For a splice-based ordered list that is the worst position (every remaining row shifts) and for a filter rebuild it is no different from any other; tilts against per-element splice designs. The removal in oimdb's ordered bucket is `indexOf` + `splice` (packages/core/src/engine/bucket/array/OIMBucketSlotsServiceArrayDriven.ts:58-63; `removeAt` :160-169).
  • The class the script's comment cites, `OIMBucketServiceOrdered` (scenarios.ts:1307-1310), does not exist in core/src; the adapter uses `OIMBucketSlotsServiceArrayDriven` (adapters/oimdb.ts:2, 138).
  • `repeatable: false` (scenarios.ts:1328) gives one run per sample (cells/runBatch.ts:55); the timed region is short, so per-sample noise is a larger share.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

delete one visible row (deleteOneRow, bind)representativeaudited against the current code

8 steps. Each step deletes one row view A shows, from different positions on the page: js-framework-benchmark's "remove row". View A must re-render once per step and stay full, pulling up the next row from below. View B must not change. Compare with "delete the visible window", which deletes the whole page at once.

Single visible-row removal from a sorted paged list with refill, eight times; a common act at a realistic size, removing from the head and upper two-thirds of the window only.

Models: A user deleting one visible item at a time from a sorted, paged list; js-framework-benchmark's remove row. Measures: One removal from an ordered group of about 200 rows, the window refilling from the row just outside it, and one full-window delivery, eight times.

Favours: Stores that patch the window incrementally over those that re-derive it, and ordered buckets with cheap removal over arrays with indexOf plus splice. Each step removes one row, so the delivery of 32 lines is likely a large share; not measured for this card. Against stores that subscribe per visible row: a removal shifts every row below it up one slot, so those stores re-point the subscriptions of the shifted rows.

  • Removal positions are fixed: `windowA[floor(i·WINDOW/8)]` (dataset.ts:1083-1086), original positions 0, 4, …, 28. After k removals the row at original position 4k sits at current position 3k, so the current positions removed are 0, 3, 6, …, 21. The last third of the window is never removed from, and the first removal is the head.
  • One `remove` per step outside any `frame` (scenarios.ts:1388-1393); batching plays no part, which is the point of this row against `deleteRows`.
  • The removed rows are copied once in `prepare` (scenarios.ts:1375-1383) and the same objects are written back by every `restore` (:1384-1387). A store that keeps the objects it is given holds these identities across samples; whether any participant has an identity-keyed cache this warms was not checked.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

the group empties under the view (drainGroup, bind)narrowaudited against the current code

Two steps, starting with group A empty. Step one inserts every row of group A, so its list is built from nothing; step two deletes all of them in one batch, so view A must end showing an empty list. No other scenario empties a list. Afterwards the store is checked for rows a partial delete left behind. View B shows a different group and must not change.

A whole selection rebuilt from nothing and emptied, ending on the empty state so that the emptying is checked; the rebuild in between is checked only for having produced a state.

Models: A selection refilled from nothing and then emptied under a mounted view: a folder whose items arrive and are all deleted, a cart filled and cleared. Measures: Inserting every row of one group into a store that holds none of them, delivering the rebuilt selection, then removing every one in one call and delivering an empty selection.

Favours: Stores that derive the group's order at read time (the lean anchor rescans) over stores that keep an ordered bucket, where bucket insert or removal is linear per row. The engine's ordered bucket removes by `indexOf` plus `splice` (packages/core/src/engine/bucket/array/OIMBucketSlotsServiceArrayDriven.ts:58-63) and inserts by `splice` (:154); the scenario file's comment on `deleteRows` (scenarios.ts:1306-1310) says the same of a class name that no longer exists. Stores with a cheap path for creating a bucket from nothing and releasing an empty one. The description's 'gives a bucket back' (scenarios.ts:1422) is phrased in the engine's terms; designs with no bucket pay nothing for it.

  • THE REBUILT SELECTION IS NOT VERIFIED. `finalStateOnly` (scenarios.ts:1432) compares only the ending state, which is empty. A write-back that lost rows, or rendered a wrong window in step one, still produces two distinct states, an empty final view and a population and grouping audit that pass, because the removal takes every id either way. The description says so (scenarios.ts:1427-1428).
  • The same row objects are written in every sample: `drainRows` is cloned once in `prepare` (scenarios.ts:1434-1437) and reused by every run. A store that keeps given objects receives these exact identities again; whether any participant has an identity-keyed cache that this makes warm was not checked.
  • Two frames over about N/50 = 200 rows at the default point (GROUPS, dataset.ts:37). No other group is touched, so view B's silence is cheap for every design.
  • B4 divides by two window deliveries (`steps: 2`, scenarios.ts:1430; floor.ts:86, 95). A correct second step delivers an EMPTY window, which costs the consumer almost nothing, so the floor overstates the minimum consumer work for this script and is not a strict lower bound on it.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

re-send unchanged list (resendUnchanged, bind)representativeaudited against the current code

One step: the 32 rows view A shows are written again, as new objects, with exactly the values they already have, like a page fetched again from a server. The benchmark code does not filter them out, so this shows whether the library itself notices that nothing changed. No view may show new text; how often views were woken for nothing is counted.

A real and frequent client event — an unchanged refetch — sized to one page; it carries no floor multiple, which fits a script whose correct answer delivers nothing.

Models: A page refetched or replayed with nothing changed — polling, refetch-on-focus, a websocket snapshot — written into the store as fresh objects. Measures: Whether the library itself detects a value-identical write and stays silent, and what the check costs.

Favours: Libraries that compare values on write (per-field equality, a no-op set): no derivation, no delivery. Against libraries that treat every write as a change (reference identity, whole-row replacement): they re-derive and deliver the identical window.

  • No adapter may pre-filter (types.ts:11-13; scenarios.ts:1464-1466, description :1484-1486). This measures each library alone, which is fair; in applications a fetch layer often provides structural sharing before the store sees the data, so the penalty on non-comparing libraries is larger here than in apps that use such a layer.
  • The page is exactly view A's visible rows (`resendCopies` are clones of `windowRows`, worker.ts:164-168, 309), so every write targets a visible row — the strongest wake. A real page refetch may include rows not on screen; neutral to slight tilt against non-comparing stores.
  • One `write(rows)` call (scenarios.ts:1496-1502) and no `frame` call: a library can batch inside `write`, so eager and deferred stores are on equal terms without `frame`.
  • ADDRESSED: the window floor. `rendersNothing` is set (scenarios.ts:1489), so `stepDeliveryOf` returns `nothing` (floor.ts:79), there is no floor (floor.ts:91-100, 144-147), and the table prints `no floor` (floor.ts:191) with the `UNBOUNDED_BECAUSE` reason (floor.ts:129-136).

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

consumer lower bound (consumerFloor, bind, floor)syntheticaudited against the current code

Lower bound, no library: a page of 32 rows rendered 32 times straight from an array of plain objects. Every participant renders through the same code, so no library can render a page for less; one that stores rows as proxies or wrapped objects also pays to read through them.

The divisor of most tables in the report; as the code stands it is not the floor its documents describe, though it no longer divides the silent scripts.

Models: Nothing an application does: the consumer alone, driven over plain objects, used as the lower bound of every window-delivery table. Measures: The cost of formatting and hashing one 32-row window delivery, per step.

Favours: No participant. As the divisor of the window tables it decides which rows carry the floor-bound mark (floor.ts:16, 197-203), so its accuracy tilts every one of those tables.

  • The code still contains the per-row ternary that floor.md's tombstone (floor.md:17-30) says was removed: `i === step % rows.length ? `p${step}` : row.label` (scenarios.ts:3219), one remainder, one compare, one branch per row and one template-literal allocation per step that no participant's `deliver` performs. floor.md says this inflated the floor and deflated every multiple; it is still there.
  • render.md:9-10 says `consumerFloor` calls `deliver` rather than inlining it, and floor.md:25-26 says it calls `deliver` over two alternating windows; the run calls `consumer.begin/row/end` directly over `floorRows` only (scenarios.ts:3209-3223). `floorRowsB`, built for that design (worker.ts:316-319; types.ts:380-381), is used by no scenario (grep over src/).
  • Drives ONE consumer per step (scenarios.ts:3211) where most scripts it scales deliver to two views; floor.md:13-15 names this as an open defect. The view count and the ternary move the printed multiple in opposite directions, so 'conservative' (floor.md:9-11) is not established.
  • Its description says tinybase hands a pooled holder and tanstack-db an enriched row (scenarios.ts:3135-3137); floor.md:6-7 says every adapter except mobx hands plain objects. tinybase's holders are plain literals overwritten in place (adapters/tinybase.ts:80-81, 110, 158-173), so that half agrees; tanstack-db hands its live query's `toArray` with the read's virtual properties widened away by a cast (adapters/tanstack-db.ts:345-348), which is not what floor.md calls plain. Which cost is higher was not measured.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

mount lower bound (mountFloor, bind, floor)syntheticaudited against the current code

Lower bound, no library: 8 cycles of subscribing 256 callbacks to one plain object, changing it, running them, unsubscribing all, changing it again. Subscribers live in a plain array with constant-time removal. No library can subscribe and unsubscribe for less; the mount and unmount tables are scaled by it.

A reference cost for one hand-written mount/unmount shape with no library; despite its label it is not a lower bound and floor.ts divides no churn table by it.

Models: Nothing an application does. It is an instrument: 256 closures pushed into one plain array, one write, every body run, one delivery, then an O(1) swap-remove of each, one more write, no delivery; eight cycles, no store and no library. Measures: The cost of allocating a closure, recording its position and its read in side arrays, running it once, and removing it by swap-with-tail, amortised over the largest subscriber count in the churn family.

Favours: Nothing by construction: no participant runs in this table. It exists to be printed beside the churn tables.

  • Its label (`mount lower bound`), its description and its own B4 answer call it a lower bound that scales the nine churn tables. `floor.ts` says the opposite: `BOUND_BY` has no `mount` entry (floor.ts:91-100) and `UNBOUNDED_BECAUSE` records that churn rows come out UNDER it (eight of eighteen on `churnShared`, floor.ts:108-119). A reader trusting the label is misled about every churn row's distance from it.
  • The per-mount bookkeeping (closure, list slot, owner and position side-array slots, a per-subscriber read slot for the churn read fold, and a swap-with-tail plus two resets to leave; scenarios.ts:3453-3480) is heavier than what a Set-based listener or a recorded-position engine pays, which is why rows beat it; the figure is a reference cost of one particular hand-written shape, not a minimum.
  • Amortises the two frames over 256 mounts, so its per-step frame share is the smallest in the family; comparing its per-step number to `churnOne` (one mount per two frames) compares mostly frame overhead.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

mount and unmount one subscriber (churnOne, churn.row)narrowaudited against the current code

8 cycles of: subscribe one component to one row, change the row; unsubscribe, change it again. The smallest mount and unmount, which every other mount and unmount scenario is compared with. The first change must reach the component once; the second must reach nobody.

One subscription mounted and disposed per two frames; a real act at its smallest size, so the number is dominated by per-frame constants rather than by the mount.

Models: A conditional render toggling one component that subscribes to one entity: mount, the entity changes, unmount, the entity changes again with nobody listening. Measures: The fixed cost of creating and disposing one subscription on one source, plus two write+settle frames per pair; with one pair per two frames, the frame cost is most of each step.

Favours: Stores with a cheap near-empty frame (settle with one dirty source and one or zero subscribers), since each step carries two full frames. Stores whose subscribe allocates little (one closure or one edge) over those that build an observer object, a dependency Set or a derived atom per subscription.

  • steps = CHURN_CYCLES × 1 = 8 (scenarios.ts:1898), so each reported step includes two writes, two settles and one delivery; the row ranks frame overhead as much as mount cost. Toward stores with low per-frame constants.
  • The row is resolved before the clock (`holdChurnRows` in `prepare`, scenarios.ts:1912-1918), so key-to-handle lookup is excluded from the mount for everyone. Toward identity-holding stores whose mount would otherwise start with a lookup that selector-based stores do not have.
  • No churn table has a floor (floor.ts:81, 91-100, 108-119), although the shared standing's B4 comment says `mountFloor` scales it (scenarios.ts:249-255).

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

N subscribers on one root, oldest out first (churnShared, churn.row)narrowaudited against the current code

8 cycles of: subscribe 32 components to the same row, change it, unsubscribe them oldest first, change it again. This is a list of components bound to one shared object being mounted and unmounted. Compare with "mount and unmount one subscriber" for the cost per component, and with the N×8 variant for whether that cost grows with the number already subscribed.

Mount and unmount of 32 subscribers sharing one source, oldest-first; a real but uncommon fan-in shape whose order and list-structure effects are below noise at this size.

Models: 32 components that all subscribe to the SAME entity mounting together and unmounting oldest-first, e.g. items that each read one shared record (current user, settings), torn down when a route changes. Measures: Per-subscriber add and remove on one source's listener list at length up to 32, plus one wake of all 32 per cycle; the per-source subscriber list structure decides it.

Favours: Listener lists with O(1) removal (Set, recorded position plus swap-remove) over arrays with indexOf plus splice, though at 32 the difference is below run-to-run spread per WHY-EACH-ROW.md:1616-1619 (3.7-5.0 % of cost at 32; recorded figures, not re-measured). Stores whose mount is one edge into an existing source list over those that build a per-subscriber observer graph.

  • All 32 subscribers on ONE row (`onSharedRow`, scenarios.ts:2010). This is the fan-in corner; the ordinary list mount, one subscriber per row, is `churnList` (scenarios.ts:2260-2285), which also differs from this row in write volume (see that card).
  • The hand-written anchor unmounts with indexOf plus splice (adapters/baseline-array.ts:638-650); per WHY-EACH-ROW.md:1530-1535 and :1580-1590 `@oimdb/core` removes by recorded position (not re-read in packages/core for this card). The anchor does more work by algorithm. Toward oimdb against the anchor.
  • Each step includes 1/32 of two frames and one wake per subscriber per cycle, so cheap wake-up helps as much as cheap mount.
  • No floor divides this table (floor.ts:81, 91-100, 108-119), contrary to the standing's B4 comment (scenarios.ts:249-255).

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

N subscribers on one root, newest out first (churnSharedReversed, churn.row)narrowaudited against the current code

The same as "N subscribers on one root, oldest out first", but the 32 components unsubscribe newest first. The difference shows whether the order of unmounting matters: a library that keeps subscribers in an array pays differently for removing from its front and from its back.

churnShared with LIFO unmount; it prices removal order on a 32-long listener list, an effect this suite's own run found below its noise at this size.

Models: The same 32 components on one shared entity as `churnShared`, torn down newest-first, as a stack of routes popped or a list unmounted from the bottom. Measures: The cost of unmount order on a 32-long per-source listener list: for an array with indexOf plus splice, a long scan and no shift instead of a short scan and a long shift.

Favours: Order-insensitive removal (Set, recorded position): those rows should equal `churnShared`; array-backed lists move.

  • At 32 subscribers the order effect is inside run-to-run spread (WHY-EACH-ROW.md:1525-1526: oimdb 126.7 vs 132.9 ns, baseline-array 73.6 vs 80.0, with 0.3-10.7 % between-process disagreement at :1549), so the pair this row exists for is not resolved at this size. Recorded figures from before the 2026-10-17 library upgrades (jotai was 2.20.2 then, 3.0.1 is installed) and before the engine's removal changed (:1568-1590); not re-measured.
  • All subscribers on one row (`onSharedRow`, scenarios.ts:2010); see `churnShared`. Order only matters where a per-source list is long, which is the uncommon shape.
  • No floor divides this table (floor.ts:81, 91-100, 108-119), contrary to the standing's B4 comment and B4 answer (scenarios.ts:249-260).

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

N×8 subscribers on one root, oldest out first (churnSharedDeep, churn.row)syntheticaudited against the current code

The same as "N subscribers on one root, oldest out first" with 256 components instead of 32. If unsubscribing is linear, eight times the components cost eight times more; sixty-four times more means it is quadratic. One size cannot tell those apart, which is why there are two.

An instrument: 256 subscribers on one source, to show whether unmount is quadratic; read only as a ratio against churnShared, not as a workload.

Models: 256 components subscribed to one shared entity, mounted and torn down oldest-first. Rare as a workload; it is the large half of a size pair against `churnShared` to expose a quadratic unmount. Measures: Whether mount plus unmount on one source is linear or quadratic in the number of subscribers on it: read against churnShared, 8× growth is linear, 64× is quadratic.

Favours: O(1) listener removal (Set delete, recorded position plus swap-remove). Array indexOf plus splice pays a quadratic term, recorded at 25-33 % of cost at 256 (WHY-EACH-ROW.md:1559-1566; not re-measured).

  • The anchor keeps indexOf plus splice (adapters/baseline-array.ts:638-650) while `@oimdb/core` removes by recorded position per WHY-EACH-ROW.md:1580-1590 (not re-read in packages/core), so on this row the anchor is algorithmically handicapped against the engine. Toward oimdb in the oimdb/anchor ratio.
  • 256 subscribers on one row (dataset.ts:146, `onSharedRow`, scenarios.ts:2010) is a stress size for a single source; ordinary lists spread subscribers over rows.
  • Each cycle also wakes all 256, so wake cost is in every step.
  • No floor divides this table (floor.ts:81, 91-100, 108-119); the `mount` reason says rows of this table come out under `mountFloor` (floor.ts:110-113).

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

N×8 subscribers on one root, newest out first (churnSharedDeepReversed, churn.row)syntheticaudited against the current code

256 components on one row, unsubscribing newest first. With the other three variants it shows whether the effect of unmount order grows with the number of components or stays constant.

An instrument completing the size × order square for unmount on one source; meaningful only as a ratio against its three siblings.

Models: 256 subscribers on one shared entity torn down newest-first; the fourth corner of the size × order square. Measures: Whether an unmount-order effect grows with the number of subscribers on one source (array indexOf plus splice) or is constant (Set, recorded position).

Favours: Order-insensitive O(1) removal; array-backed lists pay the long scan on every unmount.

  • Same anchor asymmetry as churnSharedDeep: anchor indexOf plus splice (adapters/baseline-array.ts:638-650) against the engine's positional removal (`unsubscribeFrom`, packages/core/src/engine/computed/OIMEffect.ts:118-126). Toward oimdb in that ratio.
  • Stress size on a single source (dataset.ts:146); one subscriber per row (`churnList`) has no order effect at all.
  • No floor divides this table (floor.ts:81, 91-100, 108-119).

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

one subscriber over many sources (churnWide, churn.wide)narrowaudited against the current code

8 cycles of: subscribe one component that reads 64 rows, change the first of them, unsubscribe, change it again. The other variants vary how many components watch one row; this one varies how many rows one component watches, which is what a subscription pays to register with each of its sources and to leave them. Compare with "mount and unmount one subscriber", whose component reads one row.

One subscriber over 64 statically known sources mounted and disposed; real for aggregate components, blind to dynamic dependency tracking, and its check proves registration on one source only.

Models: One component that reads 64 entities at once (a summary, a total, a chart over a selection) mounting and unmounting. Measures: What a subscription pays for a 64-entry source list: registering in 64 sources on mount and leaving each on unmount, plus any deduplication or expansion of the list.

Favours: Stores whose multi-source subscribe is one object plus one edge per source (an effect over a source array, a hand-written list per id) over stores that compose a derived node over 64 per-entity nodes. Stores that take the source list as given; the script never asks a store to discover its sources by tracking reads, so tracking-based designs pay for a capability the script does not exercise.

  • The source list is static and known at mount (`mountOnRows(at, 0, CHURN_WIDE)`, scenarios.ts:2149). No dynamic dependencies: a component whose reads change between renders is not represented. Toward explicit-source designs.
  • The 64 rows are resolved before the clock (`holdChurnRows` in `prepare`, scenarios.ts:1912-1918), so the lookup of 64 keys is excluded from every mount.
  • One subscriber per cycle, so per step = one 64-source pair plus two frames; the frame share is small relative to 64 registrations but still present.
  • No floor divides this table (floor.ts:81, 91-100, 108-119).

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

N subscribers on one column (churnColumn, churn.column)narrowaudited against the current code

The same as "N subscribers on one root, oldest out first" (32 components, 8 cycles), but each component subscribes to one field of the row, `label`, instead of the whole row. The difference is what subscribing to a single field costs. A library with no per-field subscription skips this scenario rather than repeat its whole-row number.

Mount and unmount of 32 field-level subscriptions on one row; read only against churnShared, with two libraries absent from this table, and no frame that shows the payoff of column addressing.

Models: 32 components that each read one FIELD (`label`) of one shared entity, as a field-level selector or signal, mounting together and unmounting oldest-first. Measures: The difference between subscribing to a column identity and to a whole row, at the same count, root and order as churnShared: minting or finding the column handle and releasing it.

Favours: Stores with a first-class field identity (field signals, column handles) over stores that model a field subscription as a selector with an equality check. Stores that mint the column handle cheaply and share it across the 32 subscribers.

  • Two libraries decline: lokijs (adapters/lokijs.ts:472, reason at :1010-1017) and redux-toolkit (adapters/redux-toolkit.ts:547, reason at :1137-1144), as do `baseline-array-indexed` (adapters/baseline-array-indexed.ts:405) and `control-write` (harness/control.ts:1258). This table and churnShared hold different populations; the pair comparison is across two populations for those rows.
  • The hand-written anchor keeps a second Map of `label` subscribers by row id (adapters/baseline-array.ts:431-432, mount at :583-588) and its settle probes both maps for every touched row (adapters/baseline-array.ts:531-543). That probe is paid on every churn script, not only here. WHY-EACH-ROW.md:1627-1636 recorded the anchor at 174.6 vs 73.6 ns/pair and attributes it to a `${id}|label` key the current anchor no longer builds; that figure describes an older anchor body.
  • Only `label` is written, and every subscriber reads `label`; nothing measures whether a column subscription stays silent when ANOTHER column of the row changes, which is the point of subscribing to a column.
  • All 32 on one row (`mountOnColumn` reads `churnRows[0]`, e.g. adapters/oimdb.ts:489-495); see churnShared.
  • No floor divides this table: `stepDeliveryOf` returns `mount` (floor.ts:81), `BOUND_BY` has no `mount` entry (floor.ts:91-100), `UNBOUNDED_BECAUSE` gives the reason (floor.ts:108-119).

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

N subscribers on N rows, a list (churnList, churn.row)representativeaudited against the current code

8 cycles of: subscribe 32 components, each to its own row, the way a list mounts one component per row; change some of those rows in one batch; unsubscribe them oldest first; change the same rows again. Each cycle changes 4 fewer rows, so the number of components that re-render proves each watches its own row. After unsubscribing nobody may be notified. Compare with "N subscribers on one root, oldest out first", where all components share one row.

One subscription per row for a 32-row list, mounted, written and torn down; the ordinary list shape at a small size, whose gap against the shared-root row also carries 272 extra writes.

Models: A list of 32 items mounting one component per row, a batch of those rows updating, then the list unmounting: the ordinary list mount. Measures: 32 single-row subscriptions on 32 distinct rows mounted and disposed per cycle, plus a frame that writes 4 to 32 of those rows inside `frame` before and after the unmount.

Favours: Stores with a per-row subscriber list: each list has length one, so list structure (array, Set, position) stops mattering and the per-subscription allocation decides. Libraries whose batching API `frame` reaches (scenarios.ts:1886-1889): up to 32 writes per frame become one notification. Redux Toolkit's adapter defers listeners to the frame end with autoBatch (adapters/redux-toolkit.ts:72-101), but each of its 32 subscriber selectors still runs once per frame. Against stores with one store-wide listener: every standing subscriber's selector runs on each notification, written row or not (adapters/redux-toolkit.ts:449-462).

  • THE PAIR WITH `churnShared` IS NOT ISOLATED. The description says the gap against `churnShared` is what a subscriber list per row costs (scenarios.ts:2272-2274). The scripts also differ in write volume: this one writes 32+28+…+4 = 144 rows twice per run, 288 `patchLabel` calls inside `frame` (`churnListPrefix`, scenarios.ts:2020-2022; `writeFrame`, :1880-1890), where `churnShared` writes 16 calls outside any `frame`. The gap includes 272 extra writes and 16 frame scopes.
  • 32 rows is a small list; js-framework-benchmark-style list mounts are 1000 rows. The mount count per cycle is the same as `churnShared`'s, by design.
  • The rows are resolved before the clock (`holdChurnRows`, scenarios.ts:1912-1918), so key lookup is out of every mount.
  • No floor divides this table: `stepDeliveryOf` returns `mount` (floor.ts:81), `BOUND_BY` has no `mount` entry (floor.ts:91-100), `UNBOUNDED_BECAUSE` gives the reason (floor.ts:108-119).

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

N subscribers over a derivation chain (churnChain, churn.chain)narrowthe code changed after this audit

A dashboard of 32 tiles; tile i summarises rows i to i+7 through a chain of 4 derived values, built when the tile mounts, like a component's selectors. 8 cycles of: mount all tiles, change row 0, unmount them oldest first, change row 0 again. Only tile 0 reads row 0, so exactly one tile may update, and after unmounting none may. Measured: building chains of derived values on mount and taking them apart on unmount.

Per-subscriber linear selector stacks built and destroyed; it prices mount-time chain construction, with every chain's depth checked on audited passes, but no graph shape (sharing, cutoff) that differentiates reactive engines.

Models: 32 components each building its own selector stack at mount (a selector factory, per-instance derived atoms or computeds) of 4 derivations over 8 entities, then torn down. Measures: Building and tearing down a 4-deep linear derivation chain per subscriber, including whatever walk the store does to find the roots under the chain.

Favours: Hand-written code, which knows the roots statically and builds nothing at mount (adapters/baseline-array.ts:589-618); the standing admits the two sides do not do the same job (B1 NOT MET, scenarios.ts:2326-2334). Stores whose derived nodes are cheap to allocate and whose subscription does not expand roots through the chain.

  • The chain is linear: level k applies `chainLevelOf` to level k−1 (derivations.ts:1-7; e.g. adapters/oimdb.ts:496-527, adapters/mobx.ts:415-429, adapters/redux-toolkit.ts:548-558). No diamond (that is `churnDiamond`), no fan-in between derivations, no equality cutoff exercised (every write changes root 0 and so every level), no derivation shared between the 32 subscribers.
  • Depth 4 (dataset.ts:162) is shallow; a store with O(depth) per-level overhead is hard to separate from one with O(1).
  • All 32 subscribers build identical chains over the same 8 rows (scenarios.ts:2378-2379); in applications such selectors are often memoised once and shared. Toward cheap per-instance allocation, against stores that would share.
  • The mount comparison against the anchor is not comparable (B1 NOT MET), and the report prints no per-row note for it, by the standing's own text.
  • Population: signaldb and lokijs decline the chain (adapters/signaldb.ts:1175-1180, adapters/lokijs.ts:1018-1024), as do `baseline-array-indexed` (adapters/baseline-array-indexed.ts:405) and `control-write` (harness/control.ts:1258).
  • No floor divides this table: `stepDeliveryOf` returns `mount` (floor.ts:81), `BOUND_BY` has no `mount` entry (floor.ts:91-100), and `UNBOUNDED_BECAUSE` gives the reason (floor.ts:108-119).

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

a write through standing chains (chainFrameWrite, churn.chain)narrowthe code changed after this audit

The same 32-tile dashboard as "N subscribers over a derivation chain", mounted before timing starts. 16 steps, each changing row 7: the 8 tiles that read it must recompute their chains and the rest must not wake. Nothing is mounted or unmounted, so this is the cost of running the chains; the other scenario is the cost of building them.

Propagation through standing per-component selector stacks, isolated from mounting; real in kind but linear, unshared and shallow, and the full depth of every chain is checked on audited passes.

Models: A screen of 32 mounted components, each with its own stack of 4 derived values over 8 entities, receiving one write to an entity they all read, frame after frame. Measures: Propagating one root write through 32 standing linear derivation chains and running every subscriber body once — the run half of `churnChain`, with mounting outside the clock.

Favours: Engines whose derived nodes are cheap to re-evaluate: each level of the oimdb wiring is an `OIMSingleComputed` applying `chainLevelOf` to the level below (adapters/oimdb.ts:525-545). The hand-written anchor reads the 8 roots once per wake and applies the 4 levels in one body (adapters/baseline-array.ts:594-618, `derive` at :602-610); it re-evaluates nothing it did not need, so it is a fair lower reference for the frame.

  • Every write changes root 0's label (CHURN_MARKS, scenarios.ts:1735-1738), so every level's value changes and no equality cutoff is exercised; no diamond (that is `churnDiamond`), no fan-in between derivations, and the 32 chains are built separately over the same 8 roots, so a store that would share them gets no credit.
  • Depth 4 over 8 roots (dataset.ts:161-162) is shallow; O(1) and O(depth) per-level overheads are hard to separate here.
  • The consumer receives one line per step (`deliverChurn`, render.ts:143-153), so the consumer's share of the time is small and the row is mostly store work. No floor divides it (see standing).
  • Each step is one `patchLabel` outside `frame` (scenarios.ts:2481-2487), so batching plays no part.
  • Population: signaldb and lokijs decline the chain (adapters/signaldb.ts:1175-1180, adapters/lokijs.ts:1018-1024), as do `baseline-array-indexed` (no churn wiring, adapters/baseline-array-indexed.ts:405) and `control-write` (harness/control.ts:1258).

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

N subscribers over a diamond (churnDiamond, churn.diamond)narrowaudited against the current code

8 cycles of: mount 32 components, each building its own diamond, two values derived from row 0 and a third that combines both; change row 0; unmount them oldest first; change it again. The combined value must be computed once per change, not once per branch: computing it twice is the "glitch" this checks for. Compare with "N subscribers over a derivation chain", where the derived values form a line.

A per-component diamond built and destroyed at mount, gated on glitch-freedom; the time prices three derived nodes per subscriber over one shared root, and every standing diamond's joined text is checked on audited passes.

Models: 32 components each building, at mount, two derived values from one shared entity and a third that combines them, then torn down; the combined value must update once per change. Measures: Building and disposing three derived nodes and one subscription per component over one shared root, plus one propagation through 32 diamonds per cycle, with a glitch (the join running once per arm) turned into a failure rather than a time.

Favours: Hand-written code, which computes both arms and the join inline in one body and builds no graph (adapters/baseline-array.ts:619-637); the standing says the mount is not comparable (B1 NOT MET, scenarios.ts:2541-2548). Libraries whose derived nodes are cheap to allocate and to dispose. Every passing library is glitch-free on this graph, so the time ranks graph construction and teardown, not scheduling. Pull-based or topologically ordered designs pass the correctness gate for nothing (mobx computeds, adapters/mobx.ts:430-436; reselect, adapters/redux-toolkit.ts:559-570); a push design without ordering fails instead of ranking.

  • ONE SHARED ROOT. Every diamond is over `churnRows[0]` (`mountOnDiamond(at, 0)`, scenarios.ts:2587), so a store where each arm subscribes to the root puts 64 arm subscriptions on one source list. List-structure costs of `churnShared` (indexOf plus splice) are mixed into this row.
  • The 32 diamonds are identical and never shared; a store that would dedupe identical derivations gets no credit, and one with cheap per-instance allocation is favoured.
  • The only write is one `patchLabel` per frame outside `frame` (`writeFrame` with count 1, scenarios.ts:1880-1885), so batching plays no part.
  • No floor divides this table: `stepDeliveryOf` returns `mount` (floor.ts:81), `BOUND_BY` has no `mount` entry (floor.ts:91-100) and `UNBOUNDED_BECAUSE` gives the reason (floor.ts:108-119).
  • Population differs from the row shape: signaldb and lokijs decline the diamond (adapters/signaldb.ts:1181-1186, adapters/lokijs.ts:1025-1031), as do `baseline-array-indexed` (adapters/baseline-array-indexed.ts:405) and `control-write` (harness/control.ts:1258).

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

a write through standing diamonds (diamondFrameWrite, churn.diamond)not audited

The same 32 diamonds as "N subscribers over a diamond", mounted before timing starts. 16 steps, each changing row 0: every diamond recomputes once per step. Nothing is mounted or unmounted, so this is the cost of running diamonds; the other scenario is the cost of building them.

churn against a standing population (churnResident, churn.row)narrowaudited against the current code

256 components stay subscribed to one row the whole time. 8 cycles of: subscribe 32 more to the same row, change it, unsubscribe those, change it again. A real screen keeps most of its subscriptions and mounts or unmounts a few; this shows whether that costs more when many subscribers are already there.

Churn of 32 subscribers against 256 standing ones on the same source; an end-to-end churn-plus-notify cost, dominated by resident wake-ups, not a mount cost under load.

Models: A screen that keeps most of its subscriptions and churns a fraction: 256 standing subscribers on one entity, 32 more mounted and unmounted on it per cycle. Measures: End-to-end churn against a long standing listener list on one source: 32 mounts and unmounts plus 288 + 256 wakes per cycle, not mount cost alone.

Favours: Stores with cheap wake-up per subscriber: per cycle 544 bodies run where churnShared runs 32 (WHY-EACH-ROW.md:1651-1660), so wake cost dominates the time. Stores whose unmount is O(1) in the standing list (Set, recorded position); indexOf plus splice scans up to 288 entries per unmount.

  • The residents share the churned root (`mountResident: onSharedRow`, scenarios.ts:2683), so both frames wake them; the row cannot separate mount cost from wake cost (A1 NOT MET, scenarios.ts:2612-2620). A reader using it as 'mount cost when 256 are standing' reads the wrong number.
  • In an application the standing subscriptions of a screen sit on many entities, so a churned mount does not lengthen any one list; putting all 288 on one source makes list length the variable, which is the uncommon case.
  • Per step (`steps` = 8 × 32, scenarios.ts:1898) carries 17 wakes plus a share of two frames. Toward stores with fast notification loops.
  • Anchor uses indexOf plus splice (adapters/baseline-array.ts:638-650) while the engine removes by recorded position per WHY-EACH-ROW.md:1580-1590 (not re-read in packages/core); toward oimdb in that ratio.
  • No floor divides this table (floor.ts:81, 91-100, 108-119).

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

an application screen fills (appFill, churn.row)narrowaudited against the current code

An app screen: 80 cards in 10 decks owned by 5 users, already in the store. In one step, 180 components mount (one per card, one per tag shown on a card, one per deck name, and one per deck date, which reads a setting of the deck's user) and 46 of the 95 records change. The only scenario where data changes and components mount together. Exactly 87 components, those whose own record changed, must re-render.

Mount wave plus one partial write frame over a small single-collection scene; the woke count and, on audited passes, the per-slot read fold say which row every subscriber sits on.

Models: A screen opening: 180 components mount over 80 cards, 10 decks and 5 users, and part of the data they show changes in the same frame. Measures: Mounting 180 single-row subscriptions inside the clock, then one frame of 46 label writes that must wake exactly the 87 subscribers whose own row was written, delivered as one line.

Favours: Stores whose per-subscription mount is cheap; 180 mounts against 46 writes make the mount the larger share of the step. Libraries whose batching API `frame` reaches (scenarios.ts:2916-2921) pay one notification instead of 46. The wake count does not change with batching: every subscriber reads one row (`mountOnRows(…, 1)`, scenarios.ts:2749-2753), and each written row is written once. Against stores with one store-wide listener: every standing subscriber's selector runs at the notification, written row or not (adapters/redux-toolkit.ts:449-462).

  • Nothing is inserted. The 95 scene rows are the first 95 rows of the dataset (`holdAppScene`, scenarios.ts:2726-2734), already in the store from the load (worker.ts:342-353, called at :362); the frame PATCHES labels. A screen fill usually creates rows as components mount, so key-creation cost is not in this row.
  • The three entity kinds are names, not types: cards, decks and users are rows of one collection with one shape, distinguished only by index offsets (scenarios.ts:2692-2700). A deck's date subscriber reads a fixed user row chosen by the harness (`appUserOfDeck`, :2700), so no relation is resolved by the store.
  • Each card has two subscribers on the same row (card and tag 0, scenarios.ts:2739-2742), so the fan-in is two per card, one per deck name and two per user.
  • One frame, 46 writes, 180 subscribers: a small screen. Mount and write are not separated, so a row's time cannot be split between them from this table alone.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

an application screen in use (appRound, churn.row)narrowaudited against the current code

The same app screen as "an application screen fills", mounted before timing starts. 20 rounds, each one step: every card's tag list grows by one tag, or drops from 4 back to one, mounting or unmounting tag components; every deck is renamed, every card toggled, and one user's setting changed. Mounts, unmounts and changes to cards, decks and users happen together. Each round must produce one update with exactly the expected components re-rendered.

A dense composite frame — mounts, unmounts and writes over the whole scene, every frame — with an exact wake count and, on audited passes, a per-slot read fold that catch leaked, missing or misplaced subscriptions; real in kind, heavier than any screen sustains.

Models: A mounted screen in heavy use: lists of tags growing and shrinking under every card, every deck renamed, every card toggled and one user's setting changed, all in each frame. Measures: One frame per round of subscriber mounts or unmounts followed by 91 writes over three entity roles, with the exact number of woken subscribers named in the delivered line.

Favours: Stores with cheap mount and unmount: each round mounts 80 tag subscribers, or unmounts 240 on every fourth round (tag count cycles 2, 3, 4, 1 via `appTagsAfter`, scenarios.ts:2701, 2972-2978). Stores whose wake cost is per subscriber of the written row rather than per standing subscriber. A store with one store-wide listener runs every subscriber's selector at each notification (adapters/redux-toolkit.ts:449-462). Inside `frame` the Redux Toolkit adapter defers notification to the frame end with autoBatch (adapters/redux-toolkit.ts:72-101), so that is one walk over the 180 to 420 standing subscribers per round, not one per dispatch. Libraries whose batching API `frame` reaches (scenarios.ts:2982-2993) notify once per round instead of 91 times.

  • Intensity: every card and every deck is rewritten in every one of 20 frames and every card's tag list changes every frame. A real screen does each of these sometimes; all of them every frame is a stress composite.
  • Single collection, harness-resolved relations, two subscribers per card row at rest: the same scene as `appFill` (see that card).
  • SELECTIVITY IS ENFORCED, NOT MEASURED. The oracle's line names `appRoundWoke(round)` (scenarios.ts:2702-2703, 3013), so a library that wakes bodies outside the written rows fails rather than ranking slow. Every passing row reports the same counts; time is the only discriminator.
  • Mounts and unmounts happen before `frame` is opened (scenarios.ts:2973-2978 against :2982), so a library that would batch subscription changes with writes cannot.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

one setting moves (appSettingMove, churn.row)representativeaudited against the current code

The same app screen as "an application screen fills", mounted before timing starts. 20 steps, each changing one user's setting. Only that user's 2 deck-date components read it and must update; nothing else may. Measured: how quickly a library finds the few components that depend on a value stored in another record.

A common, selective write on a mounted screen; it prices finding a few subscribers among many, its counters are fixed by the check, and the audited fold proves which two bodies ran and what they read.

Models: A user changes one preference on a mounted screen (date format, locale, a toggle), and only the few components that read it should update. Measures: The cost of finding and running the 2 subscribers of one written row among 180 standing ones, per write.

Favours: Stores with a per-row or per-value subscriber list: the cost of a step does not depend on how many other subscribers stand. Against stores with one store-wide listener: every subscriber's selector runs on every write (adapters/redux-toolkit.ts:449-462), 180 per step here. Each step is one dispatch outside `frame`, so autoBatch flushes at once (adapters/redux-toolkit.ts:88-90, 103-108).

  • On a timed sample the delivered line is the same on every step: woke = 2 and subscriber 0's read, which is card 0 and is never written (scenarios.ts:3038-3046; render.ts:140-141). The moved dates enter the line only on the verify and proof passes, through the per-slot read fold.
  • The counters the report prints come from the audited passes (verify emit, worker.ts:545-549; proof-pass emit, worker.ts:671-676), where the fold makes every step's line distinct: `check` then expects 20 deliveries and 20 distinct (scenarios.ts:3047-3055), so redundant is 0 on every passing row. The counters are identical across passing rows; only the time differs.
  • 180 standing subscribers is a small screen; the gap between selective and store-wide designs grows with that count, and this point is where it is smallest.
  • One write per frame, so `frame` is not used and has nothing to change.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

read a page by key (readByKey, reads.byKey)narrowaudited against the current code

8 steps. Each looks up 32 rows by key, spread across the whole store, and renders `id rank label` for each. Nothing is written: the only scenario that times reading rather than reacting to a change. The keys may not be looked up in advance. The hand-written baseline answers with one Map lookup per key.

Untracked lookup of 32 rows by key per page out of 10,000; it prices raw keyed access and delivery, not the tracked read an application's render performs.

Models: Rendering a list from an array of ids against a normalised store: for each id, fetch the entity and render three of its fields. Eight pages of 32 ids, strided through 10,000 rows. Measures: The store's key-to-entity lookup and field reads, untracked, plus one 32-line delivery per page; nothing is written and nothing settles.

Favours: Stores whose lookup is one hash probe returning a plain object (Map-backed stores; both anchors do one `byId.get` per key, `adapters/baseline-array.ts:357-365`, `adapters/baseline-array-indexed.ts:334-342`) over stores that return proxies, enrich rows, or allocate per read. tanstack-db's keyed read is `collection.get` on the backing collection (`adapters/tanstack-db.ts:830-838`), which returns the row through `getWithVirtualProps` (`node_modules/@tanstack/db/dist/esm/collection/index.js:339-341`, `state.js:137-163`): a virtual-props record per call and an enriched copy cached per key. TinyBase is read as two `getCell` calls per key and a fresh row object per key (`adapters/tinybase.ts:907-924`); that is the adapter's reading of the library's cell API, not the script's.

  • The read happens outside any tracking context. In an application the same read occurs inside a component render or a computed and registers a dependency; signal and proxy stores pay that tracking cost there and do not pay it here. Toward fine-grained reactive stores relative to how they would fare on a tracked read.
  • The ban on resolving keys before the clock (`types.ts:141-143`, `scenarios.ts:4299-4303`) is a rule in prose; no check detects an adapter that kept handles from bind time. Compliance of all adapters is unverified by this card (oimdb `adapters/oimdb.ts:852-860`, mobx `adapters/mobx.ts:578-586`, tanstack-db, tinybase, lokijs `adapters/lokijs.ts:599-607` and both anchors comply).
  • A 32-line delivery per page is a large share of a step whose store work is 32 map probes; `consumerFloor` is the floor here (`floor.ts:86, 95`), so the multiple column is the reading to use.
  • Strided keys (`dataset.ts:902-905`) defeat contiguous layouts; a real id list is often in insertion or sort order, which would favour array-backed stores. Toward hash stores, mildly.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

scroll the window (scrollWindow, reads.byWindow)narrowaudited against the current code

8 steps. Each scrolls view A within group A, a quarter page at a time down to one full page and back to the top. No data changes. Every step must show a new page; view B, a filtered view of the same group that does not scroll, must not change. Compare with "the whole window re-sorted": there the data moves under a fixed page, here the page moves over fixed data.

Moves a window by a quarter-window up to one window deep and back; prices shallow offset changes only, and is read beside deepScroll, which asks the deep case.

Models: A user scrolling a sorted, filtered list: the visible window moves over unchanged data while a second view on the same group stays put. Measures: The cost of re-answering a window at a new offset over a maintained or re-derived ordering, plus whatever re-pointing of per-row subscriptions the store does, and whether the unmoved view is woken.

Favours: Rescanning stores, for which a new offset is nearly free on top of a scan they do anyway (the lean anchor's `render` walks the population each settle, `adapters/baseline-array.ts:286-301`), and listener-parameterised windows (TinyBase re-registers with offset/limit, `adapters/tinybase.ts:849-862`; `WHY-EACH-ROW.md:2043-2046`). Stores with change routing that leave view B unwoken (LokiJS dirties neither view on a scroll and re-reads only view A's slice, `adapters/lokijs.ts:608-628`; `WHY-EACH-ROW.md:2047-2049`).

  • Offsets go 8, 16, 24, 32, 24, 16, 8, 0 at WINDOW 32 (`dataset.ts:877-883`): never deeper than one window into a 200-row group. The deep case is now its own row, `deepScroll` (`scenarios.ts:4415-4457`), whose offsets go out to the group size less one window in four strides (`dataset.ts:884-887`); read this row beside it.
  • Each step jumps a quarter of the window at once; real scrolling delivers many small offset changes per second. The direction of that bias is unverified.
  • The comment that group A 'holds only two windows' (`dataset.ts:196-202`) is true at the `small` point (3,200 rows, 64 per group) and not at the default (10,000 rows, 200 per group, `cells/points.ts:4-6`).
  • oimdb re-points all 32 per-row subscriptions every step: `scrollTo` sets `shapeMoved` (`adapters/oimdb.ts:864-869`) and the next frame's `resync` disposes and re-creates one effect per visible row (`:765-781`), where only 8 rows actually enter and leave. That is the adapter's choice, not the script's, and it counts against oimdb. Its offset is an index into the ordered slot array (`slots[at]` from `state.offset`, `:770-771`), not a prefix walk.
  • tanstack-db's plain row declines `reads.byWindow` (`adapters/tanstack-db.ts:1386-1389`, reason at `:1368-1374`, an unindexed `setWindow` returns a promise), so this table holds seventeen of the eighteen participants; the eager and indexed tanstack-db rows carry it.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

scroll deep into the group (deepScroll, reads.byWindow)narrowaudited against the current code

8 steps. Like "scroll the window", but view A jumps in four equal steps to the last full page of the group and back, as in virtual scrolling far from the top. No data changes. A library that keeps the group sorted jumps straight to the position; one that does not sorts the whole group again and discards everything above the page. Every step must show a full new page; view B must not change.

The scroll script at deep offsets, which separates a maintained order from a re-selection that grows with the offset; at the default size the deepest window is only 168 rows in.

Models: Jumping a virtualised list far from its head and back, as a scrollbar drag does, over data that does not change. Measures: How the cost of producing one window grows with its offset into an ordered group, from 42 to 168 rows deep and back, with nothing written.

Favours: Stores that keep each group's order as a sequence they can slice at an offset: the deep window costs what the shallow one does. Against top-k re-selection whose k is offset plus window: both anchors select the top `offset + WINDOW` rows and render the tail (adapters/baseline-array.ts:286-294; adapters/baseline-array-indexed.ts:254-261), as does the mobx view (adapters/mobx.ts:478-488). At the deepest offset k equals the whole 200-row group, so the selection becomes a full insertion sort of the group. Stores that subscribe per visible row pay one re-point per visible row per step whatever the offset (adapters/oimdb.ts:864-869 sets `shapeMoved`, consumed at :809-810), so depth is not what separates them.

  • DEEP IS SHALLOW. At the default point a group holds 200 rows (DEFAULT_N 10 000, registry.ts:170; GROUPS 50, dataset.ts:37), so the deepest offset is 168 (`deepStride` = floor((200 − 32) / 4) = 42, dataset.ts:884-887). A virtual list in an application can be thousands of rows deep; the gap between an indexed slice and a growing top-k is smallest here.
  • Each step jumps 42 rows, not a smooth scroll of a few rows; a store that reuses most of the previous window gets nothing for it.
  • The description says the deepest offset is the group's size less one window (scenarios.ts:4420-4421). That holds only when `groupSize − WINDOW` is divisible by 4, which it is at the default point (168).
  • View B, the fixed two-axis window over group A, must not change; the lean anchor re-renders it on every settle (adapters/baseline-array.ts:295-300), counted as redundant and permitted.
  • `tanstack-db` (autoIndex off) declines `reads.byWindow` (adapters/tanstack-db.ts:1368-1374, 1388): in @tanstack/db 0.15 `setWindow` without an index settles asynchronously. The library is in this table only through `tanstack-db-eager` and `tanstack-db-indexed`, so its unindexed configuration is not priced here.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

the view switches group (viewSwitch, reads.bySwitch)representativeaudited against the current code

8 steps. Each switches view A to another group, like a user changing tab or filter: 7 different groups, then back to group A. No data changes. Every step must show a full page of the new group from its top; view B must not change. A library that keeps a list per group reads another list; one that does not filters the whole store again.

A tab or filter switch over resident data; it prices re-selection on a moving view definition, and a library that kept per-group results warm across the fixed sequence would pass unseen.

Models: A user switching tab or filter: the list view re-points to a different group of already-loaded rows and shows its first page. Measures: The cost of changing what a mounted view selects on, with no data written: reading another group's ordered first window and delivering it, eight times.

Favours: Stores that keep every group indexed and ordered at write time (a bucket per group plus an ordered list), so a switch reads an existing structure. Both anchors are present for this: the lean anchor rescans the whole population (adapters/baseline-array.ts:286-294, 373-377), the indexed one re-selects from the new group's unordered bucket (adapters/baseline-array-indexed.ts:254-262, 351-355). Against stores whose view is a query object fixed at construction: TanStack DB builds a new live query per switch (adapters/tanstack-db.ts:850-856), TinyBase re-runs a parameterised query (adapters/tinybase.ts:930-934), LokiJS replaces the DynamicView's filter (adapters/lokijs.ts:615-619). That is how those libraries are used, so the cost is theirs. Against stores that subscribe per visible row and must re-point every subscription on a switch (oimdb's view holds the new group's bucket and order and releases the old ones per switch, then re-points its per-row effects, adapters/oimdb.ts:871-884, 765-781).

  • THE SAME SEVEN GROUPS EVERY RUN. `switchGroups` is fixed by the plan (dataset.ts:889-899): g2, g8, g14, g20, g26, g32, g38, then g0 at the default 50 groups. Each timed sample revisits them, so any per-group result a library keeps alive across switches is warm from the second sample on. Whether any library here does so was not checked; the standing forbids it for adapters (A1, B3, scenarios.ts:4473-4477, 4502-4506) and nothing in `check` can see it.
  • Nothing is written and every group is already resident and of equal size (about 200 rows, dataset.ts:434-454, guard at :759-770). A real switch often coincides with a fetch; this is the in-memory half.
  • Every switch lands at offset 0 (`TReadBinding.switchGroup`, types.ts:147-149). A switch that keeps a scroll position is not asked.
  • View B is fixed over group A on the second axis (oracle.ts:360-363). Its silence is free for every store that does not re-run all views on any change; both anchors re-render B on every settle (adapters/baseline-array.ts:295-300; adapters/baseline-array-indexed.ts:263-268) and pay it as redundant deliveries, which `check` permits.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

a view filtered on two axes (filterTwoAxes, reads.byTwoAxes)narrowaudited against the current code

4 steps with two views of the same group: view A filters by `group` only, view B by `group` and a second condition. The steps move two rows out of the group and back: one that matches view B's second condition and one that does not. View A must update all four times, view B only twice. Measured: how often view B was woken for a row its filter already excluded.

Counts how often a two-predicate view is woken by moves its second predicate excludes, over four moves; the second predicate is immutable and its parameters fixed, so the hard half of multi-axis filtering is absent.

Models: Two list views over the same group, one filtered by group alone and one by group AND a second attribute (status AND assignee); rows move between groups and only some of the moves are visible to the narrower view. Measures: How often the two-predicate view is woken by a group move of a row its second predicate already excludes, and the cost of four group moves through both views.

Favours: Stores that can keep a second index keyed on both predicates, e.g. oimdb's second `OIMIndex` whose `selectKey` folds the axis into the key (adapters/oimdb.ts:692-698, `selectKey` at :694) or LokiJS's `applyWhere` dynamic view (adapters/lokijs.ts:499, 526); such a view is never woken by an off-axis row, by construction. Because the second axis is derived from the id (`onSecondAxis`, dataset.ts:393-394), any store may file a row on it once at insert and never maintain it; designs with expensive index maintenance pay nothing for the second index here.

  • The second axis is immutable (dataset.ts:381-392; A1 NOT MET at scenarios.ts:4598-4607): no step changes it, so re-filing a row because the second predicate's field changed is never measured. Toward index-per-predicate designs, whose maintenance cost on that field is exactly what is skipped.
  • The filter parameters never change: no step switches the view to a different value of either predicate (the user changing a filter chip), which is the most frequent two-axis event in a UI and where a pre-built composite index has to be rebuilt or a second one held. Toward pre-indexed designs. `viewSwitch` (`reads.bySwitch`) switches the group of view A only, never the two-axis view.
  • Four steps (`steps: 4`, scenarios.ts:4665) and two moved rows; the time is dominated by four settles and up to eight window deliveries. The row's own description says the redundancy count, not the time, is the result (scenarios.ts:4584).
  • Both movers are the first on-axis and first off-axis rows of view A's window (dataset.ts:862-863), so every move is visible to view A; a move of a row outside both windows (the common case in a 10,000-row store) is not asked here.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

relation lower bound (relationFloor, bind, floor)syntheticaudited against the current code

Lower bound, no library: the 16 steps of "a write to a related entity" and "a record keyed by two identities", each rendering the changed view straight from arrays of strings. Looking up the linked records is left out, because that is what those two scenarios measure. No library can come out below it.

The delivery-only share of the two relation scripts, measured with no store; a valid divisor for them, not a workload.

Models: Nothing an application does: the two relation scripts with the store removed, delivering 8-line views straight from arrays of strings. Measures: The cost every relation participant pays alike: writing a name or mark into a prepared text array and one `deliverRelation` of 8 lines per step, 16 steps.

Favours: Nothing by construction: no participant runs in this table. It divides relationWrite and compositeKeyWrite (`floor.ts:98`, via `stepDeliveryOf` returning `relation` at `floor.ts:82`).

  • The floor delivers ONE view per step; a participant that wakes both views (the lean anchor, by design: `adapters/baseline-array.ts` relation `settle` renders both on any write) pays two deliveries per step, so its multiple includes a redundant delivery the floor does not. That is intended, and makes every multiple an over-estimate of store work.
  • The owner-to-lines mapping is computed in `prepare` (`scenarios.ts:5146-5158`), as the adapters do in `holdRelation`; the floor and the participants are on the same footing about the join.
  • The mark half allocates a template string per step (`scenarios.ts:5184`), as the participants' script does (`scenarios.ts:5005`); both sides carry it. The name half writes prepared strings (`RELATION_NAMES`, `scenarios.ts:4761-4764`), as `relationWrite` does.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

a write to a related entity (relationWrite, relations)narrowaudited against the current code

8 steps with two record types: 8 rows each point to an owner, 4 owners with two rows each. Each step changes one owner's `name`; no row changes. View A shows each row with its owner's name, so it must update and two of its lines change. View B shows the same rows through another linked record and must not change. No row changes its owner.

Eight owner renames reaching an 8-row joined view, with the foreign key resolved by each adapter before the clock; real in shape, tiny in size, and blind to re-parenting and to any store's own join.

Models: A related record changes and every row showing it updates: a user renames themselves and the 2 messages they authored re-render their author name; repeated for 4 users, 8 times. Measures: A write to one entity of a second type reaching a view that renders it against rows of the first type, with the row-to-owner mapping resolved before the clock; plus whether a second view over the same rows (via pair records) is woken.

Favours: Stores with per-entity subscriptions on the second type: a subscription on the 4 owner entities wakes view A and never view B (oimdb holds owner slots and row slots at bind, `adapters/oimdb.ts:946` `bindRelationViews`, `holdRelation` from `:1046`, one effect per touched owner slot at `:1074-1080`). Designs with no relational machinery at all: the foreign key is resolved once by the ADAPTER in `holdRelation` (anchor `adapters/baseline-array.ts:813-834`, `rowOwners`; oimdb `rowOwnerSlots`, `adapters/oimdb.ts:1061-1063`; tanstack-db builds its own `ownerLines` map, `adapters/tanstack-db.ts:1128-1130`, and its owner live query is a `where ... inArray` over the owner collection, not a join, `:1010-1017`), so a store's native join (a live-query join, a relationships module) is neither needed nor credited.

  • The relationship is immutable (`ownerOf` derives it from the id, `dataset.ts:357-372`; A1 NOT MET at `scenarios.ts:4783-4793`): no step re-parents a row (moving a task to another project), which is where a store's join maintenance is paid. Toward stores without join indexes.
  • Size is 8 rows, 4 owners, fan-out 2, 8 steps (`dataset.ts:265-287`). A real list of messages with authors is tens to hundreds of rows on screen and thousands in the store; at 8 the delivery and settle constants dominate. Toward stores with low per-frame cost.
  • Because the join is resolved positionally before the clock, the timed step is one field write on a held owner plus one notification plus an 8-line delivery; it differs from a single-entity column patch mainly in which collection holds the entity.
  • The lean anchor wakes both views every settle (`adapters/baseline-array.ts:701-708`, one `dirty` flag; `settle` at `:860-865` renders both), so its B deliveries are all redundant by construction; that is the comparison the row is built for, and it counts against the anchor.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

a record keyed by two identities (compositeKeyWrite, relations)narrowaudited against the current code

8 steps. Each changes the `mark` of a record identified by a pair (owner, row), with the two-part key built fresh on every call. View B shows these marks and must update every step; view A must not change. Measured: finding a record by a two-part key; a hand-written store joins the two ids into a string and looks it up in a Map. The records exist before timing starts, so nothing is created.

Eight updates to records keyed by (owner, row), each composed per call; real in kind, but at this size the settle and delivery dominate and minting a pair is not timed.

Models: A record that exists per pair of entities (a reaction per (user, message), a read receipt, a membership role per (team, member)) being updated, one pair per frame, while a joined view over the same rows must stay quiet. Measures: Composing a two-part key from two identities per call, resolving it to an existing record, writing one field, settling, and delivering an 8-line view; plus whether the joined view is woken.

Favours: Stores whose composite lookup is cheap relative to a settle: a joined string into a Map (anchor, `pairKey`, adapters/baseline-array.ts:735, used at :852), a trie over scalar tuples (adapters/oimdb-legacy.ts:747, 766-775, `OIMCollectionStoreTrieDriven`), or a tree over entity slots (adapters/oimdb.ts:946-965, `OIMSlotStoreServiceTreeDriven` in `bindRelationViews`). Stores that route the pair write to the pair view only; the anchor's single `dirty` flag wakes the joined view redundantly every step.

  • One key composition per step against one settle and one 8-line delivery per step (scenarios.ts:5004-5007); the composite-key cost the row is named for is likely a small share of each step. That share is unverified by measurement here; `relationFloor` gives the delivery share.
  • Every record exists before the clock (`holdRelation` in `prepare`, scenarios.ts:4988-4990), so the mint of a new pair (the first reaction on a message) is not measured. Toward stores whose insert path is expensive.
  • The two key segments are always an existing owner and an existing row; a composite key over scalars that are not entities is out of scope for `@oimdb/core` (scenarios.ts:4725-4729) but measured for `oimdb-3.12.1`, so the table compares two different key shapes under one label, as SCENARIOS.md:158 says.
  • 8 records, 8 steps (`RELATION_ROWS`, dataset.ts:272; `steps`, scenarios.ts:4983): a toy size for a pair table, whose real size is the product of two populations.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

single-value lower bound (singleFloor, bind, floor)syntheticaudited against the current code

Lower bound, no library: 32 renders of one line, each with a different value, with no store. Every single-value scenario renders through the same code, so the gap between a library and this bound is the library's own cost.

An instrument, not a workload: the per-step consumer cost of a one-line delivery, against which `singleWrite` rows are read as multiples.

Models: Nothing an application does: 32 deliveries of one prepared line through `deliverSingle`, with no store and no value held. Measures: The consumer's cost of one single-value delivery, used as the per-step floor for `singleWrite`.

Favours: Not applicable: it has one row, measured in one adapter's process (FLOOR_ADAPTER, registry.ts:73), and ranks nobody.

  • The description calls the bound tight — 'the gap between a row of that family and 1.00 is that row's store and nothing else' (scenarios.ts:5245-5251). The gap also holds the adapter's glue between write and delivery and the harness's `settle` call per step, which this floor does not make. Those belong to using the library, so 'store' should be read as 'store plus its binding'.
  • The prepared marks are allocated once at module load (SINGLE_MARKS, scenarios.ts:5237-5240) and reused by `singleWrite` (:5427), so neither side allocates a value inside the clock.
  • It scales `singleWrite` only. `singleResend` sets `rendersNothing` (scenarios.ts:5459), so `stepDeliveryOf` returns `nothing` before it reaches the `single` branch (floor.ts:79, 83) and it has no floor (floor.ts:129-136).

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

write one value (singleWrite, single)representativeaudited against the current code

32 steps. Each sets a new value on one standalone value: no key, no collection, no list. View A shows it and must update every step. A second value beside it never changes and must not update; how often its view was woken anyway is counted.

The commonest write in a signal-style application, sized as it happens — one value, one event, one reader — and checked as a sequence, so a skipped or reordered write fails.

Models: One value the application holds — a toggle, a counter, a selected id — written once per user event and read by one component. Measures: The cost of one write to a held value, the library's notification, and a one-line delivery, with a second value beside it that must stay silent.

Favours: Libraries built around a value cell with its own subscriber list (signals, atoms): a write is a field store and a short notify. Against libraries whose every write goes through a collection, document or transaction path; for them this wiring stores one value in machinery made for many. How each adapter maps a single value is the participants' cards' question, not this one's.

  • One subscriber per value, no derived value, no fan-out: the smallest reactive graph there is. Differences in graph scheduling do not show.
  • Each step is its own frame, one write and one `settle` (scenarios.ts:5424-5430), so `frame` is not called and has nothing to change.
  • The bystander is checked for distinct renders only (scenarios.ts:5434); a library that wakes it is counted in its delivery column rather than failed. That is the intended reading (description, scenarios.ts:5409-5411).

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence

re-write one value (singleResend, single)narrowaudited against the current code

32 steps. Each sets one standalone value to the value it already has. The benchmark code does not filter this out, so it shows whether the library compares before it notifies: if it does, nothing renders; if not, the same line renders every step.

A frequent no-op write, but on a primitive, so it ranks libraries by whether they compare at all; read it beside `singleWrite`, which proves the same write method moves the value.

Models: Setting a held value to what it already holds — a state setter called with the current value, a toggle re-applied, a form field re-synced. Measures: Whether the library itself suppresses a notification for an unchanged primitive, and the cost of the write path when it does or does not.

Favours: Libraries that compare before notifying: they deliver nothing, and a correct row is close to the cost of the write call. Against libraries that notify on every write: each step wakes the subscriber, which renders the identical line.

  • The value is a primitive string (`seeds[0]`, scenarios.ts:5467; SINGLE_SEEDS, dataset.ts:328). For a primitive, reference equality is value equality, so any library comparing with `===` or `Object.is` recognises it for free. The row separates 'compares at all' from 'never compares'; it cannot separate structural from reference comparison, which `resendUnchanged` asks with fresh objects (scenarios.ts:1496-1502).
  • A store whose `writeSingle` does nothing passes: the stored value is `seeds[0]` either way, `check` asks only that nothing distinct was rendered (:5473-5475), and the single-value audit reads back the value the model also holds (worker.ts:457-459; oracle.ts:621-641). `writeSingle` is proved by `singleWrite`, which calls the same method; the proof is across rows, not inside this one.
  • No floor (`rendersNothing`, :5459; floor.ts:79, 129-136): a row that wakes is not relieved of its consumer share. That is what the row is meant to show.

claude-opus-5-5 (verified), 2026-10-17 — full card with evidence