Skip to main content

Participants

A library is measured when it owns the data and emits a change signal for it, both halves its own. Each row is driven by an adapter in packages/bench/src/adapters/, and each adapter has an audit card answering one question per wiring: is this the way the library's own documentation and source say to do it, on its fast path?

verdictmeaning
idiomaticthe documented way, on the library's fast path
improvablecorrect, but a documented faster way exists and is not used
handicappedthe adapter makes the library do work an ordinary user would not
advantagedthe adapter does part of the library's job, or skips work the script asks for

A card is tied to the exact adapter source and library versions it was written against. When either changes, the card is shown as stale until somebody re-reads it. The state is computed, not remembered.

baseline-arrayidiomaticthe code changed after this audit

no library, and it is not a library claim: the harness owns the Map the values live in and the dirty flag that drives the consumer. This is the naive hand-written arm, and the ANCHOR only for the scenarios `baseline-indexed` declines.

The naive hand-written anchor as it says it is: a Map, one dirty flag and a full top-k rescan of the population per view per settle; the churn store is callback arrays per row id, its chain body applies every level of the derivation to the first root's label, and its diamond body computes both sides and the join once per settle.

bindidiomaticMap of copied rows (baseline-array.ts:115-128), one dirty flag set by every write including patchNote (142-146), and a settle that rescans the whole population for every view through the shared top-k helper (87-96, 187-193). Re-delivering view B for a group-A write and both views for a note or re-send is the declared naive behaviour (header 45-48), not an accident. pin keeps the Map's own objects (162-175), which the cellDelivery standing allows. Both cell views are delivered on every dirty settle (102-109). frame calls run() (186): there is no library and nothing to batch.
bindPerGroupidiomaticThe same body with fifty views (baseline-array.ts:988), so one settle is fifty full-population rescans. That is the declared absence of a group index (header 50-54); the index is priced by baseline-indexed.
churn.rowidiomaticArray of callbacks per row id, push to mount, indexOf plus splice to unmount (join 460-464, mountOnRows 574-582, unmount 638-650). The settle walks each written row's subscriber list and probes the `label` column map with the row id (531-554, probe at 539-542), one Map miss per written row in row-shaped scripts, named in departure (962-971). The mount resolves row `from` once and the body reads its label off that object (466-473); every churn script writes by patchLabel, which mutates in place, so the held object cannot go stale. Under the churn read fold (auditChurnReads, scenarios.ts:1900) every standing slot's read is checked: churnList mounts slot `at` on row `at` (scenarios.ts:2279) and the body reads exactly that row. frame calls run() (520).
churn.wideidiomaticJoins 64 per-row lists, body reads the first row alone (574-582), as departure states.
churn.columnidiomaticA second Map of the label column's subscribers keyed by row id (432, 583-588), woken from the settle's probe (539-542): a column identity a hand-writer would build.
churn.chainidiomaticNo derivation object is built; the body (594-618) reads every root once, keeps the first root's label, then applies chainLevelOf for levels 1..depth, so the delivered text is chainHeadOf(label, depth) (harness/derivations.ts:3-7). The mount pays nothing for the chain; churnChain declares B1 not met for exactly this asymmetry, and as the floor that is its role. chainFrameWrite (scenarios.ts:2390-2505) mounts the same chains before the clock and times the frame alone.
churn.diamondidiomaticOne callback on the root row's list (620-637) that computes diamondLeftOf and diamondRightOf of the label and diamondJoinOf of both, guarded by a settle counter (settleCount, 446, incremented at 532) so it runs at most once per settle even if the row was written twice in the frame: recompute on settle, one join per frame, what a person writes by hand for a two-sided derivation over one row. churnDiamond (scenarios.ts:2507-2593) mounts on row 0 and expects every slot to read diamondHeadOf(label), which this body produces. Not run.
reads.byKeyidiomaticOne Map get per key, nothing resolved in advance (357-365).
reads.byWindowidiomaticscrollTo moves a number and sets dirty (369-372); the settle rescans the population for top-(offset+window) and delivers the tail (286-301). frame calls run() (347).
reads.byTwoAxesidiomaticThe same rescan with the axis clause (295-300, visibleOnAxisInto at 297), always over view.groupA.
reads.bySwitchidiomaticswitchGroup sets the group view A selects on (pagedGroup, 283), offset 0, and dirty (373-377); the next settle rescans the population for the new group, exactly as a scroll settles. View B stays on group A and is re-delivered on the same flag with unchanged content, so viewSwitch (scenarios.ts:4459-4559) counts one redundant B delivery per step; its check asks only that B's distinct renders stay 0, which holds. Not run.
relationsidiomaticSeparate rows, owners and pairs Maps (702-705); owners and pair records resolved once in holdRelation (813-835); writePair composes the joined key per call and probes the Map (pairKey 735, writePair 851-855), as TRelationBinding.writePair requires. Both views re-render on any write (860-865), declared in the header (696-699). frame calls run() (796).
singleidiomaticTwo variables, a dirty flag, one delivery per dirty settle, no value comparison (904-951); frame calls run() (931).

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

baseline-indexedidiomaticthe code changed after this audit

no library, and it is not a library claim: the harness owns the Map, the buckets and the change signal. It is the ANCHOR every ratio is divided by wherever it takes part — the competent hand-written arm — and its gap to `baseline-array` is the price of a group index plus the re-renders it skips for writes nothing on screen depends on.

baseline-array plus an unordered row bucket per group and the set of buckets written since the last settle; a settle re-derives only the views over those buckets, so under the fifty-view wiring a one-row move re-renders one group, and nothing routes by column. Every churn shape is declined, the diamond included, as are relations and single.

bindidiomaticMap plus an unordered array bucket per group kept on write (baseline-array-indexed.ts:42-59, 102-166); every write adds the group it touched to dirtyGroups, both groups for a row that changed group (113-117, 153-159), and the settle renders the views whose group is in the set, then clears it (69-88, 192-196). The render runs the shared top-k over the view's own bucket (77-86). A patchNote still re-renders the view over its row's group (142-147): the bucket knows the row, not the column, and column routing is left out on purpose (baseline-array-indexed.md, 'What the index is, and what is part of it'). A write to a key the store does not hold marks nothing (137-138 and the same guard in each patch), where baseline-array sets dirty anyway; no view's content can change in that case. Once pinned, any dirty group re-delivers both cell views (90-97, 181-190). frame calls run() (191).
bindPerGroupidiomaticThe same body with fifty views (404). consumerPerGroup moves one row's rank in one group per step, so one bucket is dirty and one view is re-derived and delivered per step. This is the competent hand-written arm admission names (387-390).
churn.rowdeclinedDeclined by noChurn (405-411): a churn binding derives no view, so the group index has nothing to do and the row would be baseline-array's churn store under a second name.
churn.widedeclinedThe same declaration as churn.row (noChurn, 405); justified for the same reason.
churn.columndeclinedThe same declaration as churn.row (noChurn, 405); justified for the same reason.
churn.chaindeclinedThe same declaration as churn.row (noChurn, 405); justified for the same reason. chainFrameWrite, a churn.chain script, has no row here either.
churn.diamonddeclinedThe same declaration as churn.row (noChurn, 405; noChurn declines all five shapes, harness/types.ts:106-112). A diamond over one row is a derived value, not a view over a group, so the bucket is not involved and the row would be baseline-array's diamond callback.
reads.byKeyidiomaticOne Map get per key (334-342), identical to baseline-array; the index is not involved. frame calls run() (331).
reads.byWindowidiomaticscrollTo sets an offset and dirty (346-349); the settle selects top-(offset+window) out of view A's bucket and delivers the tail (254-269, 356-360). The read binding keeps one dirty flag rather than a bucket set (departure, 383-385; baseline-array-indexed.md, 'What the index is'). The bucket keeps no order, so each scroll re-selects; the md declines a sort on purpose, so that the anchor gap prices the index and not an index plus a sort.
reads.byTwoAxesidiomaticAxis clause over group A's bucket (263-268), fixed on view.groupA whatever view A shows.
reads.bySwitchidiomaticswitchGroup sets the group view A reads (pagedGroup, 235), offset 0, and dirty (350-355); the settle selects from that group's bucket (259), which write already keeps, so a switch fills nothing and costs one selection over one bucket. View B is re-delivered on the same flag with unchanged content, one redundant delivery per viewSwitch step; the check asks only that B's distinct renders stay 0 (scenarios.ts:4551-4554). After a switch the one dirty flag re-delivers both views on any write, the unwritten one as a redundant delivery (baseline-array-indexed.md). Not run.
relationsdeclinedDeclined by noRelations (418-426): the relation binding has no group or window, so this row would repeat baseline-array's relation store.
singledeclinedDeclined by noSingle (427-436): nothing to group.

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

oimdb 4.1.0idiomaticthe code changed after this audit

the row values live in the library — an entity service's slots, written through writeSlotContentByKey and its slotContentService's updateEntityColumn and markEntityChanged, and read back as slot.entity — and the change signal is the library's own OIMEffectService effect over a slot, a column, a bucket or an index order, delivered at the frame flush; the GROUP FILING and the ORDER are the library's too, an OIMSlotCollectionIndexService whose selectKey runs on each write, moves the row between its buckets itself and an OIMSortedComputedService re-sorts a held group's order when a write touches the sorter's columns.

The built engine through its public exports only: one channelled entity collection; an OIMIndex over the group column feeding an OIMComputedCollectionSorted (rank then id as columns) whose held slot is the order of a group (createRows, createGroupOrders); slot, column-group and order effects from OIMEffectService, painted by settle after channel.flush. The churn binding is a channelled entity collection alone, with no index and no order, like every other library's churn wiring. The group filing and the order are the library's: the collection calls selectKey on each write and the sorted computed re-sorts only when a write touches rank or id.

bindidiomaticbindViews (oimdb.ts:332) builds the OIMDB, an OIMEffectService, the collection from createRows (86) and orderByGroup from createGroupOrders (92-106): an OIMComputedCollectionSorted over createOIMIndexSetDriven on group with columns BY_RANK_THEN_ID. Each view holds one group-order slot (makeView, 234-257) with one effect on it and one effect over the column-group slots of its window entities (resync, 259-293); settle is channel.flush then paint (383). The row-store methods are bindRowWrites (144): write is insertEntities then upsertEntities, label and note patches assign slot.entity and call markEntityChanged with the one column, with no equality check (161-174), setRank and setGroup are updateEntityByKey, so the index files the move itself; frame is channel.openSubframe/closeSubframe (182-189). dispose (442) is channel.dropEverythingUnchecked and the adapter's arrays cleared. Not measured.
bindPerGroupidiomaticThe same body with fifty held groups (oimdb.ts:1066), so the same write path paid across fifty maintained buckets and fifty sorted computeds.
churn.rowidiomaticbindChurnStore (oimdb.ts:551) builds its own OIMDB and one OIMEntityCollection and nothing else: no index, no order, so a churn write is a slot write and its effects; groupOrder answers undefined, which the churn standings allow. The plain writes come from bindRowWrites (144). holdChurnRows (605) resolves the slots once with rows.getSlotByKey; one effectService.createEffect over the root slots per mount whose body reads row `from` (mountOnRows, 617-624), disposeEffect on unmount (641). Under the churn read fold every standing slot's read is checked.
churn.wideidiomaticOne effect over count roots; the body reads the first root only, declared in departure.
churn.columnidiomaticmountOnColumn (oimdb.ts:625-631) takes rows.holdColumn(slot, 'label'), subscribes one effect to that column slot and gives the hold back at once with rows.unholdColumn, so the effect's subscription keeps the column slot; unmount disposes the effect, so the last unmount of a cycle releases the column slot and the next cycle's first mount mints it again. Not measured.
churn.chainidiomaticcreateChurnMounts (oimdb.ts:482) builds the chain levels as slots of one createOIMComputedCollection<number, string> with oimSameValueZeroGuard (490-504), keyed at * CHAIN_KEYS_PER_SUBSCRIBER + level: level 1's sources are the count roots and it derives chainLevelOf of their joined labels, each level above takes the slot below as its source computed and derives chainLevelOf of its value. subscribeHead (528-537) holds the keys bottom up, puts one effectService.createEffect on the head and gives the holds back, so unmount's disposeEffect releases the head and each release gives back the level below. The delivered text is chainHeadOf(label, depth) (harness/derivations.ts).
churn.diamondidiomaticLeft and right nodes over the one root slot and a join over both, deriving diamondJoinOf of their values, as slots of a second createOIMComputedCollection keyed at * DIAMOND_KEYS_PER_SUBSCRIBER + node (oimdb.ts:506-526), with one effect on the join through the same subscribeHead. The effect is enlisted once per frame, so the join derives once per frame, which churnDiamond's check asserts. Not run.
reads.byKeyidiomaticrows.findEntityByKey per key inside readKeys, nothing resolved before the call (oimdb.ts:711-720), as TReadBinding.readKeys requires. Every key the plan names is a stored entity's id, so no read here mints.
reads.byWindowidiomaticbindReadViews (667) builds two createGroupOrders, one per index (683-687); each view holds a group-order slot and its shape effect is on that slot, so a write that leaves the sorted list as it was wakes no view. scrollTo only marks (723); the next frame re-points the window by indexing the order's settled list from offset to offset + window.
reads.byTwoAxesidiomaticA second OIMIndex whose selectKey answers OFF_THE_SECOND_AXIS for entities off the axis (oimdb.ts:661, 686), the composite-predicate form, with its own sorted computed; the library re-files and re-sorts both indexes on a write.
reads.bySwitchidiomaticswitchGroup (oimdb.ts:730-740) holds the other group's order slot, disposes view A's shape effect, gives the old order back with unholdSlot, re-subscribes the shape effect on the new order, sets offset 0 and marks; the settle delivers through the same resync as scrollTo. View B's effects are untouched, so viewSwitch's view-B check is met without a redundant delivery. The new key is held before the old one is given back, so a switch to the group already shown keeps its slot. Not run.
relationsidiomaticbindRelationViews (oimdb.ts:755): owners and rows in two collections on one channel, pair records in a third keyed by [ownerSlot, rowSlot] over OIMSlotStoreServiceTreeDriven. holdRelation (839) holds the segments through the slots holdSlotByKey returns, mints the pair records untimed with upsertEntity, and puts one effect on each touched owner (view A) and each pair record (view B); writePair (880) composes a new key array per call and descends, as the contract requires. frame is run(): nothing in this binding files work to a subframe close. dispose (904) is the channel drop and the adapter's arrays cleared. No relation script times dispose.
singleidiomaticbindSingleStore (oimdb.ts:922): two OIMSingleEntity records on one channel, one effect each (954, 961), delivery in settle after channel.flush (986-996); writeSingle is entity.update (973), so singleResend gets the library's own no-change check. frame is run(); dispose (997) disposes the two effects.

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

oimdb-sorted-index 4.1.0not audited

the row values live in the library — an entity service's slots, written through writeSlotContentByKey and its slotContentService's updateEntityColumn and markEntityChanged, and read back as slot.entity — and the change signal is the library's own OIMEffectService effect over a slot, a column or a bucket, delivered at the frame flush; the GROUP FILING and the ORDER are the library's too, an OIMSlotCollectionSortedArrayIndexService whose selectKey runs on each write, moves the row between its buckets itself and keeps each bucket sorted by rank then id at the write.

oimdb-3.12.1 3.12.1idiomaticthe code changed after this audit

the row columns live in the entity slots of a 3.12.1 collection and are grouped and ordered by its own derived array index; the change signal is the engine's keyed emitters — collection.emitter per row and index.emitter per bucket — delivered at the event queue's frame end.

createOIMCollectionKit with a field-masked writer and a derived array index per group, keyed emitters as the signal, renders at FRAME_END; the churn binding builds its collection without the kit so the column shape can subscribe through the exported field emitter, and the chain and diamond shapes build the OIMComputed nodes and OIMEffect the scripts ask for on the queue's compute runtime.

bindidiomaticKit with OIMSlotWriterFieldMasked and the default merge updater (oimdb-legacy.ts:61-67), derivedArrayIndex by group ordered by compareRows with deps group, rank, id (68-75); one index.emitter.subscribeOnKey per view (107-112), keyed collection subscriptions only on the window's rows (116-136), refresh without re-subscribing when only content changed (139-147, 186-202). Writes are upsertMany/removeManyByPks/upsertOneByPk (208-228). deps make label and note writes irrelevant to the index (core-legacy/src/core/OIMDerivedCollectionIndexArrayBased.ts:40-47); with compareEntities any relevant write marks its bucket for a full re-sort (same file 205-207, 220-222), which the md records as a finding of the library. frame calls run() (278): 3.12.1 has no batch call, and every keyed delivery already waits for queue.flush() (core-legacy/src/core/OIMEventQueue.ts:127-186), which is settle (279).
bindPerGroupidiomaticThe same body with fifty bucket subscriptions (oimdb-legacy.ts:1086).
churn.rowidiomaticcollection.emitter.subscribeOnKey per subscriber, release to unmount (415-426, 524-530); the slot is resolved untimed in holdChurnRows and item is read per wake (labelAt 355-358, 405-414), because the merge updater allocates a new entity per write. The body reads row `from`, the row the churn read fold expects of each slot (churnList mounts slot `at` on row `at`, scenarios.ts:2279). The collection is new OIMReactiveCollection with createUpdateEmitter (327-339) instead of the kit, which is the same constructor (core-legacy/src/dx/OIMCollectionKit.ts:24); the field emitter is a subclass that adds one method and leaves subscribeOnKey as it is (core/OIMCarrierKeyedFieldEmitter.ts:47-70). frame calls run() (383).
churn.wideidiomaticOne subscribeOnKeys over the 64 keys (427-442); the body reads all 64 labels in reverse so the first is kept, more body work than the tinybase and baseline wide bodies, which read one.
churn.columnidiomaticcollection.emitter.subscribeOnKeyFields(pk, labelMask, body) (444-454), the mask built once from the registry the field-masked writer was handed (326-335, 341), so its bits are the writer's (core/OIMSlotWriterFieldMasked.ts:55-63; core/OIMCarrierKeyedFieldEmitter.ts:56-70).
churn.chainidiomaticOne OIMComputed with an on.collection dependency per root, deriving chainLevelOf(first root's label, 1) (456-471), depth - 1 more over on.computed, level k deriving chainLevelOf(level k-1, k) (472-478), and an OIMEffect on the head that renders head.get() (479-486), so the text is chainHeadOf(label, depth) (harness/derivations.ts:3-7). All on getOIMComputeRuntime(queue) (340), the runtime the kit uses (dx/OIMCollectionKit.ts:29). Unmount destroys the effect then the computeds head-first (487-492); dispose destroys the runtime after the collection (531-539). Constructed directly rather than through kit.computed/kit.effect because those add every node to the kit's OIMDisposeScope (dx/OIMCollectionKit.ts:53, 66), which has no removal (core/OIMDisposeScope.ts:46-53, 65-84). chainFrameWrite builds the same chains in prepare and times the frame alone.
churn.diamondidiomaticTwo OIMComputed over the one root's on.collection deriving diamondLeftOf and diamondRightOf of its label, a third over on.computed of both deriving diamondJoinOf, and an OIMEffect on the join (oimdb-legacy.ts:495-523), on the same runtime as the chain. The runtime schedules by level (modules/effect/core/OIMEffect.ts:65, 138) and OIMEffect.onComputedInvalidate returns when already scheduled (same file 134-139), so the join and the subscriber run once per flush, which churnDiamond's check asserts. Unmount destroys the effect, the join, then both sides (516-521). Not run.
reads.byKeyidiomaticgetSlotByPk per key and one item load (673-682); nothing resolved in advance.
reads.byWindowidiomaticscrollTo moves the page start and marks shapeMoved (685-689); the settle re-reads the live bucket slice and re-points 32 keyed subscriptions (614-630, 701-714). frame calls run() (669).
reads.byTwoAxesidiomaticA second derivedArrayIndex keyed on group plus axis (563-566), so the library files both predicates; every write that touches group, rank or id maintains both indexes.
reads.bySwitchidiomaticswitchGroup (691-697) releases view A's index.emitter subscription (stops[0], 605-611), subscribes on the other group's key, points the page at that bucket (pagedGroup, 568, read by paged.slotsOf 583) and offset 0, and marks; the settle resyncs exactly as after scrollTo. View B is not marked, so viewSwitch's view-B check is met with no redundant delivery. The derived index keeps every group's bucket already, so the switch fills nothing. Not run.
relationsidiomaticThree kits on one queue, the pairs kit on OIMCollectionStoreTrieDriven keyed by a ctk tuple (747, 753-777); owner and pair slots resolved untimed for reading (846-904); patchOwnerName and writePair go through upsertOneByPk with the tuple built per call (908-918). OIMCollection has no slot-addressed write (core-legacy/src/core/OIMCollection.ts:97-150), so the pin saves only the read. frame calls run() (838).
singleidiomaticOIMReactiveObject with a keyed subscription per property and a FRAME_END render (964-1038). frame calls run() (1024).
What would make it faster or more idiomatic
  • oimdb-legacy.md 'The opt-ins': orderBy with a zero-padded rank joined to the id could express rank-then-id (OIMDerivedCollectionIndexArrayBased.ts:301-305 compares with < and >); neither wired nor measured, and whether every scripted rank is non-negative was not checked. Would move every bind row that writes rank if it is faster than compareEntities.

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

tinybase 10.0.1idiomaticthe code changed after this audit

the row values live in a TinyBase Store's cells and the change signal is the library's own — addResultSortedRowIdsListener and addResultRowListener on a query, addResultCellListener on the head of a chain of queries and on the join of a diamond, addCellListener on a cell — all called by TinyBase when the transaction finishes; the adapter keeps no values of its own.

TinyBase's documented query path (one query per view, a sorted-row-ids listener with offset and limit on a calculated rank-then-id sort cell, per-row result listeners, one transaction per write call outside a frame and one per script frame), with each churn chain and each diamond built as queries from queries and the view switch as a query param; the read and churn wirings store the row id as a cell because a where callback is handed no row id.

bindidiomaticOne query per view selecting rank, label and a calculated order cell where group (tinybase.ts:206-213), window ids from addResultSortedRowIdsListener(order, offset 0, limit window) (watchShape, 133-146), content through one addResultRowListener per window row; when the shape moves only the rows that left lose their listener and only the rows that entered get one (rewatchRows 153-170, renderWindow 174-190, settle 274-292). Outside a frame each write call is its own transaction (store.transaction around a multi-row loop, a bare setCell otherwise), and frame is store.transaction, inside which those nest (transactedStoreOf 61-79, transactionFrameOf 52-56). The order cell is a fixed-width rank joined to the row id (45-50), so TinyBase's one-cell sort produces the rank-then-id order itself; there is no hand sort and no tie left to the library at the window edge. Rows are written as four cells, the id being the key (237-243).
bindPerGroupidiomaticThe same body with fifty queries (tinybase.ts:794), each maintained by TinyBase on every write to the table. The Indexes module (setIndexDefinition(id, table, 'group', sortKey, , rowIdSorter), @types/indexes/index.d.ts:424-431; index.js:1154-1268) keeps a sorted slice per group but has no window: getSliceRowIds copies the whole slice (index.js:1333-1334) and addSliceRowIdsListener fires on any membership or order change in the group (1279, 1341-1342), so a 32-row window over it would wake on reorders outside the window or need an adapter-side window compare, which TBinding forbids. Kept as queries; the reason is in tinybase.md.
churn.rowidiomaticstore.addRowListener per subscriber on one row id, delListener to unmount (366-378, 333-337); the body reads row `from`'s label with getCell (labelAt 330-331), the row the churn read fold expects of each slot (churnList mounts slot `at` on row `at`, scenarios.ts:2279). The store carries no queries in this wiring, so nothing else is maintained on write. frame is store.transaction (transactedStoreOf, 78).
churn.wideidiomaticOne addRowListener per row of the 64 (366-378), since addRowListener takes one row id or null; the body reads the first row only, as departure states (752-762). churnWide writes row 0 alone per frame (scenarios.ts:2014, rowsWrittenIn churnRowOnly), so each subscriber wakes once.
churn.columnidiomaticstore.addCellListener(TABLE, id, 'label') (379-386): TinyBase's own column identity.
churn.chainidiomaticQueries from queries (390-418): a root query over TABLE where the stored id cell is one of the subscriber's rows, selecting group, rank, note and a calculated label holding chainLevelOf(label, 1), then depth - 1 queries each defined with setQueryDefinition(id, true, belowQueryId, …) (@types/queries/index.d.ts:2280-2310, since 8.3.0) selecting chainLevelOf(label below, k) as label, and addResultCellListener on the head's label of the first row (409-413), so the text read is chainHeadOf(label, depth). Unmount runs the mount's own release, which deletes the listener and the definitions head first (414-417, unmount 333-337). Defining the root query evaluates its where over every table row (index.js:5365-5368), which is the mount cost the library charges for a derivation. chainFrameWrite builds the same stacks in prepare and times the frame alone.
churn.diamondidiomaticQueries from queries (419-447): a left and a right query over TABLE, each where('id', rowId) and each selecting one calculated cell (diamondLeftOf(label) as left, diamondRightOf(label) as right), and a join query rooted on the left result that joins the right result by the same row id (join(true, rightId, on-callback), @types/queries/index.d.ts:1440-1444, since 8.3.0) and selects diamondJoinOf(left, right) as join; addResultCellListener on that cell. Once per frame by reading index.js (see the prose), not by a run. Each mount pays two whole-table where evaluations.
reads.byKeyidiomaticTwo getCell calls per key, rank and label, a missing row answering undefined (518-534); nothing resolved in advance.
reads.byWindowidiomaticThe window is a property of the listener (@types/queries/index.d.ts:4028-4035), so scrollTo deletes it, registers one at the new offset and reads the page with getResultSortedRowIds on the order cell (pageAt, 498-504; scrollTo 535); the settle then moves the row listeners of the rows that left onto the rows that entered (rewatchRows 153-170). This is the API's only way to move an offset. frame is store.transaction (transactedStoreOf, 78).
reads.byTwoAxesidiomaticThe axis is a where(callback) inside the query over the stored id cell (479-486, callback at 485), so TinyBase evaluates both predicates. This, and the churn chain's root query, are why those two wirings keep the id cell.
reads.bySwitchidiomaticThe paged query filters on where('group', param('group')) with the param seeded to group A (468-478); switchGroup calls queries.setParamValue('paged', 'group', group), which writes the param store (index.js:5496-5501) whose row listener re-runs the definition (5459-5467): the result table is deleted (4973) and the where re-evaluated over the whole table (5365-5368) inside one result-store transaction (4809). switchGroup then moves the window to offset 0 through the same pageAt a scroll uses (537-540). The settle delivers view A; view B's query is untouched, so viewSwitch's view-B check is met with no redundant delivery. The param, not a re-definition, is TinyBase's documented way to change what a live query selects (@types/queries/index.d.ts:820-849 Param, since 7.2.0; setParamValue at 2520). Not run.
relationsidiomaticThree tables in one store, owners and pair records as rows, addCellListener on each touched owner's name and each pair's mark (holdRelation 615-642), patchOwnerName and writePair as single setCell calls, each its own transaction, with the pair id composed per call (645-653). Rows are written as four cells (598-605). frame is store.transaction (transactedStoreOf, 78).
singleidiomaticTinyBase Values: setValue, getValue and addValueListener per value (689-746); frame is store.transaction (726).
What would make it faster or more idiomatic
  • NOT APPLIED. tinybase.ts:794: an Indexes-module wiring (one index by group with a sort key) for consumerPerGroup. bind and bindPerGroup must share one body (harness/types.ts:340-341), and the module has no windowed slice or windowed listener (index.js:1333-1342), so the window's change check would become the adapter's; see tinybase.md, 'Why the views are queries'.

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

signaldb 1.8.1idiomaticthe code changed after this audit

the row values live in a SignalDB Collection's documents and the change signal is the library's own cursor observeChanges, fired from the collection's write inside Observer.runChecks; the adapter-side `written` Set holds ids only, to choose insert over updateOne, and no row value is in it.

SignalDB's framework-free recipe (Collection with a group index, one sorted and limited find cursor per view, observeChanges as the signal, collection.batch per frame); the library's own per-write costs dominate. The keyed read is one find({id: {$in: page}}) per page through the id provider, a scroll and a view switch each build a new cursor, and the chain and diamond shapes are declined because SignalDB has no derivation primitive.

bindidiomaticCollection with createIndex('group') (adapters/signaldb.ts:87-89), one find({group}, {sort: {rank: 1, id: 1}, limit}) per view observed with all four callbacks and skipInitial (signaldb.ts:120-144). Writes are updateOne $set per patch (signaldb.ts:245-256) and insert/updateOne inside collection.batch for write/remove (signaldb.ts:214-244); frame is the same collection.batch around the script's writes (signaldb.ts:110, 257), opened once because batch does not nest (createBatchFrame 32-46; node_modules/@signaldb/core/dist/index23.mjs:560-567). Inside a frame the index rebuild and every cursor's requery wait for the frame's end (index23.mjs:391-394, 510-517). Each updateOne copies the memory array and, outside a batch, rebuilds every index over the whole collection (index23.mjs:422-427, 447-449, 391-403, 619-643); that is the library. The settle fetches each pending cursor again because the observer keeps its window private (signaldb.ts:307-318). The adapter-side `written` Set (signaldb.ts:109) holds ids to choose insert over updateOne; disclosed in departure and admission (signaldb.ts:1140-1155).
bindPerGroupidiomaticThe same body with fifty cursors (signaldb.ts:1194); every write requeries all fifty (index23.mjs:510-527), which is SignalDB's model, once per frame inside a frame.
churn.rowidiomaticfind({id}) plus observeChanges({added, changed}, false) per subscriber (signaldb.ts:506-530): the mount label comes from `added` on the observer's first run, the one getItems registration already performs (index10.mjs:139-142, index9.mjs:56-104), and a wake reads row `from`'s label off the document `changed` carries; `added` only reads, so a mount is not a wake. unmount stops the observer and cleans up the cursor (561-568). The read is the one the churn read fold expects of each slot (churnList mounts slot `at` on row `at`, scenarios.ts:2279). No group index in this wiring, since no churn cursor selects on group. frame is collection.batch (422, 470).
churn.wideidiomaticOne find({id: {$in: ids}}) cursor per subscriber, the same body as churn.row (signaldb.ts:506-530), SignalDB's way to observe many documents; the $in resolves through the id provider registered at construction (index23.mjs:151; index22.mjs:12-42). The body keeps the first source's label, the one value the line renders, out of the documents `added` and `changed` carry, and counts a wake on every `changed`; no findOne and no second memory-array copy per wake. Declared in departure (1146-1148).
churn.columnidiomaticfind({id}, {fields: {label: 1}}) with the same added/changed pair (signaldb.ts:531-553): the observer diffs the projected document (index10.mjs:72-88, index9.mjs:56-80), so a note write produces no changed call. A column identity built from the library's own diff.
churn.chaindeclinedDeclined in churnShapes (signaldb.ts:1161-1166; mountOnChain throws through declinedMount, 554). @signaldb/core exports no derived-value primitive (dist/index.d.ts:1-18) and a cursor's result is not an input to another cursor, so a mount could only be the wide $in cursor with the depth levels re-run by hand in its body. Removes signaldb from churnChain and chainFrameWrite, both churn.chain scripts.
churn.diamonddeclinedDeclined in churnShapes (signaldb.ts:1167-1172; mountOnDiamond throws, 555). The same absence: no computed value to build the two branches or the join from, so the diamond could only be three functions called by hand inside one observer body, which the contract forbids. Removes signaldb from churnDiamond.
reads.byKeyidiomaticOne find({id: {$in: page}}).fetch() per page (signaldb.ts:703-708), applied under the ruling that a per-page $in is the library's lookup. getIndexInfo sends a non-scalar id selector to the index providers (index23.mjs:404-420); the first provider is the id index registered at construction (index23.mjs:151), and createExternalIndex resolves $in key by key in the order given (index21.mjs:28-29, index22.mjs:12-42), so positions come back in the page's key order, the id drops out of the residual selector and getItems returns them without a match pass (index23.mjs:458-476). One memory-array copy per page, where the findOne per key it replaces paid one per key (index23.mjs:545-554, 447-449). Nothing is resolved in advance.
reads.byWindowidiomaticskip is fixed at cursor construction (pagedCursorOf, signaldb.ts:610-614), so scrollTo stops and cleans up the old cursor and observes a new one at the new skip (repointPaged 630-636, scrollTo 714-717). That is SignalDB's model. frame is collection.batch (606, 697).
reads.byTwoAxesidiomaticBoth predicates are in the selector, the axis as $regex '[02468][0-9][0-9]$' on id (signaldb.ts:642-658); onSecondAxis tests the evenness of the third-from-last character's code (dataset.ts:393-394), which for a digit is the digit's evenness, and every dataset id ends in seven digits (dataset.ts:437, 910, 930, 959), so the two agree on every row.
reads.bySwitchidiomaticA cursor takes its selector at construction, so switchGroup sets the paged group, resets the offset and goes through the same repoint scrollTo uses: stop and clean up the old cursor, observe a new find({group}, {sort, skip: 0, limit}) and mark it (pagedGroup 609, repointPaged 630-636, switchGroup 718-722). The settle delivers it as it delivers a scroll (723-732). View B's cursor is untouched and not marked, so viewSwitch's view-B check is met with no redundant delivery. Not run.
relationsidiomaticThree collections and two observed $in cursors, one per view (holdRelation, signaldb.ts:916-967). Each render is one fetch of the cursor its view observes, placed by an id-to-lines map built in holdRelation (maps 822-823, filled 929-932; renders 833-855), the pattern the cell wiring uses. frame batches the owners and pairs collections, the two the relation scripts write (803-806, 894); the row collection is left out because closing a batch rebuilds that collection's whole id index (index23.mjs:396-403).
singleidiomaticA document per value and a find({id}) cursor per value (signaldb.ts:1061-1134), declared as the nearest thing SignalDB has to a scalar; frame is collection.batch (1115). dispose stops the observers and calls collection.dispose() (1128-1132).

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

tanstack-db 0.15.0idiomaticthe code changed after this audit

the row values live in a TanStack DB collection, written through its own sync interface (begin/write/commit), and the change signal is the library's own subscribeChanges on a live query collection, fired from commit() before the write returns; the adapter keeps no values of its own.

TanStack DB 0.15 on its default autoIndex 'off', written through the sync interface (one sync transaction per frame) and read through live queries and subscribeChanges; chain and diamond are live queries over live queries deriving with fn.select, and a view switch builds a new live query. The scroll wiring is declined on this row because an unindexed setWindow returns a promise in 0.15. In 0.15 a committed batch is published inside a scheduler context, so the diamond's join runs once per write on the sync path too, which is what the adapter's departure string now says.

bindidiomaticOne createLiveQueryCollection per view, where(group).orderBy(rank).orderBy(id).limit(window).select(id, rank, label), subscribed with subscribeChanges and includeInitialState false through `watchChanges` (adapters/tanstack-db.ts:227-245, 193-199); delivery from live.toArray in settle (tanstack-db.ts:299-311). A note write yields a projected row deepEqual to the previous one and the commit pushes no event for it (node_modules/@tanstack/db/src/collection/state.ts:1392-1402). After pin, two projected live queries over the pinned ids, one selecting label and one note, each drive their own consumer (tanstack-db.ts:253-292), so a write wakes only its column; each cell is read back with live.get(id) per pinned id (tanstack-db.ts:270-273).
bindPerGroupidiomaticThe same body handed fifty views (tanstack-db.ts:891): fifty ordered, limited, projected live queries over one backing collection.
frameidiomaticframe is one sync transaction per collection the frame's writes reach: the first write on a collection inside a frame calls begin and every later one joins it; the frame's end commits each opened one (tanstack-db.ts:77-106). Outside a frame each write call is its own begin/write/commit, committed before the call returns; no transaction is held open until settle, the same reading of an unframed write tinybase.ts follows with one store.transaction per call. No script nests a frame, so the frame keeps a flag rather than a depth. The sync interface does not nest: commit takes the last pending transaction (db/src/collection/sync.ts:285-313) and commitPendingTransactions applies only committed ones (state.ts:1060-1120), which is why writes join the open transaction instead of opening their own; the comment at tanstack-db.ts:97 cites sync.ts:285-290.
churn.rowidiomaticsubscribeChanges on the backing collection with where eq(row.id, …) and includeInitialState false (tanstack-db.ts:384-401), the documented filtered subscription (db/src/types.ts:1094-1115). The body reads the row back with rows.get and stores it per slot, so the verify pass's per-slot read fold sees each subscriber's own read (tanstack-db.ts:347, 389, 400; harness/render.ts:124-141).
churn.wideidiomaticOne subscribeChanges with where inArray(row.id, sources) (tanstack-db.ts:393-396). The body reads the first source alone; the dependency set is the where clause, not the reads, so this does not shrink the subscription, and the first source is what churnWide's model expects every subscriber to read (scenarios.ts:2149-2154). Declared in departure (tanstack-db.ts:846-848).
churn.columnidiomaticA live query per subscriber over the one row with select(id, label) (tanstack-db.ts:402-423): TanStack DB's where filters rows, and a projection is its only column narrowing. A pipeline per subscriber is the price; WHY-EACH-ROW.md (churnColumn) says the same. The body reads the label from the backing collection, not from the live query (tanstack-db.ts:418).
churn.chainidiomaticdepth live queries built in the mount: level 1 is where inArray(row.id, roots) over the backing collection with fn.select deriving chainLevelOf(label, 1) (tanstack-db.ts:427-438); each level k from 2 is a live query from the one below with fn.select deriving chainLevelOf(text, k) (tanstack-db.ts:442-456). The subscriber is on the head and reads the head's row for root `from` with head.get(id) (tanstack-db.ts:458-468). Every level is cleaned up in the unmount (tanstack-db.ts:352-359); cleanup() returns a promise but retires local state synchronously (db/src/collection/lifecycle.ts:466-480, 512-522). fn.select is the library's functional projection, documented as not optimisable (db/src/query/builder/index.ts:946-985); nothing above level 1 has a where or an orderBy to optimise.
churn.diamondidiomaticTwo live queries over root `from` (where eq(row.id, id), fn.select of diamondLeftOf / diamondRightOf, tanstack-db.ts:472-483) and a third that innerJoins them on id and fn.selects diamondJoinOf(left.text, right.text) (tanstack-db.ts:484-494); the subscriber is on the join and reads its one row (tanstack-db.ts:495-504). All three are cleaned up on unmount. In 0.15 emitEvents publishes every committed batch inside withPublicationContext (db/src/collection/changes.ts:255-283; db/src/scheduler.ts:183-216), and a live query's graph run is scheduled into that context with its source builders as dependencies (db/src/query/live/graph-scheduler.ts:13-29; collection-config-builder.ts:710-736), so the join waits until both branches have run and runs once per write. Read, not run; the adapter's departure says the same (tanstack-db.ts:843-845).
reads.byKeyidiomaticcollection.get per key on the backing collection (tanstack-db.ts:568-576; db/src/collection/index.ts:734-736); nothing resolved in advance.
reads.byWindowdeclinedDeclined by the adapter (tanstack-db.ts:868-871, reason UNINDEXED_WINDOW_IS_ASYNC at tanstack-db.ts:850-856): with autoIndex off and no index, setWindow in 0.15 starts a subset load and returns a promise (db/src/query/live/collection-config-builder.ts:299-410, the promise branch at 392-410), and the harness never yields. The two indexed rows carry this table.
reads.byTwoAxesidiomaticSecond predicate as q.fn.where inside the pipeline (tanstack-db.ts:542-555); a move of a row the predicate excludes produces no output change and no event, so view B is woken only by the library.
reads.bySwitchidiomaticA live query's where is fixed at construction and setWindow moves offset and limit only, so switchGroup unsubscribes and cleans up the paged live query and builds one over the new group from the same factory (tanstack-db.ts:527-540, 589-594), as useLiveQuery does on a changed dependency. It subscribes with includeInitialState true (tanstack-db.ts:593), whose snapshot requestSnapshot publishes synchronously (db/src/collection/changes.ts:349-355; db/src/collection/subscription.ts:1181-1310), and that is the mark the settle delivers at offset 0. View B is untouched. On this unindexed row the new query loads the whole group; whether that load is synchronous in 0.15 when setWindow's is not was not settled.
relationsidiomaticThree collections on the sync interface; owner and pair live queries via inArray (tanstack-db.ts:646-658); pair records committed before either query exists (tanstack-db.ts:685-704); each line is read back with live.get(owner id) or live.get(pair key) (tanstack-db.ts:662-669); writePair composes the key per call (tanstack-db.ts:713-719). A frame opens a sync transaction only on the collections its writes reach (tanstack-db.ts:77-106).
singleidiomaticTanStack DB has no scalar; one row per value in a collection and a subscribeChanges narrowed by where eq(row.id, name) (tanstack-db.ts:785-812). An equal re-write is dropped by the library's deepEquals at commit (state.ts:1392-1402).

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

tanstack-db-eager 0.15.0idiomaticthe code changed after this audit

the row values live in a TanStack DB collection, written through its own sync interface (begin/write/commit) and indexed by the library under autoIndex: eager, and the change signal is its own subscribeChanges on a live query collection, fired from commit() before the write returns; the adapter keeps no values of its own.

The same adapter as tanstack-db with autoIndex 'eager' on every backing collection, one of the two remedies the library's orderBy warning offers. On the churn and single wirings eager builds an index on id that only the column, chain and diamond mounts' initial loads read; the scroll wiring is supplied here because an indexed window moves synchronously. Under 0.15's publication context the diamond's join runs once per write, as on tanstack-db.

bindidiomaticIdentical body to tanstack-db (bindWith('eager') through adapterWith, adapters/tanstack-db.ts:858-892, 905-917): projected window queries (tanstack-db.ts:227-245) and, after pin, one projected live query per cell column (tanstack-db.ts:253-273). Under eager the orderBy compiler calls ensureIndexForField on the first order key (node_modules/@tanstack/db/src/query/compiler/order-by.ts:180-197), so an auto:rank index is built and the ordered query lazy-loads instead of warning.
bindPerGroupidiomaticFifty projected live queries over one eagerly indexed collection (tanstack-db.ts:891); the first one mints auto:rank and the rest find it (db/src/indexes/auto-index.ts:40-47).
frameidiomaticOne sync transaction per collection the frame reaches, as on tanstack-db (tanstack-db.ts:77-106). Each committed batch with events also updates every index on the collection before it is emitted (db/src/collection/state.ts:1408-1411).
churn.rowidiomaticsubscribeChanges with where eq(row.id, …) (tanstack-db.ts:384-401). Under eager the subscription constructor calls ensureIndexForExpression (db/src/collection/subscription.ts:231-234), so the first mount on a churn binding's collection (created at tanstack-db.ts:334 through `syncedCollectionOf`, :111-139) builds an auto:id index over the population inside a timed cycle (auto-index.ts:58-73), and every later mount scans the index list to find it (auto-index.ts:40-47). That is what eager does for this call; declared in departure (tanstack-db.ts:909-912). Per-slot reads feed the verify pass's read fold as on tanstack-db.
churn.wideidiomaticwhere inArray(row.id, sources) (tanstack-db.ts:393-396); inArray compiles to 'in', an indexable operation (db/src/query/builder/functions.ts:707-714), so it shares the auto:id index. The body reads the first source alone, which is what churnWide's model expects; declared (tanstack-db.ts:846-848).
churn.columnidiomaticA select(id, label) live query per subscriber (tanstack-db.ts:402-423), TanStack DB's only column narrowing.
churn.chainidiomaticdepth live queries deriving chainLevelOf with fn.select, built in the mount and cleaned up in the unmount (tanstack-db.ts:424-469, 352-359); as on tanstack-db.
churn.diamondidiomaticTwo fn.select branches over root `from` and an innerJoin live query over both selecting diamondJoinOf (tanstack-db.ts:470-505). Eager changes how the branches load, not when the graphs run: in 0.15 each committed batch is published inside withPublicationContext (db/src/scheduler.ts:183-216; db/src/collection/changes.ts:272-283) and the join is scheduled with its branches as dependencies (db/src/query/live/graph-scheduler.ts:13-29), so it runs once per write. Read, not run; the adapter's departure says the same (tanstack-db.ts:843-845).
reads.byKeyidiomaticcollection.get per key (tanstack-db.ts:568-576).
reads.byWindowidiomaticSupplied on this row (only the 'off' row declines it, tanstack-db.ts:868-871). paged.utils.setWindow({ offset, limit }) (tanstack-db.ts:579-587) runs the window function that moves db-ivm's top-K in place (db/src/query/live/collection-config-builder.ts:299-410, 881-889; db-ivm/src/operators/topKWithFractionalIndex.ts:59, 68) inside a publication context, and returns true when no subset load was started (collection-config-builder.ts:392-396); rows a moved window needs come through the lazy load the auto:rank index serves. The binding throws if setWindow ever returns a promise.
reads.byTwoAxesidiomaticq.fn.where inside the pipeline (tanstack-db.ts:542-555); the library decides when view B changes.
reads.bySwitchidiomaticA new paged live query over the new group, the old one unsubscribed and cleaned up, marked by its own includeInitialState snapshot (tanstack-db.ts:527-540, 589-594). Under eager the auto:rank index the first paged query minted is found again by the new one's orderBy compile (auto-index.ts:40-47 returns on an existing index matching field and compare options), so the switch lazy-loads the new group's first window rather than the whole group.
relationsidiomaticAs on tanstack-db (tanstack-db.ts:622-753), with all three collections on eager: each is built by `syncedCollectionOf`, which passes `autoIndexOf(indexing)` (tanstack-db.ts:122, 626-628).
singleidiomaticA row per value and subscribeChanges narrowed by where eq(row.id, …) (tanstack-db.ts:785-812); under eager holdSingle's first subscription builds the auto:id index, untimed, and every write then maintains it.
What would make it faster or more idiomatic
  • Create the backing collection for the churn and single wirings with autoIndex 'off', if this row is meant to measure eager only where it serves a query (every collection takes its autoIndex from `syncedCollectionOf`, tanstack-db.ts:122). Not done: what the row stands for is the registry owner's decision; the departure states what eager does there.

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

tanstack-db-indexed 0.15.0idiomaticthe code changed after this audit

the row values live in a TanStack DB collection, written through its own sync interface (begin/write/commit) and indexed by collection.createIndex, and the change signal is the library's own subscribeChanges on a live query collection, fired from commit() before the write returns; the adapter keeps no values of its own.

The same adapter as tanstack-db with autoIndex 'off' and explicit collection.createIndex on what each wiring's live queries filter and sort on, the remedy the library's orderBy warning names first and the configuration its type docs recommend. The scroll wiring is supplied here because an indexed window moves synchronously; under 0.15's publication context the diamond's join runs once per write, as on tanstack-db.

bindidiomaticIdentical body to tanstack-db (bindWith('explicit') through adapterWith, adapters/tanstack-db.ts:858-892, 919-932), plus two indexes created right after the backing collection and before any live query (tanstack-db.ts:221-224): group with BasicIndex, rank with BTreeIndex. rank is the first order key of the window queries, so the orderBy compiler finds it (node_modules/@tanstack/db/src/query/compiler/order-by.ts:199-207; utils/index-optimization.ts:45-70) instead of warning and loading the whole group. An id BTreeIndex is created in pin, before the pinned-cell queries that filter on id with inArray (tanstack-db.ts:288, 253-268), so only the cell scripts, the ones that call pin, maintain it.
bindPerGroupidiomaticFifty projected live queries over one explicitly indexed collection (tanstack-db.ts:891).
frameidiomaticOne sync transaction per collection the frame reaches, as on tanstack-db (tanstack-db.ts:77-106). Each committed batch with events updates the explicit indexes before it is emitted (db/src/collection/state.ts:1408-1411).
churn.rowidiomaticsubscribeChanges with where eq(row.id, …) (tanstack-db.ts:384-401). An id BTreeIndex exists on this collection (tanstack-db.ts:335-337), built at bind, untimed; these subscriptions ask for no initial state and do not read it. autoIndex is off, so ensureIndexForExpression mints nothing (db/src/indexes/auto-index.ts:10-15, 86-93) and no mount builds an index; outside dev mode it returns before searching the list. Per-slot reads feed the verify pass's read fold as on tanstack-db.
churn.wideidiomaticwhere inArray(row.id, sources) (tanstack-db.ts:393-396); the body reads the first source alone, which is what churnWide's model expects; declared (tanstack-db.ts:846-848).
churn.columnidiomaticA select(id, label) live query per subscriber (tanstack-db.ts:402-423); its initial load of the one row can go through the id index.
churn.chainidiomaticdepth live queries deriving chainLevelOf with fn.select (tanstack-db.ts:424-469), cleaned up on unmount (tanstack-db.ts:352-359); level 1's inArray over the roots can load through the id index (every index supports 'in': db/src/indexes/base-index.ts:174; db/src/query/builder/functions.ts:707-714).
churn.diamondidiomaticTwo fn.select branches over root `from`, each loading its one row through the id index, and an innerJoin live query over both selecting diamondJoinOf (tanstack-db.ts:470-505). Indexes change how the branches load, not when the graphs run: in 0.15 each committed batch is published inside withPublicationContext (db/src/scheduler.ts:183-216; db/src/collection/changes.ts:272-283) and the join is scheduled with its branches as dependencies (db/src/query/live/graph-scheduler.ts:13-29), so it runs once per write. Read, not run; the adapter's departure says the same (tanstack-db.ts:843-845).
reads.byKeyidiomaticcollection.get per key (tanstack-db.ts:568-576); a keyed get reads the state map, not an index (db/src/collection/index.ts:734-736).
reads.byWindowidiomaticSupplied on this row (only the 'off' row declines it, tanstack-db.ts:868-871). group (BasicIndex) and rank (BTreeIndex) on the read binding's backing collection (tanstack-db.ts:522-525). paged.utils.setWindow({ offset, limit }) (tanstack-db.ts:579-587) moves the top-K window (db/src/query/live/collection-config-builder.ts:299-410) and returns true when no subset load was started (collection-config-builder.ts:392-396); a window that needs rows not yet loaded is filled through the lazy load the rank index serves. The binding throws if setWindow ever returns a promise.
reads.byTwoAxesidiomaticq.fn.where inside the pipeline (tanstack-db.ts:542-555); the library decides when view B changes.
reads.bySwitchidiomaticA new paged live query over the new group, the old one unsubscribed and cleaned up, marked by its own includeInitialState snapshot (tanstack-db.ts:527-540, 589-594). The new query's orderBy finds the same rank index, so its first window lazy-loads instead of loading the group.
relationsidiomaticAs on tanstack-db (tanstack-db.ts:622-753), with a BTreeIndex on owner id and on pair key (tanstack-db.ts:629-632), the columns the two relation live queries filter on with inArray (tanstack-db.ts:646-658). The rows collection carries none: no relation query reads it.
singleidiomaticA row per value and subscribeChanges narrowed by where eq(row.id, …) (tanstack-db.ts:785-812). No index: neither subscription reads initial state, so one would be maintained on every write and read by nothing; the departure says so (tanstack-db.ts:926-927).

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

lokijs 1.5.12idiomaticaudited against the current code

the row columns live in LokiJS documents inside its own collection, which is also what groups and orders them, and the change signal is the collection emitter firing insert, update and delete synchronously on every write.

LokiJS DynamicViews over one collection, each delivered only when LokiJS itself dirtied it (performSortPhase emits 'rebuild' synchronously for a dirty view and returns at once for a clean one); collections run with the documented disableMeta; LokiJS has no notification batch, so a frame runs its writes directly; a view switch replaces the paged view's group filter by its uid; the column, chain and diamond churn shapes are declined.

bindidiomaticOne DynamicView per view, applyFind({group}) plus applySortCriteria (adapters/lokijs.ts:111-125), each wrapped by a 'rebuild' listener (lokijs.ts:80-86). settle calls performSortPhase() on every view (lokijs.ts:89-93, 168-174): it returns at once when neither sortDirty nor resultsdirty is set (node_modules/lokijs/src/lokijs.js:4711-4715) and otherwise re-sorts and emits 'rebuild' (lokijs.js:4737-4739), and only then is data() read and delivered. A view is dirtied only when the written document was or becomes part of it (lokijs.js:4780-4783), so a write to group A does not redeliver view B. The re-sort per settled step is the library's passive design under a per-step settle; declared in departure (lokijs.ts:986-997).
bindPerGroupidiomaticThe same body with fifty DynamicViews (lokijs.ts:1053); a write dirties one view (two on a move), so one or two of the fifty are re-sorted and delivered per settle.
frameidiomaticframe runs its writes directly (lokijs.ts:95-96, used at 248, 412, 620, 843, 960). LokiJS has no notification batch: Collection.startTransaction only snapshots data and indexes for rollback when the collection is transactional (lokijs.js:7095-7107), and the emitter calls every listener synchronously per event (lokijs.js:831-850). A passive view already coalesces a frame's writes into one re-sort at the next settle; the churn, relation and single listeners fire once per write. Declared in departure (lokijs.ts:991-992).
churn.rowidiomaticLokiJS has no per-document subscription; each subscriber is a collection 'update'/'delete' listener that tests the document id and reads the label off the emitted document (lokijs.ts:350-354, 443-452). Every subscriber runs on every write. Each read is stored per slot and cleared on unmount (lokijs.ts:449, 451, 481), which is what the verify pass's read fold checks. Declared in departure (lokijs.ts:993-995).
churn.wideidiomaticOne listener testing membership in a Set of the sources and reading every source through the unique index, keeping the first one's label (lokijs.ts:454-470), which is what churnWide's model expects every subscriber to read (scenarios.ts:2149-2154).
churn.columndeclinedDeclined by the adapter (lokijs.ts:472, reason at 1010-1017), and the reason holds in the library: update is document-level and, with clone off and the delta changes API at its default (disabled), the emitted old document is the same object as the new one (lokijs.js:6058, 6062, 6126), so LokiJS cannot say which field moved.
churn.chaindeclinedDeclined by the adapter (lokijs.ts:473, reason at 1018-1024): a DynamicView cannot take another view as its source and the collection emitter has no per-source channel, so a chain could only be the wide listener with the depth levels re-run by hand in its body. Removes lokijs from churnChain and chainFrameWrite.
churn.diamonddeclinedDeclined by the adapter (lokijs.ts:474, reason at 1025-1031): LokiJS's derived structures are DynamicViews and Resultsets, filtered and sorted lists over one collection, and nothing computes a value from two others; the branches and the join could only be functions the adapter calls by hand inside a collection listener, which the contract forbids.
reads.byKeyidiomaticby('id', key) per key, a hash hit on the unique index (lokijs.ts:599-607; lokijs.js:7003-7017, UniqueIndex.get 7559-7561).
reads.byWindowidiomaticscrollTo sets a number (lokijs.ts:611-614) and settle slices the view's sorted list (lokijs.ts:622-624). The paged view is persistent (lokijs.ts:510-513), so a clean read returns the maintained resultdata instead of copying the group (lokijs.js:4653-4661).
reads.byTwoAxesidiomaticapplyWhere for the axis inside the view's pipeline (lokijs.ts:521-531). View B is delivered only when performSortPhase reports it rebuilt (lokijs.ts:625-627), so a document its applyWhere excludes before and after does not wake it (lokijs.js:4780-4783). The view is not persistent: no script scrolls view B, so it is read only when dirty, where a persistent view copies just the same (performSortPhase, lokijs.js:4730-4734) and keeps resultdata in step on every write besides; see lokijs.md.
reads.bySwitchidiomaticThe paged view's group filter is registered with a uid (lokijs.ts:497, 514); switchGroup resets the offset and calls applyFind({group}, uid) with the new group (lokijs.ts:616-619). applyFilter replaces the pipeline entry with that uid and calls reapplyFilters (lokijs.js:4533-4545), which resets the Resultset, re-runs the find over the whole collection, empties resultdata and queues the sort (lokijs.js:4496-4523); the next settle's performSortPhase re-sorts and emits 'rebuild', and the view is delivered at offset 0. View B is untouched. This is LokiJS's own way to change a DynamicView's filter. The viewSwitch script writes nothing between switches (scenarios.ts:4535-4554), so every step is this re-filter alone.
relationsidiomaticThree collections, each view re-read only when its own collection emitted (lokijs.ts:791-823, 845-854); writePair composes the key and probes the unique index on it per call (lokijs.ts:834-842).
singleidiomaticOne collection, two listeners on 'update' each testing the document id (lokijs.ts:923-948); LokiJS has no scalar and no per-document listener. LokiJS compares no values, so an equal write wakes the subscriber.
What would make it faster or more idiomatic
  • A binary index on group (ensureIndex / indices: ['group']) on the read binding's collection (lokijs.ts:508) would be consulted by the switch's fresh find (Resultset.find checks indices only while filterInitialized is false, lokijs.js:3547-3549), moving bySwitch from a whole-collection scan to an index range. It is a trade-off, not a fix: the index is maintained on every write of every read script and is read by none of the others (src/adapters/lokijs.md). Not done; a consumer of this table would pick it only for a switch-heavy workload.

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

mobx 7.0.6idiomaticthe code changed after this audit

every mutable column lives in its own MobX atom, on class instances annotated with makeObservable (MobX's documented store shape: accessors on the instance, no Proxy) held in an observable.map, and the group index is an observable.map of observable.sets of those same objects rather than of values; the change signal is MobX's own autorun over a computed, run at the end of the outermost action, and the chain, the diamond and the view switch are computeds and observable.boxes MobX re-evaluates itself.

MobX 7's documented store shape: rows, owners and pair records are class instances annotated with makeObservable (accessors on the instance, no Proxy) held in observable.maps, a computed per view with the shipped compareShallow comparer, an autorun per consumer, every write in an action and every script frame in one runInAction. The chain, the diamond and the view switch are computeds and boxes over observables, nothing derived by hand.

bindidiomaticcomputed + autorun per view over an observable.set bucket of row observables (adapters/mobx.ts:122-141). Rows are MobxRow instances (mobx.ts:51-71, created at mobx.ts:166) whose constructor calls makeObservable with group, rank, label and note annotated observable; id is a plain field. makeObservable goes through asObservableObject on the instance (node_modules/mobx/src/api/makeObservable.ts:22-34), which defines cached accessors directly on it (src/types/observableobject.ts:358-403, 676-688) rather than building the Proxy observable({ ...row }) builds in MobX 7 (src/api/observable.ts:209-216; src/types/dynamicobject.ts:54-60). The window computed uses compareShallow (mobx.ts:129; src/utils/comparer.ts:15-17), so a recompute that selects the same row objects in the same order does not re-run the autorun (src/core/computedvalue.ts:259-283). For a key already held all four fields are assigned unconditionally (mobx.ts:171-175); the no-change check is MobX's own prepareNewValue_ (src/types/observablevalue.ts:116-131, reached from src/types/observableobject.ts:155-178).
bindPerGroupidiomaticThe same body with fifty views (mobx.ts:1005), each computed over its own group's bucket, so the dependency sets are disjoint.
frameidiomaticframe is runInAction around the script's writes (mobx.ts:47-49; src/api/action.ts:93-95; dist/mobx.cjs.development.js:2472, cited at mobx.ts:46), used by every wiring (mobx.ts:274, 408, 649, 834, 939). Each write method is itself a runInAction, which nests, so reactions wait for the frame's outermost action and settle is a no-op on the window wiring (mobx.ts:275).
churn.rowidiomaticOne autorun per subscriber over a resolved row observable (mobx.ts:338-349, 448-452). The body reads all four atoms of the row (wholeRow, mobx.ts:353-356) because MobX tracks per property and the row shape subscribes to the whole row (SCENARIOS.md, churnColumn: 'on one column instead of the row'); declared in departure (mobx.ts:965-972). The autorun stores its read per slot on every run including the first, and unmount clears it (mobx.ts:342, 494), which is what the verify pass's read fold checks.
churn.wideidiomaticOne autorun whose body reads every one of the CHURN_WIDE rows whole and keeps the first one's label (mobx.ts:453-459), so MobX registers it on every source atom; the first label is what churnWide's model expects.
churn.columnidiomaticautorun reading row.label alone (mobx.ts:463-466); a MobX property is its own atom, so this is the column with nothing standing for it.
churn.chainidiomaticdepth computeds stacked, built inside the mount (mobx.ts:467-481): the bottom one reads the count roots whole (types.ts / SCENARIOS.md: derivations 'over several rows') and returns chainLevelOf(joined labels, 1), level k returns chainLevelOf(level k-1, k), and the autorun reads the head (harness/derivations.ts:1-13).
churn.diamondidiomaticTwo computeds over the root row read whole (types.ts:69-70, 'two derivations over root row from') deriving diamondLeftOf / diamondRightOf of its label, one computed over both (diamondJoinOf), and the autorun on the join (mobx.ts:482-488). MobX computeds are glitch-free and the reaction runs at the end of the outermost action, so the join and the autorun run once per write. Read, not run.
reads.byKeyidiomaticOne ObservableMap.get per key outside any reaction (mobx.ts:630-638), nothing resolved in advance.
reads.byWindowidiomaticThe offset is an observable.box written in an action (mobx.ts:517, 640-642); the paged computed re-runs a top-(offset+window) selection over the group bucket with compareShallow, and the autorun reads the offset itself (mobx.ts:530-540, 551-554). MobX keeps no ordered index, so the re-selection is the library's cost.
reads.byTwoAxesidiomaticonAxis computed with compareShallow (mobx.ts:541-548): a group move of a row the second predicate excludes leaves the selected objects unchanged, so view B's autorun does not re-run.
reads.bySwitchidiomaticThe group view A selects from is a second observable.box (pagedGroup, mobx.ts:518) that the paged computed reads (mobx.ts:530-540); switchGroup sets it and the offset to 0 in one runInAction (mobx.ts:643-648), so view A's autorun runs once, at the end of the action. View B's computed never reads the box. Read, not run.
relationsidiomaticOwners and pair records are MobxOwner and MobxPair instances, makeObservable with only name and mark annotated (mobx.ts:73-95), held in observable.maps (mobx.ts:767-774, 793); holdRelation resolves them once and mints pair records untimed (mobx.ts:779-814); writePair composes the key per call and does one pairs.get (mobx.ts:826-833).
singleidiomaticobservable.box plus autorun (mobx.ts:887-959), MobX's documented scalar; an equal set is dropped by the box's default compareDefault (src/types/observablevalue.ts:71, 131).

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

jotai 3.0.1idiomaticthe code changed after this audit

every row lives in its own jotai atom, one per key via `jotai-family`, read and written through the store — and each consumer is driven by `store.sub` on a derived view atom that reads per-column derived atoms (group, rank, label) and selects ids, flushed inside the write, its listener reading the selected rows back through `store.get`. The per-group ids atoms hold keys only, never a value, and the population audit enumerates the family's own `getParams` rather than any list this adapter keeps.

A vanilla jotai 3 store with one atom per row (jotai-family, since jotai 3 no longer ships atomFamily), per-column derived atom families (group, rank, label) under a derived view atom per view that selects ids, store.sub per consumer, a per-column derived atom per pinned cell, derived atoms for the chain and the diamond, and every script frame written through one write-only atom. A note write, or a label write outside the window, stops at the column atoms; a view whose recompute selects the same ids still notifies, because jotai ships no array equality and the adapter may not write one.

bindidiomaticDerived atom per view (adapters/jotai.ts:156-161) built by selectIds (jotai.ts:89-124): it reads the group's ids atom, then per id the derived group and rank column atoms, and the label column atom of the ids it renders (columnFamiliesOf, jotai.ts:77-81) — never a row atom. Each column atom returns a primitive, so Object.is (node_modules/jotai/dist/vanilla/internals.js:684) stops a write the view does not read, and the view atom is recomputed only when one of its dependencies changed (hasChangedDeps, internals.js:295-310). The view atom returns the selected ids; its listener reads those rows through store.get and delivers them (rowsOf, jotai.ts:126-133, 162-170). The cell wiring after pin builds a label atom and a note atom per pinned row and subscribes each column's render to its own atoms (jotai.ts:301-333). A recompute that selects the same ids still returns a fresh array; keeping the previous one would need an equality function written here (see improvements).
bindPerGroupidiomaticThe same body with fifty views (jotai.ts:1055), each over its own group's ids atom.
frameidiomaticframe is one store.set on a write-only frame atom; while it runs, every write method of the binding goes through that atom's get and set (access, jotai.ts:49-71), and a nested frame runs in place. The set a write function is handed does not flush while the outer write is synchronous (internals.js:495-531); only the outermost store.set recomputes and flushes in its finally (internals.js:695-709), cited at jotai.ts:48, so a multi-write frame reaches the listeners as one flush. Used by every wiring (jotai.ts:344, 456, 734, 917, 1007).
churn.rowidiomaticstore.sub directly on the resolved row atom for one source (jotai.ts:493-498); the listener reads the atom back through store.get and stores the label per slot (readRowInto, jotai.ts:404-407, 413-416), cleared on unmount (jotai.ts:551), which is what the verify pass's read fold checks.
churn.wideidiomaticA derived atom built at mount that reads every source atom (jotai.ts:500-510), subscribed; mounting it mounts the CHURN_WIDE sources. The listener reads the first source's row atom, which is what churnWide's model expects.
churn.columnidiomaticA selector atom get(rowAtom).label subscribed (jotai.ts:512-520): a row write recomputes it and Object.is on the string decides whether the listener runs (internals.js:671-690).
churn.chainidiomaticdepth derived atoms built inside the mount (jotai.ts:522-537): the bottom one reads the count root row atoms and returns chainLevelOf(joined labels, 1), level k returns chainLevelOf(get(level k-1), k); store.sub on the head mounts the chain and the roots, and the listener reads the head through store.get (headReaderOf, jotai.ts:409-411, 418-421), so the text is chainHeadOf(label, depth) (harness/derivations.ts:1-13).
churn.diamondidiomaticTwo derived atoms over the root row atom (diamondLeftOf, diamondRightOf of its label), a third reading both (diamondJoinOf), store.sub on the third (jotai.ts:538-545). The store recomputes a flush's invalidated atoms in topological order and only those with a changed dependency (internals.js:229-313), and the flush collects listeners into a Set (internals.js:196-214), so the join is recomputed and its listener called once per write. Read, not run.
reads.byKeyidiomaticrowFamily(key) plus store.get per key (jotai.ts:718-726); store.get outside a read function mounts and tracks nothing.
reads.byWindowidiomaticoffsetAtom (jotai.ts:578) written through the frame-aware setter (jotai.ts:728-730); pagedAtom re-selects the top offset+window ids of the group through the column atoms, reading label only for the ids from the offset on, and returns a fresh { offset, ids } object (jotai.ts:588-602); the listener reads the rows through store.get (jotai.ts:607-616). jotai keeps no ordered index, so the re-selection is the library's cost.
reads.byTwoAxesidiomaticonAxisAtom (jotai.ts:603-605) reads the same column atoms, and none of a row the second predicate excludes (the axis test comes first, jotai.ts:104-105). A group move of such a row still rewrites the group's ids atom, which onAxisAtom read, so it recomputes and, returning a fresh array, still notifies view B. Keeping the previous array needs a comparator written in the adapter, which the contract forbids.
reads.bySwitchidiomaticpagedAtom reads the group from pagedGroupAtom beside offsetAtom (jotai.ts:579, 588-602); switchGroup sets both through the write-only atom switchPagedGroup (jotai.ts:580-583, 731-733), so the two writes reach view A's listener as one flush. onAxisAtom never reads pagedGroupAtom. Read, not run.
relationsidiomaticOwner and pair atom families (jotai.ts:771-777); atoms resolved and pair records minted untimed in holdRelation (jotai.ts:822-830, 884-897); writePair composes the key per call and goes through pairFamily (jotai.ts:909-916). Two derived atoms render the two views (jotai.ts:832-847).
singleidiomaticatom(initial) plus store.sub (jotai.ts:967-1027), jotai's own scalar and subscriber; an equal write is dropped by Object.is (internals.js:684).
What would make it faster or more idiomatic
  • NOT APPLIED: the contract forbids it. jotai.ts:89-124 and 588-605: return the previous ids array when the newly selected ids are the same in the same order, through the self-read selectAtom uses (node_modules/jotai/dist/vanilla/utils/selectAtom.js:9-27). jotai ships no array comparator (selectAtom's equalityFn defaults to Object.is and is otherwise the caller's), so the comparison would be a value check written in the adapter, which TBinding.write forbids. With the column atoms in place, the redundant deliveries left are recomputes that select the same ids: filterTwoAxes view B on a move of an excluded row, and batch steps landing in a watched group outside its window.

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

legend-state 2.1.15idiomaticthe code changed after this audit

every column lives in a Legend-State `observable` keyed by id, written through the node and read back with `get()`/`peek()` — and each consumer is driven by `observe`, re-run from the library's own notification pass. The second observable this adapter keeps maps each group to an object keyed by member id (`byGroup[group][id].set(true)` / `.delete()`), never a value.

Rows live in one Legend-State observable keyed by id, the group index is a second observable mapping each group to an object keyed by member id and mutated a key at a time, each view is one `observe` over its own group's node and the `group`/`rank`/`label` leaves of each row, so a write wakes only the view over that row's group and a `note` write wakes none; every script frame and every multi-write method runs inside Legend's own `batch`/`beginBatch`; the chain and diamond are Legend `computed`s over whole row nodes and a view switch writes the view's own observable cursor.

bindidiomaticOne `observe` per view (legend-state.ts:123-159) reading the group's member node with `get()` (:131) and then, per member id, the `group`, `rank` and `label` leaves with `get()` and the row with `peek()` (`trackedRowOf`, :74-79). Writes go through node `set`/`delete` inside `beginBatch`/`endBatch` (:181-228); the group index is written one key at a time, `byGroup[group][id].set(true)` / `.delete()` (`groupIndexOf`, :100-108), so a move or removal is O(1) on it. A `note` write reaches no view listener (:212-214). `frame` is Legend's `batch` (:69-71, wired at :267), and the same `frame` is carried by the churn (:368), read (:596), relation (:722) and single (:870) bindings.
bindPerGroupidiomaticSame `bindViews` body with fifty bindings (legend-state.ts:926); one `observe` per view (:164), disjoint dependency sets.
churn.rowidiomatic`observe` over `node.get()` of the held row node (legend-state.ts:319-330, :400-404): the whole row, which is what the row shape subscribes to (SCENARIOS.md, churnColumn: 'on one column instead of the row'). Node proxies are resolved once in `holdChurnRows` (:392-399), which the churn contract allows. Each run stores what it read in `churnRead[at]` (:323) and `unmount` clears the slot (:447-453), so the verify-pass fold over every standing subscriber's read (render.ts:124-141) sees exactly the mounted ones. `settle` delivers once per frame only if a reaction woke (:372-382).
churn.wideidiomaticSame `mountOnRows` body with `count > 1`: one `observe` reading every source row node whole, ending on row `from` (legend-state.ts:405-411).
churn.columnidiomatic`observe` over the leaf `node.label.get()` of held row 0 (legend-state.ts:413-416). The leaf is its own node, so the column identity is the library's, not the adapter's.
churn.chainidiomaticLevel 1 is a Legend `computed` over the `count` source row nodes, each read whole (`labelOfRow`, :332-335), returning `chainLevelOf(joined labels, 1)`; levels 2..depth are each a `computed` returning `chainLevelOf(level below, level)`; an `observe` reads the head, because a computed is idle until read (legend-state.ts:417-433). Derivations over rows, as SCENARIOS.md defines churnChain.
churn.diamondidiomaticTwo Legend `computed`s over root row `from`'s node read whole (`labelOfRow`, :332-335), as types.ts:69-70 defines the shape ('two derivations over root row from'), deriving `diamondLeftOf` / `diamondRightOf` of its label; a third `computed` over both (`diamondJoinOf`), and an `observe` on the join (legend-state.ts:434-446). Whether Legend runs the join once per frame was not traced in index.js; the diamond script's check is what asserts it.
reads.byKeyidiomaticOne proxy descent and one `get()` per key, nothing hoisted, outside every `observe` (legend-state.ts:599-607). `peek()` would skip the `updateTracking` call (index.js:1409-1414); with no active tracker that call does nothing, so no difference is expected.
reads.byWindowidiomaticView A's cursor is an observable node with `group` and `at` leaves (legend-state.ts:473-479), read only by view A's `observe` (:528-537), so a scroll (`cursor.at.set`, :609-611) re-runs A and not B. A re-selects the top `offset + window` of its group from the group's member node through the same leaf reads as `bind` (`selectInto`, :492-525).
reads.byTwoAxesidiomaticView B is a second `observe` with the second predicate over group A (legend-state.ts:538-545). The predicate reads only the immutable id, so it is tested before any leaf is tracked (:502), and an off-axis row's leaves are not a dependency of B; its arrival or departure still changes group A's member node, which B tracks.
reads.bySwitchidiomatic`switchGroup` sets the cursor's `group` leaf and resets its `at` leaf to 0 inside one Legend `batch` (legend-state.ts:612-617), so view A's `observe`, which tracks both leaves, re-runs once over the new group's member node. View B tracks neither leaf.
relationsidiomaticTwo more observables, owners and pairs keyed by a composed string (legend-state.ts:658-661). Owner and pair nodes for the views are resolved in `holdRelation` (:734-767); `writePair` composes the key and descends the proxy on every call (:775-779), as `TRelationBinding.writePair` requires.
singleidiomatic`observable('')` scalars, one `observe` each, `set` outside a batch notifies before it returns; `settle` delivers only the side that woke (legend-state.ts:820-888).
What would make it faster or more idiomatic
  • legend-state.ts:74-79 — the leaf reads trade one listener per row for three on every view re-run (observe re-subscribes every run, index.js:1550 and setupTracking at :1479). They take the redundant wakes out of patchNote and batchPatchNote; whether the extra listeners slow patchColumn, patchOutsideWindow and batchPatch is unmeasured. If they do, the whole-row `node.get()` is the other documented arm and the two should be priced against each other. Left to the measurement phase.

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

effector 23.4.4idiomaticthe code changed after this audit

the rows live in Effector `Store`s — one per group in the window wiring, beside an id -> group-store table that holds handles only; one holding a Map keyed by id in the read wiring, whose `byGroup` index holds ids only, never a value; one per row in the churn and relation wirings — replaced by a reducer on every write, and each consumer is driven by `.watch` or `.updates.watch` on the store it reads.

Effector's own event-store-map-watch model. The window wiring holds one store per group, so a point write copies one group's Map and wakes that group's view alone; the read wiring keeps the population in one store, because a view switch has to re-point view A and a `combine` cannot change its inputs. The churn and relation wirings hold one store per row or owner. Effector 23 exports no batch function; in the window and cell wirings a frame is one event per touched group store carrying the array of the frame's operations, the Effector idiom for a bulk edit, and each pinned cell is its own `.map` down to one column's string.

bindidiomaticOne store per group, minted on first ask with ONE event, `opsApplied`, carrying an ordered array of write/patch/drop operations reduced by one `.on` that copies the Map at most once per call (effector.ts:74-104, asked through `nodeFor` :161-168), and an id → group-node handle table (:159). One `.map` and `.watch` per view over its own group's store (:210-220). A reducer must return a new reference for Effector to see a change (`e!==r` in the store node, node_modules/effector/effector.mjs line 1); a write wakes only the view over the written row's group. Outside a frame every method fires `opsApplied` with one operation (`send`, :182-194); inside `frame` (`groupFrame`, :196-203) operations queue per store and each touched store's event fires once when `run` returns, so a frame costs one Map copy and one view recompute per touched group, not one per write. A move is a drop on one store and a write on the other, the row read with `getState()` first, after firing the old store's queue if this frame already queued that row (:283-297; effector.md, 'What a frame is to Effector'). Every view's `.map` returns a fresh array (:119-148), so a view's watcher fires whenever its own store updates.
bindPerGroupidiomaticSame body with fifty bindings (effector.ts:1153): one `.map` per group store, so a write recomputes the one view over the written group, and a frame spread over every group fires one event per group.
churn.rowidiomaticOne store per row with its own event (effector.ts:381-387). `count === 1` subscribes with `.updates.watch` on the row store and records the store's current label as the slot's read at mount (:501-510). `.updates` skips the initial call, as effector.md says ('What a mount is'). Each watcher writes `churnRead[at]` (:399-402) and `unmount` clears it (:545-552), so the verify-pass fold over every standing read (render.ts:124-141) sees only mounted subscribers. `frame` is `run()` (:39-41): the three scripts that open a frame here (`churnList`, `appFill`, `appRound`) write distinct rows, so each row store already gets one event per frame (effector.md, 'What a frame is to Effector').
churn.wideidiomatic`combine` over the source row stores (`joinedOf`, effector.ts:404-420), then `.updates.watch` (:512-514).
churn.columnidiomatic`row store.map(row => row.label)` (effector.ts:516-523). The store's own `===` skip on the derived string is what makes it a column (effector.mjs, `e!==r`). The adapter does not compare anything.
churn.chainidiomaticLevel 1 is the `combine` over the `count` source stores returning `chainLevelOf(label of row from, 1)` (`chainJoinedOf`, effector.ts:422-431); levels 2..depth are each a `.map` returning `chainLevelOf(text, level)`; `.updates.watch` on the head (:524-533). `unmount` calls `clearNode` on every derived node (:545-552), Effector's public teardown.
churn.diamondidiomaticTwo `.map`s of root row `from`'s store (`diamondLeftOf`, `diamondRightOf` of its label) and `combine(left, right, diamondJoinOf)`, with `.updates.watch` on the join (effector.ts:534-544). All three are cleared on unmount (:545-552). That the join runs once per write is left to Effector's kernel; not traced (effector.md, 'The derivation shapes'), and the diamond script's check is what asserts it.
reads.byKeyidiomaticOne `getState()` per page and one `Map.get` per key, nothing hoisted (effector.ts:754-763).
reads.byWindowidiomaticView A's cursor (group and offset) is its own store (effector.ts:678-680). View A is `combine($state, $cursor)` (:719-727) and view B is `$state.map` (:728-730), so a scroll reruns A only (:767). The population is one store here, for the reason in `reads.bySwitch`.
reads.byTwoAxesidiomaticView B is a `.map` of `$state` with the second predicate over group A (effector.ts:728-730, predicate at :698). One-store granularity: every write in this wiring recomputes both views and copies the population Map; the only timed writes are this script's four moves.
reads.bySwitchidiomatic`switchGroup` fires `switched` (effector.ts:768), on which the cursor store's reducer returns `{ group, offset: 0 }` (:680): one event, one cursor update, one recompute of view A over the new group's ids in `$state`. View B does not read the cursor. The population stays one store in this wiring because a `combine` fixes its inputs at creation and `TViewConfig` names only two groups at bind; a partition was considered and not made (effector.md, 'Which store the population lives in'), because it would add an id → group lookup to every key `readByKey` measures while four of the five read scripts write nothing.
relationsidiomaticRows and pairs are each one store (effector.ts:817-861, :866-886), and every owner has its own store and event (:920-930). View A is `combine` over the touched owner stores (:948-956), so a pair write cannot reach it. `writePair` composes the key on every call (:987-992). No relation script opens a frame.
singleidiomatic`createStore('')` with `.on(event, (_, next) => next)` and `.updates.watch` (effector.ts:1030-1096). Re-sending an equal value is skipped by the store's own `===`.
What would make it faster or more idiomatic
  • APPLIED — the window wiring's population is partitioned into one store per group (effector.ts:74-104, :153-363), the layout nanostores' window wiring already uses; a store layout is the adapter's to choose. Unmeasured.
  • APPLIED 2026-10-20 — a frame in the window and cell wirings is one `opsApplied` event per touched group store with the array of the frame's operations (effector.ts:170-203), replacing one event and one Map copy per write. Expected to move batchPatch, batchPatchNote, patchMostRows, mixedFrame, moveAndReorder and resortWindow; unmeasured.
  • APPLIED 2026-10-20 — the cell wiring is a `.map` per pinned cell and column over the row's group store and a `combine` per column over its cells (`pinnedTextOf`, effector.ts:234-250), so a label write reaches only the label consumer by Effector's own `===` skip on the cell string. It replaced a `combine` over the whole group stores that rebuilt both columns' arrays on every pinned write. Expected to move cellDelivery; unmeasured.
  • DECLINED — derive each view into a store created with Effector's documented `updateFilter` option (node_modules/effector/index.d.ts:398) through `sample`, filtering on element-wise identity of the window rows. `updateFilter` is the library's option, but the element-wise comparator handed to it would be written in the adapter, and `TBinding.write` forbids an adapter supplying an equality its library does not ship. Not applied, by ruling.
  • DECLINED — partitioning the read wiring's population (see `reads.bySwitch`).

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

nanostores 1.5.5idiomaticthe code changed after this audit

the row columns live in the records of nanostores map stores — one per group in the window wiring, beside an id -> store table that holds handles only, and one for the population in the read wiring, beside a group index that holds ids alone and no value; the change signal is the store's own notify — inline outside a frame, drained once at the end of `batch` inside one — reaching the consumer through the subscribed computed built over it.

The window wiring holds one `map` store per group with a computed per view over its own group's store, so a point write spreads one group's record and wakes only that group's view. `frame` is nanostores' own synchronous `batch(run)`, which queues every listener and drains once when the outermost batch returns, so a multi-write frame reaches each listener once, with final values. The cell wiring is a `computed` per pinned cell and column, so the atom's own `Object.is` keeps a label write away from the note consumer. The chain and diamond are nanostores' own `computed`. A computed that loses its last listener is detached only on a 1000 ms timer (`STORE_UNMOUNT_DELAY`) the worker never reaches, so after an unmount on the churn rows, and after `pin` for the two window computeds, the edges stay and keep recomputing; that is a library limit with no public workaround, stated as a known effect and not worked around.

bindidiomaticOne `map` store per group (nanostores.ts:51, :55-62) and an id → group-store handle table (:53). One `computed` + `.subscribe` per view over its own group's store (:115-122). Point writes use the documented `setKey` (:134-140), which itself spreads the store's record (node_modules/nanostores/map/index.js:14-19) — one group's, not the population's. Batched writes publish one whole-record `set` per touched store (`write` :162-179, `remove` :180-189); a move is two store writes (:194-209). The cell wiring built by `pin` (:227-249) is a `computed` per pinned cell and column over that row's group store, returning one string, and a `computed` per column over its cells (`pinnedTextOf`, :142-156): a label write leaves every note cell's string unchanged, the atom's `set` drops it (`Object.is`, atom/index.js), and the note consumer is not delivered. `frame` is `batch(run)` (:38-40; `batch` exported at index.js:1, defined at atom/index.js:43-57, documented at atom/index.d.ts:196-224). Inside it each view's `.subscribe` listener is queued once per batch and called once when the outermost batch returns, with the computed's value at that moment (atom/index.js:15-41, :96-119). `batch` coalesces notifications only: each `setKey` inside a frame still spreads its group's record (map/index.js:14-19).
bindPerGroupidiomaticSame body with fifty computeds, each over its own group's store (nanostores.ts:880), so a write in one group recomputes one view. Same `batch` `frame` as `bind`: a frame recomputes and delivers each touched group's view once.
churn.rowidiomaticOne `map` store per row (nanostores.ts:297), `listen` on it (:350), with the store's current label recorded as the slot's read at mount (:351). `listen` does not call the listener on subscribe (atom/index.js), so a mount is not also a wake. Each wake writes `churnRead[at]` (:287-290) and `unmount` clears it (:396-402), which is what the verify-pass fold over every standing read (render.ts:124-141) checks. The multi-row frames that reach this wiring — `churnList` (`writeFrame`, scenarios.ts:1881-1891), `appFill` (:2917-2922) and `appRound` (:2983-2993) — write each row once per frame, and every subscriber is its own listener closure (:287, :350), so under `batch` every subscriber on a written row still runs exactly once, at the end of the frame rather than inline; the woke counts the scripts expect (`churnListPrefix`, `APP_FILL_WOKE`, `appRoundWoke`) count subscribers on written rows and are unchanged by the switch.
churn.wideidiomatic`computed` over the source row stores, then `listen` (nanostores.ts:354-363). Unmount splices the listener, but the computed stays attached to its sources until `STORE_UNMOUNT_DELAY` (lifecycle/index.js:117, :136-145), which no sample reaches; a KNOWN EFFECT on this row, shared with `churn.chain` and `churn.diamond`, with no public workaround, and the `departure` says its direction is unmeasured (src/adapters/nanostores.md, 'A computed with no listener stays attached for a second'). `churnWide` writes one row per frame (`rowsWrittenIn: churnRowOnly`, scenarios.ts:2152), and `writeFrame` with a count of one calls `patchLabel` without opening a `frame` at all (scenarios.ts:1883-1886), so the switch to `batch` does not touch this wiring's script.
churn.columnidiomatic`listenKeys(store, ['label'])` (nanostores.ts:365-370), the library's own key filter (listen-keys/index.js:3-29). The writes use `setKey('label', …)` (:306), which passes the key name the filter reads; `setKey` itself skips a value `Object.is`-equal to the held one (map/index.js:14). Inside a `batch` the `changed` key is `undefined` (atom/index.js:112, atom/index.d.ts:207-208) and `listenKeys` falls back to comparing the key's pre-batch and final values (listen-keys/index.js:9-16), which still filters by key; no script reaches this wiring inside a frame, because `churnColumn` writes one row (scenarios.ts:2255) and `writeFrame` opens no frame for one.
churn.chainidiomaticLevel 1 is a `computed` over the `count` source stores returning `chainLevelOf(label of row from, 1)`; levels 2..depth are each a `computed` over the level below returning `chainLevelOf(text, level)`; `listen` on the head (nanostores.ts:371-386). It carries the same deferred-unmount exposure as `churn.wide`.
churn.diamondidiomaticTwo `computed`s over root row `from`'s store (`diamondLeftOf`, `diamondRightOf` of its label), a third `computed([left, right], diamondJoinOf)`, and `listen` on the join (nanostores.ts:387-395). Read in node_modules/nanostores 1.5.5: a root write queues left's and right's recompute on the one listener queue before either runs (atom/index.js:96-119, the queue drains only when `runListenerQueue` was set by the outermost notify); each then queues the join, the first join run recomputes it and stamps `currentEpoch` (computed/index.js:32), and the second returns at `currentEpoch === epoch` (computed/index.js:12-13), so the listener fires once per write. Inside a `batch` the join's two queue entries share one listener (computed/index.js:62 registers the same `run` on both sources), and `drainQueue` skips the second because the first call cleared its pending set (atom/index.js:21-28), so the result is the same. Not run; `churnDiamond` writes one row per frame (scenarios.ts:2590) and its check is what asserts the count. Same deferred-unmount exposure as `churn.wide`.
reads.byKeyidiomaticOne `$rows.get()` per page and one property read per key, nothing hoisted (nanostores.ts:554-563).
reads.byWindowidiomaticView A's cursor is one atom holding group and offset (nanostores.ts:423). View A is `computed([$rows, $cursor])` (:470-479) and view B is `computed($rows)` (:480-482), so a scroll recomputes A only (:566-568). A scroll sets a fresh `{ group, offset }` object rather than a number. Both views are over one group, so this wiring keeps the population in one store (:421) beside a Set-per-group id index (:422). A point write spreads the 10 000-key record (`setKey`, :523-546); the only timed writes in this wiring are `filterTwoAxes`' four moves, and a partition was considered and not made (src/adapters/nanostores.md, 'What a computed can depend on').
reads.byTwoAxesidiomaticView B is `computed($rows)` with the second predicate (nanostores.ts:480-482, predicate at :448).
reads.bySwitchidiomatic`switchGroup` sets the cursor atom to `{ group, offset: 0 }` (nanostores.ts:569-571): one atom write, one notification, one recompute of view A over the new group's ids. src/adapters/nanostores.md gives the reason for one atom as `switchGroup` not being called inside a frame. Against 1.5.5 two atoms written inside `batch` would also reach view A's computed once (one `run` listener on both sources, computed/index.js:62); the one-atom shape needs no batch and costs nothing. View B does not name the atom.
relationsidiomaticOne `map` store per row, owner and pair (nanostores.ts:599-601). The views are computeds over the touched owner stores and over the pair stores (:673-692), so the two views have disjoint dependencies. `writePair` composes the key and looks up the store on every call (:713-717).
singleidiomatic`atom('')` and `listen` (nanostores.ts:757-815). `atom.set` skips a value equal under the atom's `eq`, which is `Object.is` (atom/index.js:67, :123-129).

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

nanostores-per-row 1.5.5not audited

the row columns live in one nanostores map store per row, beside id -> store tables and group membership tables that hold handles and ids only; the change signal is the row store's own notify, reaching the subscribed computed through a per-group version atom.

redux-toolkit 2.13.0idiomaticthe code changed after this audit

the row values live in the Redux store — the rows slice's `entities` record, written only by its reducers — and `store.subscribe`, which Redux calls at the end of every dispatch, is what drives the consumer; under the window and read wirings the `idsByGroup` index beside it is slice state written by those same reducers and holds ids, never values.

A normalised RTK slice with `createSelector` views, every array selector carrying reselect's `resultEqualityCheck: shallowEqual` and every subscriber applying react-redux `useSelector`'s default reference bail-out; a frame's row writes are buffered and dispatched as ONE `edited` action; the chain and diamond are memoised reselect selectors, a view switch is an action into the `view` slice; `churn.column` selects the label string and compares it by `===`.

bindidiomaticOne `store.subscribe` (redux-toolkit.ts:274-283) over one memoised selector per view (:260-271), each declared with `SHALLOW_RESULT` (:211), i.e. `memoizeOptions: { resultEqualityCheck: shallowEqual }` with react-redux's `shallowEqual`. A recomputed window holding the same row objects returns the previous array (reselect.mjs:151-156), so the reference bail-out — `useSelector`'s default (`refEquality`, react-redux.mjs:958-962) — skips it. Row writes go through `rowEditorOf` (:178-204): one `edited` action per write outside a frame, one per frame inside it.
bindPerGroupidiomaticSame body with fifty views (redux-toolkit.ts:838). Every notification calls all fifty selectors, and any write to `entities` makes all fifty recompute; only views whose window's row objects changed get a new reference and are delivered.
churn.rowidiomaticOne `store.subscribe` per subscriber over `entities[id]`. A wake is counted only when the selected reference changed (redux-toolkit.ts:359-373), which is `useSelector`'s default semantics. Every subscriber body still runs on every notification, so the time carries Redux's global notification (redux-toolkit.md, 'What the counter on a subscription-churn row counts'). The read is recorded at mount (:365) and on every wake (:371), and `unmount` clears it (:459-465). The store is the rows slice without the group index (:112-121).
churn.wideidiomaticSame subscriber, selecting a string composed from `count` rows (redux-toolkit.ts:378-387, :423-431).
churn.columnidiomatic`mountOnColumn` (redux-toolkit.ts:432-435) is `useSelector(state => entities[id].label)`: the same subscriber as `churn.row`, selecting the label string and comparing it by `===`. Redux keeps no column identity; the column is the selector, which is how a react-redux user subscribes to one field.
churn.chainidiomaticLevel 1 is a `createSelector` over `entities` returning `chainLevelOf(label of row from, 1)`; levels 2..depth are each a `createSelector` over the level below (redux-toolkit.ts:436-446); the subscriber selects the head. reselect's `identityFunctionCheck` only runs outside production (reselect.mjs:183-200, :336-353). Same subscriber as `churn.row`.
churn.diamondidiomaticAn input selector for root row `from`'s label, two `createSelector`s over it and a third over both, the subscriber on the join (redux-toolkit.ts:447-458). Reselect memoises each result function on its inputs, so an unchanged label re-runs neither branch nor the join.
reads.byKeyidiomaticOne `getState()` per page and one `entities[id]` per key, no dispatch (redux-toolkit.ts:552-561).
reads.byWindowidiomaticView A's cursor is a second slice (redux-toolkit.ts:477-489). The listener (:529-543) is two `useSelector`s for view A — the page rows (`selectPageRows`, :508-516, shallow result check) and `view.offset` — and one for view B (`selectOnAxis`, :517-521). On a scroll (:564) view B's inputs are unchanged and it is not delivered.
reads.byTwoAxesidiomaticView B is a `createSelector` over `entities` and group A's ids with the second predicate (redux-toolkit.ts:517-521, predicate at :226), with the shallow result check, so a write that leaves B's rows the same objects does not deliver B.
reads.bySwitchidiomatic`switchGroup` dispatches `view/switched` (redux-toolkit.ts:565), whose reducer sets `group` and resets `offset` in one draft (:484-487). The slice is pointed at group A by that action once, before any subscriber exists (:505).
relationsidiomaticThree slices in one store (redux-toolkit.ts:632-639), so an owner write leaves `state.pairs` unchanged and the pair selector hits its cache; both selectors carry the shallow result check (:657-666). `renderBoth` (:670-682) delivers a view only when its selector's reference changed.
singleidiomaticTwo `store.subscribe` listeners (redux-toolkit.ts:750-765), each selecting one string and rendering only when it is not `===` the last, `useSelector`'s default. No script writes a single inside a frame, so `frame` runs its function (:772).

claude-opus-5-5 (code edited 2026-10-20; nothing re-run), 2026-10-20 — full card with evidence

preact-signals 1.14.4idiomaticthe code changed after this audit

every row is a @preact/signals-core signal per mutable field (group, rank, label, note), and the id and group maps beside them hold handles to those signals rather than any value; the change signal is preact's own effect, run when the outermost batch returns.

A row is a signal per mutable field, a bucket signal per group replaced copy-on-write, and a computed plus effect per view, routed by preact's own graph; every script frame and every multi-signal write runs inside preact's `batch`, single-signal writes go through the self-batching setter, a row subscription reads every field signal of its row, the cell wiring reads one field signal per pinned cell, and the chain, diamond and view switch are preact's own `computed` and `signal`.

bindidiomatic`computed` over one bucket signal and the `group`/`rank` signals of its records, ending in an `effect` that reads the selected records' `label` (preact-signals.ts:158-165). `write` and `remove` touch only the row signals and the touched buckets (:178-238). `readAll` reads every field signal's `.value` through `byId`, outside any effect and so untracked (:308). `frame` is `batch` (:126-128, wired at :304), and the same `frame` is carried by the churn (:410), read (:632), relation (:749) and single (:921) bindings.
bindPerGroupidiomaticSame body with fifty views (preact-signals.ts:975); disjoint dependency sets, routed by preact.
churn.rowidiomaticAn `effect` reading all four field signals of row `from` and rendering its label (`labelOfWholeRow`, preact-signals.ts:367-372; mount :436-440), so it is a subscription to the WHOLE row, as types.ts:55-60 and SCENARIOS.md define the shape; `churn.column` is the label-only contrast. The first run is the mount and is not counted (:354-365; preact-signals.md, 'Why an effect's first run is not a wake-up'). Every run, the first included, records the read in `churnRead[at]` (:358) and `unmount` clears it (:474-480).
churn.wideidiomaticOne `effect` reading every field signal of `count` rows, ending on row `from` (preact-signals.ts:441-447).
churn.columnidiomatic`computed(() => churnSignals[0].label.value)` under the `effect` (preact-signals.ts:449-452). A `note` write touches a signal the computed never read.
churn.chainidiomaticLevel 1 is a `computed` over the `count` sources returning `chainLevelOf(their labels joined, 1)`; levels 2..depth are each a `computed` returning `chainLevelOf(level below, level)`; the effect reads the head (preact-signals.ts:453-466). `depth` computeds in all.
churn.diamondidiomaticTwo `computed`s over root row `from`'s `label` signal (`diamondLeftOf`, `diamondRightOf`) and a third `computed` over both (`diamondJoinOf`), with the effect on the join (preact-signals.ts:467-473). That the join runs once per frame is left to preact's own graph; the adapter adds no guard, and the diamond script's check is what asserts it.
reads.byKeyidiomaticOne `byId.get` and the `.value` reads of `shownOf` per key, outside any effect, nothing hoisted (preact-signals.ts:635-645).
reads.byWindowidiomatic`$offset` (preact-signals.ts:505) is read only by `$paged`, which slices `$sorted` (:518-533), so a scroll re-runs the slice and never the sort. `scrollTo` is one setter call (:647-649). A scroll does not touch view B (:534-536).
reads.byTwoAxesidiomaticView B is a computed over the same bucket with the second predicate (preact-signals.ts:534-536, predicate at :112).
reads.bySwitchidiomaticView A's group is a `signal` (`$group`, preact-signals.ts:506) read by `$sorted` (:518-529). `switchGroup` writes `$group` and resets `$offset` to 0 inside one `batch` (:650-655), so the effect re-runs once, over the new group's bucket. View B reads neither signal.
relationsidiomaticOwner and pair records each get their own signal. View A's effect reads owner signals and view B's reads pair signals (preact-signals.ts:796-811), so the two views have disjoint dependencies. `writePair` composes the key on every call (:821-825). The owner and pair `$...Population` signals (:689, :694) are written only in the untimed `writeOwners` and `holdRelation`.
singleidiomaticBare `signal.value = v` with no `batch` (preact-signals.ts:916-918). The setter opens and closes its own batch (node_modules/@preact/signals-core/src/index.ts:461-487).

claude-opus-5-5 (author; not yet re-verified), 2026-10-20 — full card with evidence

alien-signals 3.2.1idiomaticthe code changed after this audit

every column lives in an alien-signals `signal` — a row is a signal per mutable field (group, rank, label, note), read by calling it — and each consumer is driven by alien's own `effect`, queued by the graph and run synchronously by `endBatch` or by the unbatched write itself. The id -> signal and group -> signal maps this adapter keeps hold handles only, never a value.

The preact adapter's shape in alien's surface, with one difference the library offers: a row is a signal per mutable field, a bucket signal per group is MUTATED IN PLACE and announced with the documented `trigger` (preact copies the bucket), and a computed plus effect per view; every script frame and every multi-signal write runs inside `startBatch`/`endBatch`, a row subscription reads every field signal of its row, the cell wiring reads one field signal per pinned cell, and the chain, diamond and view switch are alien's own `computed` and `signal`.

bindidiomatic`computed` over one bucket signal and the `group`/`rank` signals of its records, ending in `effect` (alien-signals.ts:259-266). `write`, `remove` and `setGroup` mutate the touched buckets in place and call `trigger` once over them (`fileRows` :152-183, `unfileRows` :185-211, `moveRow` :213-229, `triggerBuckets` :146-150), the README's documented path for a mutated value. `readAll` calls each field signal through `byId` (:348). `frame` is `inBatch`, `startBatch`/`endBatch` in a try/finally (:137-144, wired at :343), and the same `frame` is carried by the churn (:444), read (:598), relation (:709) and single (:877) bindings.
bindPerGroupidiomaticSame body with fifty views (alien-signals.ts:937); disjoint dependency sets, routed by alien's graph.
churn.rowidiomatic`effect` calling all four field signals of row `from` and rendering its label (`labelOfWholeRow`, alien-signals.ts:404-409; mount :471-475), so it is a subscription to the WHOLE row, as types.ts:55-60 and SCENARIOS.md define the shape; `churn.column` is the label-only contrast. The first run is the mount and is not counted (:391-402). Every run, the first included, records the read in `churnRead[at]` (:395) and `unmount` clears it (:509-515).
churn.wideidiomaticOne `effect` calling every field signal of `count` rows, ending on row `from` (alien-signals.ts:476-482).
churn.columnidiomatic`computed(() => churnSignals[0].label())` under the effect (alien-signals.ts:484-487). A `note` write touches a signal the computed never read.
churn.chainidiomaticLevel 1 is a `computed` over the `count` sources returning `chainLevelOf(their labels joined, 1)`; levels 2..depth are each a `computed` returning `chainLevelOf(level below, level)`; the effect calls the head (alien-signals.ts:488-501).
churn.diamondidiomaticTwo `computed`s over root row `from`'s `label` signal (`diamondLeftOf`, `diamondRightOf`), a third `computed` over both (`diamondJoinOf`), the effect on the join (alien-signals.ts:502-508). That the join runs once per frame is left to alien's own graph; the adapter adds no guard, and the diamond script's check is what asserts it.
reads.byKeyidiomaticOne `byId.get` and the signal calls of `shownOf` per key, outside every effect, so nothing is tracked or hoisted (alien-signals.ts:600-609).
reads.byWindowidiomatic`$offset` (alien-signals.ts:536) is read only by `paged`, which slices `sorted` (:550-563), so a scroll re-runs the slice and never the sort. `scrollTo` is one bare setter call (:610-612). A scroll leaves view B untouched (:564-566).
reads.byTwoAxesidiomaticView B is a computed over the same bucket with the second predicate (alien-signals.ts:564-566, predicate at :123).
reads.bySwitchidiomaticView A's group is a `signal` (`$group`, alien-signals.ts:537) that `sorted` calls (:550-559). `switchGroup` writes `$group` and resets `$offset` to 0 inside one `inBatch` (:613-618), so the effect runs once, over the new group's bucket. View B calls neither signal.
relationsidiomaticOwner and pair records each get their own signal. View A's effect calls owner signals and view B's calls pair signals (alien-signals.ts:756-771), so the two views have disjoint dependencies. `writePair` composes the key on every call (:781-786). The owner and pair population signals (:648, :653) are written only in the untimed `writeOwners` and `holdRelation`.
singleidiomaticBare `signal(v)` with no batch (alien-signals.ts:872-874). An unbatched write flushes before it returns (node_modules/alien-signals/esm/index.mjs:301-311).

claude-opus-5-5 (author; not yet re-verified), 2026-10-20 — full card with evidence

zustand 5.0.15idiomaticthe code changed after this audit

the row values live in one vanilla zustand store — the `entities` record of its state, replaced only through `setState` — and the store's own listener set, run by `setState` before it returns and filtered by `subscribeWithSelector`, is what drives every consumer; under the window and read wirings the `idsByGroup` lists beside `entities` are state of the same store and hold ids, never values.

One vanilla `createStore` per wiring holding the normalised shape, written by immutable `setState` updates, with every consumer a `subscribeWithSelector` listener compared by `Object.is` or the shipped `shallow`; a frame's row writes are buffered and applied as ONE `setState`, every `setState` re-runs every selector in the store, a re-send of unchanged values notifies because nothing compares values, and `churn.chain` and `churn.diamond` are declined because zustand has no derivation primitive.

bindidiomaticOne store (zustand.ts:203-205) and one `subscribeWithSelector` listener per view selecting that group's top-k window through `selectionOf`, compared with `shallow` (:208-220), the comparison `useShallow` applies (node_modules/zustand/esm/react/shallow.mjs:4-10). Writes are immutable `setState` updaters built from a list of edits (`entitiesEdited`, `rowsEdited`, :83-132). `frame` (`rowEditorOf`, :139-165) buffers the row writes issued inside it and applies them as one `setState` when it returns; outside a frame each write is its own `setState`. A write to group B re-runs view A's selector and the `shallow` comparison leaves it undelivered. The cell wiring (`pin`, :235-253) is two listeners selecting the pinned `label` and `note` strings with `shallow` and `fireImmediately`, so a label write delivers the label consumer only.
bindPerGroupidiomaticSame body with fifty listeners (zustand.ts:647). Every `setState` runs all fifty selectors — fifty top-k derivations and fifty `shallow` comparisons — and only the views whose window holds a new row object are delivered.
churn.rowidiomaticOne `subscribeWithSelector` listener per subscriber selecting `entities[id]` with the default `Object.is` (zustand.ts:277-291, :324-329; equality at esm/middleware.mjs:254-258). The mount subscribes with `fireImmediately`, so the selector runs once per mount and that first call records the read; the middleware passes the same slice as next and previous there (esm/middleware.mjs:263-265), which is how the listener tells it from a wake (:285-288). `unmount` deletes the listener and clears the read slot (:344-350). Every `setState` runs every standing subscriber's selector, so the time carries zustand's global notification. The store holds `entities` alone (`onlyEntitiesEdited`, :134-137): no churn script reads a grouping.
churn.wideidiomaticThe subscriber selects the tuple of its `count` rows and compares it with `shallow` (zustand.ts:330-336), the documented multi-value selection (README.md:216-221); the rendered text is the first row's label (:296-303). Because the tuple holds the row objects, a write to any of the `count` rows wakes the subscriber, not only a write to the first; churnWide writes only the first (harness/scenarios.ts:2139-2140).
churn.columnidiomaticThe subscriber selects `entities[id].label` with the default `Object.is` (zustand.ts:338-341), so a write to another column of the row re-runs the selector and does not wake it. The column filter is the middleware's equality on a selected string (esm/middleware.mjs:254-258), the same thing the README's `state.paw` example shows (README.md:209-210); the adapter compares nothing.
churn.chaindeclinedDeclined with a written `absent` (zustand.ts:587-593, :626-629); `mountOnChain` throws through `declinedMount` (:342). The package ships no derived value: a selector is re-run per notification and nothing caches a level's output (esm/vanilla.mjs:1-21, esm/middleware.mjs:249-271), so a chain would be either one flat function or memoisation written in the adapter.
churn.diamonddeclinedDeclined for the same reason and with the same text as `churn.chain` (zustand.ts:587-593); `mountOnDiamond` throws (:343).
reads.byKeyidiomaticOne `getState()` per page and one `entities[id]` per key, nothing resolved in advance and no `setState` (zustand.ts:409-418).
reads.byWindowidiomaticView A's cursor is a `cursor` field of the same state (zustand.ts:359-373). A scroll is one `setState` of a fresh cursor (:419-423); view A's selector takes the top `offset + window` of the cursor's group and slices the page (:378-390), view B's selector re-runs over unchanged rows and `shallow` leaves it undelivered (:391-401). The selection is a top-k walk and not a re-sort.
reads.byTwoAxesidiomaticView B selects group A's window under the second predicate (zustand.ts:391-401, predicate in `selectionOf` at :182). A move of a row view B's predicate excluded replaces only that row's object, so B's window stays `shallow`-equal and is not delivered.
reads.bySwitchidiomatic`switchGroup` sets `cursor` to `{ group, offset: 0 }` in one `setState` (zustand.ts:424-426); view A's selector reads the new group's id list (:378-390); view B's inputs are unchanged and `shallow` holds.
relationsidiomaticOwners and pairs are two more records of the same state (zustand.ts:438-447). The views select the owners' names and the pairs' marks as string arrays with `shallow` and `fireImmediately` (:478-491), so an owner write leaves the pair view undelivered and a pair write the owner view. Both selectors run on every `setState`, and the pair selector composes each key per line per notification. `writePair` composes its key per call (:501-508).
singleidiomaticA two-field store and two listeners selecting `value` and `bystander` with the default `Object.is` (zustand.ts:523-585, listeners at :543-560). `writeSingle` is `setState({ value })` (:564-566); no script writes a single inside a frame, so `frame` runs its function (`runDirectly`, :167-169): the merged state is a new object, so `setState` notifies (esm/vanilla.mjs:6-9), and the middleware's `Object.is` on the selected string is what keeps the bystander silent and makes singleResend wake neither.

claude-opus-5-5 (code edited 2026-10-20; nothing re-run), 2026-10-20 — full card with evidence

valtio 2.3.2idiomaticthe code changed after this audit

the row columns live in valtio proxies — one per row, filed under `rows` and, in the window and read wirings, under its group's bucket in `byGroup` of the same `proxy` state — and the change signal is valtio's own listener notification, run inside the write by `subscribe(…, true)` and `subscribeKey(…, true)`, which marks the view that `settle` renders.

One vanilla `proxy` state per wiring mutated in place, every consumer a `subscribe` or `subscribeKey` with the sync flag because the default microtask arm never runs in a worker that does not yield, each listener marking its view and `settle` rendering the marked ones; there is no batch, a subscription hears its whole subtree, valtio's per-property `Object.is` makes a re-send silent, and `churn.chain` and `churn.diamond` are declined because 2.3.2 ships no derivation primitive.

bindidiomaticOne `proxy({ rows, byGroup })` (valtio.ts:151-155) holding each row proxy under the population and under its group bucket (:93-132). Each view is `subscribe(bucket, mark, true)` (:157-174); `settle` delivers each marked view once through `visibleOf` over the bucket's values (:247-270). The sync arm is the only one that runs here: the default arm defers to a microtask (node_modules/valtio/vanilla.js:210-216), the flag calls back inside the set (:206-208). `frame` calls its function directly (valtio.ts:52-54); the vanilla entry exports no batch (vanilla.js:278-285). A subscription hears its whole bucket, so a note write or a write below the window marks the view and delivers text it already shows. The cell wiring (`pin`, valtio.ts:203-236) is `subscribeKey` on `label` and `note` of each pinned row proxy (vanilla/utils.js:5-17), so a label write marks the label view only.
bindPerGroupidiomaticSame body with fifty bucket subscriptions (valtio.ts:738). A write reaches only the listeners of the bucket its row is filed in; a parent with no listener is never wired to its children (vanilla.js:120-133), so the population record costs nothing per write.
churn.rowidiomatic`subscribe(row, body, true)` on the row proxy resolved at `holdChurnRows` (valtio.ts:312-343). The read is taken from the proxy at mount and is not a wake; `woke` is counted only in the body; `unmount` releases the listener and clears the read slot (:359-365). The churn and application scripts driven through this wiring write rows with `patchLabel` (harness/scenarios.ts:1883, :1888, :2484, :3040-3044), so a whole-row subscription wakes exactly the subscribers on the written rows; a write to another column of the row would wake it too, which is what a row subscription means.
churn.wideidiomatic`subscribe` takes one proxy (vanilla.js:193-225), so the subscriber is one `subscribe` per source sharing one body, released together on unmount (valtio.ts:320-346); the rendered text is the first source's label. Mount pays `count` listener registrations, which is what a valtio user over several proxies writes.
churn.columnidiomatic`subscribeKey(row, 'label', body, true)` (valtio.ts:344-356), the shipped per-property subscription: a whole-proxy `subscribe` whose callback runs only when `Object.is` says `label` moved (vanilla/utils.js:9-13). The adapter compares nothing.
churn.chaindeclinedDeclined with a written `absent` (valtio.ts:675-684, :717-720); `mountOnChain` throws through `declinedMount` (:357). valtio 2.3.2 ships no derived value: `derive` left for the separate `derive-valtio`, the shipped utils are listed at vanilla/utils.js:575-583, getters are unmemoised functions with no change signal (README.md:300-313), and `watch` is deprecated (vanilla/utils.js:21-27) and an effect, not a value.
churn.diamonddeclinedDeclined for the same reason and with the same text as `churn.chain` (valtio.ts:675-684); `mountOnDiamond` throws (:358).
reads.byKeyidiomaticOne `rows[id]` property read through the proxy per key, nothing resolved in advance and nothing written (valtio.ts:417-426).
reads.byWindowidiomaticView A's cursor is a `cursor` proxy in the same state (valtio.ts:383-387). View A listens to the cursor (:401) and to the bucket of the cursor's group (`subscribePagedBucket`, :397-399). A scroll is one set of `cursor.offset` (:427-429), which marks view A through its `cursor` subscription; `settle` takes the top `offset + window` of the cursor's bucket with `visibleInto` and delivers the page at the offset (:436-454). View B listens to group A's bucket only and is not marked by a scroll. The selection is a top-k walk, not a re-sort.
reads.byTwoAxesidiomaticView B is `subscribe(groupA bucket, mark, true)` (valtio.ts:402-408), delivered through `visibleOnAxisInto` (:455-468). Any write into group A marks it, including rows its predicate excludes, and those deliveries are redundant.
reads.bySwitchidiomatic`switchGroup` releases view A's bucket subscription, subscribes to the new group's bucket, and sets `cursor.group` and `cursor.offset` (valtio.ts:430-435): two notifications on the cursor proxy, one delivery at `settle` of the new group's bucket at offset 0. A write to any other group does not mark view A. The re-subscription is inside the timed switch and pays what valtio charges for it: the first listener on a bucket wires every row proxy in it (`addListener`, vanilla.js:142-152), and the last listener leaving unwires them (vanilla.js:153-163); group A's bucket keeps view B's listener, so switching back to it wires nothing.
relationsidiomaticOwners and pairs are two records of one state (valtio.ts:482-486). The line sources are resolved once at `holdRelation` and the two views are `subscribe(owners)` and `subscribe(pairs)` with the sync flag, delivered at hold and then at `settle` when marked (:583-592). An owner write does not mark the pair view and a pair write does not mark the owner view. `writePair` composes its key per call and looks it up through `pairs`.
singleidiomaticOne `proxy({ value, bystander })` and two `subscribeKey` listeners (valtio.ts:608-673). A write of `value` runs both listeners, because both are subscriptions to the same proxy, and only the `value` callback passes `Object.is` (vanilla/utils.js:9-13), so the bystander is not delivered. A re-send of the stored value is a no-op in the set trap (vanilla.js:56-58) and wakes neither.

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

xstate-store 4.2.3idiomaticthe code changed after this audit

the row values live in the context of an @xstate/store store — its `rows` record, replaced only by the store's own transitions — and the change signal is the store's atom, which `send` sets and which pushes through the `select`/`createAtom` computeds subscribed over it; under the window and read wirings the `idsByGroup` index beside the rows is context written by the same transitions and holds ids, never values.

One `createStore` per entity type with immutable transitions sent as `store.send` events, every consumer a subscription to a `store.select` or `createAtom` computed over the store; the package ships no batch, so `frame` buffers its row events and sends ONE `framed` event that re-triggers them through `enqueue.trigger`, one transition and one notification per frame; window, cell, relation and both read views compare with the package's own `shallowEqual`, and the wide churn subscriber selects the `count`-tuple of row objects under it; every churn shape, including the column, chain and diamond, is built from `select` and `createAtom`.

bindidiomaticOne rows store (xstate-store.ts:115-169) and one `store.select(..., shallowEqual)` per view, subscribed (:260-268). Every point event spreads the whole `rows` record (:105-113, :151-166), the README's immutable pattern (node_modules/@xstate/store/README.md:28-45). A transition that changes the snapshot recomputes both views (store-55b22bbd.js:751-755); `shallowEqual` (xstate-store.js:13-27) delivers only a view whose window holds a different row object. `frame` (`rowWritesOf`, :201-228) buffers the row events and sends one `framed` event whose handler (:60-76) re-triggers them with `enqueue.trigger`, so a frame is one transition and one `atom.set` (store-55b22bbd.js:847-875, :646-649).
bindPerGroupidiomaticThe same body with fifty selections (xstate-store.ts:689, body :258-303). One write recomputes all fifty selectors, since all depend on the one store atom; `shallowEqual` keeps the forty-nine whose window did not change from delivering.
churn.rowidiomatic`store.select(context => context.rows[id])` per subscriber, subscribed, with the row's label recorded at mount (xstate-store.ts:335-341, :362-367). The first effect run does not call the observer (store-55b22bbd.js:365-372), so a mount is not a wake. A write to another row returns the same row object and `Object.is` keeps the subscriber silent (store-55b22bbd.js:395, :405). The initial read at xstate-store.ts:340 is `source.get()` on a computed the effect has just evaluated, so it returns the cached snapshot without re-running the selector (store-55b22bbd.js:421-436). `unmount` stops the effect and clears the slot (:398-404); the selection purges its edge to the store synchronously (store-55b22bbd.js:252-258, :517-521). Every subscriber's selector runs on every transition. The store is `createEntitiesStore` (:171-199), the rows record without the group index, because no churn script reads a grouping.
churn.wideidiomatic`store.select` returning the `count`-tuple of row objects (xstate-store.ts:368-373) compared with the package's `shallowEqual`, rendering the first defined row's label (`firstLabelOf`, :317-324). A write to any of the `count` rows yields a different tuple element and wakes the subscriber; a write elsewhere leaves every element the same object. The same shape as zustand's wide subscriber (zustand.ts:330-336).
churn.columnidiomatic`store.select` of row 0's label alone (xstate-store.ts:375-378). The library's own selection comparator (`Object.is`, store-55b22bbd.js:395, :405) is what tells a label write from a write to another column; the adapter compares nothing. The store still has one change signal, so every column selector runs on every write — the same cost as `churn.row`, with a different filter.
churn.chainidiomaticLevel 1 is `store.select` returning `chainLevelOf(composed label, 1)`; levels 2..depth are `createAtom(() => chainLevelOf(below.get(), level))`; the subscriber is on the head (xstate-store.ts:379-389). `createAtom` with a getter is the package's computed (store-55b22bbd.js:343-437). Teardown cascades down the levels through `unwatched` (:252-258). Level 1 composes a string, as alien-signals' level-1 computed does (alien-signals.ts:456-462), so the chain's cut-off is the library's `Object.is` on that string.
churn.diamondidiomaticA `select` of root row `from`'s label, `createAtom`s for `diamondLeftOf` and `diamondRightOf` over it, a `createAtom` join over both, the subscriber on the join (xstate-store.ts:390-397). The reactive core is alien-signals adapted in-package (store-55b22bbd.js:3-5, propagate :95-144, checkDirty :145-211), which marks the join pending once and recomputes it once per write. Not run; the diamond script's check is what asserts it.
reads.byKeyidiomaticOne `getSnapshot()` per page and one property read per key, nothing resolved in advance, no event sent (xstate-store.ts:459-468).
reads.byWindowidiomaticView A's cursor is a second store with `scrolled` and `switched` events (xstate-store.ts:417-429). View A is a `createAtom` reading both stores via `store.get()` (:431-443), the README's tracked read (README.md:353); view B is a `select` over the rows store alone (:444-447), so a scroll recomputes A only. A scroll is one `send` (:469). View A's atom compares its `offset` and then its rows with `shallowEqual` (:443), through `createAtom`'s `compare` option (store-55b22bbd.js:395).
reads.byTwoAxesidiomaticView B is `select` over the rows store with the second predicate (xstate-store.ts:444-447, predicate in `selectionOf` :244) and `shallowEqual`. View A is the `paged` atom (:431-443); it depends on the rows store's atom, so every transition filterTwoAxes causes recomputes it (scenario lines from the 2026-10-17 audit, not re-read), and its comparator — same offset and `shallowEqual` rows — keeps it from delivering when the moved row was outside its window, as zustand's sliced page under `shallow` does (zustand.ts:378-390).
reads.bySwitchidiomatic`switchGroup` sends one `switched` event setting `{ group, offset: 0 }` (xstate-store.ts:424-427, :470): one atom write, one recompute of view A over the new group's bucket. View B does not read the cursor store.
relationsidiomaticRows, owners and pairs in a store each (xstate-store.ts:487-527). View A is a `select` over the owners store, view B over the pairs store, both with `shallowEqual` (:541-550), so a write to one type never marks the other view. `writePair` composes the key on every call (:556-557).
singleidiomaticOne store with `value` and `bystander` in context and a `select` of each, subscribed (xstate-store.ts:572-637); no script writes a single inside a frame, so `frame` runs its function (`runDirectly`, :34-36). A re-send of the same value produces a new context and notifies the store atom, and the selection's `Object.is` (store-55b22bbd.js:405) keeps both subscribers silent.
What would make it faster or more idiomatic
  • Unmeasured: inside a frame every triggered event is still its own handler, so a frame of k point writes spreads the rows record k times. One bulk event applying all k edits to one copy would spread it once; `enqueue.trigger` is what the package ships for one transition, and a bulk event is the adapter's own transition, so it is left as a question.
  • Unmeasured: partitioning the rows record by group (one record per group inside context, or one store per group as the nanostores adapter does) would cut a point write's copy from the population to one group. It is not a pattern the README shows, and it is a different normalisation rather than a faster use of the same API.

claude-opus-5-5 (code edited 2026-10-20; nothing re-run), 2026-10-20 — full card with evidence

vue-reactivity 3.5.43idiomaticthe code changed after this audit

every row is a @vue/reactivity `shallowRef` per mutable field (group, rank, label, note), and the id and group maps beside them hold handles to those refs rather than any value; the change signal is the ref's own dep trigger, which queues each subscribed effect through its `scheduler` for `settle` to run.

The preact and alien wiring in @vue/reactivity's primitives — a shallowRef per mutable field of each row, a shallowRef bucket per group mutated in place and announced with the documented `triggerRef`, a computed plus effect per view. The package exports no batch, so every effect is created with the `scheduler` option: a trigger queues it, and `settle` runs each queued effect whose `dirty` is set — the job queue @vue/runtime-core keeps and this package does not ship, the same mark-then-render-at-settle mechanism the valtio row gets.

bindidiomatic`computed` over one bucket ref and the `group`/`rank` refs of its records, ending in an effect that reads the selected records' `label` (vue-reactivity.ts:277-284). `write`, `remove` and `setGroup` mutate the touched buckets in place and `triggerRef` each once (`fileRows` :185-214, `unfileRows` :216-239, `moveRow` :241-254). `readAll` reads the field refs outside any effect, untracked (:348). `frame` is `run()` (:129-131); `settle` drains the effect queue (:134-155, wired at :347).
bindPerGroupidiomaticSame body with fifty views (vue-reactivity.ts:847); each view's computed reads only its own bucket, so Vue's dep graph routes a write to one view.
churn.rowidiomaticAn effect reading all four field refs of row `from` and rendering its label (`labelOfWholeRow`, vue-reactivity.ts:384-389; mount :450-455), so it is a subscription to the WHOLE row, as SCENARIOS.md defines the shape. The effect's creation run (reactivity.cjs.prod.js:457-474) is the mount and records the read in `churnRead[at]` without counting (:372-381); `unmount` stops the runner and clears the slot (:478-484). `settle` drains the queue, then delivers once if anything woke (:432-437).
churn.wideidiomaticOne effect reading every field ref of `count` rows, ending on row `from` (vue-reactivity.ts:391-397, :450-455).
churn.columnidiomatic`computed(() => record.label.value)` under the effect (vue-reactivity.ts:456-459). A `note` write touches a ref the computed never read, so neither runs.
churn.chainidiomaticLevel 1 is a `computed` returning `chainLevelOf(labels of the count sources joined, 1)`; levels 2..depth are each a `computed` over the one below; the effect reads the head (vue-reactivity.ts:460-470). `depth` computeds in all.
churn.diamondidiomaticTwo `computed`s over root row `from`'s label ref (`diamondLeftOf`, `diamondRightOf`) and a third over both (`diamondJoinOf`), the effect on the join (vue-reactivity.ts:471-477). The effect is in the queue once however many branches notify it, and `settle` runs it once; the diamond script's check asserts it.
reads.byKeyidiomaticOne `byId.get` and one untracked `.value` per field read per key, nothing hoisted (vue-reactivity.ts:564-572).
reads.byWindowidiomaticView A's group and offset are two refs (vue-reactivity.ts:508-509). A `sorted` computed orders the group's bucket and a `paged` computed slices it (:512-527), so a scroll re-runs only the slice. `scrollTo` is one ref write (:573-575). View B's computed reads neither ref (:528-530).
reads.byTwoAxesidiomaticView B is a computed over the same bucket with the second predicate (vue-reactivity.ts:528-530, predicate at :116).
reads.bySwitchidiomatic`switchGroup` writes the group ref and resets the offset ref (vue-reactivity.ts:576-579); view A's effect is queued by both and is in the set once, so it runs once at `settle` over the new group's bucket.
relationsidiomaticOwner and pair records each get their own `shallowRef`. View A's effect reads owner refs and view B's reads pair refs (vue-reactivity.ts:682-697), so the two views' dependencies are disjoint. `writePair` composes the key on every call (:702-706). The population refs (:597, :600) are written only in the untimed `writeOwners` and `holdRelation`.
singleidiomaticBare `ref.value = v` (vue-reactivity.ts:784-786). The setter compares with `hasChanged` (reactivity.cjs.prod.js:1428); a changed value queues the effect, and `settle` runs it and delivers (:790-800).

claude-opus-5-5 (author; not yet re-verified), 2026-10-20 — full card with evidence

solid-js 1.9.15idiomaticthe code changed after this audit

every row is a solid-js `createSignal` per mutable field (group, rank, label, note), and the id and group maps beside them hold the [get, set] pairs of those signals rather than any value; the change signal is solid's own `createEffect`, run when the outermost update returns.

Solid's signal layer outside components: a createSignal per mutable field of each row, a bucket signal per group created with `equals: false` and mutated in place, a createMemo plus createEffect per view inside a createRoot, every script frame in Solid's own batch; the chain, diamond and view switch are createMemo and createSignal. The reactive build is imported by path because under node `solid-js` resolves to the inert server build, and solid-js/store is not used because it imports the bare `solid-js` and would sit on that server build.

bindidiomaticA `createMemo` over one bucket signal and the `group`/`rank` signals of its records, ending in a `createEffect` that reads the selected records' `label`, all inside one `createRoot` (solid-signals.ts:240-250). `write`, `remove` and `setGroup` mutate the touched buckets in place inside `batch` and set each to its own array, which notifies because the bucket signal has `equals: false` (`bucketOfIn` :127-136, `announce` :138-140, `fileRows` :154-185, `unfileRows` :187-212, `moveRow` :214-230). `readAll` calls each field getter through `byId` outside any tracking scope (:313). `frame` is `batch` (:123-125; node_modules/solid-js/dist/solid.js:452-454).
bindPerGroupidiomaticThe same body with fifty views (solid-signals.ts:825); disjoint dependency sets, routed by Solid's graph.
churn.rowidiomaticA `createEffect` inside its own `createRoot` reading all four field getters of row `from` and rendering its label (`labelOfWholeRow`, solid-signals.ts:358-363; `subscribe` :338-354; mount :437-442), so it is a subscription to the WHOLE row, as types.ts:55-60 and SCENARIOS.md define the shape; `churn.column` is the label-only contrast. The first run is the mount, writes the read slot and is not counted; `unmount` disposes the root and clears the slot (:466-472). The first run happens before `createRoot` returns, because the root's `runUpdates` drains the effect queue (dist/solid.js:177-197, :222-229, :819-834, :875-877). That holds only for a mount outside an open batch — inside one, `runUpdates` sets `wait` (:823) and the first run is deferred to the outer batch's end.
churn.wideidiomaticOne `createEffect` reading every field getter of `count` rows, ending on row `from` (solid-signals.ts:365-371, :437-442).
churn.columnidiomaticA `createMemo` returning the row's label under the effect (solid-signals.ts:356, :443-445). A `note` write touches a signal the memo never read, so nothing re-runs and the column identity is Solid's.
churn.chainidiomaticLevel 1 is a `createMemo` over the `count` sources returning `chainLevelOf(their labels joined, 1)`; levels 2..depth are each a `createMemo` over the one below; the effect reads the head (solid-signals.ts:446-457). All `depth` memos are owned by the subscriber's root, so `unmount` disposes them (dist/solid.js:946-979).
churn.diamondidiomaticTwo `createMemo`s over root row `from`'s `label` getter (`diamondLeftOf`, `diamondRightOf`) and a third over both (`diamondJoinOf`), the effect on the join (solid-signals.ts:458-465). Once-per-frame is Solid's own: a node is queued only while clean (dist/solid.js:669-670, :935-945). The adapter adds no guard; the diamond script's check asserts it.
reads.byKeyidiomaticOne `byId.get` and the getter calls of `shownOf` per key, untracked, nothing hoisted (solid-signals.ts:544-552).
reads.byWindowidiomaticThe offset is a `createSignal` (solid-signals.ts:490) read only by the `paged` memo, which slices the `sorted` memo (:496-511), so a scroll re-runs the slice and never the sort — the shape of the preact and alien read wirings. `scrollTo` is one bare setter call (:553-555). View B's memo reads neither signal (:512-514).
reads.byTwoAxesidiomaticView B is a `createMemo` over the same bucket with the second predicate (solid-signals.ts:512-514, :518-520, predicate at :110).
reads.bySwitchidiomaticView A's group is a `createSignal` (solid-signals.ts:491) read by the `sorted` memo. `switchGroup` writes the group and resets the offset to 0 inside one `batch` (:556-561), so the effect re-runs once over the new group's bucket.
relationsidiomaticOwner and pair records each in their own `createSignal`. View A's effect reads owner getters and view B's reads pair getters, in one root created by `holdRelation` (solid-signals.ts:673-687), so the two views have disjoint dependencies. `writePair` composes the key on every call (:693-697).
singleidiomaticTwo signals, two effects in one root, the bare setter (solid-signals.ts:737-756, :763-765). The setter calls `writeSignal`, which runs its own `runUpdates` (dist/solid.js:206-211, :663-681), and a re-send of the stored value is stopped by Solid's `===` comparator (:654).
What would make it faster or more idiomatic
  • Coverage, not speed: Solid's documented collection API is `createStore` from `solid-js/store` with `reconcile`/`produce`. It is unreachable under this harness: `store/dist/store.js:1` imports the bare `solid-js`, which under node resolves to `dist/server.js` (package.json `exports['.'].node`), and `solid-js/store` itself resolves to `store/dist/server.js` under `node`. Spawning the solid-js worker with `--conditions=browser` (src/harness/measureBatch.ts, the worker's `args`, where no conditions flag is passed today) would let a store-backed wiring be measured as a second participant beside this one. Nothing shows a store is FASTER than a signal per field — a store is per-property signals behind a proxy — so this is not what `improvable` means and the verdict is not lowered for it.

claude-opus-5-5 (author; not yet re-verified), 2026-10-20 — full card with evidence

tanstack-store 0.11.2idiomaticthe code changed after this audit

every row's columns live in a @tanstack/store `createAtom` holder whose compare always reports a change, so a write mutates the held row in place and sets the same reference back; the id and group maps beside them hold handles to those atoms rather than any value; the change signal is the library's own `subscribe` on a derived atom, run when the outermost `batch` returns.

A `Store` per row, a bucket `Store` per group, and a derived store (`createStore(fn)`) per view with `subscribe` as its consumer, all on @tanstack/store 0.11's alien-signals core; every frame and every multi-store write runs inside the library's `batch`, the cell wiring narrows to a column with a derived store per pinned cell, and the chain, diamond and view switch are the library's own derived stores. 0.11.2 exports no `Derived` or `Effect` class: `createStore(fn)` is the derivation and `subscribe` the only subscriber.

bindidiomaticA derived store per view over one bucket store and its row stores, consumed by `subscribe` (tanstack-store.ts:205-214, selection at :50-80). `write` and `remove` touch only the row stores and the touched buckets, each inside one `batch` (:106-170). `frame` is `batch` (:39-41; node_modules/@tanstack/store/src/atom.ts:70-79), carried by every binding. `readAll` reads `.state` of each row store through `byId` (:276).
bindPerGroupidiomaticSame body with fifty views (tanstack-store.ts:741); disjoint dependency sets, routed by the library's graph.
churn.rowidiomatic`subscribe` on the row store, reading `label` (tanstack-store.ts:380-384, helper :303-314). `subscribe` does not call back on subscribe (src/atom.ts:178-191), so the mount reads `.state` into `churnRead[at]` (:312) and is not counted; each callback records the read and counts a wake (:308-311); `unmount` unsubscribes and clears the slot (:412-418).
churn.wideidiomaticA derived store over the `count` row stores, ending on row `from`, subscribed (tanstack-store.ts:316-322, :385-386). A subscription watches one store (src/atom.ts:178-191), so several sources are expressed as the library's own derived store over them.
churn.columnidiomatic`createStore(() => source.state.label)` under the subscription (tanstack-store.ts:388-392). The derived store's `Object.is` compare (src/atom.ts:201, :222) stops a `note` write there, so the column identity is the library's.
churn.chainidiomaticLevel 1 is a derived store over the `count` sources returning `chainLevelOf(label of row from, 1)`; levels 2..depth each derive `chainLevelOf(level below, level)`; `subscribe` on the head (tanstack-store.ts:393-402).
churn.diamondidiomaticTwo derived stores over root row `from` (`diamondLeftOf`, `diamondRightOf` of its label), a third over both (`diamondJoinOf`), `subscribe` on the join (tanstack-store.ts:403-411). The subscription effect is queued once per propagation because `propagate` queues only a WATCHING sub (src/alien.ts:151-153) and `notify` clears that flag as it queues (src/atom.ts:52-55); it re-runs only after `checkDirty` (src/atom.ts:302-309); not run here, the diamond script's check asserts it.
reads.byKeyidiomaticOne `byId.get` and one `.state` read per key, outside any tracking context, nothing hoisted (tanstack-store.ts:480-488).
reads.byWindowidiomaticOffset store (tanstack-store.ts:436) read only by view A's derived store, which returns the offset with the rows (:440-452), subscribed at :463-465. `scrollTo` is one `setState` (:489-491). View B (:453-460) does not read the offset.
reads.byTwoAxesidiomaticView B is a derived store over the same bucket with the second predicate (tanstack-store.ts:453-460, predicate at :61).
reads.bySwitchidiomaticView A's group is a store (`$group`, tanstack-store.ts:437) that view A's derived store reads beside `$offset` (:440-452). `switchGroup` sets `$group` and resets `$offset` to 0 inside one `batch` (:492-497), so the subscription runs once over the new group's bucket. View B reads neither.
relationsidiomaticOwner and pair records each get a store. View A is a derived store over the owner stores and view B over the pair stores (tanstack-store.ts:598-611), so the dependencies are disjoint. `writePair` composes the key on every call (:622-626). The population stores (:514, :517) are written only in the untimed `writeOwners` and `holdRelation`.
singleidiomatic`createStore('')` and `subscribe`, written with a bare `setState` (tanstack-store.ts:650-706). The setter flushes on its own (src/atom.ts:261-268) and skips an `Object.is`-equal value (src/atom.ts:222), which is what `singleResend` meets.
What would make it faster or more idiomatic
  • DECLINED, docs checked 2026-10-20 — every store here is a `Store`, which wraps an atom and binds three methods per instance (node_modules/@tanstack/store/src/store.ts:30-37; dist/store.js:7-9); `createAtom` (src/atom.ts:146-273) is the primitive underneath. The TanStack Store docs present `Store` as the API: the quick-start opens with 'You'll start by creating a new store instance, which is a wrapper around your data' and never mentions `createAtom` (tanstack.com/store/latest/docs/quick-start); `createAtom` appears only as a bare signature in the generated reference (docs/reference/functions/createAtom), with no guidance on when to prefer it. The docs do not point to the lighter primitive, so the per-row `Store` (tanstack-store.ts:126, :339, :541) stays. What it costs — one wrapper object and three bound functions per row on `batchInsert`, `coldStart`, `appFill` and `growUnderSubscription` — is unmeasured.

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

tanstack-table 9.3.1 not a participant

a headless view layer: it never holds the rows (`data` stays the caller's array) and has no change signal for them — `onStateChange` reports table state, never data. Neither half of the rule, so there is no store here to compare.