Skip to main content

The price of a call

What does each call cost against the plain JavaScript you would have written instead of it? writeSlotContentByKey against map.set(id, entity). A one-column update against entity.title = value.

Each table on this page is generated from the published price measurements (npm run price:publish in packages/bench). No figure on the page is typed by hand. A price measured against an older core than the one the site was built from is marked measured before the current core: the reading holds for what it measured, but it is not a price of the code documented here.

Nothing on this page compares OIMDB to another library. That is Benchmarks.

How to read a price​

  • Ours is the call. Floor is what a person writes by hand for the same result. The ratio is ours over floor.
  • The caveat under each call says what the two sides do differently. A floor is sometimes a single store that does a fraction of the work and sometimes a hand-written version that does most of it. Where both exist for one operation, the two prices bracket the cost, and neither alone is it.
  • The path a price sits on decides whether it matters. A charge paid once at startup and a charge paid for every entity a write touches are not comparable. The tables below are grouped by path, from rarest to hottest.
  • A ratio inside the noise is not a reading. Every run carries two controls, shown next. Read no ratio closer to 1.00 than the second control's distance from it.

The instrument​

The first control doubles the work on purpose and must read about 2×. The second runs the same body under two names and must read 1.00. Together they say what the run could resolve.

Ourstwo units of arithmetic per iteration
Floorone unit of arithmetic per iteration
37 ns ours19 ns floor1.92×floor timed twice: 1.0% apart
What the two sides do differently

NOT A PRICE — an instrument check, and it is printed first because nothing below it means anything until it passes. The true ratio is a little UNDER 2: both sides pay the driving loop once, so the exact expectation is (2u + L) / (u + L) with L the loop and u one unit, which at sixteen dependent steps per unit puts it around 1.9. A reading below 1.5 means this process could not resolve a deliberate doubling, and the runner voids the report rather than printing prices under it.

measured 2026-10-23no explanation yetcontrol-resolution-2x
Oursone unit of arithmetic per iteration
Floorthe same body again, over its own copy of the same state
19 ns ours19 ns floor1.00×floor timed twice: 0.1% apart
What the two sides do differently

NOT A PRICE — the noise floor. The two sides are identical code over identical, separately-allocated state, so the true ratio is 1.00 exactly and every departure from it printed here was produced by this machine at this moment. The rule that follows is the one the whole table is read under: NO RATIO CLOSER TO 1.00 THAN THIS GAP IS A READING. It also bounds the per-row noise figure, which is the same idea measured again inside every pair — each pair times its floor twice, once before our side and once after, and prints how far the two disagreed.

measured 2026-10-23no explanation yetcontrol-scale-same-body

Published 2026-10-23T11:06:57.973Z.

Per declaration​

Paid once per application, screen or module: building a collection, an index, the root.

OursindexService.createIndexStoreSlot(entityStoreSlot) over `group` on a population already holding a thousand rows, holdSlotsByKeys every group, then disposeIndexStoreSlot and unholdSlot
Floorbuild a Map of Sets from the same thousand rows, then clear it
95.28 µs ours47.76 µs floor1.99×floor timed twice: 2.5% apart
What the two sides do differently

THE ENGINE WALKS THE POPULATION AGAIN, SO THIS IS A DECLARATION ONCE MORE. It replaces `index-fill.over-a-loaded-population-vs-hand-built-map`, whose caller did the walk and the per-bucket write because the index of that day touched no population; the auto-index files every row it can see into a bucket the moment the bucket is minted (`OIMIndexService`'s source-slot collection, through `collectBucketMemberSlotsForKey`), so a `holdSlotsByKeys` over all sixty-four groups is one walk of the thousand rows, one `selectKey` per row, one index-key write per row and one hold per row. No figure recorded under the old id attaches to this one. THE INDEX SERVICE IS BUILT ONCE OUTSIDE THE CLOCK, so the type is not in this number: `new-index-service.vs-new-map-of-sets` prices `createOIMIndexService` on its own. BOTH SIDES BUILD AND THEN GIVE BACK INSIDE THE CLOCK: ours disposes the index store slot — which drops its listener, releases its index-key position (a second walk of the population, clearing each row's cell) and clears every bucket, unholding each row — and then unholds the sixty-four buckets so each is released; the floor clears every set and then the map. The floor reads `row.group` off held copies; ours reads it through `slot.entity`. What ours buys that the floor cannot: the index keeps filing every later write, and each bucket is an identity that can be subscribed. Direction: inflates our ratio; paid once per index.

measured 2026-10-23no explanation yetindex.hold-every-group-of-a-loaded-population-vs-hand-built-map
OursentityService.createStoreSlot(db)
Floornew Map()
33 ns ours16 ns floor2.12×floor timed twice: 0.3% apart
What the two sides do differently

A POPULATION AGAINST THE CONTAINER THAT WOULD HAVE HELD IT, with the entity service built once outside the clock, so what is timed is the instance and not the type. Ours also builds the store slot that carries the store and answers to the store-slot listener; the store itself is a `Map` of the same kind the floor makes. What the type costs — the key selector, the defaults read off `OIMDB`, the content services — is `new-entity-service.vs-new-map`'s and is not in this number. Direction: inflates our ratio; paid once per population.

measured 2026-10-23whynew-collection.vs-new-map
Oursnew OIMDB()
Floorthe object a person keeps instead: a frame number and a queue
162 ns ours5 ns floor30×floor timed twice: 4.3% apart
What the two sides do differently

NOT A LIKE-FOR-LIKE FLOOR. Nobody hand-writes a database; the nearest thing is the bookkeeping a person keeps beside their `Map`, which is a frame counter and a list of what to repaint. Ours constructs an unused-slot collector, a channel with its frame record, clock, error policy, pending-effect list, three handler sets and seven bound arrows, and the root that holds both. Direction: inflates our ratio without limit, and it is paid ONCE per application. It is on the table because a price nobody prints is a price nobody believes, not because the multiple means anything. What the absolute figure is MADE OF is what `new-db.vs-the-same-object-graph-by-hand` beside it is for.

measured 2026-10-23no explanation yetnew-db.vs-hand-written-frame-state
Oursnew OIMDB()
Floorthe same twenty allocations written out — seven objects, three arrays, three sets and seven closures over them
161 ns ours73 ns floor2.21×floor timed twice: 5.7% apart
What the two sides do differently

THIS ROW EXISTS TO SPLIT `new-db.vs-hand-written-frame-state`, WHOSE FLOOR IS TWO ALLOCATIONS AND WHOSE MULTIPLE THEREFORE HAS NO UPPER BOUND. What that row cannot say is whether the price of a database is its OBJECT GRAPH — twenty allocations that a person keeping the same state would also have made — or something about the class that carries it. This floor allocates the graph and nothing else, read off `OIMDB`, `OIMUnusedSlotCollector`, `OIMChannel` and the default `OIMErrorPolicyLogAndContinue`: the root, the collector and its tracked list, the options object `OIMDB` spreads for the channel, the channel, its frame record with its handler set, the error policy, the pending-effect list, the clock, the subframe-close and after-each-flush sets, the after-each-frame buffer, and the seven bound arrows `enlist`, `collectError`, `runOnceOnSubframeClose`, `openSubframe`, `closeSubframe`, `write` and `writeWithoutFlushCheck`. THE COUNT WAS SEVENTEEN, TRANSCRIBED FROM AN `OIMDB` THAT NO LONGER EXISTS, and no reading of this row taken against that floor is comparable with one taken against this one. WHAT IS LEFT IN THE RATIO is the class: two instance shapes with their field initialisers and the `OIMFlushScheduler` base constructor against object literals built in one place. A reading at 1.00 says the price IS the graph and the only way down is to hold fewer things at birth — which every candidate field would pay for with a test on a path that runs per frame or per write. Above 1.00 it says the construction costs more than what it constructs, and names the size of that. BOTH SIDES DROP EVERYTHING THEY MAKE, so both hand the collector the same shape of garbage at the same rate and the scavenges inside a pass are charged to numerator and denominator alike. Direction: this floor does far MORE than the floor of the row it splits — it is our own graph transcribed — so this ratio is not comparable with any other row in this table. It is a decomposition instrument and not a price.

measured 2026-10-23whynew-db.vs-the-same-object-graph-by-hand
OurscreateOIMEntityService(db, row => row.id)
Floornew Map()
50 ns ours16 ns floor3.08×floor timed twice: 5.3% apart
What the two sides do differently

THE TYPE AGAINST THE CONTAINER THAT WOULD HAVE HELD ITS INSTANCES, and it does not include a store slot: no population is made here. Ours reads the defaults off `OIMDB` and `OIMDefaults`, builds the content-change listener list, the content batch list and the index-key positions, wires the internal owner, the entity content service and the store aggregate to one another, and keeps the key selector — which is the closure a caller passes and which the floor does not need because the caller writes `row.id` at every call site instead. The floor is the same `new Map()` as `new-collection.vs-new-map`, because a hand-written store has no per-type object at all: everything here is charged to us. Direction: inflates our ratio; paid once per entity type, however many populations are then made from it.

measured 2026-10-23no explanation yetnew-entity-service.vs-new-map
OurscreateOIMIndexService(db, { entityService, slotContentService: new OIMSlotContentBucketServiceSetDriven(), selectKey: row => row.group })
Floornew Map() of Sets, empty
68 ns ours16 ns floor4.28×floor timed twice: 4.0% apart
What the two sides do differently

THE INDEX TYPE ALONE: no store slot is made, so no listener is installed and no row is walked; `index.hold-every-group-of-a-loaded-population-vs-hand-built-map` is where the instance and its walk are priced. Ours builds the bucket service the index files into — its slot store, its set-driven slot service, its column owner options and the defaults read off `OIMDB` — and keeps the key selector and the entity service it listens to. The floor is an empty `Map` of `Set`s, the container a hand-built grouping starts from; it has no per-type object, so everything here is charged to us. Direction: inflates our ratio; paid once per index type.

measured 2026-10-23no explanation yetnew-index-service.vs-new-map-of-sets

Published 2026-10-23T11:06:57.973Z.

Per relationship​

Paid once when a reader and a piece of data are joined: a mount, a subscription, a resolve.

Oursconst effect = OIMEffectService.INSTANCE.createEffect(db, [slot], [], body); OIMEffectService.INSTANCE.disposeEffect(effect)
Floorset.add(handler); set.delete(handler)
36 ns ours33 ns floor1.08×floor timed twice: 0.8% apart
What the two sides do differently

THE MOUNT AND THE UNMOUNT AS ONE OPERATION, because half of a subscription is not a thing a screen ever does. The only subscriber is an effect. Ours allocates a `TOIMEffect`, files it on the slot's effect list and holds the slot, asks whether the slot was written since the batch opened so a write already in it still reaches the newcomer, and on the way out clears its pending mark, swaps itself out of the list, unholds the slot and asks whether anything still keeps it. The one-element source array is built outside the clock, per slot, so the caller's literal is not charged. The floor adds to a `Set` somebody else has to remember to create, and can never tell the new subscriber about a write that already landed. Direction: inflates our ratio. Every slot here carries a value, so the unhold never releases an identity.

measured 2026-10-23no explanation yeteffect.attach-and-dispose-vs-set-add-delete
Ours1 createComputedStoreSlot calls on one standing void-key OIMComputedService in a chain, createEffectImmediate over the head, disposeEffect, db.flush()
Floor1 alien computed() in a chain, effect() over the head, then its dispose()
209 ns ours73 ns floor2.86×floor timed twice: 0.2% apart
What the two sides do differently

ONE OPERATION IS ONE MOUNT AND UNMOUNT: create a chain of 1 derived nodes over a standing root, create one effect over the head and run it once (which reads the whole chain), then dispose the effect. ARCHITECTURAL POINT: build at subscription against lazy linking, measured as what subscribing costs. Ours builds ONE OIMComputedService per side outside the clock and, per node inside it, one createComputedStoreSlot over OIMSlotStoreServiceSingleSlotDriven with its own derive and createSources: a store slot per relationship, not a service per node. Each node then mints its slot, holds its sources, merges the root list the effect subscribes to and subscribes the effect to the root and the head; disposal unsubscribes, and the flush that ends the operation releases every node, which unholds its sources down the chain. Alien-signals allocates one closure-backed node per computed and links dependencies as the first run reads them; disposing the effect unlinks it and each computed left without subscribers unlinks its own dependencies. EXPECTED DIRECTION [FIGURE STATED IN ADVANCE]: ours above alien at every depth, because ours pays for a declared, held, stamped graph up front, which is what the matching run rows are meant to pay back. Read this row together with the run row of the same depth. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.subscription.build.d1
Ours64 createComputedStoreSlot calls on one standing void-key OIMComputedService in a chain, createEffectImmediate over the head, disposeEffect, db.flush()
Floor64 alien computed() in a chain, effect() over the head, then its dispose()
8.09 µs ours2.67 µs floor3.03×floor timed twice: 0.2% apart
What the two sides do differently

ONE OPERATION IS ONE MOUNT AND UNMOUNT: create a chain of 64 derived nodes over a standing root, create one effect over the head and run it once (which reads the whole chain), then dispose the effect. ARCHITECTURAL POINT: build at subscription against lazy linking, measured as what subscribing costs. Ours builds ONE OIMComputedService per side outside the clock and, per node inside it, one createComputedStoreSlot over OIMSlotStoreServiceSingleSlotDriven with its own derive and createSources: a store slot per relationship, not a service per node. Each node then mints its slot, holds its sources, merges the root list the effect subscribes to and subscribes the effect to the root and the head; disposal unsubscribes, and the flush that ends the operation releases every node, which unholds its sources down the chain. Alien-signals allocates one closure-backed node per computed and links dependencies as the first run reads them; disposing the effect unlinks it and each computed left without subscribers unlinks its own dependencies. EXPECTED DIRECTION [FIGURE STATED IN ADVANCE]: ours above alien at every depth, because ours pays for a declared, held, stamped graph up front, which is what the matching run rows are meant to pay back. Read this row together with the run row of the same depth. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.subscription.build.d64
Ours8 createComputedStoreSlot calls on one standing void-key OIMComputedService in a chain, createEffectImmediate over the head, disposeEffect, db.flush()
Floor8 alien computed() in a chain, effect() over the head, then its dispose()
964 ns ours351 ns floor2.74×floor timed twice: 0.5% apart
What the two sides do differently

ONE OPERATION IS ONE MOUNT AND UNMOUNT: create a chain of 8 derived nodes over a standing root, create one effect over the head and run it once (which reads the whole chain), then dispose the effect. ARCHITECTURAL POINT: build at subscription against lazy linking, measured as what subscribing costs. Ours builds ONE OIMComputedService per side outside the clock and, per node inside it, one createComputedStoreSlot over OIMSlotStoreServiceSingleSlotDriven with its own derive and createSources: a store slot per relationship, not a service per node. Each node then mints its slot, holds its sources, merges the root list the effect subscribes to and subscribes the effect to the root and the head; disposal unsubscribes, and the flush that ends the operation releases every node, which unholds its sources down the chain. Alien-signals allocates one closure-backed node per computed and links dependencies as the first run reads them; disposing the effect unlinks it and each computed left without subscribers unlinks its own dependencies. EXPECTED DIRECTION [FIGURE STATED IN ADVANCE]: ours above alien at every depth, because ours pays for a declared, held, stamped graph up front, which is what the matching run rows are meant to pay back. Read this row together with the run row of the same depth. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.subscription.build.d8
OursentityService.holdSlotByKey(entityStoreSlot, id) — resolve a key to an identity and keep it, minting on a miss
Floormap.get(id)
25 ns ours21 ns floor1.20×floor timed twice: 1.5% apart
What the two sides do differently

THE FLOOR CANNOT MINT AND CANNOT KEEP, and those are the two differences. `holdSlotByKey` promises an identity for a key the population has never seen, so a caller can subscribe to a row before it arrives; and the hold is a COUNTED REFERENCE, so nothing can unfile that identity while the caller still has it. Every key here HITS, so the minting branch never runs — what is left over the map read is the store call, the `=== undefined` compare that is false on every hit, and one `holdCount++` (`OIMSlotCollectionService.holdSlotByKey` into `slot.owner.holdSlot`). THE TWO ALLOCATIONS THIS CAVEAT CHARGED NO LONGER EXIST AND NOTHING REPLACES THEM. It read "TWO ALLOCATIONS PER CALL: the `{ slot, release }` record and the release closure `holdSlot` builds", and that was the charge the row was built to expose: a minting door that allocated where a `Map.get` does not. No door hands back such a record — `holdSlotByKey` returns the slot and increments one field — so the hit path allocates nothing on either side and what is left between the two columns is one call and one store. Direction: inflates our ratio, now by the store call and the increment alone. READ IT AGAINST `find.vs-map-get` DIRECTLY ABOVE — the gap between the two is what the minting door costs over the reading one, on the hit path, and that gap is the whole reason the documentation says to hold an identity rather than resolve it per read. THIS BODY NEVER GIVES THE HOLD BACK. The door is `slot.owner.unholdSlot`, which decrements the count, and nothing here calls it, so the hold count grows for the life of the process — one decrement per call that we do not charge ourselves for, and it is the only item on this row that runs in our favour. This row measures a minting HOLD.

measured 2026-10-23no explanation yethold.vs-map-get

Published 2026-10-23T11:06:57.973Z.

Per frame​

Paid once per frame, however many entities moved in it: the flush, delivering to a subscriber, recomputing a derivation.

Oursa held computed slot over one entity, refreshed by its OIMComputedService store slot at the read after the frame
Floorset a dirty flag on write, recompute on read if dirty
38 ns ours5 ns floor8.09×floor timed twice: 0.1% apart
What the two sides do differently

THE FLOOR IS A REAL MEMO AND DOES THE SAME JOB: it is invalidated by the write, it recomputes once however many writes landed, and it answers the same number. ONE HALF OF THIS CAVEAT WAS TRUE OF THE OLD ENGINE AND IS NOT TRUE OF THIS ONE. It said the floor recomputes LAZILY at the read where ours recomputes EAGERLY during the frame, so a value nobody reads was free for the floor and paid for by us. A derivation is a slot that nothing ever marks now — it is asked, not woken — so both sides are lazy and a value nobody reads is free on both. WHAT THAT LEAVES IN THE RATIO is the settle itself: ours compares the clock stamp of every source against the stamp it last derived at and only then runs the body, where the floor reads one boolean. WHAT OURS STILL BUYS AND THE FLOOR CANNOT: the graph. A memo over another memo has to be invalidated by hand and in the right order; `oimRefreshComputedSlot` refreshes its source computeds first. The 1024 derivations are the slots of ONE `OIMComputedService` store slot keyed by position, each held, so the read is `getValueForSlot` on an identity resolved before the clock and no key is looked up. That is not exercised by the one-level derivation here, so it is charged to us and never credited — direction: inflates our ratio, by an amount a deeper graph would show and this row cannot. Ours additionally gates on the comparator before marking anything downstream, and the derivation here always changes, so that gate never saves us a wake-up.

measured 2026-10-23no explanation yetcomputed.recompute-vs-hand-memo
Oursdb.flush() with nothing marked and nobody subscribed
Floora call that bumps a frame counter
3 ns ours1 ns floor2.41×floor timed twice: 355.2% apart
What the two sides do differently

THE FLOOR HERE IS ESSENTIALLY ZERO AND THE RATIO IS THEREFORE NOT A READING — take the absolute nanoseconds on our side and ignore the multiple. A hand-written store has no frame to close, so the nearest thing to a floor is the bookkeeping a person writes instead, and V8 inlines that to almost nothing. What ours does for the money: runs the effect graph's drain, swaps the two delivery lists, walks an empty delivery, runs the after-flush and after-each-frame phases, sweeps identities nobody holds and reports errors. This number is the fixed cost every other frame row carries, which is what makes it worth printing even though its ratio means nothing. AND THE MULTIPLE IS NOT THE ONLY THING TO IGNORE HERE: the floor is timed twice around our side and the two timings disagree by more than the gap they bracket, which is what the noise column on this row says. The absolute figure on our side is the reading; it is split by `flush.empty-vs-the-same-bookkeeping-by-hand`, whose floor performs these same phases inline.

measured 2026-10-23whyflush.empty-vs-noop
Oursdb.flush() with nothing marked and nobody subscribed
Floorthe same phases written out inline over a plain object: the two guards, the before-flush test, the empty leaf walk, the two emptiness tests and the counter
3 ns ours25 ns floor0.11×floor timed twice: 0.8% apart
What the two sides do differently

THIS ROW EXISTS TO SPLIT `flush.empty-vs-noop`, WHICH IS A PRICE AGAINST NOTHING. That row puts an empty frame against a counter bump, so its multiple prices the existence of a frame rather than anything inside one, and it cannot say which part of the absolute figure is the bookkeeping and which is the SHAPE the bookkeeping is written in. This floor does the same work: the same field reads, the same stores, the same walk of an empty leaf array, the same two emptiness tests — the after-each-frame set and the error list — and the same frame-counter increment, over a plain object with no methods. THE FLOOR WAS RE-TRANSCRIBED and it is a SHORTER body than the one this row was first measured with. It used to write out the two-list delivery swap, the levelled scheduler drain, the release sweep, the deferred-callback queue and the bound on the spare list, because `OIMDB.runFrame` did all five. `OIMChannelService.flush`does none of them: a frame is one pass over one flat `leaves` array, then `dispatchAfterEachFrame`, then `reportErrors`. Keeping the old phases would have made this floor do MORE than the engine, which is the one direction a floor may never drift in — so nothing recorded against this id is a like-for-like continuation of what it measures now, and no earlier figure is re-attributed to it. WHAT IS LEFT IN THE RATIO: the call frames our side enters (`flush`, `runFrame`, `dispatchAfterEachFrame`, `reportErrors`), the two `try`/`finally` regions, the `do`/`while` a single frame still goes round once, and the difference between a class field and a property of an object literal. A reading at 1.00 says the phases ARE the price and nothing can come off without dropping a phase; a reading above it says the structure is worth attacking and names its size. Direction: this floor does MORE than any floor in this file — it is our own design transcribed — so the ratio understates our cost against a primitive and is not comparable with the rows around it. It is a decomposition instrument and not a price.

measured 2026-10-23whyflush.empty-vs-the-same-bookkeeping-by-hand
Ours1× updateEntityColumn on one root, then db.flush(); one OIMEffectService.createEffectWithSourceTracking effect reading the root through readSourceSlot runs once
Floor1× root(v) with no batch; the alien effect on the root runs after every write
45 ns ours26 ns floor1.72×floor timed twice: 1.3% apart
What the two sides do differently

ONE OPERATION IS 1 WRITES TO ONE ROOT AND ONE SETTLE, with one effect reading the root. Ours runs the body once at the flush; alien-signals with no batch runs it 1 times per operation. THIS IS THE SAME TASK AS graph.coalescing.unbatched.k1, with the same floor builder; only the ours effect differs. The effect comes from OIMEffectService.createEffectWithSourceTracking instead of createEffectImmediate, and its dependencies are tracked at run time: each run reads its sources through effectSourceTracker (readSourceSlot for a root, readSourceComputedValue for a computed) instead of the root and computed lists declared once at build. Read this row against graph.coalescing.unbatched.k1: the difference between the two is the price of tracking against declaring on this task. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.coalescing-tracked.unbatched.k1
Ours16× updateEntityColumn on one root, then db.flush(); one OIMEffectService.createEffectWithSourceTracking effect reading the root through readSourceSlot runs once
Floor16× root(v) with no batch; the alien effect on the root runs after every write
176 ns ours418 ns floor0.42×floor timed twice: 0.4% apart
What the two sides do differently

ONE OPERATION IS 16 WRITES TO ONE ROOT AND ONE SETTLE, with one effect reading the root. Ours runs the body once at the flush; alien-signals with no batch runs it 16 times per operation. THIS IS THE SAME TASK AS graph.coalescing.unbatched.k16, with the same floor builder; only the ours effect differs. The effect comes from OIMEffectService.createEffectWithSourceTracking instead of createEffectImmediate, and its dependencies are tracked at run time: each run reads its sources through effectSourceTracker (readSourceSlot for a root, readSourceComputedValue for a computed) instead of the root and computed lists declared once at build. Read this row against graph.coalescing.unbatched.k16: the difference between the two is the price of tracking against declaring on this task. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.coalescing-tracked.unbatched.k16
Ours4× updateEntityColumn on one root, then db.flush(); one OIMEffectService.createEffectWithSourceTracking effect reading the root through readSourceSlot runs once
Floor4× root(v) with no batch; the alien effect on the root runs after every write
85 ns ours103 ns floor0.82×floor timed twice: 0.1% apart
What the two sides do differently

ONE OPERATION IS 4 WRITES TO ONE ROOT AND ONE SETTLE, with one effect reading the root. Ours runs the body once at the flush; alien-signals with no batch runs it 4 times per operation. THIS IS THE SAME TASK AS graph.coalescing.unbatched.k4, with the same floor builder; only the ours effect differs. The effect comes from OIMEffectService.createEffectWithSourceTracking instead of createEffectImmediate, and its dependencies are tracked at run time: each run reads its sources through effectSourceTracker (readSourceSlot for a root, readSourceComputedValue for a computed) instead of the root and computed lists declared once at build. Read this row against graph.coalescing.unbatched.k4: the difference between the two is the price of tracking against declaring on this task. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.coalescing-tracked.unbatched.k4
Ours16× updateEntityColumn on one root, then db.flush(); one effect on the root runs once
FloorstartBatch(); 16× root(v); endBatch(); the alien effect on the root runs once
191 ns ours104 ns floor1.83×floor timed twice: 0.3% apart
What the two sides do differently

ONE OPERATION IS 16 WRITES TO ONE ROOT AND ONE SETTLE, with one effect reading the root, and THE FLOOR BATCHES. ARCHITECTURAL POINT: frame coalescing against per-write delivery, with the floor given the coalescing it offers by hand. Ours enlists the effect on the first write and runs it once at the flush; alien-signals wraps the writes in startBatch/endBatch and runs the effect once at endBatch. Both arms run the body once per operation, so this row is the fairness check for the unbatched row of the same count: it shows how much of that row's difference is coalescing and how much is the cost of each write itself. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.coalescing.batched.k16
Ours1× updateEntityColumn on one root, then db.flush(); one effect on the root runs once
Floor1× root(v) with no batch; the alien effect on the root runs after every write
43 ns ours26 ns floor1.65×floor timed twice: 0.2% apart
What the two sides do differently

ONE OPERATION IS 1 WRITES TO ONE ROOT AND ONE SETTLE, with one effect reading the root. ARCHITECTURAL POINT: frame coalescing against per-write delivery. Ours enlists the effect on the first write of the frame, finds it already changed in this frame on every later write, and runs the body once at the flush. Alien-signals with no batch runs the effect synchronously at the end of every write, so the body runs 1 times per operation. EXPECTED DIRECTION [FIGURE STATED IN ADVANCE]: with a single write ours pays the flush and alien pays nothing extra, so ours is above alien there; as writes per frame grow, alien pays one effect run per write and ours pays one in total, so the ratio is expected to fall. The batched row at the largest count is the fairness check. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.coalescing.unbatched.k1
Ours16× updateEntityColumn on one root, then db.flush(); one effect on the root runs once
Floor16× root(v) with no batch; the alien effect on the root runs after every write
182 ns ours416 ns floor0.44×floor timed twice: 0.6% apart
What the two sides do differently

ONE OPERATION IS 16 WRITES TO ONE ROOT AND ONE SETTLE, with one effect reading the root. ARCHITECTURAL POINT: frame coalescing against per-write delivery. Ours enlists the effect on the first write of the frame, finds it already changed in this frame on every later write, and runs the body once at the flush. Alien-signals with no batch runs the effect synchronously at the end of every write, so the body runs 16 times per operation. EXPECTED DIRECTION [FIGURE STATED IN ADVANCE]: with a single write ours pays the flush and alien pays nothing extra, so ours is above alien there; as writes per frame grow, alien pays one effect run per write and ours pays one in total, so the ratio is expected to fall. The batched row at the largest count is the fairness check. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.coalescing.unbatched.k16
Ours4× updateEntityColumn on one root, then db.flush(); one effect on the root runs once
Floor4× root(v) with no batch; the alien effect on the root runs after every write
84 ns ours103 ns floor0.82×floor timed twice: 0.4% apart
What the two sides do differently

ONE OPERATION IS 4 WRITES TO ONE ROOT AND ONE SETTLE, with one effect reading the root. ARCHITECTURAL POINT: frame coalescing against per-write delivery. Ours enlists the effect on the first write of the frame, finds it already changed in this frame on every later write, and runs the body once at the flush. Alien-signals with no batch runs the effect synchronously at the end of every write, so the body runs 4 times per operation. EXPECTED DIRECTION [FIGURE STATED IN ADVANCE]: with a single write ours pays the flush and alien pays nothing extra, so ours is above alien there; as writes per frame grow, alien pays one effect run per write and ours pays one in total, so the ratio is expected to fall. The batched row at the largest count is the fairness check. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.coalescing.unbatched.k4
OursupdateEntityColumn(value) on 128 roots, then db.flush(); a computed single-slot store slot per root over its value column slot and one effect over all of them
FloorstartBatch(); value(v) on 128 rows; endBatch(); an alien computed per row over its value signal and one alien effect over all of them
17.85 µs ours5.40 µs floor3.30×floor timed twice: 0.8% apart
What the two sides do differently

ONE OPERATION IS ONE FRAME: one column written on every one of 128 roots, and one settle. Each root has two columns, value and note; a derived value per root reads value only (value × 2), and one effect reads all 128 derived values, which is a derived collection wholly on screen. THE WRITTEN COLUMN IS THE ONE THE DERIVED VALUES READ, so both arms re-derive every value and run the effect once. Ours sources each derived value on the held column slot of value (rootEntityService.holdColumn), so a note write does not reach it; alien has one signal per field, the shape every signal adapter in this bench uses, and batches the frame with startBatch/endBatch, since ours delivers once per frame. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.derived-collection.bulk-read-column.n128
OursupdateEntityColumn(note) on 128 roots, then db.flush(); a computed single-slot store slot per root over its value column slot and one effect over all of them
FloorstartBatch(); note(v) on 128 rows; endBatch(); an alien computed per row over its value signal and one alien effect over all of them
7.89 µs ours985 ns floor8.01×floor timed twice: 1.7% apart
What the two sides do differently

ONE OPERATION IS ONE FRAME: one column written on every one of 128 roots, and one settle. Each root has two columns, value and note; a derived value per root reads value only (value × 2), and one effect reads all 128 derived values, which is a derived collection wholly on screen. THE WRITTEN COLUMN IS ONE NO DERIVED VALUE READS, so neither arm may re-derive anything or run the effect, and what is left is what each arm pays to learn that. Ours sources each derived value on the held column slot of value (rootEntityService.holdColumn), so a note write does not reach it; alien has one signal per field, the shape every signal adapter in this bench uses, and batches the frame with startBatch/endBatch, since ours delivers once per frame. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.derived-collection.bulk-unread-column.n128
Ours8× updateEntityColumn on the root, then db.flush(), under 1 computed single-slot store slots and one effect over the head
FloorstartBatch(); 8× root(v); endBatch(), under 1 alien computeds and one alien effect over the head
125 ns ours86 ns floor1.46×floor timed twice: 2.0% apart
What the two sides do differently

ONE OPERATION IS ONE FRAME: 8 writes to the root and one settle, under a standing chain of 1 derived nodes (each the previous plus one) and one effect reading the head. The chain and the effect are built, and read once, outside the clock. ARCHITECTURAL POINT: a revision clock against dirty-mark propagation, measured as what a write costs under a deep standing graph. Ours stamps the root with the next revision on each write and enlists only the effects subscribed to the root; the effect is subscribed to the root slot of the chain directly, so no write walks the chain. At the flush the effect asks the head, each node asks its source, compares source stamps and re-derives, so the chain is walked once, at the read. Alien-signals walks the subscriber chain on the first write of the batch and flags every node pending (node_modules/alien-signals/esm/system.mjs, propagate), later writes in the same batch stop at the already-pending first node, and endBatch runs the effect, which pulls the chain and re-derives every node. Both arms re-derive all 1 nodes once and run the effect once per operation. EXPECTED DIRECTION [FIGURE STATED IN ADVANCE]: the write side is constant for ours and grows with depth for alien, the read side grows with depth on both, so if the write-side walk is what separates them the ratio falls as depth grows; a ratio that stays flat across the three depths says the pull at the read dominates on both arms. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.revision-clock.batched-writes.d1
Ours8× updateEntityColumn on the root, then db.flush(), under 64 computed single-slot store slots and one effect over the head
FloorstartBatch(); 8× root(v); endBatch(), under 64 alien computeds and one alien effect over the head
1.66 µs ours1.55 µs floor1.07×floor timed twice: 0.1% apart
What the two sides do differently

ONE OPERATION IS ONE FRAME: 8 writes to the root and one settle, under a standing chain of 64 derived nodes (each the previous plus one) and one effect reading the head. The chain and the effect are built, and read once, outside the clock. ARCHITECTURAL POINT: a revision clock against dirty-mark propagation, measured as what a write costs under a deep standing graph. Ours stamps the root with the next revision on each write and enlists only the effects subscribed to the root; the effect is subscribed to the root slot of the chain directly, so no write walks the chain. At the flush the effect asks the head, each node asks its source, compares source stamps and re-derives, so the chain is walked once, at the read. Alien-signals walks the subscriber chain on the first write of the batch and flags every node pending (node_modules/alien-signals/esm/system.mjs, propagate), later writes in the same batch stop at the already-pending first node, and endBatch runs the effect, which pulls the chain and re-derives every node. Both arms re-derive all 64 nodes once and run the effect once per operation. EXPECTED DIRECTION [FIGURE STATED IN ADVANCE]: the write side is constant for ours and grows with depth for alien, the read side grows with depth on both, so if the write-side walk is what separates them the ratio falls as depth grows; a ratio that stays flat across the three depths says the pull at the read dominates on both arms. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.revision-clock.batched-writes.d64
Ours8× updateEntityColumn on the root, then db.flush(), under 8 computed single-slot store slots and one effect over the head
FloorstartBatch(); 8× root(v); endBatch(), under 8 alien computeds and one alien effect over the head
300 ns ours269 ns floor1.12×floor timed twice: 0.3% apart
What the two sides do differently

ONE OPERATION IS ONE FRAME: 8 writes to the root and one settle, under a standing chain of 8 derived nodes (each the previous plus one) and one effect reading the head. The chain and the effect are built, and read once, outside the clock. ARCHITECTURAL POINT: a revision clock against dirty-mark propagation, measured as what a write costs under a deep standing graph. Ours stamps the root with the next revision on each write and enlists only the effects subscribed to the root; the effect is subscribed to the root slot of the chain directly, so no write walks the chain. At the flush the effect asks the head, each node asks its source, compares source stamps and re-derives, so the chain is walked once, at the read. Alien-signals walks the subscriber chain on the first write of the batch and flags every node pending (node_modules/alien-signals/esm/system.mjs, propagate), later writes in the same batch stop at the already-pending first node, and endBatch runs the effect, which pulls the chain and re-derives every node. Both arms re-derive all 8 nodes once and run the effect once per operation. EXPECTED DIRECTION [FIGURE STATED IN ADVANCE]: the write side is constant for ours and grows with depth for alien, the read side grows with depth on both, so if the write-side walk is what separates them the ratio falls as depth grows; a ratio that stays flat across the three depths says the pull at the read dominates on both arms. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.revision-clock.batched-writes.d8
Ours1× updateEntityColumn on a scroll position, then db.flush(); a computed single-slot store slot first visible index over it and one effect on the index
Floor1× position(v) with no batch; an alien computed first visible index and one alien effect on it
59 ns ours39 ns floor1.51×floor timed twice: 0.3% apart
What the two sides do differently

ONE OPERATION IS 1 WRITE OF A SCROLL POSITION AND ONE SETTLE. A derived first visible index, floor(position / 32), sits on the position and one effect reads the index, so the position changes on every write and the index once per 32 writes: the effect body runs once per 32 pixels on both arms. THE SAME-VALUE STATEMENT BELOW HOLDS FOR THE POSITION AND NOT FOR THE INDEX: the index is stopped by each arm's own equality check (the default sameValueGuard of OIMComputedService, and alien's computed comparison), which is what this row prices. ARCHITECTURAL POINT: a value written every frame whose consumer wakes rarely, which is the shape of a virtualised list under scroll. Ours enlists the effect on the write, and at the flush the effect asks the index, which re-derives, finds the same value and stops. Alien-signals propagates pending flags to the computed and the effect on the write, and the effect checks the computed, which re-derives and stops. Browsers dispatch scroll at most once per rendered frame, so k1 is the scroll case; k4 is a handler that moves the position several times. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.scroll-window.k1
Ours4× updateEntityColumn on a scroll position, then db.flush(); a computed single-slot store slot first visible index over it and one effect on the index
Floor4× position(v) with no batch; an alien computed first visible index and one alien effect on it
102 ns ours162 ns floor0.63×floor timed twice: 0.4% apart
What the two sides do differently

ONE OPERATION IS 4 WRITES OF A SCROLL POSITION AND ONE SETTLE. A derived first visible index, floor(position / 32), sits on the position and one effect reads the index, so the position changes on every write and the index once per 32 writes: the effect body runs once per 32 pixels on both arms. THE SAME-VALUE STATEMENT BELOW HOLDS FOR THE POSITION AND NOT FOR THE INDEX: the index is stopped by each arm's own equality check (the default sameValueGuard of OIMComputedService, and alien's computed comparison), which is what this row prices. ARCHITECTURAL POINT: a value written every frame whose consumer wakes rarely, which is the shape of a virtualised list under scroll. Ours enlists the effect on the write, and at the flush the effect asks the index, which re-derives, finds the same value and stops. Alien-signals propagates pending flags to the computed and the effect on the write, and the effect checks the computed, which re-derives and stops. Browsers dispatch scroll at most once per rendered frame, so k1 is the scroll case; k4 is a handler that moves the position several times. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.scroll-window.k4
OursentityService.getSlotByKey(entityStoreSlot, id) then slotContentService.updateEntity(slot, patch), flush, and the subscription fires — per key delivered
Floormap.get(id) and store the field, add the id to a Set of changed ids, and at flush call every handler a Map of id → handlers holds for each changed id
54 ns ours63 ns floor0.87×floor timed twice: 0.6% apart
What the two sides do differently

Both sides address the entity by its string key on every write and deliver once per flush. Ours has no update-by-key door: each write is `getSlotByKey` and then `slotContentService.updateEntity`. Ours resolves the key to the slot and then reaches the subscribers through `slot.effects`; the floor resolves the key twice, once to the row and once at flush to its handlers. One write per key per frame, a thousand keys, one subscriber each. The floor holds only for a one-column write that nothing but the subscriber listens to.

measured 2026-10-23no explanation yetsubscribe.by-key.deliver-vs-changed-ids-at-flush
Oursupdate the entity, flush, and the subscription fires — per identity delivered
Floorstore the field and call the handler at once, with no flush
34 ns ours1 ns floor26×floor timed twice: 171.8% apart
What the two sides do differently

The price of deferred delivery against none at all. The floor calls the handler inside the write, so a handler can see half of a frame's update; it is not a floor anything with once-per-flush delivery can reach, and `subscribe.deliver-vs-queue-at-flush` is the floor that is. The gap between the two pairs is what deferral itself costs by hand; the rest of this ratio is the identity registration, the stamp, the enlist and the frame.

measured 2026-10-23no explanation yetsubscribe.deliver-vs-direct-call
Oursupdate the entity, flush, and the subscription fires — per identity delivered
Flooreach entity a record with its own subscriber list: store the field, queue the record once, and at flush call every subscriber of every queued record
34 ns ours8 ns floor4.04×floor timed twice: 1.6% apart
What the two sides do differently

Both sides deliver once per flush, after every write of the frame has landed, so no handler sees half an update, and both reach an entity's subscribers through the entity itself — `slot.effects` on ours, `record.subscribers` on the floor — with no lookup by key. One write per identity per frame is the worst case for us: nothing is saved by coalescing. The fixed cost of a frame is divided by a thousand deliveries here; `flush.empty-vs-noop` prices it on its own. The floor holds only for a one-column write that nothing but the subscriber listens to: with an index, a bucket or a timer that flushes synchronously, a hand-written store would need the guard a subframe gives.

measured 2026-10-23no explanation yetsubscribe.deliver-vs-queue-at-flush
OurseffectService.createEffect([column slot of 'title'], [], h) — the narrowest signal the engine has
Floorstore the field, queue the entity once when the moved name is 'title', and call h for each queued entity at flush
104 ns ours7 ns floor14×floor timed twice: 0.2% apart
What the two sides do differently

The one column that moved is the one subscribed to, on both sides, and both deliver once per flush after every write of the frame has landed. A column of an entity is its own identity in ours, minted by `holdColumn`, and a write marks only the column slots that exist, so a `note` write does not reach a `title` subscriber at all. The mint is outside the clock (one per entity, at build); inside it ours pays the write path, the column mark, the enlist and the frame, against the floor's store, string compare, flag test and push on the write, and flag clear and call at flush.

measured 2026-10-23no explanation yetsubscribeToField.deliver-vs-filtered-queue-at-flush

Published 2026-10-23T11:06:57.973Z.

Per write​

Paid once for each call that changes something.

Oursone forwarding stage reached through a stages array, handed its continuation
Floorone forwarding link holding its continuation in a field — the shipped construction
28 ns ours18 ns floor1.54×floor timed twice: 0.7% apart
What the two sides do differently

THE TWO WAYS TO SPELL A CHAIN, WITH EXACTLY ONE STAGE IN EACH so the comparison is about the SPELLING and not about depth. Both arms put one forwarding step between `OIMSlotContentEntityService` and `createOIMEntityWriterInPlace`, and that step does nothing but pass the call on. THE DIFFERENCE, and it is the whole row: the field-bound arm reads `this.inner` and calls a method on it; the parameter arm ALLOCATES THE CONTINUATION — a closure over the stage index and the receiver — and hands it in, on every write. PREDICTED OPERATION COUNT per write: the field arm pays two property loads and a call; the parameter arm pays a closure allocation, an array load, a property load and two calls. WHICH WAY THE UNMEASURED DIFFERENCE PUSHES: against the parameter arm, and only that way — it does everything the field arm does and allocates on top [FIGURE STATED IN ADVANCE]. WHAT THE PARAMETER FORM BUYS, which no number here prices: a stage that never names what is under it, so an order can be composed at run time. A reader deciding between the two owes that against whatever this costs. THE WRITE AROUND THE LINK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertNotFlushing`, the isOnFastPath read, the column walk over a ONE-COLUMN patch, the equality call, the store into `slot.entity`, the report to the channel, releaseWrittenSlotIfUnheld and the frame that closes the pass. ONE OPERATION IS ONE `updateEntity` OF ONE COLUMN OF ONE ROW, over a population of 1024, with a frame per pass over the population — so the frame is one part in 1024 of the row. The link is touched ONCE per operation: `updateEntity` reaches `patchEntity` and no other door. A row that removed a column would touch it twice and is not measured here.

measured 2026-10-23whychain.next-as-a-parameter-vs-next-held-in-a-field
Oursone updateEntityColumn, then effectService.runEffectIfSourcesChanged(effect), no flush
Floorone root(v) with no batch; one alien effect on the root runs after the write
22 ns ours26 ns floor0.83×floor timed twice: 0.4% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO ONE ROOT, and ours stops at: the write and the effect service, with no frame. ARCHITECTURAL POINT: none; this row splits graph.coalescing.unbatched.k1, whose ours side is one write, one db.flush() and one effect run. Every row of this group stands against the same floor, one alien write with one alien effect on the root, so the ns difference between two rows of the group is the price of the step one row adds over the other. The write-and-effect-run row calls effectService.runEffectIfSourcesChanged directly, so it pays the effect service and no frame; after its first write the frame never closes, so the slot counts as changed in the open frame and the write enlists nothing more. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.delivery.write-and-effect-run-without-flush
Oursone updateEntityColumn on a held root, then db.flush(), no effect
Floorone root(v) with no batch; one alien effect on the root runs after the write
24 ns ours26 ns floor0.90×floor timed twice: 0.7% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO ONE ROOT, and ours stops at: the write and an empty frame. ARCHITECTURAL POINT: none; this row splits graph.coalescing.unbatched.k1, whose ours side is one write, one db.flush() and one effect run. Every row of this group stands against the same floor, one alien write with one alien effect on the root, so the ns difference between two rows of the group is the price of the step one row adds over the other. The write-and-effect-run row calls effectService.runEffectIfSourcesChanged directly, so it pays the effect service and no frame; after its first write the frame never closes, so the slot counts as changed in the open frame and the write enlists nothing more. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.delivery.write-and-flush-without-effect
Oursone updateEntityColumn on a held root, no effect, no flush
Floorone root(v) with no batch; one alien effect on the root runs after the write
7 ns ours26 ns floor0.26×floor timed twice: 0.4% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO ONE ROOT, and ours stops at: the write. ARCHITECTURAL POINT: none; this row splits graph.coalescing.unbatched.k1, whose ours side is one write, one db.flush() and one effect run. Every row of this group stands against the same floor, one alien write with one alien effect on the root, so the ns difference between two rows of the group is the price of the step one row adds over the other. The write-and-effect-run row calls effectService.runEffectIfSourcesChanged directly, so it pays the effect service and no frame; after its first write the frame never closes, so the slot counts as changed in the open frame and the write enlists nothing more. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.delivery.write-only
Oursone updateEntityColumn(note) on a held root whose value column slot is held, no effect, no flush
Floorone root(v) with no batch; one alien effect on the root runs after the write
54 ns ours27 ns floor2.04×floor timed twice: 1.7% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO ONE ROOT, and ours stops at: the write of a column nobody reads, on an entity one of whose other columns is held. ARCHITECTURAL POINT: none; this row splits graph.coalescing.unbatched.k1, whose ours side is one write, one db.flush() and one effect run. Every row of this group stands against the same floor, one alien write with one alien effect on the root, so the ns difference between two rows of the group is the price of the step one row adds over the other. The write-and-effect-run row calls effectService.runEffectIfSourcesChanged directly, so it pays the effect service and no frame; after its first write the frame never closes, so the slot counts as changed in the open frame and the write enlists nothing more. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.delivery.write-with-another-column-held
OursupdateEntityColumn on the unread branch value, then db.flush(); the OIMEffectService.createEffectWithSourceTracking effect reads flag and then active only, through readSourceSlot
Floorinactive(v) with no batch; the alien effect reads flag() and then active() only
23 ns ours2 ns floor12×floor timed twice: 0.0% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO THE INACTIVE BRANCH AND ONE SETTLE. An effect reads a flag and then one of two values, and the flag selects the first, so the written value is one the body does not read. The tracked effect read only the flag and the active value on its last run, so the write to the inactive value must wake nothing on either arm. EXPECTED BODY RUNS PER OPERATION [FIGURE STATED IN ADVANCE]: alien 0, ours 0; both run counts are sunk into priceSink.number at the end of each pass, and an ours count above 0 is a defect of the tracked strategy. THIS IS THE SAME TASK AS graph.dependencies.inactive-branch.s3, with the same floor builder; only the ours effect differs. The effect comes from OIMEffectService.createEffectWithSourceTracking instead of createEffectImmediate, and its dependencies are tracked at run time: each run reads its sources through effectSourceTracker (readSourceSlot for a root, readSourceComputedValue for a computed) instead of the root and computed lists declared once at build. Read this row against graph.dependencies.inactive-branch.s3: the difference between the two is the price of tracking against declaring on this task. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.dependencies-tracked.inactive-branch.s3
OursupdateEntityColumn on one of 1 roots, then db.flush(); one OIMEffectService.createEffectWithSourceTracking effect reads all 1 root slots through readSourceSlot and sums them
Floorone of 1 alien signals written with no batch; one alien effect reads and sums all of them
44 ns ours28 ns floor1.58×floor timed twice: 0.6% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO ONE OF 1 ROOTS, chosen round-robin, AND ONE SETTLE; one effect reads every root and sums them. Each run reads the 1 roots through effectSourceTracker.readSourceSlot, so both arms re-track on every run. THIS IS THE SAME TASK AS graph.dependencies.reads-per-run.r1, with the same floor builder; only the ours effect differs. The effect comes from OIMEffectService.createEffectWithSourceTracking instead of createEffectImmediate, and its dependencies are tracked at run time: each run reads its sources through effectSourceTracker (readSourceSlot for a root, readSourceComputedValue for a computed) instead of the root and computed lists declared once at build. Read this row against graph.dependencies.reads-per-run.r1: the difference between the two is the price of tracking against declaring on this task. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.dependencies-tracked.reads-per-run.r1
OursupdateEntityColumn on one of 128 roots, then db.flush(); one OIMEffectService.createEffectWithSourceTracking effect reads all 128 root slots through readSourceSlot and sums them
Floorone of 128 alien signals written with no batch; one alien effect reads and sums all of them
479 ns ours1.27 µs floor0.38×floor timed twice: 0.1% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO ONE OF 128 ROOTS, chosen round-robin, AND ONE SETTLE; one effect reads every root and sums them. Each run reads the 128 roots through effectSourceTracker.readSourceSlot, so both arms re-track on every run. THIS IS THE SAME TASK AS graph.dependencies.reads-per-run.r128, with the same floor builder; only the ours effect differs. The effect comes from OIMEffectService.createEffectWithSourceTracking instead of createEffectImmediate, and its dependencies are tracked at run time: each run reads its sources through effectSourceTracker (readSourceSlot for a root, readSourceComputedValue for a computed) instead of the root and computed lists declared once at build. Read this row against graph.dependencies.reads-per-run.r128: the difference between the two is the price of tracking against declaring on this task. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.dependencies-tracked.reads-per-run.r128
OursupdateEntityColumn on one of 16 roots, then db.flush(); one OIMEffectService.createEffectWithSourceTracking effect reads all 16 root slots through readSourceSlot and sums them
Floorone of 16 alien signals written with no batch; one alien effect reads and sums all of them
103 ns ours204 ns floor0.50×floor timed twice: 2.4% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO ONE OF 16 ROOTS, chosen round-robin, AND ONE SETTLE; one effect reads every root and sums them. Each run reads the 16 roots through effectSourceTracker.readSourceSlot, so both arms re-track on every run. THIS IS THE SAME TASK AS graph.dependencies.reads-per-run.r16, with the same floor builder; only the ours effect differs. The effect comes from OIMEffectService.createEffectWithSourceTracking instead of createEffectImmediate, and its dependencies are tracked at run time: each run reads its sources through effectSourceTracker (readSourceSlot for a root, readSourceComputedValue for a computed) instead of the root and computed lists declared once at build. Read this row against graph.dependencies.reads-per-run.r16: the difference between the two is the price of tracking against declaring on this task. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.dependencies-tracked.reads-per-run.r16
OursupdateEntityColumn on one of 2 roots, then db.flush(); one OIMEffectService.createEffectWithSourceTracking effect reads all 2 root slots through readSourceSlot and sums them
Floorone of 2 alien signals written with no batch; one alien effect reads and sums all of them
47 ns ours43 ns floor1.11×floor timed twice: 0.1% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO ONE OF 2 ROOTS, chosen round-robin, AND ONE SETTLE; one effect reads every root and sums them. Each run reads the 2 roots through effectSourceTracker.readSourceSlot, so both arms re-track on every run. THIS IS THE SAME TASK AS graph.dependencies.reads-per-run.r2, with the same floor builder; only the ours effect differs. The effect comes from OIMEffectService.createEffectWithSourceTracking instead of createEffectImmediate, and its dependencies are tracked at run time: each run reads its sources through effectSourceTracker (readSourceSlot for a root, readSourceComputedValue for a computed) instead of the root and computed lists declared once at build. Read this row against graph.dependencies.reads-per-run.r2: the difference between the two is the price of tracking against declaring on this task. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.dependencies-tracked.reads-per-run.r2
OursupdateEntityColumn on one of 4 roots, then db.flush(); one OIMEffectService.createEffectWithSourceTracking effect reads all 4 root slots through readSourceSlot and sums them
Floorone of 4 alien signals written with no batch; one alien effect reads and sums all of them
54 ns ours72 ns floor0.75×floor timed twice: 0.3% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO ONE OF 4 ROOTS, chosen round-robin, AND ONE SETTLE; one effect reads every root and sums them. Each run reads the 4 roots through effectSourceTracker.readSourceSlot, so both arms re-track on every run. THIS IS THE SAME TASK AS graph.dependencies.reads-per-run.r4, with the same floor builder; only the ours effect differs. The effect comes from OIMEffectService.createEffectWithSourceTracking instead of createEffectImmediate, and its dependencies are tracked at run time: each run reads its sources through effectSourceTracker (readSourceSlot for a root, readSourceComputedValue for a computed) instead of the root and computed lists declared once at build. Read this row against graph.dependencies.reads-per-run.r4: the difference between the two is the price of tracking against declaring on this task. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.dependencies-tracked.reads-per-run.r4
OursupdateEntityColumn on one of 8 roots, then db.flush(); one OIMEffectService.createEffectWithSourceTracking effect reads all 8 root slots through readSourceSlot and sums them
Floorone of 8 alien signals written with no batch; one alien effect reads and sums all of them
67 ns ours112 ns floor0.60×floor timed twice: 0.3% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO ONE OF 8 ROOTS, chosen round-robin, AND ONE SETTLE; one effect reads every root and sums them. Each run reads the 8 roots through effectSourceTracker.readSourceSlot, so both arms re-track on every run. THIS IS THE SAME TASK AS graph.dependencies.reads-per-run.r8, with the same floor builder; only the ours effect differs. The effect comes from OIMEffectService.createEffectWithSourceTracking instead of createEffectImmediate, and its dependencies are tracked at run time: each run reads its sources through effectSourceTracker (readSourceSlot for a root, readSourceComputedValue for a computed) instead of the root and computed lists declared once at build. Read this row against graph.dependencies.reads-per-run.r8: the difference between the two is the price of tracking against declaring on this task. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.dependencies-tracked.reads-per-run.r8
OursupdateEntityColumn on the unread branch value, then db.flush(); the effect declares flag, active and inactive as sources
Floorinactive(v) with no batch; the alien effect reads flag() and then active() only
41 ns ours2 ns floor21×floor timed twice: 0.1% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO THE INACTIVE BRANCH AND ONE SETTLE. An effect reads a flag and then one of two values, and the flag selects the first, so the written value is one the body does not read. ARCHITECTURAL POINT: declared against auto-tracked dependencies, measured on a conditional branch. Ours has no auto-tracking: the flag and both values are declared as the effect's sources, so a write to the unread value schedules the effect and the flush runs the body. Alien-signals subscribed the effect only to what its last run read, so the write finds no subscriber and nothing runs; the floor is a signal store with no one listening. EXPECTED BODY RUNS PER OPERATION [FIGURE STATED IN ADVANCE]: alien 0, ours 1; both run counts are sunk into priceSink.number at the end of each pass. The ratio is therefore large by construction and prices the work ours does that the floor skips, not a slower path doing the same work. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.dependencies.inactive-branch.s3
OursupdateEntityColumn on one of 1 roots, then db.flush(); one effect declaring all 1 root slots sums them
Floorone of 1 alien signals written with no batch; one alien effect reads and sums all of them
46 ns ours28 ns floor1.61×floor timed twice: 0.2% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO ONE OF 1 ROOTS, chosen round-robin, AND ONE SETTLE; one effect reads every root and sums them. ARCHITECTURAL POINT: declared against auto-tracked dependencies, measured as what each read inside a run costs. Ours declares the 1 root slots as the effect's sources once, at build; a run checks each source stamp before the body and the body reads each entity, and nothing is re-linked. Alien-signals has no declaration: every run re-tracks, each read of a signal inside the body checks or re-creates its dependency link, and the run is synchronous at the end of the write, so there is no settle call. EXPECTED DIRECTION [FIGURE STATED IN ADVANCE]: the per-read cost of re-tracking grows with the number of roots on alien, so the ratio is expected to fall as the root count grows, if re-tracking costs more per read than the stamp check ours does per source. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.dependencies.reads-per-run.r1
OursupdateEntityColumn on one of 128 roots, then db.flush(); one effect declaring all 128 root slots sums them
Floorone of 128 alien signals written with no batch; one alien effect reads and sums all of them
391 ns ours1.29 µs floor0.30×floor timed twice: 2.1% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO ONE OF 128 ROOTS, chosen round-robin, AND ONE SETTLE; one effect reads every root and sums them. ARCHITECTURAL POINT: declared against auto-tracked dependencies, measured as what each read inside a run costs. Ours declares the 128 root slots as the effect's sources once, at build; a run checks each source stamp before the body and the body reads each entity, and nothing is re-linked. Alien-signals has no declaration: every run re-tracks, each read of a signal inside the body checks or re-creates its dependency link, and the run is synchronous at the end of the write, so there is no settle call. EXPECTED DIRECTION [FIGURE STATED IN ADVANCE]: the per-read cost of re-tracking grows with the number of roots on alien, so the ratio is expected to fall as the root count grows, if re-tracking costs more per read than the stamp check ours does per source. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.dependencies.reads-per-run.r128
OursupdateEntityColumn on one of 16 roots, then db.flush(); one effect declaring all 16 root slots sums them
Floorone of 16 alien signals written with no batch; one alien effect reads and sums all of them
67 ns ours198 ns floor0.34×floor timed twice: 0.0% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO ONE OF 16 ROOTS, chosen round-robin, AND ONE SETTLE; one effect reads every root and sums them. ARCHITECTURAL POINT: declared against auto-tracked dependencies, measured as what each read inside a run costs. Ours declares the 16 root slots as the effect's sources once, at build; a run checks each source stamp before the body and the body reads each entity, and nothing is re-linked. Alien-signals has no declaration: every run re-tracks, each read of a signal inside the body checks or re-creates its dependency link, and the run is synchronous at the end of the write, so there is no settle call. EXPECTED DIRECTION [FIGURE STATED IN ADVANCE]: the per-read cost of re-tracking grows with the number of roots on alien, so the ratio is expected to fall as the root count grows, if re-tracking costs more per read than the stamp check ours does per source. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.dependencies.reads-per-run.r16
OursupdateEntityColumn on one of 2 roots, then db.flush(); one effect declaring all 2 root slots sums them
Floorone of 2 alien signals written with no batch; one alien effect reads and sums all of them
44 ns ours43 ns floor1.03×floor timed twice: 1.2% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO ONE OF 2 ROOTS, chosen round-robin, AND ONE SETTLE; one effect reads every root and sums them. ARCHITECTURAL POINT: declared against auto-tracked dependencies, measured as what each read inside a run costs. Ours declares the 2 root slots as the effect's sources once, at build; a run checks each source stamp before the body and the body reads each entity, and nothing is re-linked. Alien-signals has no declaration: every run re-tracks, each read of a signal inside the body checks or re-creates its dependency link, and the run is synchronous at the end of the write, so there is no settle call. EXPECTED DIRECTION [FIGURE STATED IN ADVANCE]: the per-read cost of re-tracking grows with the number of roots on alien, so the ratio is expected to fall as the root count grows, if re-tracking costs more per read than the stamp check ours does per source. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.dependencies.reads-per-run.r2
OursupdateEntityColumn on one of 4 roots, then db.flush(); one effect declaring all 4 root slots sums them
Floorone of 4 alien signals written with no batch; one alien effect reads and sums all of them
48 ns ours71 ns floor0.68×floor timed twice: 0.0% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO ONE OF 4 ROOTS, chosen round-robin, AND ONE SETTLE; one effect reads every root and sums them. ARCHITECTURAL POINT: declared against auto-tracked dependencies, measured as what each read inside a run costs. Ours declares the 4 root slots as the effect's sources once, at build; a run checks each source stamp before the body and the body reads each entity, and nothing is re-linked. Alien-signals has no declaration: every run re-tracks, each read of a signal inside the body checks or re-creates its dependency link, and the run is synchronous at the end of the write, so there is no settle call. EXPECTED DIRECTION [FIGURE STATED IN ADVANCE]: the per-read cost of re-tracking grows with the number of roots on alien, so the ratio is expected to fall as the root count grows, if re-tracking costs more per read than the stamp check ours does per source. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.dependencies.reads-per-run.r4
OursupdateEntityColumn on one of 8 roots, then db.flush(); one effect declaring all 8 root slots sums them
Floorone of 8 alien signals written with no batch; one alien effect reads and sums all of them
54 ns ours112 ns floor0.48×floor timed twice: 0.2% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO ONE OF 8 ROOTS, chosen round-robin, AND ONE SETTLE; one effect reads every root and sums them. ARCHITECTURAL POINT: declared against auto-tracked dependencies, measured as what each read inside a run costs. Ours declares the 8 root slots as the effect's sources once, at build; a run checks each source stamp before the body and the body reads each entity, and nothing is re-linked. Alien-signals has no declaration: every run re-tracks, each read of a signal inside the body checks or re-creates its dependency link, and the run is synchronous at the end of the write, so there is no settle call. EXPECTED DIRECTION [FIGURE STATED IN ADVANCE]: the per-read cost of re-tracking grows with the number of roots on alien, so the ratio is expected to fall as the root count grows, if re-tracking costs more per read than the stamp check ours does per source. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.dependencies.reads-per-run.r8
Oursone updateEntityColumn on the root, then db.flush(), under a standing chain of 1 computed single-slot store slots and one OIMEffectService.createEffectWithSourceTracking effect reading the head through readSourceComputedValue
Floorone root(v) with no batch, under a standing chain of 1 alien computeds and one alien effect
70 ns ours42 ns floor1.68×floor timed twice: 2.2% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO THE ROOT AND ONE SETTLE, under a standing chain of 1 derived nodes and one effect over the head. The tracked effect reads the head through effectSourceTracker.readSourceComputedValue, so the head computed is the one source it tracks. THIS IS THE SAME TASK AS graph.subscription.run.d1, with the same floor builder; only the ours effect differs. The effect comes from OIMEffectService.createEffectWithSourceTracking instead of createEffectImmediate, and its dependencies are tracked at run time: each run reads its sources through effectSourceTracker (readSourceSlot for a root, readSourceComputedValue for a computed) instead of the root and computed lists declared once at build. Read this row against graph.subscription.run.d1: the difference between the two is the price of tracking against declaring on this task. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.subscription-tracked.run.d1
Oursone updateEntityColumn on the root, then db.flush(), under a standing chain of 64 computed single-slot store slots and one OIMEffectService.createEffectWithSourceTracking effect reading the head through readSourceComputedValue
Floorone root(v) with no batch, under a standing chain of 64 alien computeds and one alien effect
1.59 µs ours1.51 µs floor1.05×floor timed twice: 0.1% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO THE ROOT AND ONE SETTLE, under a standing chain of 64 derived nodes and one effect over the head. The tracked effect reads the head through effectSourceTracker.readSourceComputedValue, so the head computed is the one source it tracks. THIS IS THE SAME TASK AS graph.subscription.run.d64, with the same floor builder; only the ours effect differs. The effect comes from OIMEffectService.createEffectWithSourceTracking instead of createEffectImmediate, and its dependencies are tracked at run time: each run reads its sources through effectSourceTracker (readSourceSlot for a root, readSourceComputedValue for a computed) instead of the root and computed lists declared once at build. Read this row against graph.subscription.run.d64: the difference between the two is the price of tracking against declaring on this task. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.subscription-tracked.run.d64
Oursone updateEntityColumn on the root, then db.flush(), under a standing chain of 8 computed single-slot store slots and one OIMEffectService.createEffectWithSourceTracking effect reading the head through readSourceComputedValue
Floorone root(v) with no batch, under a standing chain of 8 alien computeds and one alien effect
235 ns ours222 ns floor1.06×floor timed twice: 0.2% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO THE ROOT AND ONE SETTLE, under a standing chain of 8 derived nodes and one effect over the head. The tracked effect reads the head through effectSourceTracker.readSourceComputedValue, so the head computed is the one source it tracks. THIS IS THE SAME TASK AS graph.subscription.run.d8, with the same floor builder; only the ours effect differs. The effect comes from OIMEffectService.createEffectWithSourceTracking instead of createEffectImmediate, and its dependencies are tracked at run time: each run reads its sources through effectSourceTracker (readSourceSlot for a root, readSourceComputedValue for a computed) instead of the root and computed lists declared once at build. Read this row against graph.subscription.run.d8: the difference between the two is the price of tracking against declaring on this task. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.subscription-tracked.run.d8
Oursone updateEntityColumn on the root, then db.flush(), under a standing chain of 1 computed single-slot store slots and one effect
Floorone root(v) with no batch, under a standing chain of 1 alien computeds and one alien effect
68 ns ours42 ns floor1.61×floor timed twice: 0.9% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO THE ROOT AND ONE SETTLE, under a standing chain of 1 derived nodes and one effect over the head. ARCHITECTURAL POINT: build at subscription against lazy linking, measured as what running costs once the graph stands. Ours stamps the root, schedules the effect it subscribed to at build, and on flush pulls the chain by stamp comparison. Alien-signals has no settle call: the write propagates pending flags down the chain and runs the effect synchronously at the end of the write, with no batch; a batch of one write would add only the start and end calls. Read against the build row of the same depth: the build row is what ours pays up front, this row is whether it comes back per write. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.subscription.run.d1
Oursone updateEntityColumn on the root, then db.flush(), under a standing chain of 64 computed single-slot store slots and one effect
Floorone root(v) with no batch, under a standing chain of 64 alien computeds and one alien effect
1.57 µs ours1.50 µs floor1.04×floor timed twice: 0.4% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO THE ROOT AND ONE SETTLE, under a standing chain of 64 derived nodes and one effect over the head. ARCHITECTURAL POINT: build at subscription against lazy linking, measured as what running costs once the graph stands. Ours stamps the root, schedules the effect it subscribed to at build, and on flush pulls the chain by stamp comparison. Alien-signals has no settle call: the write propagates pending flags down the chain and runs the effect synchronously at the end of the write, with no batch; a batch of one write would add only the start and end calls. Read against the build row of the same depth: the build row is what ours pays up front, this row is whether it comes back per write. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.subscription.run.d64
Oursone updateEntityColumn on the root, then db.flush(), under a standing chain of 8 computed single-slot store slots and one effect
Floorone root(v) with no batch, under a standing chain of 8 alien computeds and one alien effect
233 ns ours219 ns floor1.06×floor timed twice: 0.4% apart
What the two sides do differently

ONE OPERATION IS ONE WRITE TO THE ROOT AND ONE SETTLE, under a standing chain of 8 derived nodes and one effect over the head. ARCHITECTURAL POINT: build at subscription against lazy linking, measured as what running costs once the graph stands. Ours stamps the root, schedules the effect it subscribed to at build, and on flush pulls the chain by stamp comparison. Alien-signals has no settle call: the write propagates pending flags down the chain and runs the effect synchronously at the end of the write, with no batch; a batch of one write would add only the start and end calls. Read against the build row of the same depth: the build row is what ours pays up front, this row is whether it comes back per write. Ours is @oimdb/core from source: a void-key entity store slot root (createStoreSlot, slotContentService.upsertEntity, holdSingleSlot) of an OIMSingleSlotService from createOIMSingleEntityService, written through slotContentService.updateEntityColumn, void-key computed store slots (createComputedStoreSlot, computedCollectionService.slotContentService.getValueForSlot) of an OIMComputedService for anything derived, one effect from OIMEffectService, and db.flush() as the settle. The floor is alien-signals 3.2: signal, computed, effect, and startBatch/endBatch where the row says so. Every write stores a new number from a counter, so no write on either arm is stopped by a same-value check. Each arm runs in its own process.

measured 2026-10-23no explanation yetgraph.subscription.run.d8
OursslotContentService.deleteEntity(slot) with one OIMIndexService store slot over `group`
Floormap.delete(id) and Set.delete(row) from the group it was in
239 ns ours99 ns floor2.41×floor timed twice: 1.1% apart
What the two sides do differently

Ours finds the bucket to leave through the key the row's own `indexKeys` cell carries — one cell read and one bucket-store `Map.get` — where the floor hashes the id and then hashes the group name. Against that, ours clears the value, tells the index through its content listener, unholds the row from the bucket, queues the bucket for the change-close flush that marks it on the channel, and unfiles the emptied identity; the flush that closes this batch is inside the timed body. The buckets are held for the whole pass, so none is released under the clock. The floor leaves an empty Set behind for ever and tells nobody.

measured 2026-10-23no explanation yetremove.indexed-vs-hand-index
OursslotContentService.deleteEntity(slot) — through the identity, no index registered
Floormap.delete(id)
54 ns ours35 ns floor1.53×floor timed twice: 1.9% apart
What the two sides do differently

THE HASH IS ON THE FLOOR'S SIDE ONLY: ours is handed the identity and the floor hashes a string, which flatters us — the deleteEntityByKey path is not priced here and would cost us that lookup too. Against that, ours clears the value through the writer, reports it on the channel, recomputes emptiness and asks whether anything holds or references the identity before it unfiles it from the store — an unheld, emptied slot is released at the call. The flush that closes the batch is inside the timed body. The floor's row is gone the instant delete returns and nothing can be subscribed to it. Both sides rebuild their population between passes, untimed.

measured 2026-10-23whyremove.vs-map-delete
OursentityService.slotContentService.updateEntity(slot, { group }) with an index store slot over group, then indexService.slotContentService.getBucketMemberSlots(bucket) — the auto-index, in place
Floormove the row between two Sets, write the column, iterate one Set
317 ns ours91 ns floor3.47×floor timed twice: 1.1% apart
What the two sides do differently

THE ARM IS THE AUTO-INDEX, IN PLACE. THE MOVE IS THE ENGINE'S: the index listens to the collection's content changes, so `updateEntity` alone re-files the row — `updateIndexKeyForSlot` reads the previous key off the slot's index-key cell, runs `selectKey` on the new entity, writes the cell, and calls `findSlotByKey` then `addBucketMemberSlot` for the new key and `findSlotByKey` then `removeBucketMemberSlot` for the old, each a hash of the address, a `Set` edit, a hold or an unhold and a channel mark queued to the change close. A caller writes one call and cannot forget to move a row. [FIGURE STATED IN ADVANCE] Expect this to be the closest arm of the task; if a manual door comes out closer, the listener path costs more than the caller writing the move. THE FLOOR IS THE SAME CODE FOR EVERY ARM OF THIS TASK, which is the property that makes the arms comparable at all. It moves the row between two `Set`s — the container our unordered bucket holds its members in, so this is the structural equal and not a cheaper shape — writes the column, and iterates one group. WHAT IT DOES LESS OF, and every item pushes our ratio UP: it keeps no identity that outlives the value, so nothing can be subscribed to a row or to a group; it stamps no clock; it records no moved columns; it keeps no hold count, so a group cannot be resolved by address and handed to a consumer; and its groups can be read by iterating them and by nothing else. WHAT IS ON BOTH SIDES AND CANCELS: the read group is held from outside the clock on both, and the read visits the same members on both. WHERE THE FLOOR IS CHARGED MORE THAN IT SHOULD BE, stated because it flatters us: it hashes `row.group` to find the departure set, where the index arm reads the previous key off the slot's own index-key cell.

measured 2026-10-23no explanation yetsweep.grouped-column.index-in-place
OursentityService.slotContentService.updateEntity(slot, { group }) with an index store slot over group, then indexService.slotContentService.getBucketMemberSlots(bucket) — the auto-index, replacing
Floormove the row between two Sets, write the column, iterate one Set
343 ns ours97 ns floor3.53×floor timed twice: 1.1% apart
What the two sides do differently

THE ARM IS THE AUTO-INDEX, REPLACING. THE MOVE IS THE ENGINE'S: the index listens to the collection's content changes, so `updateEntity` alone re-files the row — `updateIndexKeyForSlot` reads the previous key off the slot's index-key cell, runs `selectKey` on the new entity, writes the cell, and calls `findSlotByKey` then `addBucketMemberSlot` for the new key and `findSlotByKey` then `removeBucketMemberSlot` for the old, each a hash of the address, a `Set` edit, a hold or an unhold and a channel mark queued to the change close. A caller writes one call and cannot forget to move a row. [FIGURE STATED IN ADVANCE] Expect this to be the closest arm of the task; if a manual door comes out closer, the listener path costs more than the caller writing the move. THE FLOOR IS THE SAME CODE FOR EVERY ARM OF THIS TASK, which is the property that makes the arms comparable at all. It moves the row between two `Set`s — the container our unordered bucket holds its members in, so this is the structural equal and not a cheaper shape — writes the column, and iterates one group. WHAT IT DOES LESS OF, and every item pushes our ratio UP: it keeps no identity that outlives the value, so nothing can be subscribed to a row or to a group; it stamps no clock; it records no moved columns; it keeps no hold count, so a group cannot be resolved by address and handed to a consumer; and its groups can be read by iterating them and by nothing else. WHAT IS ON BOTH SIDES AND CANCELS: the read group is held from outside the clock on both, and the read visits the same members on both. WHERE THE FLOOR IS CHARGED MORE THAN IT SHOULD BE, stated because it flatters us: it hashes `row.group` to find the departure set, where the index arm reads the previous key off the slot's own index-key cell.

measured 2026-10-23no explanation yetsweep.grouped-column.index-replacing
OursentityService.slotContentService.updateEntity(slot, { group }), slotContentService.removeBucketMemberSlotAt + insertBucketMemberSlotAt at the end, then slotContentService.getBucketMemberSlots(bucket)
Floormove the row between two Sets, write the column, iterate one Set
281 ns ours94 ns floor3.00×floor timed twice: 0.3% apart
What the two sides do differently

THE ARM IS THE POSITIONAL DOOR, IN PLACE. THE MEMBERSHIP IS THE CALLER'S ON THIS ARM: the bucket collection is not an index and hears no write, so the move is made in the same statement sequence as the write, inside the timed body. WHAT THE ARM PAYS THAT THE FLOOR DOES NOT: `updateEntity` walks the patch, gates the column, builds the moved-column list and marks the row on the channel; then the move marks both buckets and keeps the slot's hold count. THE ADDRESS IS RESOLVED THE SAME WAY ON BOTH SIDES: one `getSlotByKey` per end of the move, which is the hash the floor pays as `byGroup.get(next)`. THE OLD GROUP IS READ OFF THE STORED ROW BEFORE THE WRITE LANDS, which a caller holding the slot can always do. THIS ARM TAKES THE POSITIONAL DOOR on an `OIMSlotContentBucketServiceArrayDriven`, so the caller owns the order: `getBucketMemberSlotPosition` finds the member in the bucket it is leaving — an `indexOf` over that group — `removeBucketMemberSlotAt` splices it out, and `insertBucketMemberSlotAt` at `getBucketMemberSlotCount` appends it to the one it joins. It is O(members of the group being left) against the floor's hash, and that is the largest single term on this row. THE FLOOR IS THE SAME CODE FOR EVERY ARM OF THIS TASK, which is the property that makes the arms comparable at all. It moves the row between two `Set`s — the container our unordered bucket holds its members in, so this is the structural equal and not a cheaper shape — writes the column, and iterates one group. WHAT IT DOES LESS OF, and every item pushes our ratio UP: it keeps no identity that outlives the value, so nothing can be subscribed to a row or to a group; it stamps no clock; it records no moved columns; it keeps no hold count, so a group cannot be resolved by address and handed to a consumer; and its groups can be read by iterating them and by nothing else. WHAT IS ON BOTH SIDES AND CANCELS: the read group is held from outside the clock on both, and the read visits the same members on both. WHERE THE FLOOR IS CHARGED MORE THAN IT SHOULD BE, stated because it flatters us: it hashes `row.group` to find the departure set, where the index arm reads the previous key off the slot's own index-key cell.

measured 2026-10-23no explanation yetsweep.grouped-column.manual-positional
OursentityService.slotContentService.updateEntity(slot, { group }), slotContentService.writeBucketMemberSlots on both buckets, then slotContentService.getBucketMemberSlots(bucket)
Floormove the row between two Sets, write the column, iterate one Set
16.13 µs ours89 ns floor180×floor timed twice: 0.7% apart
What the two sides do differently

THE ARM IS THE WHOLE-BUCKET DOOR, IN PLACE. THE MEMBERSHIP IS THE CALLER'S ON THIS ARM: the bucket collection is not an index and hears no write, so the move is made in the same statement sequence as the write, inside the timed body. WHAT THE ARM PAYS THAT THE FLOOR DOES NOT: `updateEntity` walks the patch, gates the column, builds the moved-column list and marks the row on the channel; then the move marks both buckets and keeps the slot's hold count. THE ADDRESS IS RESOLVED THE SAME WAY ON BOTH SIDES: one `getSlotByKey` per end of the move, which is the hash the floor pays as `byGroup.get(next)`. THE OLD GROUP IS READ OFF THE STORED ROW BEFORE THE WRITE LANDS, which a caller holding the slot can always do. `writeBucketMemberSlots` is handed each bucket's new membership, asks the bucket content service whether the bucket already holds exactly those slots, and — since it does not — replaces the set and reports who arrived and who left. Moving one row is therefore TWO FULL BUCKET REWRITES, plus the caller's own `indexOf` and `splice` on the array it keeps beside them, on groups of a hundred and twenty-eight. THIS IS THE DOOR A RE-HYDRATED SERVER LIST USES and pricing it on a one-row move is pricing it on its worst task; the distance between it and the other arms is what the finer doors are worth. THE FLOOR IS THE SAME CODE FOR EVERY ARM OF THIS TASK, which is the property that makes the arms comparable at all. It moves the row between two `Set`s — the container our unordered bucket holds its members in, so this is the structural equal and not a cheaper shape — writes the column, and iterates one group. WHAT IT DOES LESS OF, and every item pushes our ratio UP: it keeps no identity that outlives the value, so nothing can be subscribed to a row or to a group; it stamps no clock; it records no moved columns; it keeps no hold count, so a group cannot be resolved by address and handed to a consumer; and its groups can be read by iterating them and by nothing else. WHAT IS ON BOTH SIDES AND CANCELS: the read group is held from outside the clock on both, and the read visits the same members on both. WHERE THE FLOOR IS CHARGED MORE THAN IT SHOULD BE, stated because it flatters us: it hashes `row.group` to find the departure set, where the index arm reads the previous key off the slot's own index-key cell.

measured 2026-10-23no explanation yetsweep.grouped-column.manual-set-members
OursentityService.slotContentService.upsertEntity(entityStoreSlot, row) with the values the row already holds — the shipped default, no index
Floormap.get(id), then compare each column and assign only what moved
103 ns ours24 ns floor4.31×floor timed twice: 0.1% apart
What the two sides do differently

THE ARM IS THE SHIPPED DEFAULT, NO INDEX. NOTHING MOVES ON EITHER SIDE, which is the point of the task: `upsertEntity` finds the key populated, `insertEntity` hands it to `writeEntity`, whose writer `putEntity` patches the columns the row carries, walks the stored row for columns it does not carry (there are none), is told nothing moved, and returns before it marks anything or tells any listener. The floor gets the row and compares. THIS IS THE FAIREST FLOOR IN THE SUITE: a hand-written store that wanted to wake anybody would need the same decision this write makes. WHERE THE FLOOR STILL DOES LESS, both pushing our ratio UP: it compares four columns named at compile time where `patchEntity` enumerates whatever the patch carries, and it never looks for columns the stored row has that the new one does not, where `putEntity` walks the stored row with a `hasOwnProperty` per column first. On the indexed arm ours also opens and closes a change window per row; the un-indexed arm takes the flat path and opens none. THE HASH IS ON BOTH SIDES: ours calls `selectKey` and the store's `get`, the floor calls `byId.get`. THE FLUSH IS INSIDE OUR NUMBER and closes a batch that queued nothing. NO INDEX IS BUILT on this arm, which is the baseline the indexed arm is read against. THE SAME SOURCE ROWS ARE RE-SENT EVERY PASS, so no pass can drift into being a real write.

measured 2026-10-23no explanation yetsweep.poll-unchanged.in-place-default
OursentityService.slotContentService.upsertEntity(entityStoreSlot, row) with the values the row already holds — the shipped default, one index
Floormap.get(id), then compare each column and assign only what moved
97 ns ours24 ns floor4.05×floor timed twice: 1.3% apart
What the two sides do differently

THE ARM IS THE SHIPPED DEFAULT, ONE INDEX. NOTHING MOVES ON EITHER SIDE, which is the point of the task: `upsertEntity` finds the key populated, `insertEntity` hands it to `writeEntity`, whose writer `putEntity` patches the columns the row carries, walks the stored row for columns it does not carry (there are none), is told nothing moved, and returns before it marks anything or tells any listener. The floor gets the row and compares. THIS IS THE FAIREST FLOOR IN THE SUITE: a hand-written store that wanted to wake anybody would need the same decision this write makes. WHERE THE FLOOR STILL DOES LESS, both pushing our ratio UP: it compares four columns named at compile time where `patchEntity` enumerates whatever the patch carries, and it never looks for columns the stored row has that the new one does not, where `putEntity` walks the stored row with a `hasOwnProperty` per column first. On the indexed arm ours also opens and closes a change window per row; the un-indexed arm takes the flat path and opens none. THE HASH IS ON BOTH SIDES: ours calls `selectKey` and the store's `get`, the floor calls `byId.get`. THE FLUSH IS INSIDE OUR NUMBER and closes a batch that queued nothing. AN INDEX LISTENS AND IS NEVER REACHED. This arm carries one `OIMIndexService` store slot over `group` with every bucket held, so the collection has a content-change listener; a write that lands nothing never calls it. [FIGURE STATED IN ADVANCE] Expect this arm to be indistinguishable from the un-indexed one within both rows' noise. The floor keeps no groups on this arm either, so the index is charged entirely to us. THE SAME SOURCE ROWS ARE RE-SENT EVERY PASS, so no pass can drift into being a real write.

measured 2026-10-23no explanation yetsweep.poll-unchanged.one-index-declared
OursentityService.slotContentService.upsertEntity(entityStoreSlot, row) with the values the row already holds — createOIMEntityWriterReplacing, no index
Floormap.get(id), then compare each column and assign only what moved
100 ns ours24 ns floor4.17×floor timed twice: 0.2% apart
What the two sides do differently

THE ARM IS CREATEOIMENTITYWRITERREPLACING, NO INDEX. NOTHING MOVES ON EITHER SIDE, which is the point of the task: `upsertEntity` finds the key populated, `insertEntity` hands it to `writeEntity`, whose writer `putEntity` patches the columns the row carries, walks the stored row for columns it does not carry (there are none), is told nothing moved, and returns before it marks anything or tells any listener. The floor gets the row and compares. THIS IS THE FAIREST FLOOR IN THE SUITE: a hand-written store that wanted to wake anybody would need the same decision this write makes. WHERE THE FLOOR STILL DOES LESS, both pushing our ratio UP: it compares four columns named at compile time where `patchEntity` enumerates whatever the patch carries, and it never looks for columns the stored row has that the new one does not, where `putEntity` walks the stored row with a `hasOwnProperty` per column first. On the indexed arm ours also opens and closes a change window per row; the un-indexed arm takes the flat path and opens none. THE HASH IS ON BOTH SIDES: ours calls `selectKey` and the store's `get`, the floor calls `byId.get`. THE FLUSH IS INSIDE OUR NUMBER and closes a batch that queued nothing. NO INDEX IS BUILT on this arm, which is the baseline the indexed arm is read against. THE SAME SOURCE ROWS ARE RE-SENT EVERY PASS, so no pass can drift into being a real write.

measured 2026-10-23no explanation yetsweep.poll-unchanged.replacing
OursslotContentService.updateEntity(slot, patch) — one column, no index reads it
Floorrow.title = value
17 ns ours1 ns floor13×floor timed twice: 0.4% apart
What the two sides do differently

THE LOOKUP IS ON NEITHER SIDE — ours holds the slot, the floor holds the object, both resolved outside the clock. That is the comparison this row is for. What ours does that a store cannot: it walks the patch, refuses names a row may not carry, gates each column on the default equality, builds the list of what moved, stamps the slot and the collection, and tests the row's column store and the population's listener list so a column subscriber or an index could be told. THAT DEFAULT IS SAMEVALUEZERO AND WAS AN INLINE `===` WHEN 2026-08-20-price/write WAS RECORDED. The call was there under both — the predicate has always been reached through the strategy's captured parameter — so the delta is one comparison, and only on a column that moved, which is one per write here. `update.column-vs-the-strict-equality-default` is that delta on its own and is unrun; until it runs, this row's recorded figure is a figure for the older body. Direction: inflates our ratio; the tracked row below prices the part of that a person would have had to write anyway. The patch object is REUSED rather than written as a literal per call — a caller who writes { title } inline pays one more allocation per write than this row charges us for. The batch closes with one flush per eight thousand writes, which is why every write in it takes the marking path rather than the already-stamped early return. THE REUSED PATCH IS ALSO WHAT STOPS THIS ROW BEING SUBTRACTED FROM `update.unchanged-vs-field-store`, and that subtraction is the only way anyone has to split this number into the walk that decides and the tail that reports. The unchanged row hands `updateEntity` a DIFFERENT patch object per write and its floor reads the value out of that object; this row reuses one patch and its floor reads a local. Two differences, both on the wrong side of the subtraction. `update.column-vs-field-store-a-patch-per-write` is this row with the unchanged row's patch supply and the unchanged row's floor, and it exists so the split can be taken arm for arm instead of across two bodies that differ in three ways.

measured 2026-10-23no explanation yetupdate.column-vs-field-store
OursslotContentService.updateEntity(slot, patch) — one column, one patch object per row
Floorrow.title = patch.title
18 ns ours2 ns floor9.39×floor timed twice: 1.9% apart
What the two sides do differently

THE ROW ABOVE, ARM FOR ARM WITH `update.unchanged-vs-field-store`, AND THAT IS ITS WHOLE REASON. The only handle anybody has on how the row above's gap divides is the unchanged row, which times the same call up to the point where the comparator finds every column equal and returns before marking anything. Subtracting one from the other would give the walk and the tail — except that the two bodies differ in three ways at once: the row above REUSES one patch object where the unchanged row allocates eight thousand and hands a different one to every write, and its floor stores a local where the unchanged row's floor reads the value off the patch first. A fresh patch per write is a fresh receiver for `isPlain` and for the `for…in`, and the extra load is a real instruction on the floor. Both differences push the same way and neither is the thing being priced. THIS ROW REMOVES ALL THREE. The patch supply is the unchanged row's — one object per row, built outside the clock — and the floor is the unchanged row's floor to the character. What is left between this row's `ours` and the unchanged row's `ours` is exactly what a write that MOVES a column does and a write that moves nothing does not: one store into the entity, the moved-names array and its push, two `OIMChannelService.write` calls — the row and the population — one `columnSlotStoreService.get` probe for the moved column inside `OIMColumnOwner.markColumnsChanged`, and the frame that closes the batch. EIGHT PATCH ARRAYS, ONE PER TITLE, so this row moves the column on exactly the writes the row above moves it on. The title advances by one of eight per batch and every row in a batch is written with the same title, which is the row above's rotation with the shared object unpicked into one object per row. THE FLUSH IS ON THIS SIDE OF THE SUBTRACTION AND NOT ON THE UNCHANGED ROW'S: nothing is marked there, so no frame is asked for. `flush.empty-vs-noop` [2026-08-20-price/frame] prices a frame with nothing queued, and over eight thousand writes it is four thousandths of a nanosecond each — named here because it belongs to the difference, not because it can be seen in it.

measured 2026-10-23no explanation yetupdate.column-vs-field-store-a-patch-per-write
OursslotContentService.updateEntity(slot, patch) — one column, no index reads it
Floortest the row for a column store and the population for listeners, then row.title = value
17 ns ours3 ns floor5.94×floor timed twice: 0.0% apart
What the two sides do differently

THE TWO "IS ANYBODY LISTENING" GUARDS, PUT ON THE FLOOR. A write that moves a column asks two questions before it can skip the routing: `OIMSlotContentEntityService.isOnFastPath` tests `entitySlot.columnSlotStore !== undefined` (no column of this row was ever subscribed to), and the content change listener check reads `slot.storeSlot` and then that store slot's `contentChangeListeners` and tests `length !== 0` (no index hears this population); isOnFastPath also reads updatesEmptinessOnColumnWrite, which the floor does not. Both hold on every row of this fixture. Inside `update.column-vs-field-store` they are two operations among thirty and nothing separates them; here the floor makes the identical two tests on an identically empty state, so THE ITEM IS THE DIFFERENCE BETWEEN THAT ROW'S GAP AND THIS ROW'S GAP. OUR ARM IS THAT ROW'S ARM TO THE CHARACTER — the same fixture, the same reused patch, the same rotation of eight titles, the same flush per eight thousand writes. OPERATION COUNT, THE DIFFERENCE ONLY: per row, one field load and one `undefined` compare for the column store, one load of the row's store-slot pointer and one `undefined` compare, one load of that store slot's listeners array and one `undefined` compare, one length load and one compare. Expected inside the noise floor.

measured 2026-10-23no explanation yetupdate.column-vs-field-store-and-the-listener-guards
OursslotContentService.updateEntity(slot, patch) — the shipped default, which is SameValueZero
Floorthe same update on a population built with createOIMEntityWriterInPlace({ sameValueGuard: (a, b) => a === b })
18 ns ours18 ns floor1.00×floor timed twice: 0.6% apart
What the two sides do differently

THE ONE ITEM OF THE WRITE PATH THAT IS IN NO RECORDED NUMBER, BECAUSE IT POSTDATES THEM ALL. Every write row in `2026-08-20-price/write` was measured against a default equality that was an inline `a === b`. The default is `oimSameValueZeroGuard` now — `a === b || (a !== a && b !== b)` — and what that costs is not a call, since the predicate was already reached through the strategy's captured parameter on both designs. IT IS ONE COMPARISON, AND ONLY ON A COLUMN THAT MOVED: an equal column settles on the first clause and short-circuits, byte for byte what was there before, while a moved column then evaluates `a !== a` and short-circuits on that. BOTH ARMS ARE `entityService.updateEntity` ON THE SAME FIXTURE, one column moving per write, so the difference is that one comparison per write and the state of one inline cache. The floor's predicate is a different function object of the same shape as the shipped `oimSameValueZeroGuard` — module-level, monomorphic, one expression, no closure. THIS PAIR DECLARES `isolate` AND IT MUST. `changedColumns` is ONE compiled body however many writers the factory builds, so `sameValueGuard(entity[name], source[name])` inside it is one call site for the whole process. Building both arms in one process would make that site see two functions and would spoil BOTH of them equally, which is a measurement of nothing. The same reasoning, and the same declaration, is on `alt.equality-predicate.shared-default-vs-inlined.with-a-second-comparator-present`, where making the site polymorphic is the subject rather than the hazard. DO NOT BORROW `alt.equality-predicate.shared-default-vs-inlined.unchanged-resend` FOR THIS. That row prices the predicate's CALL FRAME against a walk with no parameter at all, on an UNCHANGED re-send where every column settles on the first clause — so the second comparison this row exists for never executes in it. The two rows are about the parameter and about the body, and they do not substitute. ONE COMPARISON PER WRITE IS BELOW WHAT THIS INSTRUMENT RESOLVED ON ITS OWN SCALE CONTROL, and that is the expected reading, stated in advance so a run can refute it: this pair should come back inside the noise floor. If it does, the argument in `oimSameValueZeroGuard.ts` — that the new answer is free on the hot path and spends only where it saves a report, a reindex and a wake-up — holds at the write. If it does NOT, there is a real cost on the hottest path in the engine and the `NaN` defect was bought with something.

measured 2026-10-23no explanation yetupdate.column-vs-the-strict-equality-default
OursslotContentService.updateEntity(slot, patch) — one column, no index reads it
Floorgate on !==, store, then queue the entity once per frame by a stamp kept per position
14 ns ours5 ns floor2.83×floor timed twice: 1.3% apart
What the two sides do differently

THE FLOOR NOW DOES THE JOB. It compares before it writes, so a re-send moves nothing; it keeps a frame stamp per entity position so ten writes to one entity queue it once; and it queues the entity so a frame could deliver it. Four lines. What it still does not do: record WHICH columns moved (so no field-granular subscription is possible), route to an index, or mark the collection separately from the entity. Direction: still inflates our ratio, and this is the number to quote when somebody asks what the engine costs over doing it properly by hand.

measured 2026-10-23no explanation yetupdate.column-vs-tracked-store
OursslotContentService.updateEntityColumn(slot,'title', value) — one column, no index reads it
Floorgate on !==, store, then queue the entity once per frame by a stamp kept per position
7 ns ours5 ns floor1.35×floor timed twice: 0.4% apart
What the two sides do differently

The same floor as update.column-vs-tracked-store, against the column door: no patch object and no walk over it. Both sides hand over one value per write and queue each entity at most once per frame.

measured 2026-10-23no explanation yetupdate.entity-column-vs-tracked-store
OursslotContentService.updateEntity(slot, { group }) — an OIMIndexService store slot over `group` re-files the row
Floordelete from the old Set, store the column, add to the new Set
322 ns ours94 ns floor3.42×floor timed twice: 0.3% apart
What the two sides do differently

THE INDEX IS AUTOMATIC AGAIN, SO THIS IS THE ORIGINAL QUESTION. The `OIMIndexService` store slot hears its source collection through a content-change listener: `updateEntity` marks the row, the listener reads the key the row was last filed under from the row's own `indexKeys` cell, compares it with `selectKey(entity)` and moves the slot with `removeBucketMemberSlotByKey` + `addBucketMemberSlotByKey`. The caller writes one column and nothing else. All sixty-four buckets are held before the clock, because an index files only into buckets that exist. A reading recorded under this id while the move was the caller's (`removeSlotAt` + `appendSlot` on a positional bucket collection) priced a different body and must not be quoted against this one. WHERE THE TWO SIDES ARE NOT DOING THE SAME WORK. Ours resolves BOTH buckets by key through the bucket store (two `Map.get`), as the floor resolves both `Set`s; the unordered bucket is a `Set`, so leave and join are hashes on both sides. Ours additionally reads and writes the row's index cell, holds and unholds the row from the buckets, queues both buckets for the change-close flush that marks them on the channel so a subscriber can be woken, and marks the row itself — and the flush that closes the batch is inside the timed body. The floor can be read by iterating it and by nothing else. Direction: inflates our ratio.

measured 2026-10-23no explanation yetupdate.indexed-column-vs-hand-index
OursslotContentService.updateEntity(slot, patch) with the value the row already holds
Floorrow.title = value — a store that always happens
12 ns ours2 ns floor6.49×floor timed twice: 0.0% apart
What the two sides do differently

THE TWO SIDES DO OPPOSITE THINGS, ON PURPOSE. Ours walks the patch, finds every column equal, returns before marking anything and wakes nobody; the floor stores unconditionally because it has nothing to protect. So this is not "which is faster at the same work" — it is what the comparator gate costs when it fires, against the cheapest possible thing that ignores the question. No flush closes this batch, because nothing was marked and there is nothing for a frame to deliver: that is the point of the row. Direction: inflates our ratio; what the gate buys is that a screen re-sending a server payload it already holds does not repaint.

measured 2026-10-23no explanation yetupdate.unchanged-vs-field-store
OursslotContentService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)
Floorconst row = map.get(id); if (row !== undefined) row.title = value
29 ns ours21 ns floor1.37×floor timed twice: 0.4% apart
What the two sides do differently

The column door by key: no patch object and no walk over one. Both sides pay the lookup; ours then compares the value, writes it in place and marks the entity changed once per frame.

measured 2026-10-23no explanation yetupdateByKey.column-vs-map-get-and-store
Oursconst slot = entityService.getSlotByKey(entityStoreSlot, id); slot.entity.title = value; slotContentService.markEntityChanged(slot, ['title'])
Floorconst row = map.get(id); if (row !== undefined) row.title = value
33 ns ours21 ns floor1.58×floor timed twice: 0.7% apart
What the two sides do differently

The hand-mutation door by key: the caller writes the stored entity itself and names the column it moved. Both sides pay the lookup; ours runs no comparison, and markEntityChanged, with nothing reading `title` on this fixture, takes its flat path — the channel write and releaseWrittenSlotIfUnheld — and opens no subframe.

measured 2026-10-23no explanation yetupdateByKey.in-place-and-mark-vs-map-get-and-store
OursslotContentService.updateEntity(entityService.getSlotByKey(entityStoreSlot, id), patch) — there is no update-by-key door, so the timed body is the slot lookup plus updateEntity
Floorconst row = map.get(id); if (row !== undefined) row.title = value
40 ns ours21 ns floor1.89×floor timed twice: 0.0% apart
What the two sides do differently

THE ONE WRITE ROW WHERE BOTH SIDES PAY THE LOOKUP, which is what makes it the fair comparison for a key that arrived from outside. Ours is one map read and then the identity path priced two rows up; the floor is one map read and a store. The difference between this ratio and the update.column ratio is the price of NOT having held the identity — the engine's own source puts that at 103-132 ns against 36-51 [NO RUN BEHIND THIS FIGURE], and this row is the independent check on that claim.

measured 2026-10-23no explanation yetupdateByKey.vs-map-get-and-store
OursslotContentService.upsertEntity(entityStoreSlot, row) — a key that already carries a value
Floorcopy five columns onto the stored object, one store each
119 ns ours4 ns floor33×floor timed twice: 0.0% apart
What the two sides do differently

THE FLOOR CANNOT EXPRESS ONE HALF OF WHAT UPSERT PROMISES. An upsert of an existing key also REMOVES the columns the new value does not carry, which means walking the stored row to find them; here both rows carry all five columns, so that walk finds nothing and the floor's five stores are the same net effect. Ours additionally gates each column on the default equality, so only the column that actually moved is written and reported, where the floor writes all five every time. THAT DEFAULT IS SAMEVALUEZERO AND WAS AN INLINE `===` WHEN THIS ROW WAS RECORDED: the four columns this fixture does not move settle on the first clause and cost what they cost before, and the one that moves carries one comparison this figure never saw. Direction: mixed — the gate saves us four stores and costs us five comparisons plus a moved-list allocation, and the marking and routing are ours alone. Read it beside update.column: the difference between the two is what sending a whole row costs over sending the column that changed. THE STRUCTURAL CAVEAT AT THE HEAD OF THIS REPORT RUNS BACKWARDS ON THIS ROW AND ON NO OTHER WRITE ROW. It says a Map-keyed floor pays a hash our identity path does not, which flatters us. Here it is the reverse: the floor is handed `held[i]` by its index and never looks anything up, while ours is handed a ROW and must resolve its key — `selectKey` and then the store lookup inside `writeContentByKey`, a `Map.get` over eight thousand string keys. That lookup is inside our number and outside the floor's, so this row overstates what the design costs a caller who already holds the identity. `upsert.whole-row-vs-map-get-and-five-stores` is the same measurement with the lookup on both sides; the difference between the two rows is the hash, and neither alone is the price of an upsert.

measured 2026-10-23no explanation yetupsert.whole-row-vs-five-stores
OursslotContentService.upsertEntity(entityStoreSlot, row) — a key that already carries a value
Floorwalk the stored row for columns the new one does not carry, then five stores
115 ns ours40 ns floor2.89×floor timed twice: 0.1% apart
What the two sides do differently

THE DEPARTURE WALK, PUT ON THE FLOOR, WHICH IS THE ONLY WAY THIS HARNESS CAN PRICE AN OPERATION THAT NEITHER ARM OF AN EXISTING ROW ISOLATES. `upsert.whole-row-vs-five-stores` charges our side a walk of the STORED row's own names, with a `hasOwnProperty` probe of the caller's row per name, and its floor makes neither — so the walk sits inside that row's residual with the marking, the routing and four extra columns of comparison, and nothing separates it from them. Here the floor makes the identical walk, to the line of `OIMSlotContentEntityService.writeEntity`, and stores five columns after it. THE ITEM IS THE DIFFERENCE BETWEEN THIS ROW'S GAP AND THAT ROW'S GAP, and nothing else about either arm changes. OUR ARM IS THAT ROW'S ARM TO THE CHARACTER — the same fixture, the same two whole-row variants alternating so `title` moves on every row of every pass, the same flush per eight thousand writes, the same absence of an index, a subscriber and a projection. So the two rows' `ours` columns should agree to within the between-pair disagreement of this piece, and a run where they do not is a run that has said something about the machine rather than about the walk. OPERATION COUNT, THE DIFFERENCE ONLY: one `for…in` over the five names the stored row carries, five `hasOwnProperty` probes of a five-property row, and one `??=` test that never fires — both rows of this fixture carry all five columns, so nothing ever leaves and no array is allocated on either arm. That is the walk at its CHEAPEST: it finds nothing, which is what a server re-sending whole rows always makes it do, and it is the case an upsert being a whole-row replace is charged for. A payload that genuinely drops a column would add a push, a `deleteColumns` call and an `undefined` write per departing name to our side and a `delete` to the floor. WHAT THIS ROW IS NOT. It is not a merge-versus-replace comparison — the floor here is not the rejected design, it is the shipped design with one item lifted out of it and set beside a hand-written store. The rejected design is `upsertEntity` WITHOUT the walk, which is `upsert.whole-row-vs-five-stores` with a floor that does less, and no row in this suite is that. Read this one as the price of the item, not as a verdict on the consequence.

measured 2026-10-23no explanation yetupsert.whole-row-vs-five-stores-and-a-departure-walk
OursslotContentService.upsertEntity(entityStoreSlot, row) — a key that already carries a value
Floorconst stored = map.get(row.id); then copy five columns onto it
113 ns ours24 ns floor4.81×floor timed twice: 1.4% apart
What the two sides do differently

THE ROW ABOVE, WITH THE LOOKUP PUT BACK ON THE FLOOR. `upsertEntity` is handed a ROW and not an identity, so it calls `selectKey` and then `writeContentByKey` — a `Map.get` over eight thousand string keys — before it can write anything. The floor of `upsert.whole-row-vs-five-stores` is handed `held[i]` by its loop index and never looks anything up, which makes that row the one write row in this suite where the hash falls on OUR side. Here the floor resolves the same key through its own `Map` first, so both sides pay one hash and the row is what a person doing this job by hand would actually have written. OUR SIDE IS THE SAME BODY AS THE ROW ABOVE, deliberately and to the line: the same fixture, the same two whole-row variants alternating so the title moves on every row of every pass, the same flush per eight thousand writes. Nothing about our arm differs, so the two rows' `ours` columns should agree to within the between-pair disagreement of this piece, and the difference between the two FLOORS is one `Map.get` and one `undefined` test. READ THE PAIR OF ROWS, NOT EITHER ONE: the row above prices an upsert against a floor that already knows where the row is, this one against a floor that has to find out, and a caller sits at one or the other depending on whether the write came from a socket payload or from something they were holding. WHAT IS STILL NOT EQUAL. The floor's five stores are unconditional where ours gates each column on the default equality — SameValueZero — and writes the one that moved; ours walks the stored row for columns the new value does not carry (here it finds none, so the net effect matches); and the marking, the presence of a `columnSlotStoreService.get` probe per moved column and the frame that closes the batch are ours alone. All three are stated on the row above and are unchanged by moving the lookup — this row changes exactly one thing about that comparison, which is the point of it.

measured 2026-10-23no explanation yetupsert.whole-row-vs-map-get-and-five-stores

Published 2026-10-23T11:06:57.973Z.

Per entity per write​

Paid for every entity a write touches. This is the hottest path there is.

OursOIMChannelService.openSubframe(defaultChannelSlot); slotContentService.addBucketMemberSlot(bucketService.getSlotByKey(bucketStoreSlot, key), entitySlot) for 64 adds, one to each of 64 buckets, in one outer subframe; OIMChannelService.closeSubframe(defaultChannelSlot); then slotContentService.clearBucketMemberSlots(bucketSlot) per bucket
Floorthe same adds into a Set per bucket found by Map.get, each landed add stamped when the bucket is held, settled; a release check per bucket at the close; then every bucket cleared, stamped, settled and checked the same way
115 ns ours51 ns floor2.25×floor timed twice: 0.6% apart
What the two sides do differently

Each add of a pass goes to a DIFFERENT bucket inside one outer subframe opened on the channel, so every bucket takes exactly one add and there is nothing to coalesce; the id names how many buckets. No content-change listener. The bucket is HELD through bucketService.holdSlotByKey and carries no effect, so the channel-slot write takes its no-dependent path. With a hold and no content-change listener the shipped door takes its immediate path on every add: it writes the bucket to the channel, settles it and calls dispatchContentChange, which finds no listener; nothing is pushed for the close and no release check runs there, nor after the clear, which takes the same immediate path. The floor stamps and settles on every add too, so per add the two sides do the same observable work; the floor alone runs a release check per bucket at the close and after each clear, which returns at its hold count and pushes the ratio down by those tests. One operation is one member add. Both sides open one outer subframe per pass (ours through OIMChannelService.openSubframe and closeSubframe on the default channel slot), find each bucket by key (ours bucketService.getSlotByKey, a store get plus an undefined test, followed by the public slotContentService.addBucketMemberSlot — there is no by-key add door now, so the lookup and the add are two calls here; the floor Map.get), add the member to a Set, and after the close empty every bucket of the pass, ours through slotContentService.clearBucketMemberSlots: the clear is timed on both sides alike and carries its own stamp, settle, announce and release check. Ours additionally, per add, asserts that the channel is not flushing and that neither slot is released, opens and closes the owner's and the channel's subframe, holds the member slot and records the append on the no-op command recorder; per clear it copies the members into a fresh array, gives back each member's hold and runs each member's release check. The floor keeps plain objects and holds nothing. All of that pushes the ratio up, against ours. No flush runs inside a pass: the channel has no scheduler and the bucket no effect, so nothing asks for a frame and the clock only advances. The bucket collection is built with OIMSlotReleasePolicyNever and the floor's release check mirrors it, keeping an empty bucket: under the default policy an unheld bucket emptied by the per-pass clear is released and unfiled, and the next pass's adds would find no bucket and land nowhere. The release check is therefore priced as its tests, never as a release.

measured 2026-10-23no explanation yetbucket-adds.held.64-buckets-one-add-each
OursOIMChannelService.openSubframe(defaultChannelSlot); slotContentService.addBucketMemberSlot(bucketService.getSlotByKey(bucketStoreSlot, key), entitySlot) for 8 adds, one to each of 8 buckets, in one outer subframe; OIMChannelService.closeSubframe(defaultChannelSlot); then slotContentService.clearBucketMemberSlots(bucketSlot) per bucket
Floorthe same adds into a Set per bucket found by Map.get, each landed add stamped when the bucket is held, settled; a release check per bucket at the close; then every bucket cleared, stamped, settled and checked the same way
122 ns ours50 ns floor2.43×floor timed twice: 0.9% apart
What the two sides do differently

Each add of a pass goes to a DIFFERENT bucket inside one outer subframe opened on the channel, so every bucket takes exactly one add and there is nothing to coalesce; the id names how many buckets. No content-change listener. The bucket is HELD through bucketService.holdSlotByKey and carries no effect, so the channel-slot write takes its no-dependent path. With a hold and no content-change listener the shipped door takes its immediate path on every add: it writes the bucket to the channel, settles it and calls dispatchContentChange, which finds no listener; nothing is pushed for the close and no release check runs there, nor after the clear, which takes the same immediate path. The floor stamps and settles on every add too, so per add the two sides do the same observable work; the floor alone runs a release check per bucket at the close and after each clear, which returns at its hold count and pushes the ratio down by those tests. One operation is one member add. Both sides open one outer subframe per pass (ours through OIMChannelService.openSubframe and closeSubframe on the default channel slot), find each bucket by key (ours bucketService.getSlotByKey, a store get plus an undefined test, followed by the public slotContentService.addBucketMemberSlot — there is no by-key add door now, so the lookup and the add are two calls here; the floor Map.get), add the member to a Set, and after the close empty every bucket of the pass, ours through slotContentService.clearBucketMemberSlots: the clear is timed on both sides alike and carries its own stamp, settle, announce and release check. Ours additionally, per add, asserts that the channel is not flushing and that neither slot is released, opens and closes the owner's and the channel's subframe, holds the member slot and records the append on the no-op command recorder; per clear it copies the members into a fresh array, gives back each member's hold and runs each member's release check. The floor keeps plain objects and holds nothing. All of that pushes the ratio up, against ours. No flush runs inside a pass: the channel has no scheduler and the bucket no effect, so nothing asks for a frame and the clock only advances. The bucket collection is built with OIMSlotReleasePolicyNever and the floor's release check mirrors it, keeping an empty bucket: under the default policy an unheld bucket emptied by the per-pass clear is released and unfiled, and the next pass's adds would find no bucket and land nowhere. The release check is therefore priced as its tests, never as a release.

measured 2026-10-23no explanation yetbucket-adds.held.8-buckets-one-add-each
OursOIMChannelService.openSubframe(defaultChannelSlot); slotContentService.addBucketMemberSlot(bucketService.getSlotByKey(bucketStoreSlot, key), entitySlot) for 1 adds to one bucket in one outer subframe; OIMChannelService.closeSubframe(defaultChannelSlot); then slotContentService.clearBucketMemberSlots(bucketSlot) per bucket
Floorthe same adds into a Set per bucket found by Map.get, each landed add stamped when the bucket is held, settled; a release check per bucket at the close; then every bucket cleared, stamped, settled and checked the same way
125 ns ours50 ns floor2.51×floor timed twice: 0.3% apart
What the two sides do differently

Every add of a pass goes to ONE bucket inside one outer subframe opened on the channel; the id names how many adds a pass makes. No content-change listener. The bucket is HELD through bucketService.holdSlotByKey and carries no effect, so the channel-slot write takes its no-dependent path. With a hold and no content-change listener the shipped door takes its immediate path on every add: it writes the bucket to the channel, settles it and calls dispatchContentChange, which finds no listener; nothing is pushed for the close and no release check runs there, nor after the clear, which takes the same immediate path. The floor stamps and settles on every add too, so per add the two sides do the same observable work; the floor alone runs a release check per bucket at the close and after each clear, which returns at its hold count and pushes the ratio down by those tests. One operation is one member add. Both sides open one outer subframe per pass (ours through OIMChannelService.openSubframe and closeSubframe on the default channel slot), find each bucket by key (ours bucketService.getSlotByKey, a store get plus an undefined test, followed by the public slotContentService.addBucketMemberSlot — there is no by-key add door now, so the lookup and the add are two calls here; the floor Map.get), add the member to a Set, and after the close empty every bucket of the pass, ours through slotContentService.clearBucketMemberSlots: the clear is timed on both sides alike and carries its own stamp, settle, announce and release check. Ours additionally, per add, asserts that the channel is not flushing and that neither slot is released, opens and closes the owner's and the channel's subframe, holds the member slot and records the append on the no-op command recorder; per clear it copies the members into a fresh array, gives back each member's hold and runs each member's release check. The floor keeps plain objects and holds nothing. All of that pushes the ratio up, against ours. No flush runs inside a pass: the channel has no scheduler and the bucket no effect, so nothing asks for a frame and the clock only advances. The bucket collection is built with OIMSlotReleasePolicyNever and the floor's release check mirrors it, keeping an empty bucket: under the default policy an unheld bucket emptied by the per-pass clear is released and unfiled, and the next pass's adds would find no bucket and land nowhere. The release check is therefore priced as its tests, never as a release.

measured 2026-10-23no explanation yetbucket-adds.held.one-bucket-1-adds
OursOIMChannelService.openSubframe(defaultChannelSlot); slotContentService.addBucketMemberSlot(bucketService.getSlotByKey(bucketStoreSlot, key), entitySlot) for 1 adds to one bucket in one outer subframe, one content-change listener; OIMChannelService.closeSubframe(defaultChannelSlot); then slotContentService.clearBucketMemberSlots(bucketSlot) per bucket
Floorthe same adds into a Set per bucket found by Map.get, each landed add stamped when the bucket is held, settled and announced to the listener; a release check per bucket at the close; then every bucket cleared, stamped, settled and checked the same way
213 ns ours53 ns floor4.03×floor timed twice: 0.5% apart
What the two sides do differently

Every add of a pass goes to ONE bucket inside one outer subframe opened on the channel, with one content-change listener added through OIMContentChangeListenerService.INSTANCE.addContentChangeListener(bucketStoreSlot, …); the id names how many adds a pass makes. The bucket is HELD through bucketService.holdSlotByKey and carries no effect, so the channel-slot write takes its no-dependent path. With a content-change listener the shipped door takes its batch path whether or not the bucket is held: the first add of a pass writes, settles and announces the bucket (the announce is buffered by the door's own subframe and delivered at its close) and pushes the bucket once for the outermost close; every later add only flags it; the outermost close writes, settles and announces it once more and runs its release check. The listener therefore hears a bucket at most twice per pass, where the floor stamps, settles and announces on every add. Whenever a bucket takes more than one add in a pass the floor does more work than ours, and that pushes the ratio down, in our favour, the more so the more adds a bucket takes. One operation is one member add. Both sides open one outer subframe per pass (ours through OIMChannelService.openSubframe and closeSubframe on the default channel slot), find each bucket by key (ours bucketService.getSlotByKey, a store get plus an undefined test, followed by the public slotContentService.addBucketMemberSlot — there is no by-key add door now, so the lookup and the add are two calls here; the floor Map.get), add the member to a Set, and after the close empty every bucket of the pass, ours through slotContentService.clearBucketMemberSlots: the clear is timed on both sides alike and carries its own stamp, settle, announce and release check. Ours additionally, per add, asserts that the channel is not flushing and that neither slot is released, opens and closes the owner's and the channel's subframe, holds the member slot and records the append on the no-op command recorder; per clear it copies the members into a fresh array, gives back each member's hold and runs each member's release check. The floor keeps plain objects and holds nothing. All of that pushes the ratio up, against ours. No flush runs inside a pass: the channel has no scheduler and the bucket no effect, so nothing asks for a frame and the clock only advances. The bucket collection is built with OIMSlotReleasePolicyNever and the floor's release check mirrors it, keeping an empty bucket: under the default policy an unheld bucket emptied by the per-pass clear is released and unfiled, and the next pass's adds would find no bucket and land nowhere. The release check is therefore priced as its tests, never as a release.

measured 2026-10-23no explanation yetbucket-adds.held.one-bucket-1-adds-with-a-listener
OursOIMChannelService.openSubframe(defaultChannelSlot); slotContentService.addBucketMemberSlot(bucketService.getSlotByKey(bucketStoreSlot, key), entitySlot) for 64 adds to one bucket in one outer subframe; OIMChannelService.closeSubframe(defaultChannelSlot); then slotContentService.clearBucketMemberSlots(bucketSlot) per bucket
Floorthe same adds into a Set per bucket found by Map.get, each landed add stamped when the bucket is held, settled; a release check per bucket at the close; then every bucket cleared, stamped, settled and checked the same way
68 ns ours32 ns floor2.12×floor timed twice: 0.0% apart
What the two sides do differently

Every add of a pass goes to ONE bucket inside one outer subframe opened on the channel; the id names how many adds a pass makes. No content-change listener. The bucket is HELD through bucketService.holdSlotByKey and carries no effect, so the channel-slot write takes its no-dependent path. With a hold and no content-change listener the shipped door takes its immediate path on every add: it writes the bucket to the channel, settles it and calls dispatchContentChange, which finds no listener; nothing is pushed for the close and no release check runs there, nor after the clear, which takes the same immediate path. The floor stamps and settles on every add too, so per add the two sides do the same observable work; the floor alone runs a release check per bucket at the close and after each clear, which returns at its hold count and pushes the ratio down by those tests. One operation is one member add. Both sides open one outer subframe per pass (ours through OIMChannelService.openSubframe and closeSubframe on the default channel slot), find each bucket by key (ours bucketService.getSlotByKey, a store get plus an undefined test, followed by the public slotContentService.addBucketMemberSlot — there is no by-key add door now, so the lookup and the add are two calls here; the floor Map.get), add the member to a Set, and after the close empty every bucket of the pass, ours through slotContentService.clearBucketMemberSlots: the clear is timed on both sides alike and carries its own stamp, settle, announce and release check. Ours additionally, per add, asserts that the channel is not flushing and that neither slot is released, opens and closes the owner's and the channel's subframe, holds the member slot and records the append on the no-op command recorder; per clear it copies the members into a fresh array, gives back each member's hold and runs each member's release check. The floor keeps plain objects and holds nothing. All of that pushes the ratio up, against ours. No flush runs inside a pass: the channel has no scheduler and the bucket no effect, so nothing asks for a frame and the clock only advances. The bucket collection is built with OIMSlotReleasePolicyNever and the floor's release check mirrors it, keeping an empty bucket: under the default policy an unheld bucket emptied by the per-pass clear is released and unfiled, and the next pass's adds would find no bucket and land nowhere. The release check is therefore priced as its tests, never as a release.

measured 2026-10-23no explanation yetbucket-adds.held.one-bucket-64-adds
OursOIMChannelService.openSubframe(defaultChannelSlot); slotContentService.addBucketMemberSlot(bucketService.getSlotByKey(bucketStoreSlot, key), entitySlot) for 64 adds to one bucket in one outer subframe, one content-change listener; OIMChannelService.closeSubframe(defaultChannelSlot); then slotContentService.clearBucketMemberSlots(bucketSlot) per bucket
Floorthe same adds into a Set per bucket found by Map.get, each landed add stamped when the bucket is held, settled and announced to the listener; a release check per bucket at the close; then every bucket cleared, stamped, settled and checked the same way
59 ns ours35 ns floor1.70×floor timed twice: 3.1% apart
What the two sides do differently

Every add of a pass goes to ONE bucket inside one outer subframe opened on the channel, with one content-change listener added through OIMContentChangeListenerService.INSTANCE.addContentChangeListener(bucketStoreSlot, …); the id names how many adds a pass makes. The bucket is HELD through bucketService.holdSlotByKey and carries no effect, so the channel-slot write takes its no-dependent path. With a content-change listener the shipped door takes its batch path whether or not the bucket is held: the first add of a pass writes, settles and announces the bucket (the announce is buffered by the door's own subframe and delivered at its close) and pushes the bucket once for the outermost close; every later add only flags it; the outermost close writes, settles and announces it once more and runs its release check. The listener therefore hears a bucket at most twice per pass, where the floor stamps, settles and announces on every add. Whenever a bucket takes more than one add in a pass the floor does more work than ours, and that pushes the ratio down, in our favour, the more so the more adds a bucket takes. One operation is one member add. Both sides open one outer subframe per pass (ours through OIMChannelService.openSubframe and closeSubframe on the default channel slot), find each bucket by key (ours bucketService.getSlotByKey, a store get plus an undefined test, followed by the public slotContentService.addBucketMemberSlot — there is no by-key add door now, so the lookup and the add are two calls here; the floor Map.get), add the member to a Set, and after the close empty every bucket of the pass, ours through slotContentService.clearBucketMemberSlots: the clear is timed on both sides alike and carries its own stamp, settle, announce and release check. Ours additionally, per add, asserts that the channel is not flushing and that neither slot is released, opens and closes the owner's and the channel's subframe, holds the member slot and records the append on the no-op command recorder; per clear it copies the members into a fresh array, gives back each member's hold and runs each member's release check. The floor keeps plain objects and holds nothing. All of that pushes the ratio up, against ours. No flush runs inside a pass: the channel has no scheduler and the bucket no effect, so nothing asks for a frame and the clock only advances. The bucket collection is built with OIMSlotReleasePolicyNever and the floor's release check mirrors it, keeping an empty bucket: under the default policy an unheld bucket emptied by the per-pass clear is released and unfiled, and the next pass's adds would find no bucket and land nowhere. The release check is therefore priced as its tests, never as a release.

measured 2026-10-23no explanation yetbucket-adds.held.one-bucket-64-adds-with-a-listener
OursOIMChannelService.openSubframe(defaultChannelSlot); slotContentService.addBucketMemberSlot(bucketService.getSlotByKey(bucketStoreSlot, key), entitySlot) for 8 adds to one bucket in one outer subframe; OIMChannelService.closeSubframe(defaultChannelSlot); then slotContentService.clearBucketMemberSlots(bucketSlot) per bucket
Floorthe same adds into a Set per bucket found by Map.get, each landed add stamped when the bucket is held, settled; a release check per bucket at the close; then every bucket cleared, stamped, settled and checked the same way
62 ns ours29 ns floor2.16×floor timed twice: 0.3% apart
What the two sides do differently

Every add of a pass goes to ONE bucket inside one outer subframe opened on the channel; the id names how many adds a pass makes. No content-change listener. The bucket is HELD through bucketService.holdSlotByKey and carries no effect, so the channel-slot write takes its no-dependent path. With a hold and no content-change listener the shipped door takes its immediate path on every add: it writes the bucket to the channel, settles it and calls dispatchContentChange, which finds no listener; nothing is pushed for the close and no release check runs there, nor after the clear, which takes the same immediate path. The floor stamps and settles on every add too, so per add the two sides do the same observable work; the floor alone runs a release check per bucket at the close and after each clear, which returns at its hold count and pushes the ratio down by those tests. One operation is one member add. Both sides open one outer subframe per pass (ours through OIMChannelService.openSubframe and closeSubframe on the default channel slot), find each bucket by key (ours bucketService.getSlotByKey, a store get plus an undefined test, followed by the public slotContentService.addBucketMemberSlot — there is no by-key add door now, so the lookup and the add are two calls here; the floor Map.get), add the member to a Set, and after the close empty every bucket of the pass, ours through slotContentService.clearBucketMemberSlots: the clear is timed on both sides alike and carries its own stamp, settle, announce and release check. Ours additionally, per add, asserts that the channel is not flushing and that neither slot is released, opens and closes the owner's and the channel's subframe, holds the member slot and records the append on the no-op command recorder; per clear it copies the members into a fresh array, gives back each member's hold and runs each member's release check. The floor keeps plain objects and holds nothing. All of that pushes the ratio up, against ours. No flush runs inside a pass: the channel has no scheduler and the bucket no effect, so nothing asks for a frame and the clock only advances. The bucket collection is built with OIMSlotReleasePolicyNever and the floor's release check mirrors it, keeping an empty bucket: under the default policy an unheld bucket emptied by the per-pass clear is released and unfiled, and the next pass's adds would find no bucket and land nowhere. The release check is therefore priced as its tests, never as a release.

measured 2026-10-23no explanation yetbucket-adds.held.one-bucket-8-adds
OursOIMChannelService.openSubframe(defaultChannelSlot); slotContentService.addBucketMemberSlot(bucketService.getSlotByKey(bucketStoreSlot, key), entitySlot) for 8 adds to one bucket in one outer subframe, one content-change listener; OIMChannelService.closeSubframe(defaultChannelSlot); then slotContentService.clearBucketMemberSlots(bucketSlot) per bucket
Floorthe same adds into a Set per bucket found by Map.get, each landed add stamped when the bucket is held, settled and announced to the listener; a release check per bucket at the close; then every bucket cleared, stamped, settled and checked the same way
73 ns ours31 ns floor2.34×floor timed twice: 1.9% apart
What the two sides do differently

Every add of a pass goes to ONE bucket inside one outer subframe opened on the channel, with one content-change listener added through OIMContentChangeListenerService.INSTANCE.addContentChangeListener(bucketStoreSlot, …); the id names how many adds a pass makes. The bucket is HELD through bucketService.holdSlotByKey and carries no effect, so the channel-slot write takes its no-dependent path. With a content-change listener the shipped door takes its batch path whether or not the bucket is held: the first add of a pass writes, settles and announces the bucket (the announce is buffered by the door's own subframe and delivered at its close) and pushes the bucket once for the outermost close; every later add only flags it; the outermost close writes, settles and announces it once more and runs its release check. The listener therefore hears a bucket at most twice per pass, where the floor stamps, settles and announces on every add. Whenever a bucket takes more than one add in a pass the floor does more work than ours, and that pushes the ratio down, in our favour, the more so the more adds a bucket takes. One operation is one member add. Both sides open one outer subframe per pass (ours through OIMChannelService.openSubframe and closeSubframe on the default channel slot), find each bucket by key (ours bucketService.getSlotByKey, a store get plus an undefined test, followed by the public slotContentService.addBucketMemberSlot — there is no by-key add door now, so the lookup and the add are two calls here; the floor Map.get), add the member to a Set, and after the close empty every bucket of the pass, ours through slotContentService.clearBucketMemberSlots: the clear is timed on both sides alike and carries its own stamp, settle, announce and release check. Ours additionally, per add, asserts that the channel is not flushing and that neither slot is released, opens and closes the owner's and the channel's subframe, holds the member slot and records the append on the no-op command recorder; per clear it copies the members into a fresh array, gives back each member's hold and runs each member's release check. The floor keeps plain objects and holds nothing. All of that pushes the ratio up, against ours. No flush runs inside a pass: the channel has no scheduler and the bucket no effect, so nothing asks for a frame and the clock only advances. The bucket collection is built with OIMSlotReleasePolicyNever and the floor's release check mirrors it, keeping an empty bucket: under the default policy an unheld bucket emptied by the per-pass clear is released and unfiled, and the next pass's adds would find no bucket and land nowhere. The release check is therefore priced as its tests, never as a release.

measured 2026-10-23no explanation yetbucket-adds.held.one-bucket-8-adds-with-a-listener
OursOIMChannelService.openSubframe(defaultChannelSlot); slotContentService.addBucketMemberSlot(bucketService.getSlotByKey(bucketStoreSlot, key), entitySlot) for 64 adds, one to each of 64 buckets, in one outer subframe; OIMChannelService.closeSubframe(defaultChannelSlot); then slotContentService.clearBucketMemberSlots(bucketSlot) per bucket
Floorthe same adds into a Set per bucket found by Map.get, each landed add stamped when the bucket is held, settled; a release check per bucket at the close; then every bucket cleared, stamped, settled and checked the same way
133 ns ours53 ns floor2.51×floor timed twice: 0.5% apart
What the two sides do differently

Each add of a pass goes to a DIFFERENT bucket inside one outer subframe opened on the channel, so every bucket takes exactly one add and there is nothing to coalesce; the id names how many buckets. No content-change listener. NOTHING HOLDS the bucket: it is minted through holdSlotByKey and given back through bucketSlot.owner.unholdSlot at build. The channel write door returns at once for an unheld slot, so ours stamps nothing, and the floor guards its stamp by the same hold count and stamps nothing either. With no listener and no hold the shipped door settles the first add of a pass at once and pushes the bucket once for the outermost close; every later add only flags it; the close settles it once more and runs its release check. The floor settles on every add and runs the release check for every bucket at the close. Whenever a bucket takes more than one add in a pass the floor does more settles than ours, which pushes the ratio down, in our favour. One operation is one member add. Both sides open one outer subframe per pass (ours through OIMChannelService.openSubframe and closeSubframe on the default channel slot), find each bucket by key (ours bucketService.getSlotByKey, a store get plus an undefined test, followed by the public slotContentService.addBucketMemberSlot — there is no by-key add door now, so the lookup and the add are two calls here; the floor Map.get), add the member to a Set, and after the close empty every bucket of the pass, ours through slotContentService.clearBucketMemberSlots: the clear is timed on both sides alike and carries its own stamp, settle, announce and release check. Ours additionally, per add, asserts that the channel is not flushing and that neither slot is released, opens and closes the owner's and the channel's subframe, holds the member slot and records the append on the no-op command recorder; per clear it copies the members into a fresh array, gives back each member's hold and runs each member's release check. The floor keeps plain objects and holds nothing. All of that pushes the ratio up, against ours. No flush runs inside a pass: the channel has no scheduler and the bucket no effect, so nothing asks for a frame and the clock only advances. The bucket collection is built with OIMSlotReleasePolicyNever and the floor's release check mirrors it, keeping an empty bucket: under the default policy an unheld bucket emptied by the per-pass clear is released and unfiled, and the next pass's adds would find no bucket and land nowhere. The release check is therefore priced as its tests, never as a release.

measured 2026-10-23no explanation yetbucket-adds.unheld.64-buckets-one-add-each
OursOIMChannelService.openSubframe(defaultChannelSlot); slotContentService.addBucketMemberSlot(bucketService.getSlotByKey(bucketStoreSlot, key), entitySlot) for 8 adds, one to each of 8 buckets, in one outer subframe; OIMChannelService.closeSubframe(defaultChannelSlot); then slotContentService.clearBucketMemberSlots(bucketSlot) per bucket
Floorthe same adds into a Set per bucket found by Map.get, each landed add stamped when the bucket is held, settled; a release check per bucket at the close; then every bucket cleared, stamped, settled and checked the same way
133 ns ours49 ns floor2.72×floor timed twice: 0.2% apart
What the two sides do differently

Each add of a pass goes to a DIFFERENT bucket inside one outer subframe opened on the channel, so every bucket takes exactly one add and there is nothing to coalesce; the id names how many buckets. No content-change listener. NOTHING HOLDS the bucket: it is minted through holdSlotByKey and given back through bucketSlot.owner.unholdSlot at build. The channel write door returns at once for an unheld slot, so ours stamps nothing, and the floor guards its stamp by the same hold count and stamps nothing either. With no listener and no hold the shipped door settles the first add of a pass at once and pushes the bucket once for the outermost close; every later add only flags it; the close settles it once more and runs its release check. The floor settles on every add and runs the release check for every bucket at the close. Whenever a bucket takes more than one add in a pass the floor does more settles than ours, which pushes the ratio down, in our favour. One operation is one member add. Both sides open one outer subframe per pass (ours through OIMChannelService.openSubframe and closeSubframe on the default channel slot), find each bucket by key (ours bucketService.getSlotByKey, a store get plus an undefined test, followed by the public slotContentService.addBucketMemberSlot — there is no by-key add door now, so the lookup and the add are two calls here; the floor Map.get), add the member to a Set, and after the close empty every bucket of the pass, ours through slotContentService.clearBucketMemberSlots: the clear is timed on both sides alike and carries its own stamp, settle, announce and release check. Ours additionally, per add, asserts that the channel is not flushing and that neither slot is released, opens and closes the owner's and the channel's subframe, holds the member slot and records the append on the no-op command recorder; per clear it copies the members into a fresh array, gives back each member's hold and runs each member's release check. The floor keeps plain objects and holds nothing. All of that pushes the ratio up, against ours. No flush runs inside a pass: the channel has no scheduler and the bucket no effect, so nothing asks for a frame and the clock only advances. The bucket collection is built with OIMSlotReleasePolicyNever and the floor's release check mirrors it, keeping an empty bucket: under the default policy an unheld bucket emptied by the per-pass clear is released and unfiled, and the next pass's adds would find no bucket and land nowhere. The release check is therefore priced as its tests, never as a release.

measured 2026-10-23no explanation yetbucket-adds.unheld.8-buckets-one-add-each
OursOIMChannelService.openSubframe(defaultChannelSlot); slotContentService.addBucketMemberSlot(bucketService.getSlotByKey(bucketStoreSlot, key), entitySlot) for 1 adds to one bucket in one outer subframe; OIMChannelService.closeSubframe(defaultChannelSlot); then slotContentService.clearBucketMemberSlots(bucketSlot) per bucket
Floorthe same adds into a Set per bucket found by Map.get, each landed add stamped when the bucket is held, settled; a release check per bucket at the close; then every bucket cleared, stamped, settled and checked the same way
143 ns ours49 ns floor2.93×floor timed twice: 0.1% apart
What the two sides do differently

Every add of a pass goes to ONE bucket inside one outer subframe opened on the channel; the id names how many adds a pass makes. No content-change listener. NOTHING HOLDS the bucket: it is minted through holdSlotByKey and given back through bucketSlot.owner.unholdSlot at build. The channel write door returns at once for an unheld slot, so ours stamps nothing, and the floor guards its stamp by the same hold count and stamps nothing either. With no listener and no hold the shipped door settles the first add of a pass at once and pushes the bucket once for the outermost close; every later add only flags it; the close settles it once more and runs its release check. The floor settles on every add and runs the release check for every bucket at the close. Whenever a bucket takes more than one add in a pass the floor does more settles than ours, which pushes the ratio down, in our favour. One operation is one member add. Both sides open one outer subframe per pass (ours through OIMChannelService.openSubframe and closeSubframe on the default channel slot), find each bucket by key (ours bucketService.getSlotByKey, a store get plus an undefined test, followed by the public slotContentService.addBucketMemberSlot — there is no by-key add door now, so the lookup and the add are two calls here; the floor Map.get), add the member to a Set, and after the close empty every bucket of the pass, ours through slotContentService.clearBucketMemberSlots: the clear is timed on both sides alike and carries its own stamp, settle, announce and release check. Ours additionally, per add, asserts that the channel is not flushing and that neither slot is released, opens and closes the owner's and the channel's subframe, holds the member slot and records the append on the no-op command recorder; per clear it copies the members into a fresh array, gives back each member's hold and runs each member's release check. The floor keeps plain objects and holds nothing. All of that pushes the ratio up, against ours. No flush runs inside a pass: the channel has no scheduler and the bucket no effect, so nothing asks for a frame and the clock only advances. The bucket collection is built with OIMSlotReleasePolicyNever and the floor's release check mirrors it, keeping an empty bucket: under the default policy an unheld bucket emptied by the per-pass clear is released and unfiled, and the next pass's adds would find no bucket and land nowhere. The release check is therefore priced as its tests, never as a release.

measured 2026-10-23no explanation yetbucket-adds.unheld.one-bucket-1-adds
OursOIMChannelService.openSubframe(defaultChannelSlot); slotContentService.addBucketMemberSlot(bucketService.getSlotByKey(bucketStoreSlot, key), entitySlot) for 1 adds to one bucket in one outer subframe, one content-change listener; OIMChannelService.closeSubframe(defaultChannelSlot); then slotContentService.clearBucketMemberSlots(bucketSlot) per bucket
Floorthe same adds into a Set per bucket found by Map.get, each landed add stamped when the bucket is held, settled and announced to the listener; a release check per bucket at the close; then every bucket cleared, stamped, settled and checked the same way
230 ns ours52 ns floor4.44×floor timed twice: 0.7% apart
What the two sides do differently

Every add of a pass goes to ONE bucket inside one outer subframe opened on the channel, with one content-change listener added through OIMContentChangeListenerService.INSTANCE.addContentChangeListener(bucketStoreSlot, …); the id names how many adds a pass makes. NOTHING HOLDS the bucket: it is minted through holdSlotByKey and given back through bucketSlot.owner.unholdSlot at build. The channel write door returns at once for an unheld slot, so ours stamps nothing, and the floor guards its stamp by the same hold count and stamps nothing either. With a content-change listener the shipped door takes its batch path whether or not the bucket is held: the first add of a pass writes, settles and announces the bucket (the announce is buffered by the door's own subframe and delivered at its close) and pushes the bucket once for the outermost close; every later add only flags it; the outermost close writes, settles and announces it once more and runs its release check. The listener therefore hears a bucket at most twice per pass, where the floor stamps, settles and announces on every add. Whenever a bucket takes more than one add in a pass the floor does more work than ours, and that pushes the ratio down, in our favour, the more so the more adds a bucket takes. One operation is one member add. Both sides open one outer subframe per pass (ours through OIMChannelService.openSubframe and closeSubframe on the default channel slot), find each bucket by key (ours bucketService.getSlotByKey, a store get plus an undefined test, followed by the public slotContentService.addBucketMemberSlot — there is no by-key add door now, so the lookup and the add are two calls here; the floor Map.get), add the member to a Set, and after the close empty every bucket of the pass, ours through slotContentService.clearBucketMemberSlots: the clear is timed on both sides alike and carries its own stamp, settle, announce and release check. Ours additionally, per add, asserts that the channel is not flushing and that neither slot is released, opens and closes the owner's and the channel's subframe, holds the member slot and records the append on the no-op command recorder; per clear it copies the members into a fresh array, gives back each member's hold and runs each member's release check. The floor keeps plain objects and holds nothing. All of that pushes the ratio up, against ours. No flush runs inside a pass: the channel has no scheduler and the bucket no effect, so nothing asks for a frame and the clock only advances. The bucket collection is built with OIMSlotReleasePolicyNever and the floor's release check mirrors it, keeping an empty bucket: under the default policy an unheld bucket emptied by the per-pass clear is released and unfiled, and the next pass's adds would find no bucket and land nowhere. The release check is therefore priced as its tests, never as a release.

measured 2026-10-23no explanation yetbucket-adds.unheld.one-bucket-1-adds-with-a-listener
OursOIMChannelService.openSubframe(defaultChannelSlot); slotContentService.addBucketMemberSlot(bucketService.getSlotByKey(bucketStoreSlot, key), entitySlot) for 64 adds to one bucket in one outer subframe; OIMChannelService.closeSubframe(defaultChannelSlot); then slotContentService.clearBucketMemberSlots(bucketSlot) per bucket
Floorthe same adds into a Set per bucket found by Map.get, each landed add stamped when the bucket is held, settled; a release check per bucket at the close; then every bucket cleared, stamped, settled and checked the same way
57 ns ours30 ns floor1.91×floor timed twice: 0.1% apart
What the two sides do differently

Every add of a pass goes to ONE bucket inside one outer subframe opened on the channel; the id names how many adds a pass makes. No content-change listener. NOTHING HOLDS the bucket: it is minted through holdSlotByKey and given back through bucketSlot.owner.unholdSlot at build. The channel write door returns at once for an unheld slot, so ours stamps nothing, and the floor guards its stamp by the same hold count and stamps nothing either. With no listener and no hold the shipped door settles the first add of a pass at once and pushes the bucket once for the outermost close; every later add only flags it; the close settles it once more and runs its release check. The floor settles on every add and runs the release check for every bucket at the close. Whenever a bucket takes more than one add in a pass the floor does more settles than ours, which pushes the ratio down, in our favour. One operation is one member add. Both sides open one outer subframe per pass (ours through OIMChannelService.openSubframe and closeSubframe on the default channel slot), find each bucket by key (ours bucketService.getSlotByKey, a store get plus an undefined test, followed by the public slotContentService.addBucketMemberSlot — there is no by-key add door now, so the lookup and the add are two calls here; the floor Map.get), add the member to a Set, and after the close empty every bucket of the pass, ours through slotContentService.clearBucketMemberSlots: the clear is timed on both sides alike and carries its own stamp, settle, announce and release check. Ours additionally, per add, asserts that the channel is not flushing and that neither slot is released, opens and closes the owner's and the channel's subframe, holds the member slot and records the append on the no-op command recorder; per clear it copies the members into a fresh array, gives back each member's hold and runs each member's release check. The floor keeps plain objects and holds nothing. All of that pushes the ratio up, against ours. No flush runs inside a pass: the channel has no scheduler and the bucket no effect, so nothing asks for a frame and the clock only advances. The bucket collection is built with OIMSlotReleasePolicyNever and the floor's release check mirrors it, keeping an empty bucket: under the default policy an unheld bucket emptied by the per-pass clear is released and unfiled, and the next pass's adds would find no bucket and land nowhere. The release check is therefore priced as its tests, never as a release.

measured 2026-10-23no explanation yetbucket-adds.unheld.one-bucket-64-adds
OursOIMChannelService.openSubframe(defaultChannelSlot); slotContentService.addBucketMemberSlot(bucketService.getSlotByKey(bucketStoreSlot, key), entitySlot) for 64 adds to one bucket in one outer subframe, one content-change listener; OIMChannelService.closeSubframe(defaultChannelSlot); then slotContentService.clearBucketMemberSlots(bucketSlot) per bucket
Floorthe same adds into a Set per bucket found by Map.get, each landed add stamped when the bucket is held, settled and announced to the listener; a release check per bucket at the close; then every bucket cleared, stamped, settled and checked the same way
60 ns ours32 ns floor1.84×floor timed twice: 1.8% apart
What the two sides do differently

Every add of a pass goes to ONE bucket inside one outer subframe opened on the channel, with one content-change listener added through OIMContentChangeListenerService.INSTANCE.addContentChangeListener(bucketStoreSlot, …); the id names how many adds a pass makes. NOTHING HOLDS the bucket: it is minted through holdSlotByKey and given back through bucketSlot.owner.unholdSlot at build. The channel write door returns at once for an unheld slot, so ours stamps nothing, and the floor guards its stamp by the same hold count and stamps nothing either. With a content-change listener the shipped door takes its batch path whether or not the bucket is held: the first add of a pass writes, settles and announces the bucket (the announce is buffered by the door's own subframe and delivered at its close) and pushes the bucket once for the outermost close; every later add only flags it; the outermost close writes, settles and announces it once more and runs its release check. The listener therefore hears a bucket at most twice per pass, where the floor stamps, settles and announces on every add. Whenever a bucket takes more than one add in a pass the floor does more work than ours, and that pushes the ratio down, in our favour, the more so the more adds a bucket takes. One operation is one member add. Both sides open one outer subframe per pass (ours through OIMChannelService.openSubframe and closeSubframe on the default channel slot), find each bucket by key (ours bucketService.getSlotByKey, a store get plus an undefined test, followed by the public slotContentService.addBucketMemberSlot — there is no by-key add door now, so the lookup and the add are two calls here; the floor Map.get), add the member to a Set, and after the close empty every bucket of the pass, ours through slotContentService.clearBucketMemberSlots: the clear is timed on both sides alike and carries its own stamp, settle, announce and release check. Ours additionally, per add, asserts that the channel is not flushing and that neither slot is released, opens and closes the owner's and the channel's subframe, holds the member slot and records the append on the no-op command recorder; per clear it copies the members into a fresh array, gives back each member's hold and runs each member's release check. The floor keeps plain objects and holds nothing. All of that pushes the ratio up, against ours. No flush runs inside a pass: the channel has no scheduler and the bucket no effect, so nothing asks for a frame and the clock only advances. The bucket collection is built with OIMSlotReleasePolicyNever and the floor's release check mirrors it, keeping an empty bucket: under the default policy an unheld bucket emptied by the per-pass clear is released and unfiled, and the next pass's adds would find no bucket and land nowhere. The release check is therefore priced as its tests, never as a release.

measured 2026-10-23no explanation yetbucket-adds.unheld.one-bucket-64-adds-with-a-listener
OursOIMChannelService.openSubframe(defaultChannelSlot); slotContentService.addBucketMemberSlot(bucketService.getSlotByKey(bucketStoreSlot, key), entitySlot) for 8 adds to one bucket in one outer subframe; OIMChannelService.closeSubframe(defaultChannelSlot); then slotContentService.clearBucketMemberSlots(bucketSlot) per bucket
Floorthe same adds into a Set per bucket found by Map.get, each landed add stamped when the bucket is held, settled; a release check per bucket at the close; then every bucket cleared, stamped, settled and checked the same way
58 ns ours29 ns floor2.01×floor timed twice: 0.9% apart
What the two sides do differently

Every add of a pass goes to ONE bucket inside one outer subframe opened on the channel; the id names how many adds a pass makes. No content-change listener. NOTHING HOLDS the bucket: it is minted through holdSlotByKey and given back through bucketSlot.owner.unholdSlot at build. The channel write door returns at once for an unheld slot, so ours stamps nothing, and the floor guards its stamp by the same hold count and stamps nothing either. With no listener and no hold the shipped door settles the first add of a pass at once and pushes the bucket once for the outermost close; every later add only flags it; the close settles it once more and runs its release check. The floor settles on every add and runs the release check for every bucket at the close. Whenever a bucket takes more than one add in a pass the floor does more settles than ours, which pushes the ratio down, in our favour. One operation is one member add. Both sides open one outer subframe per pass (ours through OIMChannelService.openSubframe and closeSubframe on the default channel slot), find each bucket by key (ours bucketService.getSlotByKey, a store get plus an undefined test, followed by the public slotContentService.addBucketMemberSlot — there is no by-key add door now, so the lookup and the add are two calls here; the floor Map.get), add the member to a Set, and after the close empty every bucket of the pass, ours through slotContentService.clearBucketMemberSlots: the clear is timed on both sides alike and carries its own stamp, settle, announce and release check. Ours additionally, per add, asserts that the channel is not flushing and that neither slot is released, opens and closes the owner's and the channel's subframe, holds the member slot and records the append on the no-op command recorder; per clear it copies the members into a fresh array, gives back each member's hold and runs each member's release check. The floor keeps plain objects and holds nothing. All of that pushes the ratio up, against ours. No flush runs inside a pass: the channel has no scheduler and the bucket no effect, so nothing asks for a frame and the clock only advances. The bucket collection is built with OIMSlotReleasePolicyNever and the floor's release check mirrors it, keeping an empty bucket: under the default policy an unheld bucket emptied by the per-pass clear is released and unfiled, and the next pass's adds would find no bucket and land nowhere. The release check is therefore priced as its tests, never as a release.

measured 2026-10-23no explanation yetbucket-adds.unheld.one-bucket-8-adds
OursOIMChannelService.openSubframe(defaultChannelSlot); slotContentService.addBucketMemberSlot(bucketService.getSlotByKey(bucketStoreSlot, key), entitySlot) for 8 adds to one bucket in one outer subframe, one content-change listener; OIMChannelService.closeSubframe(defaultChannelSlot); then slotContentService.clearBucketMemberSlots(bucketSlot) per bucket
Floorthe same adds into a Set per bucket found by Map.get, each landed add stamped when the bucket is held, settled and announced to the listener; a release check per bucket at the close; then every bucket cleared, stamped, settled and checked the same way
69 ns ours30 ns floor2.30×floor timed twice: 0.1% apart
What the two sides do differently

Every add of a pass goes to ONE bucket inside one outer subframe opened on the channel, with one content-change listener added through OIMContentChangeListenerService.INSTANCE.addContentChangeListener(bucketStoreSlot, …); the id names how many adds a pass makes. NOTHING HOLDS the bucket: it is minted through holdSlotByKey and given back through bucketSlot.owner.unholdSlot at build. The channel write door returns at once for an unheld slot, so ours stamps nothing, and the floor guards its stamp by the same hold count and stamps nothing either. With a content-change listener the shipped door takes its batch path whether or not the bucket is held: the first add of a pass writes, settles and announces the bucket (the announce is buffered by the door's own subframe and delivered at its close) and pushes the bucket once for the outermost close; every later add only flags it; the outermost close writes, settles and announces it once more and runs its release check. The listener therefore hears a bucket at most twice per pass, where the floor stamps, settles and announces on every add. Whenever a bucket takes more than one add in a pass the floor does more work than ours, and that pushes the ratio down, in our favour, the more so the more adds a bucket takes. One operation is one member add. Both sides open one outer subframe per pass (ours through OIMChannelService.openSubframe and closeSubframe on the default channel slot), find each bucket by key (ours bucketService.getSlotByKey, a store get plus an undefined test, followed by the public slotContentService.addBucketMemberSlot — there is no by-key add door now, so the lookup and the add are two calls here; the floor Map.get), add the member to a Set, and after the close empty every bucket of the pass, ours through slotContentService.clearBucketMemberSlots: the clear is timed on both sides alike and carries its own stamp, settle, announce and release check. Ours additionally, per add, asserts that the channel is not flushing and that neither slot is released, opens and closes the owner's and the channel's subframe, holds the member slot and records the append on the no-op command recorder; per clear it copies the members into a fresh array, gives back each member's hold and runs each member's release check. The floor keeps plain objects and holds nothing. All of that pushes the ratio up, against ours. No flush runs inside a pass: the channel has no scheduler and the bucket no effect, so nothing asks for a frame and the clock only advances. The bucket collection is built with OIMSlotReleasePolicyNever and the floor's release check mirrors it, keeping an empty bucket: under the default policy an unheld bucket emptied by the per-pass clear is released and unfiled, and the next pass's adds would find no bucket and land nowhere. The release check is therefore priced as its tests, never as a release.

measured 2026-10-23no explanation yetbucket-adds.unheld.one-bucket-8-adds-with-a-listener
OursslotContentService.addBucketMemberSlot(bucket, slot) per inserted slot, on OIMSlotContentBucketServiceSetDriven
Floorthe same loop with no row set kept at all
144 ns ours81 ns floor1.77×floor timed twice: 2.4% apart
What the two sides do differently

WHAT A ROW SET OF EVERY INSERTED SLOT COSTS TO MAINTAIN, and it is charged to us alone: `baseline-array` keeps no such list, so the floor arm here is the honest shape of not having one. Both arms mint the slot and the copy and file them in a `Map`; ours additionally calls the PUBLIC door `addBucketMemberSlot`, which is more than the bare `Set.add` this row once priced (that step, `addSlot`, is protected now): it asserts the bucket is writable and the member not released, opens and closes a content subframe, adds to a set growing to the population size, holds the member slot, records the append and marks the bucket changed. The bucket is a single-slot store slot from `createOIMSingleBucketService`, so no collection is in either arm. The collection no longer keeps such a set of its own rows; this is the price of a consumer keeping one.

measured 2026-10-23no explanation yetinsert-gap.the-bucket-join
OursoimInsertEntityWithSanitizedCopy(slot, row) — the spread, then the `__proto__` own-key probe
Floorslot.entity = { ...row } — the spread alone
25 ns ours17 ns floor1.48×floor timed twice: 0.3% apart
What the two sides do differently

THE ONE PART OF THE COPY THE FLOOR DOES NOT PAY. `baseline-array` allocates `{ ...row }` per inserted row exactly as `oimInsertEntityWithSanitizedCopy` does, so the SPREAD is common ground and cannot be in the gap; what is ours alone is what `oimInsertEntityWithSanitizedCopy` does after it — one call and one `Object.hasOwn(stored, '__proto__')`, which is false on every row here, so the `delete` never runs. The slots are minted outside the clock and reused by both arms, so only the record is allocated inside either clock.

measured 2026-10-23no explanation yetinsert-gap.the-copying-strategy-beyond-the-spread
OurscreateOIMEntitySlot(key, owner) beside the record copy, both filed in a Map
Floorthe record copy alone, filed in a Map
77 ns ours72 ns floor1.07×floor timed twice: 0.6% apart
What the two sides do differently

THE ALLOCATION ON ITS OWN, with no engine call around it: both arms are hand-written loops over the same rows into the same kind of `Map`, and the only difference is that ours mints the fourteen-field literal `createOIMEntitySlot` returns and stores the copy on its `entity` field. The copy is on BOTH sides, because the floor adapter copies too.

measured 2026-10-23no explanation yetinsert-gap.the-fourteen-field-slot
OursentityService.slotContentService.fillEntities(entityStoreSlot, keys, rows) — mint and set, no probe
FloorentityService.slotContentService.upsertEntities(entityStoreSlot, rows) — probe, then mint and set
82 ns ours95 ns floor0.87×floor timed twice: 1.5% apart
What the two sides do differently

BOTH ARMS ARE OURS AND THE FIGURE IS THE DIFFERENCE, NOT THE RATIO. `fillEntities` files every key without asking whether it is taken, on a precondition — this collection holds nothing — checked once per call rather than per row; `upsertEntities` asks per row through `writeByKey`. So the difference is one string hash on a `Map` that grows to the population size, plus `fillEntities`'s own duplicate check — which is a second `get` per row on `fillEntities`'s side, so the two arms hash equally often and THIS ROW NOW PRICES THE WRITE DOOR'S FRAMING, NOT A HASH: `writeByKey`'s per-row change window and `selectKey` call against `fillEntities`'s one window per call. The key array `fillEntities` consumes is built outside the clock, which the shipped `insertEntities` does not do — it builds one per call. Both arms report through one channel each.

measured 2026-10-23no explanation yetinsert-gap.the-probe-one-hash-against-two
OursentityService.slotContentService.upsertEntity(entityStoreSlot, row) into an empty entity store slot
Floorconst held = byId.get(row.id); if (held === undefined) byId.set(row.id, { ...row })
88 ns ours80 ns floor1.10×floor timed twice: 0.8% apart
What the two sides do differently

THE ANCHOR ROW, AND THE ONLY ONE HERE WHOSE RATIO MEANS ANYTHING: the floor is `baseline-array.ts`'s insert copied, so this is the engine half of the scenario gap. IT IS NOT THE WHOLE SCENARIO GAP AND MUST NOT BE READ AS ONE. The `oimdb` adapter keeps its group index inside its own `write`, and `baseline-array` deliberately keeps no index at all. None of that bookkeeping is on either side of this pair. In our favour: our side takes no frame and flushes nothing, so no delivery is timed on either side. Against us: our side mints a fourteen-field slot, opens and closes a change window, stamps the clock and marks the slot on the channel per row, which the floor has no equivalent of.

measured 2026-10-23no explanation yetinsert-gap.whole-row-vs-the-baseline-floor
OursentityService.slotContentService.updateEntity(slot, { rank }), then sortedComputedService.computedCollectionService.slotContentService.getValueForSlot(sortedComputed) — createOIMComputedServiceSorted createSortedStoreSlot over an index store slot (createIndexStoreSlot), sortColumns [rank asc]
Floorswap the ranks, then indexOf/splice out and upperBound/splice in, on a sorted array
590 ns ours191 ns floor3.09×floor timed twice: 0.1% apart
What the two sides do differently

AN ENTITY MOVES WITHIN ITS GROUP, NOTHING JOINS OR LEAVES. A frame swaps the ranks of band `m` and band `m + 64` in every one of the sixty-four groups for 4 values of `m`, so each group of 128 sees 8 movers. OURS IS THE SHIPPED ORDER: an index store slot over `group` (`createOIMIndexService` with `OIMSlotContentBucketServiceSetDriven`) and a `createOIMComputedServiceSorted` and its `createSortedStoreSlot` over it with `sortColumns: [{ column: 'rank', direction: 'asc' }]`, one sorted computed held per group. NOTHING IS REPORTED BY HAND: `updateEntity` hands the index the changed columns, the index writes the group's `rank` bucket column slot, and that slot is a source of the group's sorted computed. THE READ IS INSIDE THE TIMED BODY: the computed is pulled, so the sort runs at the first `getValueForSlot` of the frame and every group is walked once per frame on both sides. THE COUNT THIS PREDICTS, per group per frame: ours copies the previous order (`slice` of 128) and runs `Array.prototype.sort` over it with the columns comparator, each compare loading `entity` off two slots and reading `rank` off both; the floor does, per mover, `indexOf`, `splice` out, `upperBoundByRank` and `splice` in. [FIGURE STATED IN ADVANCE] V8's sort over 128 entries with 8 displaced is on the order of 128 compares plus a binary search per mover, against the floor's 8 scans and 16 splices. WHERE THEY ARE NOT EQUAL: ours re-sorts the whole group however few entities moved, where the floor touches only the movers, which inflates our ratio; ours sorts once for all eight movers, which flatters us; and ours additionally walks the patch, marks the entity slot and the bucket column slot on the channel per `updateEntity`, which the floor's plain field store does not.

measured 2026-10-23no explanation yetorder.resort-within-a-bucket-vs-sorted-array-splice
OursentityService.slotContentService.upsertEntity(entityStoreSlot, entity) for 1 new keys under OIMSlotReleasePolicyAfterIdle; db.flush(); the clock moved past the window; OIMReleaseSlotCollectorServiceAfterIdle.INSTANCE.flush(afterIdleReleaseSlotCollectorSlot)
Floorthe same entities set into a Map, each key and its due time pushed onto a FIFO queue, the clock moved past the window, and the queue drained from its head deleting every due key from the Map
408 ns ours109 ns floor3.73×floor timed twice: 0.4% apart
What the two sides do differently

One operation is one entity inserted under a new key and later released when its idle window has passed; the id names how many entities one sweep inserts before the clock jumps. Both sides read one fake clock that jumps by twice the window per sweep, so every entity is due at the sweep that follows its insert and none survives it; the collector timer is a no-op and the sweep is driven by OIMReleaseSlotCollectorServiceAfterIdle.INSTANCE.flush(). Ours mints a slot per insert, files it in the slot store, stamps it on the channel, records its due time on the slot and files it in a slice Set of the release queue with a Map entry per slot, then flushes an empty channel frame; the sweep walks the due slices, asks the policy whether each slot is releasable and releases it through its owner, unfiling it from the store and from the queue Map. The floor keeps no slot, no channel and no per-key queue index: one FIFO is enough for it only because every key here shares one window, which the slice queue does not assume. All of that pushes the ratio up, against ours.

measured 2026-10-23no explanation yetrelease-after-idle.1-per-sweep
OursentityService.slotContentService.upsertEntity(entityStoreSlot, entity) for 1024 new keys under OIMSlotReleasePolicyAfterIdle; db.flush(); the clock moved past the window; OIMReleaseSlotCollectorServiceAfterIdle.INSTANCE.flush(afterIdleReleaseSlotCollectorSlot)
Floorthe same entities set into a Map, each key and its due time pushed onto a FIFO queue, the clock moved past the window, and the queue drained from its head deleting every due key from the Map
337 ns ours56 ns floor6.01×floor timed twice: 3.3% apart
What the two sides do differently

One operation is one entity inserted under a new key and later released when its idle window has passed; the id names how many entities one sweep inserts before the clock jumps. Both sides read one fake clock that jumps by twice the window per sweep, so every entity is due at the sweep that follows its insert and none survives it; the collector timer is a no-op and the sweep is driven by OIMReleaseSlotCollectorServiceAfterIdle.INSTANCE.flush(). Ours mints a slot per insert, files it in the slot store, stamps it on the channel, records its due time on the slot and files it in a slice Set of the release queue with a Map entry per slot, then flushes an empty channel frame; the sweep walks the due slices, asks the policy whether each slot is releasable and releases it through its owner, unfiling it from the store and from the queue Map. The floor keeps no slot, no channel and no per-key queue index: one FIFO is enough for it only because every key here shares one window, which the slice queue does not assume. All of that pushes the ratio up, against ours.

measured 2026-10-23no explanation yetrelease-after-idle.1024-per-sweep
OursentityService.slotContentService.upsertEntity(entityStoreSlot, entity) for 64 new keys under OIMSlotReleasePolicyAfterIdle; db.flush(); the clock moved past the window; OIMReleaseSlotCollectorServiceAfterIdle.INSTANCE.flush(afterIdleReleaseSlotCollectorSlot)
Floorthe same entities set into a Map, each key and its due time pushed onto a FIFO queue, the clock moved past the window, and the queue drained from its head deleting every due key from the Map
386 ns ours43 ns floor8.95×floor timed twice: 1.8% apart
What the two sides do differently

One operation is one entity inserted under a new key and later released when its idle window has passed; the id names how many entities one sweep inserts before the clock jumps. Both sides read one fake clock that jumps by twice the window per sweep, so every entity is due at the sweep that follows its insert and none survives it; the collector timer is a no-op and the sweep is driven by OIMReleaseSlotCollectorServiceAfterIdle.INSTANCE.flush(). Ours mints a slot per insert, files it in the slot store, stamps it on the channel, records its due time on the slot and files it in a slice Set of the release queue with a Map entry per slot, then flushes an empty channel frame; the sweep walks the due slices, asks the policy whether each slot is releasable and releases it through its owner, unfiling it from the store and from the queue Map. The floor keeps no slot, no channel and no per-key queue index: one FIFO is enough for it only because every key here shares one window, which the slice queue does not assume. All of that pushes the ratio up, against ours.

measured 2026-10-23no explanation yetrelease-after-idle.64-per-sweep
OursentityService.slotContentService.upsertEntity(entityStoreSlot, row) into an empty population, then slotContentService.findEntityByKey(entityStoreSlot, key) — the shipped default, in place
Floormap.set(row.id, { ...row }) per row, then map.get(key)
76 ns ours60 ns floor1.28×floor timed twice: 0.6% apart
What the two sides do differently

THE ARM IS THE SHIPPED DEFAULT, IN PLACE, AND THE SWEEP'S QUESTION ON THIS TASK IS WHETHER THE FORK COSTS ANYTHING AT ALL HERE. `createOIMEntityWriterInPlace` and `createOIMEntityWriterReplacing` both default `fillEntity` to `oimInsertEntityWithoutCopy`, and the insert branch of `OIMSlotContentEntityService.insertEntity` (reached by `upsertEntity`) calls `fillEntity` and no other member of the writer — so the two arms should run the same code on this path. [FIGURE STATED IN ADVANCE] Expect the two arms to differ by less than each row's own noise; a difference larger than that is the finding. THE FLOOR ALLOCATES A COPY PER ROW AND OURS DOES NOT; it also hashes one string per row. Ours additionally mints a fourteen-field slot, stores the handed row, marks the slot on the channel and decides its emptiness; on this fixture the insert takes its fast path and opens no change window. Direction: inflates our ratio, on both arms, and nothing on this axis can close it. THE READ IS ONE PER POPULATION and is there to make the fill answerable rather than to be priced. THE FLUSH IS INSIDE OUR NUMBER and has no counterpart on the floor; it runs no effect, since nothing subscribes. BOTH SIDES ABANDON THEIR CONTAINER BETWEEN PASSES and both are collected outside the clock.

measured 2026-10-23no explanation yetsweep.insert-then-read.in-place-default
OursentityService.slotContentService.upsertEntity(entityStoreSlot, row) into an empty population, then slotContentService.findEntityByKey(entityStoreSlot, key) — createOIMEntityWriterReplacing
Floormap.set(row.id, { ...row }) per row, then map.get(key)
77 ns ours59 ns floor1.30×floor timed twice: 0.4% apart
What the two sides do differently

THE ARM IS CREATEOIMENTITYWRITERREPLACING, AND THE SWEEP'S QUESTION ON THIS TASK IS WHETHER THE FORK COSTS ANYTHING AT ALL HERE. `createOIMEntityWriterInPlace` and `createOIMEntityWriterReplacing` both default `fillEntity` to `oimInsertEntityWithoutCopy`, and the insert branch of `OIMSlotContentEntityService.insertEntity` (reached by `upsertEntity`) calls `fillEntity` and no other member of the writer — so the two arms should run the same code on this path. [FIGURE STATED IN ADVANCE] Expect the two arms to differ by less than each row's own noise; a difference larger than that is the finding. THE FLOOR ALLOCATES A COPY PER ROW AND OURS DOES NOT; it also hashes one string per row. Ours additionally mints a fourteen-field slot, stores the handed row, marks the slot on the channel and decides its emptiness; on this fixture the insert takes its fast path and opens no change window. Direction: inflates our ratio, on both arms, and nothing on this axis can close it. THE READ IS ONE PER POPULATION and is there to make the fill answerable rather than to be priced. THE FLUSH IS INSIDE OUR NUMBER and has no counterpart on the floor; it runs no effect, since nothing subscribes. BOTH SIDES ABANDON THEIR CONTAINER BETWEEN PASSES and both are collected outside the clock.

measured 2026-10-23no explanation yetsweep.insert-then-read.replacing
OursslotContentService.upsertEntity(entityStoreSlot, row) with the entity stored without a copy (oimInsertEntityWithoutCopy) — a key this population has never seen
Floorif (map.get(row.id) === undefined) map.set(row.id, row)
81 ns ours58 ns floor1.40×floor timed twice: 9.6% apart
What the two sides do differently

Neither side copies the row: both store the object they were handed, and both probe the key before filing it, as an upsert must. Ours still mints an identity, files it in the identity store, stamps it on the channel and runs the insert path of writeContentByKey; the floor hashes one string. A pass fills an empty world rebuilt outside the clock, and ours closes it with db.flush().

measured 2026-10-23no explanation yetupsert.insert-by-reference-vs-map-set
OursslotContentService.upsertEntity(entityStoreSlot, row) — a key this population has never seen
Floormap.set(row.id, { ...row })
78 ns ours60 ns floor1.31×floor timed twice: 1.1% apart
What the two sides do differently

THE FLOOR DOES LESS, AND KNOWABLY SO. Ours mints an identity (a slot and an entry in the identity store — there is no per-index `links` cell, so a row carries nothing per index at all), copies the row, walks the copy's own names to refuse the ones a row may not carry, stamps the slot, stamps the collection and records the row on the presence channel so every index and every whole-population reader hears about it. The floor allocates one copy and hashes one string. Direction: this inflates our ratio, and no three-line floor can close the gap — what the extra buys is that anything subscribed to this population, or indexing it, is woken by this insert. The tracked row below is the closest a few lines get. Both sides abandon their container between passes and both are collected outside the clock, so the GC of what each allocated is NOT inside either number; our allocation per row is roughly three objects to the floor's one, and that debt is paid later.

measured 2026-10-23no explanation yetupsert.insert-vs-map-set
OursslotContentService.upsertEntity(entityStoreSlot, row) — a key this population has never seen
Floormap.set(id, copy) into a store that also queues what changed
74 ns ours71 ns floor1.04×floor timed twice: 1.9% apart
What the two sides do differently

THE FAIRER FLOOR, and it is still not equal. The floor now keeps a per-row frame stamp and a queue, so something downstream could be told — which is the job our insert is doing and the bare Map is not. What the floor still does not have: an identity that outlives the value, a per-index cell on every row, a presence channel that tells indexes and whole-population readers separately from the row itself, or any means of recording WHICH columns moved. Direction: still inflates our ratio, by less than the bare-Map row above. The pair of ratios brackets the truth; neither number alone is it.

measured 2026-10-23whyupsert.insert-vs-tracked-store

Published 2026-10-23T11:06:57.973Z.

Per read​

Paid for every value a reader takes out.

OursbucketService.getSlotByKey(bucketStoreSlot, address) — the bucket at an address, minted on a miss
FloorbyGroup.get(address)
15 ns ours8 ns floor1.84×floor timed twice: 0.0% apart
What the two sides do differently

THE ADDRESS LOOKUP ON THE BUCKET SIDE, WITHOUT THE HOLD, so a reader can see which part of `hold.vs-map-get` is the store call and which part is the hold. Every address here hits, so getSlotByKey's minting branch never runs; ours is `OIMSlotCollectionService.getSlotByKey` into its slot store service's get, one `Map.get` and the `=== undefined` compare against the floor's one `Map.get`. Both sides cycle through all sixty-four addresses. The store `OIMSlotStoreServiceMapDriven` reads is one `Map` and nothing else, so there is no cell to hit or miss.

measured 2026-10-23no explanation yetbuckets.find-vs-map-get
OursbucketService.getSlotByKey(bucketStoreSlot, [deckSlot, shelfSlot]) on a tree-driven bucket store
FloorbyDeck.get(deck).get(shelf)
16 ns ours20 ns floor0.80×floor timed twice: 1.0% apart
What the two sides do differently

AN ADDRESS OF TWO IDENTITIES AGAINST AN ADDRESS OF TWO STRINGS. Ours walks the composite key tree `OIMSlotStoreServiceTreeDriven` keeps: one `Map.get` keyed by the deck slot, one keyed by the shelf slot, then the bucket on the node — object-keyed hashes, no string hashing. The floor makes two string-keyed `Map.get`s and an `undefined` test. The key arrays are built outside the clock, as a caller holding the two segment identities would hold the pair. Every address hits a held bucket, so `getSlotByKey` never mints; it adds the store call and the `found !== undefined` test over the floor. Sixty-four combinations, eight decks by eight shelves, cycled on both sides. It replaces `chain-address.resolve-and-hold-vs-nested-map-get`, which held per call; no reading was ever recorded under either id.

measured 2026-10-23no explanation yetchain-address.resolve-vs-nested-map-get
Oursslot.entity — the row behind an identity you already hold
Floorthe object itself, held
2 ns ours1 ns floor1.27×floor timed twice: 0.3% apart
What the two sides do differently

ONE INDIRECTION AGAINST NONE, which is the smallest thing this table can ask about and is close to the resolution floor — read it against the control rows before treating any part of it as a result. Ours answers `TPriceDataRow | undefined` because an identity may carry no value; the floor answers a row. This body does NOT narrow the undefined, so the branch a real consumer writes is charged to neither side. IT IS THE WHOLE VALUE-READ PATH NOW. `value.held-getValue-vs-object` and `value.construct-and-read-vs-object` stood below this row and priced the same read through an observable; there is no observable, so this is the only shape the question has left.

measured 2026-10-23no explanation yetentity.vs-held-object
OursentityService.slotContentService.findEntityByKey(entityStoreSlot, id) — the entity of a key, or undefined
Floormap.get(id)
22 ns ours20 ns floor1.08×floor timed twice: 0.1% apart
What the two sides do differently

THE CALIBRATION ROW. `slotContentService.findEntityByKey` is a `Map.get` through the slot store service and one `.entity` load off the slot, so if this reads much above 1 the instrument is measuring call overhead rather than the library, and every other ratio in this table should be read with that in mind. Every key hits — a miss is a different path on both sides and would mix two prices.

measured 2026-10-23whyfind.vs-map-get
OursslotContentService.getBucketMemberSlotCount(bucket)
Floorset.size
1 ns ours1 ns floor1.00×floor timed twice: 0.2% apart
What the two sides do differently

Ours is one call — `slotContentService.getBucketMemberSlotCount` reads the same `Set.size` off the bucket slot's store — and that call is the whole difference. The floor reads a field of a container whose correctness is somebody else's problem. Both sides cycle through all sixty-four buckets rather than asking the same one repeatedly. THIS ROW ONCE READ BELOW 1.00 AND THAT NUMBER WAS A HASH, NOT A COUNT. The floor reached its `Set` through `sets.get(name)` — a string-keyed `Map.get` — while our side was handed the bucket out of an array. So the floor's number was very nearly all addressing and ours was very nearly all service hop, and the row reported the difference between a hash and an array load under the name of a member count. The floor now holds its sets in an array indexed exactly the way our side indexes its buckets, so both sides are addressed alike and what is left in the ratio is the service hop. This suite's standing rule is that a floor doing less is a lie in our favour; that rule was pointed at us here, and the reading it produced is withdrawn rather than qualified. THE CALL WAS `db.memberCount(bucket)` AND IS `slotContentService.getBucketMemberSlotCount(bucket)`, on the bucket content service rather than on the database — the same question through a different object. Nothing recorded before 2026-08-29 is re-attributed to it, and the prediction the old caveat carried (roughly 3.5 to 4.4, from figures in `measurements/2026-08-20-price/read-2`) was written for the old call and is not a prediction about this one.

measured 2026-10-23no explanation yetmemberCount.vs-set-size
Oursfor (const slot of slotContentService.getBucketMemberSlots(bucket)) slot.entity — per member visited
Floorfor (let i = 0; i < rows.length; i++) — per member visited
3 ns ours1 ns floor2.15×floor timed twice: 0.0% apart
What the two sides do differently

THE SAME OUR-SIDE BODY AS THE ROW ABOVE AGAINST THE FLOOR SOMEBODY WOULD ACTUALLY WRITE. An indexed array walk is the fastest way there is to visit a hundred objects and it beats a `Set` iterator handily, so this ratio is the worse of the two and the more honest answer to "what does reading a group cost me". What the array cannot do is stay correct: nothing maintains it, nothing can be woken by it, and it holds rows rather than identities that outlive them. The gap between this ratio and the `set-iteration` one above is a property of JavaScript containers, not of either design.

measured 2026-10-23no explanation yetread.members-vs-array-iteration
Oursfor (const slot of slotContentService.getBucketMemberSlots(bucket)) slot.entity — per member visited
Floorfor (const row of set) — per member visited, same container kind
3 ns ours2 ns floor1.11×floor timed twice: 0.1% apart
What the two sides do differently

THE SAME CONTAINER ON BOTH SIDES: an unordered bucket holds its members in a `Set`, so this floor is the structural equal. Ours pays two things the floor does not — the read settles whatever order report is outstanding on the bucket (nothing is outstanding here, and an unordered bucket has no order to settle, so what is charged is the ASKING) and every member is a slot the consumer must dereference to reach the row, which this body does. The per-read costs — the settle and the iterator — are amortised over the hundred-odd members of a bucket, so a caller reading buckets of one pays far more per member than this row shows.

measured 2026-10-23no explanation yetread.members-vs-set-iteration

Published 2026-10-23T11:06:57.973Z.

What these prices do not prove​

They prove what the calls cost. They do not prove the calls are the fastest the engine could have made them. That is a different measurement, against other designs for the same work rather than against the primitive, and it reads the other way up: below 1.00 the shipped design is cheaper. Those readings are on Shipped against the alternatives, and the posts on the blog that describe them each say which shipped code path they measured.