Skip to main content

Shipped against the alternatives

The price of a call says what a call costs against the plain JavaScript you would write instead. This page asks a different question: for each design the engine ships, how does it compare with another design for the same work? Most alternatives are designs that were rejected; some are a second shipped strategy for the same job. Each pair runs both sides on the same work.

Every figure here is generated from the published measurements (npm run price:publish in packages/bench). No figure is typed by hand.

How to read a pair​

  • Shipped is the design in the engine. Alternative is the other design. The ratio is shipped over alternative, so it reads the other way up from a price: below 1.00 the shipped design is cheaper, above 1.00 the alternative is.
  • A ratio close to 1.00 decides nothing. The alternative is timed twice in the pair's process, before and after the shipped side, and each card prints how far apart those two timings came out. The shipped side is timed a second time in its own process, and that gap is not published yet, so the printed gap covers only part of the ratio's error. The controls below show what the run as a whole could resolve.
  • An alternative that comes out cheaper is a finding. For that task it is either a strategy the engine is missing or a trade-off the caveat names; see Performance.
  • The caveat under each pair says what the two sides do differently, so a pair is never read as more than it measured.

The instrument​

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 relationship​

ShippedeffectService.createEffect(rootSlots, [], body) — a new TOIMEffect over 8 roots
AlternativecreateLiteralEffect(channelSlot, rootSlots, body) — a literal over 8 roots, subscribed by a shared function
92 ns shipped94 ns alternative0.99×alternative timed twice: 0.0% apart
What the two sides do differently

THE SHIPPED SERVICE AGAINST THE BENCH'S OWN LITERAL COPY OF ITS ALGORITHM. Ours is the shipped `OIMEffectService`, whose effects are plain `TOIMEffect` objects carrying an `effectService` reference. The floor is a literal copy of the same fields and the same run and dispose steps, kept in this file as module-level functions and a small literal service object (`runEffectIfSourcesChanged`, `setPositionInSubscribedSlot`) because the channel and `OIMSlotOwner.unsubscribeFromSlot` call those through the effect. Both subscribe through the same `OIMSlotOwner.subscribeToSlot`, so `isolate` keeps each arm in its own process. Each arm keeps ONE resident effect alive for the whole process, so the hidden-class loss at a full GC (WHY-EACH-ROW.md, churnChain) is excluded and what remains is the cost of the service call itself. The floor skips the shipped `createEffect`'s source-computed dedup `Set` branch, its try/catch and its frame-scheduling check, none of which does work for an effect with no source computeds. One operation is one effect created and subscribed to 8 roots; the disposal of the pass is in `reset`, untimed.

measured 2026-10-23whyalt.effect-shape.class-vs-literal-and-service.create
ShippedeffectService.disposeEffect(effect) — a TOIMEffect over 8 roots
AlternativedisposeLiteralEffect(effect) — a literal over 8 roots
95 ns shipped87 ns alternative1.10×alternative timed twice: 8.5% apart
What the two sides do differently

THE SHIPPED SERVICE AGAINST THE BENCH'S OWN LITERAL COPY OF ITS ALGORITHM. Ours is the shipped `OIMEffectService`, whose effects are plain `TOIMEffect` objects carrying an `effectService` reference. The floor is a literal copy of the same fields and the same run and dispose steps, kept in this file as module-level functions and a small literal service object (`runEffectIfSourcesChanged`, `setPositionInSubscribedSlot`) because the channel and `OIMSlotOwner.unsubscribeFromSlot` call those through the effect. Both subscribe through the same `OIMSlotOwner.subscribeToSlot`, so `isolate` keeps each arm in its own process. Each arm keeps ONE resident effect alive for the whole process, so the hidden-class loss at a full GC (WHY-EACH-ROW.md, churnChain) is excluded and what remains is the cost of the service call itself. The floor skips the shipped `createEffect`'s source-computed dedup `Set` branch, its try/catch and its frame-scheduling check, none of which does work for an effect with no source computeds. One operation is one effect unsubscribed from 8 roots; the pass's effects are created in `reset`, untimed, and one frame closes the pass.

measured 2026-10-23whyalt.effect-shape.class-vs-literal-and-service.dispose
Shippedmap.get(key) — the identity already exists, the row is on it
Alternativeidentities.get(key) ?? mint and file one — the first subscription to that key
22 ns shipped69 ns alternative0.31×alternative timed twice: 6.1% apart
What the two sides do differently

A SUBSCRIPTION TURNING A KEY INTO AN IDENTITY, the first time each key is asked. Ours minted every identity at the load, so a resolve is one hash; the two-map store mints on demand, so the first resolve of a key is a miss, a mint and a second `Map.set`. The floor's identity map is emptied between passes, untimed, so every pass is that first resolve; a key resolved twice would cost the floor one hash, as ours. The mint ours paid at the load is priced by the write row, not here.

measured 2026-10-23no explanation yetalt.identity-store.one-map-vs-two.resolve-a-key-to-an-identity
ShippedupsertEntity of a key that has none — the shipped fifteen-field entity slot literal
AlternativeREJECTED: a slot minted with its ten valued fields, the rest added on first use
122 ns shipped123 ns alternative0.99×alternative timed twice: 24.9% apart
What the two sides do differently

THE FIRST OF THE TWO READINGS THIS DECISION ASKS FOR, AND IT IS THE ONE THAT SHOULD GO AGAINST US. `createOIMEntitySlot` returns fifteen fields, five of them born`undefined` — `effects`, `entity`, `columnSlotStore`, `data`, `indexKeys` — and the rejected design (a subclass overriding `createSlot`) leaves all five out and lets the engine add each on first assignment. So ours pays five stores per identity the floor does not, and if this row does not come back ABOVE 1.00 the two designs do not differ where the argument says they do. ONE OPERATION IS ONE `upsertEntity` OF A KEY THAT HAS NO VALUE — the whole first-load path: `writeContentByKey` minting the identity, the copying writer strategy, the store, the marks. The pass CONSUMES its fixture, so both sides declare `operationsPerPass` and rebuild an empty population in the untimed `reset`. ONE DIFFERENCE THAT IS NOT THE LITERAL, in the FLOOR'S disfavour: on the floor `slot.entity =` ADDS a property rather than storing into one, a map transition per row — which is what "added on first use" means. WHAT THIS ROW CANNOT SAY is what the unused fields COST in bytes; that is `npm run retained`, and this pair does not stand in for it. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.

measured 2026-10-23no explanation yetalt.slot-literal.complete-vs-grown.mint-a-population
ShippedeffectService.createEffect([slot], [], body) then effectService.disposeEffect(effect) — per subscriber
Alternativeemitter.subscribeOnKey(key, body) then the returned unsubscribe — 3.12.1
38 ns shipped68 ns alternative0.56×alternative timed twice: 0.5% apart
What the two sides do differently

ONE OPERATION IS ONE SUBSCRIBER MOUNTED AND RELEASED, in batches of the churn family's largest count on one identity. Ours allocates a `TOIMEffect` per mount, appends it to the slot's `effects` array, holds the slot, and on dispose swap-removes it and unholds; 3.12.1 adds the handler to the carrier's `Set` and the carrier to the emitter's subscribed set, and its unsubscribe closure deletes both. Every body is a distinct closure, because the 3.12.1 `Set` collapses one function subscribed many times into one handler. Neither arm writes or flushes.

measured 2026-10-23no explanation yetalt.subscription.channel-effect-vs-3.12.1-carrier-handler.mount-and-release

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

Per frame​

Shippedmark the node at the write, recompute each marked node once when the frame closes
Alternativerecompute the node at every write
2.51 µs shipped1.60 µs alternative1.57×alternative timed twice: 0.0% apart
What the two sides do differently

ONE OPERATION IS ONE FRAME over the whole node population, each node taking the stated number of writes to its sources. Coalescing pays a flag test and a push per write and one recompute per node per frame; eager pays one recompute per write and nothing else. So the answer is a BREAK-EVEN in writes per node per frame, not a speed-up: at one write eager does strictly less, and every row above it is where coalescing has to earn its list. Both arms are plain objects; both were checked to leave every node holding the same value after a frame.

measured 2026-10-23no explanation yetalt.coalesce-vs-eager.1-writes-per-node-per-frame
Shippedmark the node at the write, recompute each marked node once when the frame closes
Alternativerecompute the node at every write
10.05 µs shipped25.62 µs alternative0.39×alternative timed twice: 0.1% apart
What the two sides do differently

ONE OPERATION IS ONE FRAME over the whole node population, each node taking the stated number of writes to its sources. Coalescing pays a flag test and a push per write and one recompute per node per frame; eager pays one recompute per write and nothing else. So the answer is a BREAK-EVEN in writes per node per frame, not a speed-up: at one write eager does strictly less, and every row above it is where coalescing has to earn its list. Both arms are plain objects; both were checked to leave every node holding the same value after a frame.

measured 2026-10-23no explanation yetalt.coalesce-vs-eager.16-writes-per-node-per-frame
Shippedmark the node at the write, recompute each marked node once when the frame closes
Alternativerecompute the node at every write
3.02 µs shipped3.21 µs alternative0.94×alternative timed twice: 0.0% apart
What the two sides do differently

ONE OPERATION IS ONE FRAME over the whole node population, each node taking the stated number of writes to its sources. Coalescing pays a flag test and a push per write and one recompute per node per frame; eager pays one recompute per write and nothing else. So the answer is a BREAK-EVEN in writes per node per frame, not a speed-up: at one write eager does strictly less, and every row above it is where coalescing has to earn its list. Both arms are plain objects; both were checked to leave every node holding the same value after a frame.

measured 2026-10-23no explanation yetalt.coalesce-vs-eager.2-writes-per-node-per-frame
Shippedmark the node at the write, recompute each marked node once when the frame closes
Alternativerecompute the node at every write
4.05 µs shipped6.41 µs alternative0.63×alternative timed twice: 0.0% apart
What the two sides do differently

ONE OPERATION IS ONE FRAME over the whole node population, each node taking the stated number of writes to its sources. Coalescing pays a flag test and a push per write and one recompute per node per frame; eager pays one recompute per write and nothing else. So the answer is a BREAK-EVEN in writes per node per frame, not a speed-up: at one write eager does strictly less, and every row above it is where coalescing has to earn its list. Both arms are plain objects; both were checked to leave every node holding the same value after a frame.

measured 2026-10-23no explanation yetalt.coalesce-vs-eager.4-writes-per-node-per-frame
Shippeda delivery list built at the write — the frame walks only what was marked
Alternativea stamp written at the write — the frame scans every subscriber for this frame's stamp
39 ns shipped992 ns alternative0.039×alternative timed twice: 0.2% apart
What the two sides do differently

ONE OPERATION IS ONE FRAME: the stated number of subscribers out of the population are marked, spread evenly, and the frame delivers to exactly those. The list pays a flag test and a push per mark and walks only the marked; the scan pays one store per mark and walks the whole population every frame. So the answer turns on the marked fraction and THE ROWS CROSS OVER: read them as a table, never as one ratio. Both arms were checked to deliver to the same number of subscribers before the clock.

measured 2026-10-23no explanation yetalt.dirty-list-vs-scan.1-of-1024-marked
Shippeda delivery list built at the write — the frame walks only what was marked
Alternativea stamp written at the write — the frame scans every subscriber for this frame's stamp
4.18 µs shipped1.88 µs alternative2.23×alternative timed twice: 0.0% apart
What the two sides do differently

ONE OPERATION IS ONE FRAME: the stated number of subscribers out of the population are marked, spread evenly, and the frame delivers to exactly those. The list pays a flag test and a push per mark and walks only the marked; the scan pays one store per mark and walks the whole population every frame. So the answer turns on the marked fraction and THE ROWS CROSS OVER: read them as a table, never as one ratio. Both arms were checked to deliver to the same number of subscribers before the clock.

measured 2026-10-23no explanation yetalt.dirty-list-vs-scan.1024-of-1024-marked
Shippeda delivery list built at the write — the frame walks only what was marked
Alternativea stamp written at the write — the frame scans every subscriber for this frame's stamp
1.07 µs shipped1.24 µs alternative0.86×alternative timed twice: 0.0% apart
What the two sides do differently

ONE OPERATION IS ONE FRAME: the stated number of subscribers out of the population are marked, spread evenly, and the frame delivers to exactly those. The list pays a flag test and a push per mark and walks only the marked; the scan pays one store per mark and walks the whole population every frame. So the answer turns on the marked fraction and THE ROWS CROSS OVER: read them as a table, never as one ratio. Both arms were checked to deliver to the same number of subscribers before the clock.

measured 2026-10-23no explanation yetalt.dirty-list-vs-scan.256-of-1024-marked
Shippeda delivery list built at the write — the frame walks only what was marked
Alternativea stamp written at the write — the frame scans every subscriber for this frame's stamp
141 ns shipped1.03 µs alternative0.14×alternative timed twice: 0.0% apart
What the two sides do differently

ONE OPERATION IS ONE FRAME: the stated number of subscribers out of the population are marked, spread evenly, and the frame delivers to exactly those. The list pays a flag test and a push per mark and walks only the marked; the scan pays one store per mark and walks the whole population every frame. So the answer turns on the marked fraction and THE ROWS CROSS OVER: read them as a table, never as one ratio. Both arms were checked to deliver to the same number of subscribers before the clock.

measured 2026-10-23no explanation yetalt.dirty-list-vs-scan.32-of-1024-marked
Shippedpush 1024 effects, then flush by swapping two lists
Alternativepush 1024 effects, then flush by draining an `Array.from` copy
5.12 µs shipped3.85 µs alternative1.33×alternative timed twice: 5.9% apart
What the two sides do differently

ONE POINT OF A TWO-POINT LINE, READ WITH ITS SIBLING. The snapshot is proportional to the queue and the swap is constant, so the empty row is where the rejected design pays its minimum and the loaded row is where the saving is largest in absolute terms. The pushes are the same code on both arms and inside both numbers. NEITHER ARM IS SHIPPED CODE: `OIMChannel` keeps one pending list and empties it in place. The build throws unless one flush walks the same count on both. THE POST'S ENGINE IS NOT THIS ENGINE. All four posts describe `@oimdb/core` 3.x, which now lives in `packages/core-legacy/`; this row runs hand-written arms shaped after the current engine, so it settles the DECISION and settles NOTHING about the withdrawn table.

measured 2026-10-23no explanation yetalt.double-buffer-vs-array-from-snapshot.1024-queued
Shippedpush 0 effects, then flush by swapping two lists
Alternativepush 0 effects, then flush by draining an `Array.from` copy
25 ns shipped32 ns alternative0.78×alternative timed twice: 1.1% apart
What the two sides do differently

ONE POINT OF A TWO-POINT LINE, READ WITH ITS SIBLING. The snapshot is proportional to the queue and the swap is constant, so the empty row is where the rejected design pays its minimum and the loaded row is where the saving is largest in absolute terms. The pushes are the same code on both arms and inside both numbers. NEITHER ARM IS SHIPPED CODE: `OIMChannel` keeps one pending list and empties it in place. The build throws unless one flush walks the same count on both. THE POST'S ENGINE IS NOT THIS ENGINE. All four posts describe `@oimdb/core` 3.x, which now lives in `packages/core-legacy/`; this row runs hand-written arms shaped after the current engine, so it settles the DECISION and settles NOTHING about the withdrawn table.

measured 2026-10-23no explanation yetalt.double-buffer-vs-array-from-snapshot.empty-flush
ShippedOIMChannelService.INSTANCE.write(channelSlot, slot); db.flush() — wakes the TOIMEffects standing on that slot
AlternativeOIMChannelService.INSTANCE.write(channelSlot, slot); db.flush() — wakes the literal effects standing on that slot
1.04 µs shipped1.14 µs alternative0.91×alternative timed twice: 1.5% apart
What the two sides do differently

THE SHIPPED SERVICE AGAINST THE BENCH'S OWN LITERAL COPY OF ITS ALGORITHM. Ours is the shipped `OIMEffectService`, whose effects are plain `TOIMEffect` objects carrying an `effectService` reference. The floor is a literal copy of the same fields and the same run and dispose steps, kept in this file as module-level functions and a small literal service object (`runEffectIfSourcesChanged`, `setPositionInSubscribedSlot`) because the channel and `OIMSlotOwner.unsubscribeFromSlot` call those through the effect. Both subscribe through the same `OIMSlotOwner.subscribeToSlot`, so `isolate` keeps each arm in its own process. Each arm keeps ONE resident effect alive for the whole process, so the hidden-class loss at a full GC (WHY-EACH-ROW.md, churnChain) is excluded and what remains is the cost of the service call itself. The floor skips the shipped `createEffect`'s source-computed dedup `Set` branch, its try/catch and its frame-scheduling check, none of which does work for an effect with no source computeds. 1024 effects stand over 57 overlapping 8-row windows of 64 rows; one operation is one write and one frame, which runs every effect whose window holds the row (up to 8).

measured 2026-10-23whyalt.effect-shape.class-vs-literal-and-service.wake
Shippedwrite 300 roots, then read 200 computeds that walk their 3 sources — chain depth 1
Alternativethe same writes, each marking its dependents dirty; each read is one boolean — depth 1
6.21 µs shipped4.61 µs alternative1.35×alternative timed twice: 0.3% apart
What the two sides do differently

THE ROW THE RECOVERED RUN ACTUALLY COVERED, REBUILT SO THE OTHER TWO HAVE SOMETHING TO BE READ AGAINST. Its figure at this geometry was 0.72x in our favour [NO RUN BEHIND THIS FIGURE], and the whole reason the other two rows exist is that this one was the ONLY depth measured. At depth 1 push is at its strongest: a consumer is one boolean away from knowing it owes a derivation, and the sources under it are roots, which are current by definition — so the arm has nothing to descend and nothing to bring up to date. If the recovered figure is going to reproduce anywhere it is here, and a reading far from it on this row means the two runs are not measuring the same thing and the other two rows should not be quoted either [FIGURE STATED IN ADVANCE]. RESIDUALS. AGAINST US, AND THEY ARE THE MAJORITY: our arm is the SHIPPED `OIMComputedService` (from `createOIMComputedService`), one per level, each node a held computed slot read through the computed collection service's `slotContentService.getValueForSlot`, so every read pays `assertNotReleased` and a call into `oimRefreshComputedSlot`; every refresh that misses the clock pays `oimRefreshSourceComputeds`, a call into `oimHasSourceChangedSinceLastRun`, a call into `oimIsRevisionAfter` per source, a call into the comparator, `isDeriving` written twice and THREE pairs of stamps written per derivation (`ranAt*`, `checkedAt*` and `changedAt*`) — the rejected arm carries one boolean and writes it once. Above level one the derive reads each source computed through its owner AGAIN, after `oimRefreshSourceComputeds` already brought it current, so each such source costs one more `getValueForSlot` that returns on its `checkedAt` pair, and the derive finds its source list by the slot's key. Our nodes are also filed as slots in a `Map` per level, with `effects`, `holdCount`, `owner` and `key` on every one of them, and the rejected node has none of that. AGAINST THE REJECTED ARM: nothing, except that it walks a recursive `markDependents` where a real engine might flatten it. WHAT NEITHER ARM PAYS: the frame. No effect is subscribed and `db.flush()` is never called, so the leaf list, the drain and the after-frame phases are on neither side — a frame is priced by `flush.empty-vs-noop` and adding it to both halves of a ratio only pulls it toward 1. WHAT IS NOT EXERCISED, and it is the design difference that no timing here can show: push marks the WHOLE transitive cone at the write, while pull stops at the first computed whose value held. Every root moves every frame here and every sum therefore changes, so the comparator never cuts anything on either arm and push is never charged for a mark it did not owe. A graph where a change is absorbed part-way up is the arrangement in which push is at its worst, and it is not measured. NOR IS THE CONSUMER AXIS: the recovered table reported the two converging where ten consumers share one computed, and every node here is read by exactly one consumer.

measured 2026-10-23whyalt.settle.pull-at-the-getter-vs-push-at-the-write.depth-1
Shippedthe same frame over a computed reading a computed — chain depth 2
Alternativethe same frame, marked at the write and descended by the flag — chain depth 2
19.64 µs shipped12.80 µs alternative1.53×alternative timed twice: 6.5% apart
What the two sides do differently

THE FIRST DEPTH THE RECOVERED RUN NEVER REACHED, AND THE ONE WHERE PUSH STARTS PAYING TWICE. A write now marks 200 nodes at level one and 200 more above them, and the walk is recursive; our arm's write is unchanged — it stamps a root and stops — while its READ grows by one level. So the two curves cross somewhere if they cross at all, and this row and the next are what say whether they do. WHAT DOES NOT CHANGE BETWEEN THE ROWS: the population, the fan-in, the number of consumers, the writes per frame and the derive body. Only the number of levels between the roots and the consumers moves, so this row minus the depth-1 row is one level, on both arms, in one process. IF THE RATIO RISES TOWARD 1.00 AS DEPTH GROWS THE VERDICT IS NARROWER THAN THE RECOVERED TABLE CLAIMED [FIGURE STATED IN ADVANCE], and if it crosses 1.00 the decision is wrong for deep chains and that is the finding this file was built to be able to report. RESIDUALS. AGAINST US, AND THEY ARE THE MAJORITY: our arm is the SHIPPED `OIMComputedService` (from `createOIMComputedService`), one per level, each node a held computed slot read through the computed collection service's `slotContentService.getValueForSlot`, so every read pays `assertNotReleased` and a call into `oimRefreshComputedSlot`; every refresh that misses the clock pays `oimRefreshSourceComputeds`, a call into `oimHasSourceChangedSinceLastRun`, a call into `oimIsRevisionAfter` per source, a call into the comparator, `isDeriving` written twice and THREE pairs of stamps written per derivation (`ranAt*`, `checkedAt*` and `changedAt*`) — the rejected arm carries one boolean and writes it once. Above level one the derive reads each source computed through its owner AGAIN, after `oimRefreshSourceComputeds` already brought it current, so each such source costs one more `getValueForSlot` that returns on its `checkedAt` pair, and the derive finds its source list by the slot's key. Our nodes are also filed as slots in a `Map` per level, with `effects`, `holdCount`, `owner` and `key` on every one of them, and the rejected node has none of that. AGAINST THE REJECTED ARM: nothing, except that it walks a recursive `markDependents` where a real engine might flatten it. WHAT NEITHER ARM PAYS: the frame. No effect is subscribed and `db.flush()` is never called, so the leaf list, the drain and the after-frame phases are on neither side — a frame is priced by `flush.empty-vs-noop` and adding it to both halves of a ratio only pulls it toward 1. WHAT IS NOT EXERCISED, and it is the design difference that no timing here can show: push marks the WHOLE transitive cone at the write, while pull stops at the first computed whose value held. Every root moves every frame here and every sum therefore changes, so the comparator never cuts anything on either arm and push is never charged for a mark it did not owe. A graph where a change is absorbed part-way up is the arrangement in which push is at its worst, and it is not measured. NOR IS THE CONSUMER AXIS: the recovered table reported the two converging where ten consumers share one computed, and every node here is read by exactly one consumer.

measured 2026-10-23whyalt.settle.pull-at-the-getter-vs-push-at-the-write.depth-2
Shippedthe same frame over a computed reading a computed reading a computed — chain depth 3
Alternativethe same frame, marked at the write through three levels — chain depth 3
31.00 µs shipped21.62 µs alternative1.43×alternative timed twice: 6.1% apart
What the two sides do differently

THE DEPTH THE RECOVERY ENTRY NAMES BY HAND — "a computed over a computed over a computed was not measured" — and the far end of the only axis that could reverse the decision. 600 nodes now stand between 300 roots and 200 consumers. THE ARITHMETIC THE ROW IS CHECKING: push pays its marking over the whole cone at every frame's first write and then reads one boolean per node; we pay nothing at the write and one comparison per source at the read. Those are the same order of magnitude, so which wins is a question about constants and not about shapes, which is exactly the kind of question a measurement settles and an operation count does not. THIS IS THE ROW TO DISTRUST IF ANY: three levels of 200 nodes is deeper than most screens go, and a reader taking a verdict from here alone has chosen the extreme of the axis. Read the three rows as a table. RESIDUALS. AGAINST US, AND THEY ARE THE MAJORITY: our arm is the SHIPPED `OIMComputedService` (from `createOIMComputedService`), one per level, each node a held computed slot read through the computed collection service's `slotContentService.getValueForSlot`, so every read pays `assertNotReleased` and a call into `oimRefreshComputedSlot`; every refresh that misses the clock pays `oimRefreshSourceComputeds`, a call into `oimHasSourceChangedSinceLastRun`, a call into `oimIsRevisionAfter` per source, a call into the comparator, `isDeriving` written twice and THREE pairs of stamps written per derivation (`ranAt*`, `checkedAt*` and `changedAt*`) — the rejected arm carries one boolean and writes it once. Above level one the derive reads each source computed through its owner AGAIN, after `oimRefreshSourceComputeds` already brought it current, so each such source costs one more `getValueForSlot` that returns on its `checkedAt` pair, and the derive finds its source list by the slot's key. Our nodes are also filed as slots in a `Map` per level, with `effects`, `holdCount`, `owner` and `key` on every one of them, and the rejected node has none of that. AGAINST THE REJECTED ARM: nothing, except that it walks a recursive `markDependents` where a real engine might flatten it. WHAT NEITHER ARM PAYS: the frame. No effect is subscribed and `db.flush()` is never called, so the leaf list, the drain and the after-frame phases are on neither side — a frame is priced by `flush.empty-vs-noop` and adding it to both halves of a ratio only pulls it toward 1. WHAT IS NOT EXERCISED, and it is the design difference that no timing here can show: push marks the WHOLE transitive cone at the write, while pull stops at the first computed whose value held. Every root moves every frame here and every sum therefore changes, so the comparator never cuts anything on either arm and push is never charged for a mark it did not owe. A graph where a change is absorbed part-way up is the arrangement in which push is at its worst, and it is not measured. NOR IS THE CONSUMER AXIS: the recovered table reported the two converging where ten consumers share one computed, and every node here is read by exactly one consumer.

measured 2026-10-23whyalt.settle.pull-at-the-getter-vs-push-at-the-write.depth-3
ShippedOIMChannelService.INSTANCE.write(channelSlot, slot); db.flush() — every effect on the slot runs
Alternativeemitter.markUpdatedKey(key); queue.flush() — every handler on the carrier runs — 3.12.1
9 ns shipped14 ns alternative0.63×alternative timed twice: 0.8% apart
What the two sides do differently

ONE OPERATION IS ONE SUBSCRIBER WOKEN; a frame wakes the whole standing set, mounted before the clock. Ours stamps the slot, enlists each effect through its pending flag, and at the flush asks each effect whether its source moved since it last ran — a stamp compare — before calling its body. 3.12.1 marks the carrier dirty once, and its flush iterates the carrier's handler `Set` and calls each. Both arms were checked to wake every subscriber exactly once per write before the clock started. Neither arm goes through a collection write: this is the subscription cost alone, not the write stack in front of it.

measured 2026-10-23no explanation yetalt.subscription.channel-effect-vs-3.12.1-carrier-handler.wake

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

Per write​

ShippedupdateEntity(slot, patch) on the shipped walk — sixteen columns, all of them moving
AlternativeREJECTED: the same write with Object.keys(source) — sixteen columns, all moving
226 ns shipped452 ns alternative0.50×alternative timed twice: 0.1% apart
What the two sides do differently

THE COUNTERWEIGHT TO THE ROW ABOVE, AND IT IS OWED. An unchanged re-send is the one write on which the shipped walk allocates nothing whatever, so measuring the rejected design only there would report its worst case as its case. Here every write moves all sixteen columns: BOTH arms allocate a changed-names array and push sixteen names into it, both assign sixteen columns, and both mark the row and its columns. The floor's names array is then one allocation among several rather than its only one, and if the shipped walk's advantage is really the allocation, this ratio is markedly closer to 1.00 than the unchanged row's. ONE OPERATION IS ONE `updateEntity` CARRYING SIXTEEN COLUMNS. The values advance by one of eight per pass and column `c` takes `titles[(round + c) & 7]`, so no write is ever handed a value the row already holds. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.

measured 2026-10-23no explanation yetalt.column-walk.for-in-vs-object-keys.every-column-moved
ShippedupdateEntity(slot, patch) on the shipped walk — for…in, own-property-ness proved once
AlternativeREJECTED: the same write with Object.keys(source) and a walk of that array
111 ns shipped227 ns alternative0.49×alternative timed twice: 0.7% apart
What the two sides do differently

THE SCENARIO THE SOURCE'S OLD FIGURE NAMED, GIVEN A DIRECTORY. The in-place writer's source once put the array-allocating form at 1.099 ms against 479 µs on "ten thousand rows rewritten with the values they already hold" [NO RUN BEHIND THIS FIGURE]. This row is that scenario: ONE OPERATION IS ONE `updateEntity` OF A ROW WITH A PATCH IT ALREADY MATCHES IN ALL SIXTEEN COLUMNS. The population is primed outside the clock so every row holds round zero's values, and the timed patch is round zero's — so every write enumerates sixteen columns, compares sixteen times, moves nothing, and returns having marked nothing. OPERATION COUNT, both arms: 16 `oimIsProtoKey` compares, 16 `oimSameValueZeroGuard` calls, 16 pairs of property loads, and no changed-names array. Ours additionally pays ONE `oimIsPlain` — one `getPrototypeOf` and two reference compares, per write. The floor pays ONE `Object.keys` — a sixteen-element array allocated, filled and abandoned per write. THE DIFFERENCE IS ONE PROTOTYPE PROBE AGAINST ONE SIXTEEN-ELEMENT ARRAY, plus whatever the two enumerations cost each other. THIS IS THE MOST FAVOURABLE SCENARIO THE SHIPPED WALK HAS, and that is why the row beside it exists. Read the two rows together or neither. A FLUSH CLOSES EACH PASS ON BOTH ARMS and is an empty one — nothing was marked. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.

measured 2026-10-23no explanation yetalt.column-walk.for-in-vs-object-keys.unchanged-resend
ShippedupdateEntity(slot, patch) — one oimIsPlain per write, and a bare for…in after it
AlternativeREJECTED: hasOwnProperty.call per column, with no oimIsPlain probe at all
117 ns shipped135 ns alternative0.87×alternative timed twice: 4.0% apart
What the two sides do differently

THE SECOND DESIGN THE SAME DECISION REFUSED. The writer's old source put the per-column probe at "a quarter of" an unchanged re-send — a share of a scenario, not a ratio, and no directory. This row is that scenario at sixteen columns. ONE OPERATION IS ONE UNCHANGED `updateEntity`, primed exactly as the first row of this file. OPERATION COUNT, ours: 1 `getPrototypeOf` and 2 reference compares, then 16 `oimIsProtoKey` compares and 16 equality calls. Floor: 16 `oimIsProtoKey` compares, 16 `Object.prototype.hasOwnProperty.call` invocations and 16 equality calls. THE DIFFERENCE IS ONE PROTOTYPE PROBE AGAINST SIXTEEN BUILTIN CALLS, per write. WHAT THE FLOOR BUYS IS NOT VISIBLE IN THIS NUMBER: unconditional correctness with no probe of the patch and no second rule for the non-plain payload. THE PATCH HERE IS A PLAIN OBJECT, the case the shipped design optimises for; on a class-instance patch ours takes the filtered walk and pays what the floor pays plus the probe. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.

measured 2026-10-23no explanation yetalt.column-walk.probe-once-vs-hasownproperty-per-column.unchanged-resend
Shippeda frame of 16 writes; all 256 derivations read 4 times each — deduped at the getter
Alternativethe same frame — deduped in the channel, by a dependent walk and a frame stamp
8.86 µs shipped2.62 µs alternative3.38×alternative timed twice: 0.4% apart
What the two sides do differently

THE OTHER END, AND THE ONE THAT SHOULD GO AGAINST US: everything derived is wanted, and wanted repeatedly. Ours walks the four sources on the FIRST read of each of the 256 derivations — 1024 comparisons a frame — and answers the other three reads of each from the slot's `checkedAt` pair against the channel clock, through `getValueForSlot` and its `assertNotReleased` every time; the channel arm asks nothing on a read and recomputes only what the writes touched. BELOW 1.0x HERE IS EXPECTED [FIGURE STATED IN ADVANCE]; a row that came out above 1.0x at BOTH ends would mean one arm is not written in its best form and the pair must not be quoted. Read with the row above and never alone: the pair IS the answer, and either row by itself reads as a verdict on "dedup" that neither one supports.

measured 2026-10-23no explanation yetalt.computed-dedup.getter-vs-channel.all-read-four-times
Shippeda frame of 16 writes; 16 of 256 derivations read once each — deduped at the getter
Alternativethe same frame — deduped in the channel, by a dependent walk and a frame stamp
480 ns shipped1.12 µs alternative0.43×alternative timed twice: 2.4% apart
What the two sides do differently

THE SHAPE AN APPLICATION USUALLY HAS, and the one the shipped arm is built for: far more derivations exist than any one frame reads. Ours settles 16 derivations and touches nothing else; the channel arm walks every dependent of all 16 written roots and recomputes each queued derivation whether or not it is read. ABOVE 1.0x HERE WOULD BE THE FINDING [FIGURE STATED IN ADVANCE], because it would mean the per-read source comparison costs more than recomputing derivations nobody wants. Both arms write through the same entity service and `OIMDB`, so the write path is common and cancels; what differs is only where the "already done this frame" question is asked. What no ratio here prices: the getter arm is what makes a derivation nobody reads cost nothing at all, which is a property of the whole engine and not of this frame.

measured 2026-10-23no explanation yetalt.computed-dedup.getter-vs-channel.few-read-once
Shippedif (!carrier.isPending) { carrier.isPending = true; pending.push(carrier) } — drained as an array
AlternativependingSet.add(carrier) — drained by iterating the Set and clearing it
4 ns shipped21 ns alternative0.19×alternative timed twice: 0.8% apart
What the two sides do differently

ONE OPERATION IS ONE MARK. A frame marks every carrier the stated number of times, in passes over the whole population, and then drains, so a repeat mark is the flag's early return on ours and a hash hit on the Set. The drain runs one counting body per carrier on both arms and both were checked to run the same number before the clock. This is the shape of `OIMChannelService.scheduleEffectRun` (the `isRunScheduled` flag and a push) and its frame loop, hand-written, so one carrier shape reaches each arm; production effects are built by one object literal in OIMEffectService, so the engine also sees one shape there.

measured 2026-10-23no explanation yetalt.dirty-flag-vs-set.1024-carriers.1-marks-each
Shippedif (!carrier.isPending) { carrier.isPending = true; pending.push(carrier) } — drained as an array
AlternativependingSet.add(carrier) — drained by iterating the Set and clearing it
2 ns shipped10 ns alternative0.18×alternative timed twice: 0.3% apart
What the two sides do differently

ONE OPERATION IS ONE MARK. A frame marks every carrier the stated number of times, in passes over the whole population, and then drains, so a repeat mark is the flag's early return on ours and a hash hit on the Set. The drain runs one counting body per carrier on both arms and both were checked to run the same number before the clock. This is the shape of `OIMChannelService.scheduleEffectRun` (the `isRunScheduled` flag and a push) and its frame loop, hand-written, so one carrier shape reaches each arm; production effects are built by one object literal in OIMEffectService, so the engine also sees one shape there.

measured 2026-10-23no explanation yetalt.dirty-flag-vs-set.1024-carriers.4-marks-each
Shippedif (!carrier.isPending) { carrier.isPending = true; pending.push(carrier) } — drained as an array
AlternativependingSet.add(carrier) — drained by iterating the Set and clearing it
6 ns shipped39 ns alternative0.16×alternative timed twice: 0.3% apart
What the two sides do differently

ONE OPERATION IS ONE MARK. A frame marks every carrier the stated number of times, in passes over the whole population, and then drains, so a repeat mark is the flag's early return on ours and a hash hit on the Set. The drain runs one counting body per carrier on both arms and both were checked to run the same number before the clock. This is the shape of `OIMChannelService.scheduleEffectRun` (the `isRunScheduled` flag and a push) and its frame loop, hand-written, so one carrier shape reaches each arm; production effects are built by one object literal in OIMEffectService, so the engine also sees one shape there.

measured 2026-10-23no explanation yetalt.dirty-flag-vs-set.65536-carriers.1-marks-each
Shippedif (!carrier.isPending) { carrier.isPending = true; pending.push(carrier) } — drained as an array
AlternativependingSet.add(carrier) — drained by iterating the Set and clearing it
2 ns shipped26 ns alternative0.092×alternative timed twice: 0.0% apart
What the two sides do differently

ONE OPERATION IS ONE MARK. A frame marks every carrier the stated number of times, in passes over the whole population, and then drains, so a repeat mark is the flag's early return on ours and a hash hit on the Set. The drain runs one counting body per carrier on both arms and both were checked to run the same number before the clock. This is the shape of `OIMChannelService.scheduleEffectRun` (the `isRunScheduled` flag and a push) and its frame loop, hand-written, so one carrier shape reaches each arm; production effects are built by one object literal in OIMEffectService, so the engine also sees one shape there.

measured 2026-10-23no explanation yetalt.dirty-flag-vs-set.65536-carriers.4-marks-each
Shippeda population built with one comparator for the whole row — asked on all sixteen
AlternativeREJECTED: a map from column name to predicate, plain === for the other fifteen
116 ns shipped200 ns alternative0.58×alternative timed twice: 1.9% apart
What the two sides do differently

WHAT A CALLER REACHING FOR THE PARAMETER ALMOST ALWAYS ACTUALLY WANTS: the one column holding a value that needs more than `===` gets the comparison it needs without every other column of every row paying for it. Sixteen columns, one of which needs an equality that is not `===`, written both ways. ONE OPERATION IS ONE UNCHANGED `updateEntity` OF SIXTEEN COLUMNS. Ours: 16 calls to the row comparator, of which 15 return on its `a === b` first line and one runs the expensive body. Floor: 16 `Map.prototype.get` probes, 15 inline `===` comparisons, and one call into the same expensive body. THE DIFFERENCE IS FIFTEEN CALLS AGAINST SIXTEEN MAP PROBES; the expensive comparison is charged once to both arms and cancels. THE EXPENSIVE COMPARATOR IS A CASE-INSENSITIVE STRING COMPARE AND NOT A DEEP EQUAL, on purpose: a deeper comparator would raise both nanosecond columns by the same amount and pull the ratio toward 1.00, so this row is the map design's best case. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.

measured 2026-10-23no explanation yetalt.equality-predicate.row-comparator-vs-column-comparators.one-column-of-sixteen
ShippedupdateEntity(slot, patch) — the shared default predicate, asked once per column
AlternativeREJECTED: SameValueZero written into the walk, with no parameter
123 ns shipped137 ns alternative0.90×alternative timed twice: 1.9% apart
What the two sides do differently

THE NEGATIVE READING A CALL-SITE DECISION IS OWED. The equality predicate is a parameter (`sameValueGuard`) so a caller can say what a change MEANS for their rows, and the argument for putting it on the hottest walk in the engine was that a shared default keeps the site monomorphic and therefore free. That is a ratio, and this row takes it. ONE OPERATION IS ONE UNCHANGED `updateEntity` OF A SIXTEEN-COLUMN ROW, primed outside the clock. Ours: 16 calls to `oimSameValueZeroGuard` through the shipped default writer's captured parameter. Floor: the same comparison — `a === b || (a !== a && b !== b)` — 16 times inline. Both: 16 `oimIsProtoKey` calls, one `oimIsPlain`, no allocation, and the early return. THE UNCHANGED WRITE IS WHERE THE PREDICATE IS THE WHOLE COLUMN; read this as the predicate's largest share of a write and not as its typical one. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.

measured 2026-10-23no explanation yetalt.equality-predicate.shared-default-vs-inlined.unchanged-resend
Shippedthe same write, in a process where one other population has its own comparator
AlternativeREJECTED: SameValueZero written into the walk — nothing can spoil it
178 ns shipped142 ns alternative1.26×alternative timed twice: 3.7% apart
What the two sides do differently

THE HALF OF THE ALTERNATIVE THE ROW ABOVE CANNOT SEE. `createOIMEntityWriterInPlace` returns a closure over ONE compiled `patchEntityInPlace` and ONE `changedColumns`, so the `sameValueGuard(entity[name], source[name])` inside it is one call site for the whole process — and one population built with its own comparator makes it polymorphic for every population that did not. A design with no parameter cannot be spoiled that way. HOW THE SPOILER IS APPLIED, outside the clock: a second population of 64 rows is built with `createOIMEntityWriterInPlace({ sameValueGuard: caseInsensitiveEquality })` and written to in this side's `reset`, which is never timed. The timed body touches only the measured population, so the WORK on the two arms is identical and the difference from the row above is the state of one inline cache. THE FLOOR IS THE SAME FLOOR AS THE ROW ABOVE, deliberately. A CAVEAT AGAINST THIS ROW: nothing here forces V8 to keep the site polymorphic; if the two rows come back identical within the noise floor, that is the first thing to suspect and the second is that polymorphism at this site is genuinely free. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.

measured 2026-10-23no explanation yetalt.equality-predicate.shared-default-vs-inlined.with-a-second-comparator-present
ShippedupdateEntity(slot, patch) — one shared predicate called from the walk
AlternativeREJECTED: name !== "__proto__" written into the walk, with no call at all
123 ns shipped136 ns alternative0.91×alternative timed twice: 0.9% apart
What the two sides do differently

THE ROW WHOSE EXPECTED ANSWER IS 1.00, STATED IN ADVANCE SO A RUN CAN REFUTE IT. `oimIsProtoKey` is module-level, monomorphic, one expression, no closure — the shape an optimiser removes — which is a claim that this ratio comes back inside the noise floor. If it does, centralising the rule is free; if it does not, the centralisation was bought with something. ONE OPERATION IS ONE UNCHANGED `updateEntity` OF SIXTEEN COLUMNS, so the difference is sixteen call frames per write against none. THE FLOOR IS NOT A DESIGN ANYBODY SHOULD SHIP: it is the duplicated comparison the rule was centralised out of, here as a measurement instrument — the isolated cost of a call level. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.

measured 2026-10-23no explanation yetalt.forbidden-name.call-vs-inlined.unchanged-resend
ShippedupdateEntity(slot, patch) — oimIsProtoKey(name), whose whole body is one comparison
AlternativeREJECTED: a Set of forbidden names, asked once per enumerated column
114 ns shipped178 ns alternative0.64×alternative timed twice: 4.2% apart
What the two sides do differently

WHAT THE RULE WOULD COST IF IT COULD GROW. The forbidden-name rule is one comparison against `OIM_PROTO_KEY`; a membership test against a collection is the shape it would take the day a second name joins it, and nothing has ever measured that. ONE OPERATION IS ONE UNCHANGED `updateEntity` OF A SIXTEEN-COLUMN ROW, primed outside the clock, so the predicate is asked sixteen times and the equality gate then ends every column — the arrangement that gives the predicate the largest share of a write it will ever have. OPERATION COUNT, ours: 16 monomorphic calls each doing one string compare. Floor: 16 `Set.prototype.has` calls, each probing a table of ONE entry. THE SET IS AT ITS BEST HERE AND THE READING IS THEREFORE THE REJECTED DESIGN'S FLOOR, NOT ITS TYPICAL COST. THE STRINGS ARE INTERNED ON BOTH ARMS, so the floor never pays a fresh hash and only pays a probe — in the floor's favour. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.

measured 2026-10-23no explanation yetalt.forbidden-name.comparison-vs-set.unchanged-resend
ShippedhandStore.delete(slot.key) on a Map of slots
Alternativemap.delete(row.id) on a Map of row copies
38 ns shipped37 ns alternative1.02×alternative timed twice: 1.1% apart
What the two sides do differently

One rung of a ladder from `map.delete(id)` to `entityService.deleteEntity(slot)` on an entity collection with no index, subscriber, column or hold. Every rung removes the same priceDataset.batch entities in the same order, one pass per population; the population is rebuilt between passes, untimed, and `db.flush()` closes every pass on every rung. Each rung adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. The hand rungs unfile into a Map of their own keyed by the same key strings; the collection's own store still holds the slots and is dropped at reset. This rung adds: reaching the key through the slot instead of the row; the key strings are the same objects.

measured 2026-10-23no explanation yetalt.ladder.remove.1-slot-key
ShippedslotStoreService.remove(store, slot.key)
AlternativehandStore.delete(slot.key)
38 ns shipped37 ns alternative1.01×alternative timed twice: 1.9% apart
What the two sides do differently

One rung of a ladder from `map.delete(id)` to `entityService.deleteEntity(slot)` on an entity collection with no index, subscriber, column or hold. Every rung removes the same priceDataset.batch entities in the same order, one pass per population; the population is rebuilt between passes, untimed, and `db.flush()` closes every pass on every rung. Each rung adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. The hand rungs unfile into a Map of their own keyed by the same key strings; the collection's own store still holds the slots and is dropped at reset. This rung adds: the call through the shipped Map-driven slot store service.

measured 2026-10-23no explanation yetalt.ladder.remove.2-store-service
Shippedwriter.clearEntity(slot), isEmpty = true, slotStoreService.remove, isReleased = true
AlternativeslotStoreService.remove(store, slot.key)
40 ns shipped37 ns alternative1.06×alternative timed twice: 4.1% apart
What the two sides do differently

One rung of a ladder from `map.delete(id)` to `entityService.deleteEntity(slot)` on an entity collection with no index, subscriber, column or hold. Every rung removes the same priceDataset.batch entities in the same order, one pass per population; the population is rebuilt between passes, untimed, and `db.flush()` closes every pass on every rung. Each rung adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. The hand rungs unfile into a Map of their own keyed by the same key strings; the collection's own store still holds the slots and is dropped at reset. This rung adds: clearing the value through the shipped in-place writer and marking the slot empty and released.

measured 2026-10-23no explanation yetalt.ladder.remove.3-writer-clear
ShippedOIMChannelService.INSTANCE.writeWithoutFlushCheck(channelSlot, slot), then the clear and unfile
Alternativethe clear and unfile
42 ns shipped40 ns alternative1.03×alternative timed twice: 0.7% apart
What the two sides do differently

One rung of a ladder from `map.delete(id)` to `entityService.deleteEntity(slot)` on an entity collection with no index, subscriber, column or hold. Every rung removes the same priceDataset.batch entities in the same order, one pass per population; the population is rebuilt between passes, untimed, and `db.flush()` closes every pass on every rung. Each rung adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. The hand rungs unfile into a Map of their own keyed by the same key strings; the collection's own store still holds the slots and is dropped at reset. This rung adds: the channel write that stamps the slot.

measured 2026-10-23no explanation yetalt.ladder.remove.4-channel
ShippedassertNotFlushing and the released check, then the channel, clear and unfile
Alternativethe channel, clear and unfile
42 ns shipped47 ns alternative0.89×alternative timed twice: 12.3% apart
What the two sides do differently

One rung of a ladder from `map.delete(id)` to `entityService.deleteEntity(slot)` on an entity collection with no index, subscriber, column or hold. Every rung removes the same priceDataset.batch entities in the same order, one pass per population; the population is rebuilt between passes, untimed, and `db.flush()` closes every pass on every rung. Each rung adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. The hand rungs unfile into a Map of their own keyed by the same key strings; the collection's own store still holds the slots and is dropped at reset. This rung adds: the two checks assertWritable runs.

measured 2026-10-23no explanation yetalt.ladder.remove.5-write-asserts
Shippedthe same inside one channel subframe
Alternativethe asserts, channel, clear and unfile
45 ns shipped53 ns alternative0.85×alternative timed twice: 25.8% apart
What the two sides do differently

One rung of a ladder from `map.delete(id)` to `entityService.deleteEntity(slot)` on an entity collection with no index, subscriber, column or hold. Every rung removes the same priceDataset.batch entities in the same order, one pass per population; the population is rebuilt between passes, untimed, and `db.flush()` closes every pass on every rung. Each rung adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. The hand rungs unfile into a Map of their own keyed by the same key strings; the collection's own store still holds the slots and is dropped at reset. This rung adds: one channel openSubframe / closeSubframe around the step.

measured 2026-10-23no explanation yetalt.ladder.remove.6-one-subframe
Shippedthe same inside two nested channel subframes
Alternativethe same inside one subframe
51 ns shipped44 ns alternative1.16×alternative timed twice: 1.8% apart
What the two sides do differently

One rung of a ladder from `map.delete(id)` to `entityService.deleteEntity(slot)` on an entity collection with no index, subscriber, column or hold. Every rung removes the same priceDataset.batch entities in the same order, one pass per population; the population is rebuilt between passes, untimed, and `db.flush()` closes every pass on every rung. Each rung adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. The hand rungs unfile into a Map of their own keyed by the same key strings; the collection's own store still holds the slots and is dropped at reset. This rung adds: a second, nested subframe. The shipped deleteEntity opens none on its fast path; on its slow path deleteEntityInSubframe opens one and releaseSlotContent nests a second inside it when the slot holds an entity.

measured 2026-10-23no explanation yetalt.ladder.remove.7-nested-subframe
ShippedentityService.deleteEntity(slot)
Alternativethe same steps written by hand, in two nested subframes
55 ns shipped50 ns alternative1.10×alternative timed twice: 0.2% apart
What the two sides do differently

One rung of a ladder from `map.delete(id)` to `entityService.deleteEntity(slot)` on an entity collection with no index, subscriber, column or hold. Every rung removes the same priceDataset.batch entities in the same order, one pass per population; the population is rebuilt between passes, untimed, and `db.flush()` closes every pass on every rung. Each rung adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. The hand rungs unfile into a Map of their own keyed by the same key strings; the collection's own store still holds the slots and is dropped at reset. This rung adds: the shipped door in place of the hand steps. On this fixture deleteEntity takes its fast path — assertWritable, the isOnFastPath read, writer.clearEntity, the channel write, markEmptiness and slot.owner.releaseSlotIfUnheld — and opens no subframe, runs no settleEmptiness and no dispatchContentChange, so the floor carries two subframes the door does not open.

measured 2026-10-23no explanation yetalt.ladder.remove.8-collection-door
ShippedassertWritable by hand, channel write, writer.clearEntity, isEmpty = true, slot.owner.releaseSlotIfUnheld (one slot.owner read per slot) — no subframe
AlternativeentityService.deleteEntity(slot)
51 ns shipped56 ns alternative0.90×alternative timed twice: 1.7% apart
What the two sides do differently

One rung of a ladder from `map.delete(id)` to `entityService.deleteEntity(slot)` on an entity collection with no index, subscriber, column or hold. Every rung removes the same priceDataset.batch entities in the same order, one pass per population; the population is rebuilt between passes, untimed, and `db.flush()` closes every pass on every rung. Each rung adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. The hand rungs unfile into a Map of their own keyed by the same key strings; the collection's own store still holds the slots and is dropped at reset. This rung adds: nothing over rung 8 in shape: the shipped deleteEntity is itself flat on this fixture, so this rung differs from it by about the isOnFastPath read, markEmptiness with a slotEmptiness.isEmpty call against a bare isEmpty = true, and the hand-inlined asserts against the assertWritable call; both keep the shipped release check and unfile.

measured 2026-10-23no explanation yetalt.ladder.remove.9-flat-door-candidate
ShippedentityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)
Alternativemap.get(id).title = value
30 ns shipped21 ns alternative1.39×alternative timed twice: 0.7% apart
What the two sides do differently

One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the whole column door by key over a bare Map store, in this ladder's own loop.

measured 2026-10-23no explanation yetalt.ladder.update-by-key.0-column-door-vs-bare-map
ShippedentityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)
Alternativemap.get(id).title = value
29 ns shipped21 ns alternative1.40×alternative timed twice: 0.6% apart
What the two sides do differently

One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. Both sides share one fixture, as the catalogue pair does.

measured 2026-10-23no explanation yetalt.ladder.update-by-key.0b-column-door-one-fixture
ShippedentityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)
Alternativemap.get(id).title = value
48 ns shipped21 ns alternative2.25×alternative timed twice: 0.3% apart
What the two sides do differently

One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. The catalogue pair's body, copied verbatim.

measured 2026-10-23no explanation yetalt.ladder.update-by-key.0c-catalogue-copy
ShippedentityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)
Alternativemap.get(id).title = value
47 ns shipped21 ns alternative2.23×alternative timed twice: 0.1% apart
What the two sides do differently

One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. The catalogue shape with the round body moved to a module-level function.

measured 2026-10-23no explanation yetalt.ladder.update-by-key.0d-catalogue-module-level-round
Shippedmap.get(id), skip when equal, store, queue once per frame
Alternativemap.get(id).title = value
27 ns shipped21 ns alternative1.28×alternative timed twice: 0.0% apart
What the two sides do differently

One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the comparison with the old value and the once-per-frame queue a bare Map store does not do.

measured 2026-10-23no explanation yetalt.ladder.update-by-key.1-compare-and-queue
ShippedentityService.getSlotByKey(entityStoreSlot, id).entity, then the same compare, store and queue
Alternativemap.get(id), skip when equal, store, queue once per frame
28 ns shipped28 ns alternative1.01×alternative timed twice: 2.3% apart
What the two sides do differently

One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: finding the entity through the collection instead of a Map of entities.

measured 2026-10-23no explanation yetalt.ladder.update-by-key.2-engine-lookup
Shippedthe same with oimSameValueZeroGuard instead of ===
AlternativegetSlotByKey, ===, store, queue
29 ns shipped28 ns alternative1.02×alternative timed twice: 1.1% apart
What the two sides do differently

One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the SameValueZero comparison the shipped writer uses.

measured 2026-10-23no explanation yetalt.ladder.update-by-key.3-same-value-zero
ShippedgetSlotByKey, then the shipped writer's patchColumn, then the hand queue
AlternativegetSlotByKey, SameValueZero, store, queue — written inline
30 ns shipped29 ns alternative1.04×alternative timed twice: 0.5% apart
What the two sides do differently

One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the call through the shipped writer object: the __proto__ check and the store it does.

measured 2026-10-23no explanation yetalt.ladder.update-by-key.4-writer-column
ShippedgetSlotByKey, patchColumn, OIMChannelService.INSTANCE.writeWithoutFlushCheck; db.flush() per round
AlternativegetSlotByKey, patchColumn, hand stamp and queue
25 ns shipped30 ns alternative0.83×alternative timed twice: 0.6% apart
What the two sides do differently

One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the shipped channel instead of a hand stamp and queue.

measured 2026-10-23no explanation yetalt.ladder.update-by-key.5-channel
Shippedthe flush and released asserts, the column-slot check, patchColumn, the channel, releaseSlotIfUnheld
AlternativegetSlotByKey, patchColumn, the channel
28 ns shipped26 ns alternative1.09×alternative timed twice: 0.7% apart
What the two sides do differently

One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the checks the door runs around the write, written by hand. The releaseSlotIfUnheld here is a full check the shipped updateEntityColumn does not run by default: it calls releaseWrittenSlotIfUnheld, a no-op unless the release policy releases written slots.

measured 2026-10-23no explanation yetalt.ladder.update-by-key.6-door-checks
ShippedentityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)
Alternativethe same steps written by hand
29 ns shipped28 ns alternative1.05×alternative timed twice: 0.6% apart
What the two sides do differently

One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the shipped door: entityService.slotContentService.updateEntityColumn → assertWritable, the isOnFastPath read, patchColumn, the channel and releaseWrittenSlotIfUnheld — not the full releaseSlotIfUnheld its floor runs.

measured 2026-10-23no explanation yetalt.ladder.update-by-key.7-column-door
ShippedentityService.slotContentService.updateEntity(entityService.getSlotByKey(entityStoreSlot, id), { title }) — the patch door
AlternativeentityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)
39 ns shipped29 ns alternative1.32×alternative timed twice: 1.2% apart
What the two sides do differently

One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the patch object and the walk over it, instead of naming the column.

measured 2026-10-23no explanation yetalt.ladder.update-by-key.8-patch-door
Shippedthe catalogue shape, plus an Int32Array frame allocated beside the fixture
Alternativemap.get(id).title = value
48 ns shipped27 ns alternative1.76×alternative timed twice: 27.3% apart
What the two sides do differently

One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. Only the frame array differs from 0d.

measured 2026-10-23no explanation yetalt.ladder.update-by-key.e1-catalogue-plus-frame-array
Shippedthe catalogue shape, the round called with the ladder's argument order
Alternativemap.get(id).title = value
48 ns shipped27 ns alternative1.77×alternative timed twice: 26.4% apart
What the two sides do differently

One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. Only the argument order differs from 0d.

measured 2026-10-23no explanation yetalt.ladder.update-by-key.e2-catalogue-ladder-arg-order
Shippedthe catalogue shape, both sides built by one round factory
Alternativemap.get(id).title = value
28 ns shipped21 ns alternative1.33×alternative timed twice: 0.2% apart
What the two sides do differently

One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. Only the shared round factory differs from 0d.

measured 2026-10-23no explanation yetalt.ladder.update-by-key.e3-catalogue-one-round-factory
ShippedentityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)
Alternativemap.get(id).title = value
29 ns shipped21 ns alternative1.37×alternative timed twice: 1.6% apart
What the two sides do differently

One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the shipped column door today, in the same loop, for comparison.

measured 2026-10-23no explanation yetalt.ladder.update-by-key.x0-column-door-now
ShippedgetSlotByKey, flush guard, patchColumn (compares), channel only when the slot has effects — no clock tick, no stamp
Alternativemap.get(id).title = value
27 ns shipped22 ns alternative1.26×alternative timed twice: 0.2% apart
What the two sides do differently

One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: what a channel with no computeds would leave: the comparison stays, the revision stamp goes.

measured 2026-10-23no explanation yetalt.ladder.update-by-key.x1-no-revision-channel
ShippedgetSlotByKey, flush guard, and a plain store when the slot has no effects
Alternativemap.get(id).title = value
25 ns shipped21 ns alternative1.16×alternative timed twice: 1.6% apart
What the two sides do differently

One rung of a ladder from `map.get(id).title = value` to `entityService.updateEntityColumn(entityService.getSlotByKey(entityStoreSlot, id), 'title', value)`. Every rung writes one column of the same priceDataset.batch entities, found by the same ids in the same order, in the same loop; each adds exactly one thing to the rung below it, and each pair re-measures the rung below as its floor in its own run. Up to the writer rung a frame is a hand-written stamp per entity and a queue drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: what a collection with no computeds could do on an unwatched slot: no comparison, no stamp.

measured 2026-10-23no explanation yetalt.ladder.update-by-key.x2-store-when-unwatched
Shippedfor…in over the patch, ===, queue once per frame
Alternativeentity.title = value after ===, queue once per frame
13 ns shipped6 ns alternative1.97×alternative timed twice: 1.2% apart
What the two sides do differently

One rung of a ladder from a hand-written tracked write (`entity.title = value` after `===`, the entity queued once per frame) to `entityService.updateEntity(slot, patch)`. Every rung writes the same slots of one population of priceDataset.batch entities, in the same loop, one { title } patch per round, and adds exactly one thing to the rung below it. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds, and the rungs sum to the whole gap only to within the drift between runs. Up to the writer-object rung a frame is a hand-written stamp per entity and a queue, drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: a patch object and a for…in over it instead of a named column.

measured 2026-10-23no explanation yetalt.ladder.update.1-patch-walk
Shippedthe same walk with the `__proto__` check, hasOwnProperty and oimSameValueZeroGuard
Alternativefor…in over the patch, ===, queue once per frame
14 ns shipped13 ns alternative1.10×alternative timed twice: 0.4% apart
What the two sides do differently

One rung of a ladder from a hand-written tracked write (`entity.title = value` after `===`, the entity queued once per frame) to `entityService.updateEntity(slot, patch)`. Every rung writes the same slots of one population of priceDataset.batch entities, in the same loop, one { title } patch per round, and adds exactly one thing to the rung below it. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds, and the rungs sum to the whole gap only to within the drift between runs. Up to the writer-object rung a frame is a hand-written stamp per entity and a queue, drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the two key guards and the SameValueZero comparison the shipped walk runs.

measured 2026-10-23no explanation yetalt.ladder.update.2-guards-and-same-value
ShippedcreateOIMEntityWriterInPlace().patchEntity(slot, patch), queue once per frame
Alternativethe same walk written inline
14 ns shipped13 ns alternative1.03×alternative timed twice: 0.7% apart
What the two sides do differently

One rung of a ladder from a hand-written tracked write (`entity.title = value` after `===`, the entity queued once per frame) to `entityService.updateEntity(slot, patch)`. Every rung writes the same slots of one population of priceDataset.batch entities, in the same loop, one { title } patch per round, and adds exactly one thing to the rung below it. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds, and the rungs sum to the whole gap only to within the drift between runs. Up to the writer-object rung a frame is a hand-written stamp per entity and a queue, drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the call through the shipped writer object instead of the walk inlined.

measured 2026-10-23no explanation yetalt.ladder.update.3-writer-object
Shippedthe shipped writer, then OIMChannelService.INSTANCE.writeWithoutFlushCheck(channelSlot, slot); db.flush() per round
Alternativethe shipped writer, then a hand stamp and queue; drained per round
11 ns shipped14 ns alternative0.83×alternative timed twice: 0.7% apart
What the two sides do differently

One rung of a ladder from a hand-written tracked write (`entity.title = value` after `===`, the entity queued once per frame) to `entityService.updateEntity(slot, patch)`. Every rung writes the same slots of one population of priceDataset.batch entities, in the same loop, one { title } patch per round, and adds exactly one thing to the rung below it. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds, and the rungs sum to the whole gap only to within the drift between runs. Up to the writer-object rung a frame is a hand-written stamp per entity and a queue, drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the shipped channel instead of a hand-written stamp and queue.

measured 2026-10-23no explanation yetalt.ladder.update.4-channel
ShippedOIMChannelService.INSTANCE.assertNotFlushing(channelSlot) and the released check, then the writer and the channel
Alternativethe shipped writer, then OIMChannelService.INSTANCE.writeWithoutFlushCheck(channelSlot, slot)
13 ns shipped11 ns alternative1.15×alternative timed twice: 0.1% apart
What the two sides do differently

One rung of a ladder from a hand-written tracked write (`entity.title = value` after `===`, the entity queued once per frame) to `entityService.updateEntity(slot, patch)`. Every rung writes the same slots of one population of priceDataset.batch entities, in the same loop, one { title } patch per round, and adds exactly one thing to the rung below it. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds, and the rungs sum to the whole gap only to within the drift between runs. Up to the writer-object rung a frame is a hand-written stamp per entity and a queue, drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: what assertWritable checks: no flush running, the identity not released.

measured 2026-10-23no explanation yetalt.ladder.update.5a-write-asserts
Shippedthe asserts, the column-store check, the writer and the channel
Alternativethe asserts, the writer and the channel
14 ns shipped13 ns alternative1.11×alternative timed twice: 0.3% apart
What the two sides do differently

One rung of a ladder from a hand-written tracked write (`entity.title = value` after `===`, the entity queued once per frame) to `entityService.updateEntity(slot, patch)`. Every rung writes the same slots of one population of priceDataset.batch entities, in the same loop, one { title } patch per round, and adds exactly one thing to the rung below it. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds, and the rungs sum to the whole gap only to within the drift between runs. Up to the writer-object rung a frame is a hand-written stamp per entity and a queue, drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the three reads updateEntity makes before choosing its path: updatesEmptinessOnColumnWrite, whether the identity has column slots, and whether the collection has content-change listeners — here as fields of a hand-held object.

measured 2026-10-23no explanation yetalt.ladder.update.5b-column-reader-check
Shippedthe asserts and checks, the writer, the channel, then slot.owner.releaseSlotIfUnheld(slot) (one slot.owner read per slot)
Alternativethe asserts and checks, the writer and the channel
15 ns shipped14 ns alternative1.09×alternative timed twice: 0.6% apart
What the two sides do differently

One rung of a ladder from a hand-written tracked write (`entity.title = value` after `===`, the entity queued once per frame) to `entityService.updateEntity(slot, patch)`. Every rung writes the same slots of one population of priceDataset.batch entities, in the same loop, one { title } patch per round, and adds exactly one thing to the rung below it. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds, and the rungs sum to the whole gap only to within the drift between runs. Up to the writer-object rung a frame is a hand-written stamp per entity and a queue, drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: a full releaseSlotIfUnheld after the write. The shipped updateEntity does not run it: its fast path calls releaseWrittenSlotIfUnheld, a no-op unless the release policy releases written slots, so this rung prices a check the shipped door skips by default.

measured 2026-10-23no explanation yetalt.ladder.update.5c-release-check
ShippedentityService.slotContentService.updateEntity(slot, patch); db.flush() per round
Alternativethe rung-5c steps written out by hand around the shipped writer and channel
15 ns shipped16 ns alternative0.96×alternative timed twice: 0.3% apart
What the two sides do differently

One rung of a ladder from a hand-written tracked write (`entity.title = value` after `===`, the entity queued once per frame) to `entityService.updateEntity(slot, patch)`. Every rung writes the same slots of one population of priceDataset.batch entities, in the same loop, one { title } patch per round, and adds exactly one thing to the rung below it. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds, and the rungs sum to the whole gap only to within the drift between runs. Up to the writer-object rung a frame is a hand-written stamp per entity and a queue, drained once per round; from the channel rung on it is the shipped channel and its flush. This rung adds: the shipped route instead of the hand helpers: entityService.slotContentService.updateEntity → assertWritable, the isOnFastPath read, the writer, the channel and releaseWrittenSlotIfUnheld — not the full releaseSlotIfUnheld its floor runs, so this pair prices the route minus that check.

measured 2026-10-23no explanation yetalt.ladder.update.5d-collection-route
ShippedpublicService.writeBucketMember(slot, member), forwarding to the internal service
AlternativeinternalService.writeBucketMember(slot, member): one store and one channel call
3 ns shipped2 ns alternative1.43×alternative timed twice: 1.3% apart
What the two sides do differently

A self-contained model, importing nothing from core, of the public/internal split Andrey approved on 2026-10-21: the public service holds the internal one in a private readonly field and each door forwards to the same internal method. Ours goes through the public door; the floor calls the internal method directly, on the same pool of 1024 slots. Both arms see one receiver class each, so the only difference is the forwarding call and its field load. No channel assert is in either arm, so this prices the hop and nothing the real door adds. Each arm runs in its own process. The door is a write: one array store and one channel call that stamps a revision.

measured 2026-10-23no explanation yetalt.layer-hop.write-through-public-layer-vs-internal
ShippedentityService.updateEntity(slot, patch) with the shipped in-place writer — 1-field, guarded for…in
Alternativethe same update with a writer whose patch walk is a for…in with no guard
20 ns shipped19 ns alternative1.07×alternative timed twice: 0.1% apart
What the two sides do differently

The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here.

measured 2026-10-23no explanation yetalt.patch-guards.for-in-guarded-vs-bare.1-field
ShippedentityService.updateEntity(slot, patch) on a 10-column entity, the patch moving every column — shipped in-place writer, guarded for…in
Alternativethe same update with a writer whose patch walk is a for…in with no guard
175 ns shipped188 ns alternative0.93×alternative timed twice: 0.5% apart
What the two sides do differently

The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here.

measured 2026-10-23no explanation yetalt.patch-guards.for-in-guarded-vs-bare.10-column-entity
ShippedentityService.updateEntity(slot, patch) on a 100-column entity, the patch moving every column — shipped in-place writer, guarded for…in
Alternativethe same update with a writer whose patch walk is a for…in with no guard
1.51 µs shipped1.58 µs alternative0.95×alternative timed twice: 0.0% apart
What the two sides do differently

The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here.

measured 2026-10-23no explanation yetalt.patch-guards.for-in-guarded-vs-bare.100-column-entity
ShippedentityService.updateEntity(slot, patch) with the shipped in-place writer — 3-field, guarded for…in
Alternativethe same update with a writer whose patch walk is a for…in with no guard
69 ns shipped71 ns alternative0.96×alternative timed twice: 1.0% apart
What the two sides do differently

The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here.

measured 2026-10-23no explanation yetalt.patch-guards.for-in-guarded-vs-bare.3-field
ShippedentityService.updateEntity(slot, patch) on a 30-column entity, the patch moving every column — shipped in-place writer, guarded for…in
Alternativethe same update with a writer whose patch walk is a for…in with no guard
426 ns shipped450 ns alternative0.95×alternative timed twice: 0.8% apart
What the two sides do differently

The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here.

measured 2026-10-23no explanation yetalt.patch-guards.for-in-guarded-vs-bare.30-column-entity
ShippedentityService.updateEntity(slot, patch) with the shipped in-place writer — 1-field, guarded for…in
Alternativethe same update with a writer whose patch walk is Object.keys with no guard
20 ns shipped21 ns alternative0.96×alternative timed twice: 3.0% apart
What the two sides do differently

The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here.

measured 2026-10-23no explanation yetalt.patch-guards.for-in-guarded-vs-object-keys.1-field
ShippedentityService.updateEntity(slot, patch) with the shipped in-place writer — 3-field, guarded for…in
Alternativethe same update with a writer whose patch walk is Object.keys with no guard
69 ns shipped108 ns alternative0.63×alternative timed twice: 1.3% apart
What the two sides do differently

The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here.

measured 2026-10-23no explanation yetalt.patch-guards.for-in-guarded-vs-object-keys.3-field
ShippedslotContentService.insertBucketMemberSlotAt(bucket, 0, slot) into a list of 1024, membership kept in a Set
Alternativethe same prepend, membership kept in a Map to positions
968 ns shipped10.98 µs alternative0.088×alternative timed twice: 0.5% apart
What the two sides do differently

THE OPERATION COUNT IS NOT IN DISPUTE. A prepend splices one member in at the front, which invalidates every position after it: the renumber is exactly `list.length - at` map writes, so 1025 of them here, against one memmove and one `Set.add` on our side. EACH OPERATION IS A PREPEND AND A REMOVAL OF THE TAIL, so the list stays the length it is named for; the removal renumbers nothing on either design. Ours is `OIMSlotContentBucketServiceArrayDriven` over `OIMBucketArrayMembershipUnique`; the floor is the same service subclassed to keep a positions map. DIRECTION: the bucket collection's own epilogue — the hold, the unhold, the `OIMChannelService.writeWithoutFlushCheck` and the emptiness update — is identical on both halves and inside both numbers, which pulls this toward 1.00. A LAZY positions map is a third design and this row does not refute it. The reading in `packages/bench/measurements/2026-08-20-alternatives/positions` was taken on a positional index and bucket mutator that are gone and is not re-attributed here.

measured 2026-10-23no explanation yetalt.prepend-list-vs-positions-map
ShippedentityService.upsertEntity(storeSlot, row) on a key that holds a value — the shipped in-place writer, guarded walks
Alternativethe same upsert with a writer whose patch and departure walks run no guard
111 ns shipped105 ns alternative1.05×alternative timed twice: 4.3% apart
What the two sides do differently

The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here. A put runs two walks: the new columns, then the stored columns the new value does not carry.

measured 2026-10-23no explanation yetalt.put-guards.guarded-vs-bare
ShippedentityService.upsertEntity(storeSlot, entity) on a key holding a 10-column entity, every column moving — shipped in-place writer, guarded walks
Alternativethe same upsert with a writer whose patch and departure walks run no guard
257 ns shipped252 ns alternative1.02×alternative timed twice: 0.4% apart
What the two sides do differently

The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here. A put runs two walks: the new columns, then the stored columns the new value does not carry.

measured 2026-10-23no explanation yetalt.put-guards.guarded-vs-bare.10-column-entity
ShippedentityService.upsertEntity(storeSlot, entity) on a key holding a 100-column entity, every column moving — shipped in-place writer, guarded walks
Alternativethe same upsert with a writer whose patch and departure walks run no guard
6.86 µs shipped6.92 µs alternative0.99×alternative timed twice: 0.2% apart
What the two sides do differently

The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here. A put runs two walks: the new columns, then the stored columns the new value does not carry.

measured 2026-10-23no explanation yetalt.put-guards.guarded-vs-bare.100-column-entity
ShippedentityService.upsertEntity(storeSlot, entity) on a key holding a 30-column entity, every column moving — shipped in-place writer, guarded walks
Alternativethe same upsert with a writer whose patch and departure walks run no guard
2.19 µs shipped2.18 µs alternative1.01×alternative timed twice: 0.2% apart
What the two sides do differently

The guards are the `__proto__` key check and the own-key check (`hasOwnProperty`) the shipped walk runs on every key of the patch. Both sides write through the shipped OIMSlotContentEntityService (entityService.slotContentService) with no index and no subscriber, so the write is one channel write and opens no subframe; only the writer differs. The same-value guard stays on both sides: it is a strategy already (`sameValueGuard`), not part of what is priced here. A put runs two walks: the new columns, then the stored columns the new value does not carry.

measured 2026-10-23no explanation yetalt.put-guards.guarded-vs-bare.30-column-entity
ShippedupsertEntity of a row missing one column — the replacement is built from the survivors
AlternativeREJECTED: { ...entity }, then delete the departing column off the copy
899 ns shipped2.03 µs alternative0.44×alternative timed twice: 0.4% apart
What the two sides do differently

The shipped side is the replacing `putEntity`: one pass over the stored row with a `hasOwnProperty` on the incoming value per column, and ONE new object built from the survivors. The rejected side keeps the two-step put the engine used to run — its spread-and-`delete` removal, then the shipped replacing `patchEntity`, which spreads a second copy — so it pays two objects where ours pays one. ONE OPERATION IS ONE `upsertEntity` OF A ROW THE POPULATION ALREADY HAS, and the passes ALTERNATE: a value without `c15`, then the whole value again — a column can only leave a row once. Both sides write the row to the channel once per upsert. THE SURROUNDING `upsertEntity` IS INSIDE BOTH NUMBERS — the marks and the content-change call — so the ratio is a LOWER BOUND on the difference between the two rebuilds. READINGS TAKEN BEFORE THE ENGINE HAD `putEntity` priced a different shipped side and do not describe this one. WHAT THIS ROW DOES NOT MEASURE is what the shipped side buys, which falls on every later READ of a row the `delete` took out of its shape. That is the row below. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.

measured 2026-10-23no explanation yetalt.replacement-rebuild.survivors-vs-spread-and-delete.the-removal
Shippedthe replacing writer: { ...entity }, then one store per column the walk recorded
AlternativeREJECTED: { ...entity, ...source } — the whole patch spread over the copy
379 ns shipped569 ns alternative0.67×alternative timed twice: 0.1% apart
What the two sides do differently

THE ARMS OF THIS QUESTION SWAPPED SIDES. The shipped replacing writer used to spread the whole patch over the copy; `createOIMEntityWriterReplacing` now assigns only the names `changedColumns` recorded, so the spread is the rejected arm. ONE OPERATION IS ONE `updateEntity` CARRYING SIXTEEN COLUMNS OF WHICH EXACTLY ONE HAS MOVED — the shape a socket re-sending a whole row produces, and the shape that makes the two designs differ most. OPERATION COUNT. Both arms: the same `changedColumns` walk — 16 `oimIsProtoKey` calls, 16 equality calls, one names array with ONE push — the marks, and one record allocated. Ours then copies 17 values from the entity and does ONE store. The floor copies 17 from the entity and 16 from the patch — 33 stores, 15 of them writing a value the copy already held. THE DIFFERENCE IS SIXTEEN PROPERTY COPIES AGAINST ONE, per write. WHAT THE SPREAD WOULD BUY, and it is not a number: a caller's `sameValueGuard` may call two different objects equal, and the spread then stores the NEWER one while reporting nothing moved, where the shipped form keeps the older one. ONLY `c00` ADVANCES, by one of eight per pass; the other fifteen columns hold the values the population was primed with. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.

measured 2026-10-23no explanation yetalt.replacing-build.assign-the-moved-vs-spread-the-patch.one-column-of-sixteen
Shippedthe replacing writer: walk to decide, then one spread and one store per moved column
AlternativeREJECTED: one spread of the entity up front, then assign each column as it is found
508 ns shipped526 ns alternative0.97×alternative timed twice: 0.4% apart
What the two sides do differently

WHAT THE SHIPPED ORDER COSTS WHEN THE WRITE REALLY CHANGES SOMETHING — a re-hydration, where every write changes something. ONE OPERATION IS ONE `updateEntity` MOVING ALL SIXTEEN COLUMNS. Both arms: 16 `oimIsProtoKey` calls, 16 equality calls, one changed-names array with 16 pushes, the marks, and exactly ONE record allocated with 17 values spread and 16 stored. The difference is that ours walks the patch to decide and then loops the 16 recorded names a second time to store them, where the floor stores as it walks. IF IT COMES BACK NEAR 1.00 the second loop is worth nothing and the rejected design loses on its own ground as well as on the unchanged-write contract. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.

measured 2026-10-23no explanation yetalt.replacing-build.decide-first-vs-build-as-you-walk.every-column-moved
Shippedthe replacing writer: walk, find nothing moved, allocate nothing
AlternativeREJECTED: copy the row up front, assign what moved, store the copy regardless
141 ns shipped397 ns alternative0.36×alternative timed twice: 1.0% apart
What the two sides do differently

THE WRITE THE SHIPPED ORDER EXISTS FOR. "Decide before you allocate" only differs from "build as you walk" on a write that moves NOTHING, and there it differs completely: ours returns false having allocated neither a row nor a names array, and the floor has already spread the row before it could know. ONE OPERATION IS ONE UNCHANGED `updateEntity` OF A SIXTEEN-COLUMN ROW, primed outside the clock. Both arms: 16 `oimIsProtoKey` calls, 16 equality calls, one `oimIsPlain`, no mark. The floor allocates one seventeen-property record, copies seventeen values into it and stores it on the slot — per write, abandoned. THE COPY IS STORED, so it escapes and V8 cannot elide it; storing it is also the faithful reading of the rejected design, which has no decision point at which to withhold the copy — and so hands readers a new reference on an unchanged write. THIS ROW MEASURES WHAT THAT COSTS AND NOT WHETHER IT IS ACCEPTABLE. Read with the `every-column-moved` row beside it. THE WRITE AROUND THE WALK IS IDENTICAL ON BOTH ARMS AND IS INSIDE BOTH NUMBERS: `assertWritable` with the channel's `assertNotFlushing`, `openSubframe`/`closeSubframe`, the writer dispatch, the `length > 0` test, and — on a write that moves something — the changed-names array, `markColumnsChanged`'s column-store probe per moved column, `OIMChannelService.writeWithoutFlushCheck` and `markContentChanged`. That is a large constant added to the numerator and the denominator alike, so it pulls this ratio toward 1.00 and the printed ratio is a LOWER BOUND on the difference between the two walks. The two nanosecond columns beside it are not pulled anywhere: subtract them to get the per-write difference the row is actually about. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.

measured 2026-10-23no explanation yetalt.replacing-build.decide-first-vs-build-as-you-walk.unchanged-resend
Shippeda hold on the four slot shapes the hold door sees (entity, bucket, push column, computed) in turn
Alternativethe same hold on the four kinds minted with ONE shape: the 15-key header plus `content`
2 ns shipped2 ns alternative1.44×alternative timed twice: 0.4% apart
What the two sides do differently

One operation is one holdCount increment, the body of OIMSlotOwner.holdSlot; an unhold is left out because an increment and a decrement of one field in one body can be folded away by the compiler. The hold door sees four shapes today (how-many-shapes-reach-the-write-door.test.ts), the pull column sharing the computed literal, which here carries computedValueService as createOIMComputedSlot does. Four shapes is the megamorphic edge.

measured 2026-10-23no explanation yetalt.slot-layout.hold-four-shapes-against-one-shape
Shippedthe channel write door handed the four shipped slot shapes in turn
Alternativethe same door reaching the common fields through one shared sub-object `slot.common`
4 ns shipped5 ns alternative0.88×alternative timed twice: 4.6% apart
What the two sides do differently

As the one-shape pair, but the candidate keeps four kind shapes and moves the fields the door touches into one sub-object of one shape: one extra load per write buys a monomorphic one.

measured 2026-10-23no explanation yetalt.slot-layout.write-door-four-shapes-against-common-part
Shippedthe channel write door handed the four shipped slot shapes (entity, bucket, column, computed) in turn
Alternativethe same door handed four kinds minted with ONE shape: common fields plus one `content` field
4 ns shipped3 ns alternative1.14×alternative timed twice: 0.4% apart
What the two sides do differently

One operation is one write; the pool cycles entity, bucket, column, computed. The door reads holdCount and effects and stamps two fields, as OIMChannel.writeWithoutFlushCheck does. Every slot is held, so the gate never returns early. Bodies are separate function literals so the two arms keep separate feedback.

measured 2026-10-23no explanation yetalt.slot-layout.write-door-four-shapes-against-one-shape
Shippedthe channel write door handed the three slot shapes that reach it today (entity, bucket, push column) in turn
Alternativethe same door handed the same three kinds minted with ONE shape: the 15-key header plus one `content` field
4 ns shipped4 ns alternative1.08×alternative timed twice: 5.8% apart
What the two sides do differently

One operation is one write; the pool cycles entity, bucket, push column, the only kinds whose slots reach OIMChannel.writeWithoutFlushCheck (how-many-shapes-reach-the-write-door.test.ts pins three). The literals copy the key order of createOIMEntitySlot, createOIMBucketSlot and OIMColumnOwnerPushDriven.createColumnSlot. Three shapes are still under the polymorphic ceiling of four, which is what this pair asks about. Every slot is held, so the gate never returns early.

measured 2026-10-23no explanation yetalt.slot-layout.write-door-three-shapes-against-one-shape
ShippedupdateEntity on a loaded population whose every slot has one shape
AlternativeREJECTED: the same write where a slot’s shape depends on what has happened to it
35 ns shipped42 ns alternative0.84×alternative timed twice: 13.5% apart
What the two sides do differently

WHERE THE SHIPPED LITERAL IS SUPPOSED TO EARN THE FIVE STORES THE ROW ABOVE CHARGES IT FOR. "Every slot of a population settles on a single hidden class" is only worth anything if something later reads those slots through a site that would otherwise go polymorphic — which is the write path: `OIMChannelService.writeWithoutFlushCheck` reads `effects`, `changedAtRevision` and `changedAtEpoch`, and the collection reads `entity` and `isReleased`, all through one compiled body per method. THE POPULATION IS DELIBERATELY HETEROGENEOUS THE WAY A SCREEN MAKES IT SO: one row in eight carries an effect (`effectService.createEffect([slot], [], body)`), which is what a mounted view of a list looks like. On ours that changes no shape — `effects` was there from birth. On the floor the subscribed slots gain a property the rest do not have, so the population holds two shapes and every one of those reads sees both. ONE OPERATION IS ONE `updateEntity` MOVING ONE COLUMN of a sixteen-column row, and the subscribed eighth really is woken — both arms subscribe the same rows to the same shared body, so the delivery is inside both numbers and cancels. THE FLOOR IS AT ITS BEST WITH TWO SHAPES; a column hold (`columnSlotStore`) or an index (`indexKeys`) adds another at the same sites, so this reading is a LOWER BOUND on what the shipped literal buys. THIS PAIR DECLARES `isolate`, AND THE READING IS UNINTERPRETABLE WITHOUT IT. Both arms reach the engine through one compiled function — `OIMSlotContentEntityService.prototype.updateEntity`, whose single call site `this.entityWriter.patchEntity(entitySlot, patch, undefined)` would see both writers in one process. Neither would then be inlined, and inlining the column walk into the write is exactly where a walk's advantage lives; worse, the failure is invisible, because a ratio of 1.00 would be equally consistent with "the two walks cost the same" and "each arm ran through caches the other had already made polymorphic". Each side is therefore probed and timed in a process that has never constructed the other, and `build` declines to fill the population it was not asked for — merely FILLING the other design's population teaches V8 its shape, so declining to time it is not enough. What it costs: `noise` now includes process-to-process variation, which is the honest thing for it to include here.

measured 2026-10-23no explanation yetalt.slot-literal.complete-vs-grown.write-a-partly-subscribed-population
Shippedone write function handed three slot shapes — entity, bucket, column
Alternativethree write functions, one per slot kind, each handed only its own shape
8 ns shipped8 ns alternative1.04×alternative timed twice: 4.1% apart
What the two sides do differently

ONE OPERATION IS THREE WRITES, one slot of each kind, in the same order on both arms over the same pool of literals. The bodies are byte-identical and are SEPARATE FUNCTION LITERALS — closures minted from one literal share their feedback, so a factory would make the rejected arm polymorphic too and the row would price nothing. These three are the literals `how-many-shapes-reach-the-write-door.test.ts` pins at `OIMChannel.writeWithoutFlushCheck`, so our arm is as polymorphic as production. `isolate` keeps the two arms from sharing a heap history.

measured 2026-10-23no explanation yetalt.slot-shape.one-write-site-against-one-per-kind
Shippedone write function handed the three shipped slot shapes
Alternativeone write function handed three slots minted with one unified shape
8 ns shipped7 ns alternative1.12×alternative timed twice: 1.1% apart
What the two sides do differently

THE HALF OF THE UNIFIED-SHAPE ARGUMENT THAT FAVOURS IT, and it must be read with `alt.slot-shape.three-shapes-against-one-at-the-mint`, which is the half that pays for it. One operation is three writes in the same order over the same pool size on both arms; the only difference is whether the site sees three hidden classes or one. The unified literal carries every field any kind needs, in one order, so it is one map. Above one is the shipped design losing at the write.

measured 2026-10-23no explanation yetalt.slot-shape.three-shapes-against-one-at-the-write
ShippedentityService.slotContentService.updateEntity(entityService.getSlotByKey(entityStoreSlot, id), patch)
AlternativeentityService.updateEntity(slotById.get(id), patch) — the same engine write, the slot found by a bare Map.get
47 ns shipped46 ns alternative1.00×alternative timed twice: 0.0% apart
What the two sides do differently

Both sides run on the same population of priceDataset.batch entities and visit the same ids in the same order. The floor reaches the same slots through a hand-built Map<id, slot>; the engine reaches them through its store service. Ours finds the slot in the store with getSlotByKey and then runs updateEntity; the floor calls updateEntity on a slot it found itself. The lookup alone is priced by alt.lookup.get-slot-by-key-vs-map-get, so what this ratio adds over that one is the by-key door around the same write.

measured 2026-10-23no explanation yetalt.update-by-key.engine-lookup-vs-map-get
Shippedthe one-channel method through the module writer, as a method on the probe
Alternativethe same steps as a plain function over the public members: assertNotFlushing, isReleased, columnSlotStore, the writer, the channel
18 ns shipped17 ns alternative1.10×alternative timed twice: 0.1% apart
What the two sides do differently

Both sides run over the same createOIMEntityService population of priceDataset.batch entities, one { title } patch per round and one flush per round; no index and no subscriber, so every write is one channel write. The probe methods reach the content service's private slotOwnerService, isOnFastPath and entityWriter through a cast (`as unknown as {…}`), the same pieces updateEntity runs on; only the shape of the door differs. This pair isolates: running the steps as a method on the probe, through the private pieces reached by the cast — assertWritable and isOnFastPath as calls — instead of inlining assertNotFlushing, isReleased and a columnSlotStore read over public members.

measured 2026-10-23no explanation yetalt.update-door.method-vs-function
Shippedthe one-channel method with releaseSlotIfUnheld
Alternativethe same method without releaseSlotIfUnheld
22 ns shipped19 ns alternative1.16×alternative timed twice: 1.6% apart
What the two sides do differently

Both sides run over the same createOIMEntityService population of priceDataset.batch entities, one { title } patch per round and one flush per round; no index and no subscriber, so every write is one channel write. The probe methods reach the content service's private slotOwnerService, isOnFastPath and entityWriter through a cast (`as unknown as {…}`), the same pieces updateEntity runs on; only the shape of the door differs. This pair isolates: a full releaseSlotIfUnheld after a landed write, which the shipped updateEntity does not run by default: it calls releaseWrittenSlotIfUnheld, a no-op unless the release policy releases written slots.

measured 2026-10-23no explanation yetalt.update-door.release-check
ShippedentityService.slotContentService.updateEntity(slot, patch) — the shipped door
Alternativea probe method doing only the one-channel path: assert, column-reader check, writer, channel, release
19 ns shipped22 ns alternative0.86×alternative timed twice: 2.8% apart
What the two sides do differently

Both sides run over the same createOIMEntityService population of priceDataset.batch entities, one { title } patch per round and one flush per round; no index and no subscriber, so every write is one channel write. The probe methods reach the content service's private slotOwnerService, isOnFastPath and entityWriter through a cast (`as unknown as {…}`), the same pieces updateEntity runs on; only the shape of the door differs. This pair isolates: the shipped OIMSlotContentEntityService.updateEntity against one probe method, and releaseWrittenSlotIfUnheld — a no-op under the default AtEmpty policy — on the shipped side against the full releaseSlotIfUnheld the method runs; both sides read isOnFastPath.

measured 2026-10-23no explanation yetalt.update-door.shipped-vs-one-channel-method
Shippedthe one-channel method with assertWritable
Alternativethe same method without assertWritable
22 ns shipped18 ns alternative1.21×alternative timed twice: 4.0% apart
What the two sides do differently

Both sides run over the same createOIMEntityService population of priceDataset.batch entities, one { title } patch per round and one flush per round; no index and no subscriber, so every write is one channel write. The probe methods reach the content service's private slotOwnerService, isOnFastPath and entityWriter through a cast (`as unknown as {…}`), the same pieces updateEntity runs on; only the shape of the door differs. This pair isolates: assertWritable: the flush guard and the released check.

measured 2026-10-23no explanation yetalt.update-door.write-asserts
Shippedthe one-channel method without release, writer read from the content service's entityWriter
Alternativethe same method, the same writer object read from a module constant
18 ns shipped18 ns alternative0.99×alternative timed twice: 0.1% apart
What the two sides do differently

Both sides run over the same createOIMEntityService population of priceDataset.batch entities, one { title } patch per round and one flush per round; no index and no subscriber, so every write is one channel write. The probe methods reach the content service's private slotOwnerService, isOnFastPath and entityWriter through a cast (`as unknown as {…}`), the same pieces updateEntity runs on; only the shape of the door differs. This pair isolates: reading the writer off the probe field instead of a module constant.

measured 2026-10-23no explanation yetalt.update-door.writer-field-vs-module-writer

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

Per entity per write​

Shipped64 adds, one to each of 64 buckets, in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativethe same adds, each one written to the channel, settled and announced at once
67 ns shipped57 ns alternative1.17×alternative timed twice: 0.9% apart
What the two sides do differently

64 adds spread over 64 different buckets inside one subframe, so there is nothing to coalesce: every bucket changes once. No content-change listener. The shipped arm marks the bucket pending once, registers a close callback in the channel's Set on every add, and writes, settles and announces the bucket once when the outermost subframe closes; the alternative does all three on every add. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.64-buckets-one-add-each
Shipped8 adds, one to each of 8 buckets, in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativethe same adds, each one written to the channel, settled and announced at once
79 ns shipped63 ns alternative1.25×alternative timed twice: 2.3% apart
What the two sides do differently

8 adds spread over 8 different buckets inside one subframe, so there is nothing to coalesce: every bucket changes once. No content-change listener. The shipped arm marks the bucket pending once, registers a close callback in the channel's Set on every add, and writes, settles and announces the bucket once when the outermost subframe closes; the alternative does all three on every add. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.8-buckets-one-add-each
Shipped64 adds, one to each of 64 buckets, in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive arm
71 ns shipped61 ns alternative1.17×alternative timed twice: 0.2% apart
What the two sides do differently

64 adds spread over 64 different buckets inside one subframe, so there is nothing to coalesce: every bucket changes once. No content-change listener. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive-by-listener.64-buckets-one-add-each
Shipped8 adds, one to each of 8 buckets, in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive arm
84 ns shipped68 ns alternative1.24×alternative timed twice: 2.1% apart
What the two sides do differently

8 adds spread over 8 different buckets inside one subframe, so there is nothing to coalesce: every bucket changes once. No content-change listener. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive-by-listener.8-buckets-one-add-each
Shipped1 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive arm
178 ns shipped103 ns alternative1.73×alternative timed twice: 0.9% apart
What the two sides do differently

1 adds to ONE bucket inside one subframe. No content-change listener. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive-by-listener.one-bucket-1-adds
Shipped1 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive arm
179 ns shipped145 ns alternative1.23×alternative timed twice: 0.3% apart
What the two sides do differently

1 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 1 changes of one bucket. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive-by-listener.one-bucket-1-adds-with-a-listener
Shipped64 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive arm
23 ns shipped22 ns alternative1.04×alternative timed twice: 1.9% apart
What the two sides do differently

64 adds to ONE bucket inside one subframe. No content-change listener. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive-by-listener.one-bucket-64-adds
Shipped64 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive arm
23 ns shipped20 ns alternative1.17×alternative timed twice: 1.0% apart
What the two sides do differently

64 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 64 changes of one bucket. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive-by-listener.one-bucket-64-adds-with-a-listener
Shipped8 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive arm
41 ns shipped31 ns alternative1.32×alternative timed twice: 1.0% apart
What the two sides do differently

8 adds to ONE bucket inside one subframe. No content-change listener. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive-by-listener.one-bucket-8-adds
Shipped8 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive arm
41 ns shipped38 ns alternative1.10×alternative timed twice: 1.4% apart
What the two sides do differently

8 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 8 changes of one bucket. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive-by-listener.one-bucket-8-adds-with-a-listener
Shipped64 adds, one to each of 64 buckets, in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive arm
72 ns shipped66 ns alternative1.09×alternative timed twice: 1.2% apart
What the two sides do differently

64 adds spread over 64 different buckets inside one subframe, so there is nothing to coalesce: every bucket changes once. No content-change listener. Every bucket is UNHELD (holdCount 0), so each one is releasable at the close and its release check runs on both arms. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive-by-listener.unheld.64-buckets-one-add-each
Shipped8 adds, one to each of 8 buckets, in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive arm
85 ns shipped75 ns alternative1.13×alternative timed twice: 2.2% apart
What the two sides do differently

8 adds spread over 8 different buckets inside one subframe, so there is nothing to coalesce: every bucket changes once. No content-change listener. Every bucket is UNHELD (holdCount 0), so each one is releasable at the close and its release check runs on both arms. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive-by-listener.unheld.8-buckets-one-add-each
Shipped1 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive arm
179 ns shipped139 ns alternative1.29×alternative timed twice: 0.7% apart
What the two sides do differently

1 adds to ONE bucket inside one subframe. No content-change listener. Every bucket is UNHELD (holdCount 0), so each one is releasable at the close and its release check runs on both arms. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive-by-listener.unheld.one-bucket-1-adds
Shipped1 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive arm
180 ns shipped146 ns alternative1.23×alternative timed twice: 0.2% apart
What the two sides do differently

1 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 1 changes of one bucket. Every bucket is UNHELD (holdCount 0), so each one is releasable at the close and its release check runs on both arms. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive-by-listener.unheld.one-bucket-1-adds-with-a-listener
Shipped64 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive arm
23 ns shipped23 ns alternative1.01×alternative timed twice: 0.6% apart
What the two sides do differently

64 adds to ONE bucket inside one subframe. No content-change listener. Every bucket is UNHELD (holdCount 0), so each one is releasable at the close and its release check runs on both arms. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive-by-listener.unheld.one-bucket-64-adds
Shipped64 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive arm
23 ns shipped20 ns alternative1.15×alternative timed twice: 1.1% apart
What the two sides do differently

64 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 64 changes of one bucket. Every bucket is UNHELD (holdCount 0), so each one is releasable at the close and its release check runs on both arms. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive-by-listener.unheld.one-bucket-64-adds-with-a-listener
Shipped8 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive arm
41 ns shipped37 ns alternative1.13×alternative timed twice: 1.3% apart
What the two sides do differently

8 adds to ONE bucket inside one subframe. No content-change listener. Every bucket is UNHELD (holdCount 0), so each one is releasable at the close and its release check runs on both arms. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive-by-listener.unheld.one-bucket-8-adds
Shipped8 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive by listener: with no content-change listener every change is written, settled and announced at once, and the bucket is pushed once into the channel-owned array only when it is releasable (unheld); with a listener it behaves as the adaptive arm
42 ns shipped39 ns alternative1.08×alternative timed twice: 1.2% apart
What the two sides do differently

8 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 8 changes of one bucket. Every bucket is UNHELD (holdCount 0), so each one is releasable at the close and its release check runs on both arms. Held scenarios never reach the array on this arm when no listener exists, so they price the immediate path plus one listener-count check and one hold-count check per add. Unheld scenarios also pay one push per bucket and its release check at the close. The model reads releasability as holdCount 0; the shipped release policy is the default, which releases an unheld bucket only when it is empty. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive-by-listener.unheld.one-bucket-8-adds-with-a-listener
Shipped64 adds, one to each of 64 buckets, in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive coalescing: a bucket's first change in a batch is written, settled and announced at once and the bucket is pushed once into a channel-owned array; later changes in the same subframe only flag it, and the outermost close writes and announces each flagged bucket once more, then runs its release check
71 ns shipped65 ns alternative1.09×alternative timed twice: 0.0% apart
What the two sides do differently

64 adds spread over 64 different buckets inside one subframe, so there is nothing to coalesce: every bucket changes once. No content-change listener. Every scenario here opens an outer subframe, so the adaptive arm always takes its batch path: the first change of each bucket costs what the immediate arm pays, and from the second change on it pays one flag write per add plus one more write and announce per bucket at the close. With a listener, the first announce is buffered by the owner's subframe and the second reaches the listener directly at the channel close, so a bucket changed more than once is heard twice. A single-item door with no outer subframe takes the immediate path and is not among these scenarios. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive.64-buckets-one-add-each
Shipped8 adds, one to each of 8 buckets, in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive coalescing: a bucket's first change in a batch is written, settled and announced at once and the bucket is pushed once into a channel-owned array; later changes in the same subframe only flag it, and the outermost close writes and announces each flagged bucket once more, then runs its release check
84 ns shipped74 ns alternative1.13×alternative timed twice: 1.9% apart
What the two sides do differently

8 adds spread over 8 different buckets inside one subframe, so there is nothing to coalesce: every bucket changes once. No content-change listener. Every scenario here opens an outer subframe, so the adaptive arm always takes its batch path: the first change of each bucket costs what the immediate arm pays, and from the second change on it pays one flag write per add plus one more write and announce per bucket at the close. With a listener, the first announce is buffered by the owner's subframe and the second reaches the listener directly at the channel close, so a bucket changed more than once is heard twice. A single-item door with no outer subframe takes the immediate path and is not among these scenarios. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive.8-buckets-one-add-each
Shipped1 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive coalescing: a bucket's first change in a batch is written, settled and announced at once and the bucket is pushed once into a channel-owned array; later changes in the same subframe only flag it, and the outermost close writes and announces each flagged bucket once more, then runs its release check
179 ns shipped141 ns alternative1.27×alternative timed twice: 0.0% apart
What the two sides do differently

1 adds to ONE bucket inside one subframe. No content-change listener. Every scenario here opens an outer subframe, so the adaptive arm always takes its batch path: the first change of each bucket costs what the immediate arm pays, and from the second change on it pays one flag write per add plus one more write and announce per bucket at the close. With a listener, the first announce is buffered by the owner's subframe and the second reaches the listener directly at the channel close, so a bucket changed more than once is heard twice. A single-item door with no outer subframe takes the immediate path and is not among these scenarios. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive.one-bucket-1-adds
Shipped1 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive coalescing: a bucket's first change in a batch is written, settled and announced at once and the bucket is pushed once into a channel-owned array; later changes in the same subframe only flag it, and the outermost close writes and announces each flagged bucket once more, then runs its release check
179 ns shipped144 ns alternative1.24×alternative timed twice: 0.0% apart
What the two sides do differently

1 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 1 changes of one bucket. Every scenario here opens an outer subframe, so the adaptive arm always takes its batch path: the first change of each bucket costs what the immediate arm pays, and from the second change on it pays one flag write per add plus one more write and announce per bucket at the close. With a listener, the first announce is buffered by the owner's subframe and the second reaches the listener directly at the channel close, so a bucket changed more than once is heard twice. A single-item door with no outer subframe takes the immediate path and is not among these scenarios. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive.one-bucket-1-adds-with-a-listener
Shipped64 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive coalescing: a bucket's first change in a batch is written, settled and announced at once and the bucket is pushed once into a channel-owned array; later changes in the same subframe only flag it, and the outermost close writes and announces each flagged bucket once more, then runs its release check
23 ns shipped19 ns alternative1.20×alternative timed twice: 0.6% apart
What the two sides do differently

64 adds to ONE bucket inside one subframe. No content-change listener. Every scenario here opens an outer subframe, so the adaptive arm always takes its batch path: the first change of each bucket costs what the immediate arm pays, and from the second change on it pays one flag write per add plus one more write and announce per bucket at the close. With a listener, the first announce is buffered by the owner's subframe and the second reaches the listener directly at the channel close, so a bucket changed more than once is heard twice. A single-item door with no outer subframe takes the immediate path and is not among these scenarios. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive.one-bucket-64-adds
Shipped64 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive coalescing: a bucket's first change in a batch is written, settled and announced at once and the bucket is pushed once into a channel-owned array; later changes in the same subframe only flag it, and the outermost close writes and announces each flagged bucket once more, then runs its release check
23 ns shipped20 ns alternative1.18×alternative timed twice: 0.4% apart
What the two sides do differently

64 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 64 changes of one bucket. Every scenario here opens an outer subframe, so the adaptive arm always takes its batch path: the first change of each bucket costs what the immediate arm pays, and from the second change on it pays one flag write per add plus one more write and announce per bucket at the close. With a listener, the first announce is buffered by the owner's subframe and the second reaches the listener directly at the channel close, so a bucket changed more than once is heard twice. A single-item door with no outer subframe takes the immediate path and is not among these scenarios. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive.one-bucket-64-adds-with-a-listener
Shipped8 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive coalescing: a bucket's first change in a batch is written, settled and announced at once and the bucket is pushed once into a channel-owned array; later changes in the same subframe only flag it, and the outermost close writes and announces each flagged bucket once more, then runs its release check
41 ns shipped36 ns alternative1.14×alternative timed twice: 1.6% apart
What the two sides do differently

8 adds to ONE bucket inside one subframe. No content-change listener. Every scenario here opens an outer subframe, so the adaptive arm always takes its batch path: the first change of each bucket costs what the immediate arm pays, and from the second change on it pays one flag write per add plus one more write and announce per bucket at the close. With a listener, the first announce is buffered by the owner's subframe and the second reaches the listener directly at the channel close, so a bucket changed more than once is heard twice. A single-item door with no outer subframe takes the immediate path and is not among these scenarios. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive.one-bucket-8-adds
Shipped8 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativeadaptive coalescing: a bucket's first change in a batch is written, settled and announced at once and the bucket is pushed once into a channel-owned array; later changes in the same subframe only flag it, and the outermost close writes and announces each flagged bucket once more, then runs its release check
42 ns shipped37 ns alternative1.12×alternative timed twice: 1.5% apart
What the two sides do differently

8 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 8 changes of one bucket. Every scenario here opens an outer subframe, so the adaptive arm always takes its batch path: the first change of each bucket costs what the immediate arm pays, and from the second change on it pays one flag write per add plus one more write and announce per bucket at the close. With a listener, the first announce is buffered by the owner's subframe and the second reaches the listener directly at the channel close, so a bucket changed more than once is heard twice. A single-item door with no outer subframe takes the immediate path and is not among these scenarios. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.adaptive.one-bucket-8-adds-with-a-listener
Shipped64 adds, one to each of 64 buckets, in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativethe same coalescing, with the pending bucket pushed once into an array the channel owns and drains at the outermost subframe close, and no close callback
71 ns shipped67 ns alternative1.07×alternative timed twice: 0.0% apart
What the two sides do differently

64 adds spread over 64 different buckets inside one subframe, so there is nothing to coalesce: every bucket changes once. No content-change listener. Both arms coalesce identically and differ only in how the pending buckets reach the close: the shipped arm adds its flush callback to the channel's Set on every add and the channel iterates that Set; the alternative pushes each bucket once into a channel-owned array, finds the owner through slot.owner and drains the array in a plain loop. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.channel-array.64-buckets-one-add-each
Shipped8 adds, one to each of 8 buckets, in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativethe same coalescing, with the pending bucket pushed once into an array the channel owns and drains at the outermost subframe close, and no close callback
86 ns shipped76 ns alternative1.13×alternative timed twice: 2.2% apart
What the two sides do differently

8 adds spread over 8 different buckets inside one subframe, so there is nothing to coalesce: every bucket changes once. No content-change listener. Both arms coalesce identically and differ only in how the pending buckets reach the close: the shipped arm adds its flush callback to the channel's Set on every add and the channel iterates that Set; the alternative pushes each bucket once into a channel-owned array, finds the owner through slot.owner and drains the array in a plain loop. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.channel-array.8-buckets-one-add-each
Shipped1 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativethe same coalescing, with the pending bucket pushed once into an array the channel owns and drains at the outermost subframe close, and no close callback
178 ns shipped142 ns alternative1.25×alternative timed twice: 0.4% apart
What the two sides do differently

1 adds to ONE bucket inside one subframe. No content-change listener. Both arms coalesce identically and differ only in how the pending buckets reach the close: the shipped arm adds its flush callback to the channel's Set on every add and the channel iterates that Set; the alternative pushes each bucket once into a channel-owned array, finds the owner through slot.owner and drains the array in a plain loop. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.channel-array.one-bucket-1-adds
Shipped1 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativethe same coalescing, with the pending bucket pushed once into an array the channel owns and drains at the outermost subframe close, and no close callback
179 ns shipped144 ns alternative1.24×alternative timed twice: 0.1% apart
What the two sides do differently

1 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 1 changes of one bucket. Both arms coalesce identically and differ only in how the pending buckets reach the close: the shipped arm adds its flush callback to the channel's Set on every add and the channel iterates that Set; the alternative pushes each bucket once into a channel-owned array, finds the owner through slot.owner and drains the array in a plain loop. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.channel-array.one-bucket-1-adds-with-a-listener
Shipped64 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativethe same coalescing, with the pending bucket pushed once into an array the channel owns and drains at the outermost subframe close, and no close callback
23 ns shipped19 ns alternative1.20×alternative timed twice: 2.3% apart
What the two sides do differently

64 adds to ONE bucket inside one subframe. No content-change listener. Both arms coalesce identically and differ only in how the pending buckets reach the close: the shipped arm adds its flush callback to the channel's Set on every add and the channel iterates that Set; the alternative pushes each bucket once into a channel-owned array, finds the owner through slot.owner and drains the array in a plain loop. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.channel-array.one-bucket-64-adds
Shipped64 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativethe same coalescing, with the pending bucket pushed once into an array the channel owns and drains at the outermost subframe close, and no close callback
23 ns shipped19 ns alternative1.23×alternative timed twice: 1.0% apart
What the two sides do differently

64 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 64 changes of one bucket. Both arms coalesce identically and differ only in how the pending buckets reach the close: the shipped arm adds its flush callback to the channel's Set on every add and the channel iterates that Set; the alternative pushes each bucket once into a channel-owned array, finds the owner through slot.owner and drains the array in a plain loop. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.channel-array.one-bucket-64-adds-with-a-listener
Shipped8 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativethe same coalescing, with the pending bucket pushed once into an array the channel owns and drains at the outermost subframe close, and no close callback
42 ns shipped33 ns alternative1.26×alternative timed twice: 1.3% apart
What the two sides do differently

8 adds to ONE bucket inside one subframe. No content-change listener. Both arms coalesce identically and differ only in how the pending buckets reach the close: the shipped arm adds its flush callback to the channel's Set on every add and the channel iterates that Set; the alternative pushes each bucket once into a channel-owned array, finds the owner through slot.owner and drains the array in a plain loop. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.channel-array.one-bucket-8-adds
Shipped8 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativethe same coalescing, with the pending bucket pushed once into an array the channel owns and drains at the outermost subframe close, and no close callback
41 ns shipped34 ns alternative1.24×alternative timed twice: 1.5% apart
What the two sides do differently

8 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 8 changes of one bucket. Both arms coalesce identically and differ only in how the pending buckets reach the close: the shipped arm adds its flush callback to the channel's Set on every add and the channel iterates that Set; the alternative pushes each bucket once into a channel-owned array, finds the owner through slot.owner and drains the array in a plain loop. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.channel-array.one-bucket-8-adds-with-a-listener
Shipped1 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativethe same adds, each one written to the channel, settled and announced at once
177 ns shipped103 ns alternative1.72×alternative timed twice: 0.1% apart
What the two sides do differently

1 adds to ONE bucket inside one subframe. No content-change listener. The shipped arm marks the bucket pending once, registers a close callback in the channel's Set on every add, and writes, settles and announces the bucket once when the outermost subframe closes; the alternative does all three on every add. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.one-bucket-1-adds
Shipped1 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativethe same adds, each one written to the channel, settled and announced at once
180 ns shipped107 ns alternative1.68×alternative timed twice: 0.1% apart
What the two sides do differently

1 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 1 changes of one bucket. The shipped arm marks the bucket pending once, registers a close callback in the channel's Set on every add, and writes, settles and announces the bucket once when the outermost subframe closes; the alternative does all three on every add. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.one-bucket-1-adds-with-a-listener
Shipped64 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativethe same adds, each one written to the channel, settled and announced at once
20 ns shipped18 ns alternative1.06×alternative timed twice: 0.7% apart
What the two sides do differently

64 adds to ONE bucket inside one subframe. No content-change listener. The shipped arm marks the bucket pending once, registers a close callback in the channel's Set on every add, and writes, settles and announces the bucket once when the outermost subframe closes; the alternative does all three on every add. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.one-bucket-64-adds
Shipped64 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativethe same adds, each one written to the channel, settled and announced at once
20 ns shipped23 ns alternative0.86×alternative timed twice: 1.6% apart
What the two sides do differently

64 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 64 changes of one bucket. The shipped arm marks the bucket pending once, registers a close callback in the channel's Set on every add, and writes, settles and announces the bucket once when the outermost subframe closes; the alternative does all three on every add. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.one-bucket-64-adds-with-a-listener
Shipped8 adds to one bucket in one subframe, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativethe same adds, each one written to the channel, settled and announced at once
37 ns shipped27 ns alternative1.37×alternative timed twice: 0.9% apart
What the two sides do differently

8 adds to ONE bucket inside one subframe. No content-change listener. The shipped arm marks the bucket pending once, registers a close callback in the channel's Set on every add, and writes, settles and announces the bucket once when the outermost subframe closes; the alternative does all three on every add. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.one-bucket-8-adds
Shipped8 adds to one bucket in one subframe, one content-change listener, coalesced: the bucket marked pending, flushed by a subframe-close callback
Alternativethe same adds, each one written to the channel, settled and announced at once
37 ns shipped35 ns alternative1.05×alternative timed twice: 1.4% apart
What the two sides do differently

8 adds to ONE bucket inside one subframe, one content-change listener on the bucket owner. Without coalescing each add is still buffered by the owner's own subframe and delivered at the close as onContentChangedMany with one entry per add, so the listener hears 8 changes of one bucket. The shipped arm marks the bucket pending once, registers a close callback in the channel's Set on every add, and writes, settles and announces the bucket once when the outermost subframe closes; the alternative does all three on every add. One operation is one member add. Both arms open the same nested subframe around each add, push the member into the bucket store, and close the frame after every outer subframe; emptying the stores there is timed on both arms alike. The bucket slot is held and has one effect, so the channel write door takes its effect path: the first write of a frame schedules the effect and the rest find it scheduled. The bodies copy OIMBucketWriter.markBucketSlotChanged, OIMChannel.writeWithoutFlushCheck and closeSubframe, and OIMSlotContentOwner.settleWrite, contentChanged and its subframe delivery, as of 2026-10-21. The release policy is the default one, which does nothing on a write, so neither arm calls it.

measured 2026-10-23no explanation yetalt.bucket-coalescing.one-bucket-8-adds-with-a-listener
Shippedmark a carrier: read its own effects list, compare its stamp, enlist, stamp it
Alternativemark a key: probe a Map<key, handlers>, dedup the key in a Set, enlist
8 ns shipped54 ns alternative0.14×alternative timed twice: 0.4% apart
What the two sides do differently

THE MARK, NOT THE DELIVERY. Ours transcribes the prefix of `OIMChannel.writeWithoutFlushCheck` — `slot.effects`, the stamp against the frame, the `isRunScheduled` check of `addEffectScheduledToRun` and the stamp store — without the clock wrap and the flush request; the floor is the self-contained emitter the post turned down, one hash to find the handlers and one string-`Set` insertion to dedup the key. Every key carries one standing effect and a frame marks 1024 distinct keys once each, so every mark enlists on both arms; closing the frame is inside both numbers once per 1024 marks. The build throws unless one frame enlists the same count on both. What the floor buys and ours does not: carriers know nothing about subscriptions, and a key with no carrier yet can be subscribed to. THE POST'S ENGINE IS NOT THIS ENGINE. All four posts describe `@oimdb/core` 3.x, which now lives in `packages/core-legacy/`; this row runs hand-written arms shaped after the current engine, so it settles the DECISION and settles NOTHING about the withdrawn table.

measured 2026-10-23no explanation yetalt.carrier-emitter-vs-key-handler-map.mark
ShippedeffectService.createEffect(db, [entityService.holdColumn(slot, 'title')], [], body) — per row
AlternativeeffectService.createEffect(db, [slot], [], body) with the body comparing `title` against what it saw last
109 ns shipped60 ns alternative1.83×alternative timed twice: 0.9% apart
What the two sides do differently

ONE OPERATION IS ONE ROW WRITE, AND A PASS IS TWO OF THEM PER ROW: every row's `note` moves and a frame runs, then every row's `title` moves and a frame runs. One subscriber per row, mounted before the clock, cares only about `title`. Ours subscribes to the column's own identity, so the `note` frame wakes nobody — the write probes the row's column store and finds no `note` column — and the `title` frame wakes every subscriber; the rejected arm subscribes to the row, so BOTH frames wake every subscriber and its body filters the `note` frame out. Each arm was checked to report exactly one title change per row per pass. The two arms put different slot shapes through the same `slotContentService.updateEntity` and the same db, so the pair is isolated.

measured 2026-10-23no explanation yetalt.column-subscription.by-column-vs-by-row.1024-rows
Shippedenqueue the effect itself, deduplicated by its own isPending flag
Alternativeenqueue a record and hand back a disposer closure that cancels it
5 ns shipped15 ns alternative0.35×alternative timed twice: 1.1% apart
What the two sides do differently

OURS IS THE SHAPE `OIMChannel` SHIPS — the private `addEffectScheduledToRun` pushes the effect by reference and dedups on `effect.isRunScheduled` — transcribed rather than called, because the public `scheduleEffectRun` also requests a flush. The floor allocates a record and a closure per enqueue, which is what the post turned down; its disposers are sunk so neither allocation can be removed. A frame enqueues 1024 distinct effects once each and then drains, and the drain is inside both numbers once per frame. The build throws unless one drain runs the same count on both. THE POST'S ENGINE IS NOT THIS ENGINE. All four posts describe `@oimdb/core` 3.x, which now lives in `packages/core-legacy/`; this row runs hand-written arms shaped after the current engine, so it settles the DECISION and settles NOTHING about the withdrawn table.

measured 2026-10-23no explanation yetalt.enqueue-by-reference-vs-disposer-closure.array-queue
Shippedcompare the leaf's frame stamp, write it, push onto the frame array — no arrival is a repeat
Alternativeadd the leaf to the frame's Set, which dedups by containment — no arrival is a repeat
6 ns shipped27 ns alternative0.23×alternative timed twice: 0.1% apart
What the two sides do differently

THE ROW WITH NOTHING TO DEDUPLICATE, AND IT IS HERE BECAUSE IT IS THE ONE THE STAMP SHOULD WIN LEAST. Every leaf reads one root, so all 200 arrivals of a frame are first arrivals: our stamp never takes its early return and the `Set` never probes an entry it already holds. What is left in the difference is a field compare plus a field store plus an array push against one hash insert, with no repeat path exercised on either side. A reader who wants to know what the stamp is worth when the graph is a tree — one consumer per root, which is what most screens are — reads this row and not the other two. It is also the row that says whether the recovered figures can be quoted at all: if the stamp does not lead here, the mechanism is not what the quoted per-arrival numbers were describing. RESIDUALS. WHAT THE `Set` BUYS, and it is not nothing: dedup and containment are ONE operation, there is no per-leaf word to keep in step, and the invariant the stamp design holds by hand — a leaf is on the frame's list iff its stamp says so — cannot be broken, so that arm cannot list a leaf twice or lose one. The stamp buys back two things the `Set` cannot: it is a FRAME NUMBER, so it is stale again at the next frame with nobody clearing it, and it is also the DETACH — a leaf let go of between the write that listed it and the flush is unlisted by writing the same field, and the frame's pass reads it again before calling. A `Set` design needs a second mechanism for that and this arm is not charged for one. WHAT THE ENGINE DOES TODAY IS NEITHER ARM AS PRICED: `TOIMEffect.isRunScheduled` is a BOOLEAN, which the frame's pass clears as it consumes a leaf and `detach` writes false — the same compare and store, so the operation count here stands, and the self-staling property this arm is credited with is one the boolean does not have. The row is a reading of the frame-number arm and owes a run against the boolean [NO RUN BEHIND THIS FIGURE]. AGAINST US: our arm carries a frame number and pays a compare and a store the `Set` arm does not, because the stamp is doing the queue's dedup as well as its own. AGAINST THE `Set` ARM: its `clear()` is proportional to what it held where our `length = 0` is not, and both are inside the operation count here rather than hidden outside it. WHAT NEITHER ARM PAYS: the write that produced the arrival and the walk of `slot.effects` that carried it, which are `OIMChannel.write`'s and identical on both sides.

measured 2026-10-23no explanation yetalt.frame-dedup.stamp-vs-set.fan-in-1
Shippedthe same three lines, at fan-in 3 — two arrivals in three are repeats
Alternativethe same Set, at fan-in 3 — two arrivals in three are repeats
3 ns shipped15 ns alternative0.21×alternative timed twice: 0.5% apart
What the two sides do differently

THE GEOMETRY THE QUOTED FIGURES WERE TAKEN AT — 200 consumers, fan-in 3, 300 roots — and the row that answers whether 0.95 ns against 5.24 ns, a factor of 5.5x, is what this mechanism costs [NO RUN BEHIND THIS FIGURE]. ONE THING ABOUT THE MIX IS NOT THE SAME AND IS SAID RATHER THAN LEFT TO BE FOUND: the quoted run reported 370 arrivals per frame of which 182 were deduplicated, and this row writes EVERY root, so a frame here is 600 arrivals of which 400 are repeats [NO RUN BEHIND THIS FIGURE]. The unit is per arrival on both, which is what makes them comparable at all; the repeat FRACTION is higher here, and since a repeat is where the stamp is strongest, this row should read at least as favourably as the quoted one and a reading below it is the interesting outcome [FIGURE STATED IN ADVANCE]. RESIDUALS. WHAT THE `Set` BUYS, and it is not nothing: dedup and containment are ONE operation, there is no per-leaf word to keep in step, and the invariant the stamp design holds by hand — a leaf is on the frame's list iff its stamp says so — cannot be broken, so that arm cannot list a leaf twice or lose one. The stamp buys back two things the `Set` cannot: it is a FRAME NUMBER, so it is stale again at the next frame with nobody clearing it, and it is also the DETACH — a leaf let go of between the write that listed it and the flush is unlisted by writing the same field, and the frame's pass reads it again before calling. A `Set` design needs a second mechanism for that and this arm is not charged for one. WHAT THE ENGINE DOES TODAY IS NEITHER ARM AS PRICED: `TOIMEffect.isRunScheduled` is a BOOLEAN, which the frame's pass clears as it consumes a leaf and `detach` writes false — the same compare and store, so the operation count here stands, and the self-staling property this arm is credited with is one the boolean does not have. The row is a reading of the frame-number arm and owes a run against the boolean [NO RUN BEHIND THIS FIGURE]. AGAINST US: our arm carries a frame number and pays a compare and a store the `Set` arm does not, because the stamp is doing the queue's dedup as well as its own. AGAINST THE `Set` ARM: its `clear()` is proportional to what it held where our `length = 0` is not, and both are inside the operation count here rather than hidden outside it. WHAT NEITHER ARM PAYS: the write that produced the arrival and the walk of `slot.effects` that carried it, which are `OIMChannel.write`'s and identical on both sides.

measured 2026-10-23no explanation yetalt.frame-dedup.stamp-vs-set.fan-in-3
Shippedthe same three lines, at fan-in 8 — seven arrivals in eight are repeats
Alternativethe same Set, at fan-in 8 — seven arrivals in eight are repeats
3 ns shipped11 ns alternative0.31×alternative timed twice: 0.1% apart
What the two sides do differently

THE WIDE END, WHERE ALMOST EVERY ARRIVAL IS A REPEAT AND THE TWO DESIGNS ARE FURTHEST APART PER ARRIVAL. A leaf reading eight roots is an ordinary derived view — a total over a group, a row joined from several records — and a frame that touches all of them offers it eight times. Our arm answers seven of those eight with one field compare and a branch; the `Set` answers each with a hash of the object identity and a bucket probe. THIS IS THE ROW TO DISTRUST IF ANY, and in the direction that flatters us: the frame's own walk and its teardown are shared by both arms and are amortised over 1600 arrivals here against 200 at fan-in 1, so the shared constant is at its smallest exactly where our margin is at its largest. Read the three rows as a table and the trend across them rather than any one of them as the price. RESIDUALS. WHAT THE `Set` BUYS, and it is not nothing: dedup and containment are ONE operation, there is no per-leaf word to keep in step, and the invariant the stamp design holds by hand — a leaf is on the frame's list iff its stamp says so — cannot be broken, so that arm cannot list a leaf twice or lose one. The stamp buys back two things the `Set` cannot: it is a FRAME NUMBER, so it is stale again at the next frame with nobody clearing it, and it is also the DETACH — a leaf let go of between the write that listed it and the flush is unlisted by writing the same field, and the frame's pass reads it again before calling. A `Set` design needs a second mechanism for that and this arm is not charged for one. WHAT THE ENGINE DOES TODAY IS NEITHER ARM AS PRICED: `TOIMEffect.isRunScheduled` is a BOOLEAN, which the frame's pass clears as it consumes a leaf and `detach` writes false — the same compare and store, so the operation count here stands, and the self-staling property this arm is credited with is one the boolean does not have. The row is a reading of the frame-number arm and owes a run against the boolean [NO RUN BEHIND THIS FIGURE]. AGAINST US: our arm carries a frame number and pays a compare and a store the `Set` arm does not, because the stamp is doing the queue's dedup as well as its own. AGAINST THE `Set` ARM: its `clear()` is proportional to what it held where our `length = 0` is not, and both are inside the operation count here rather than hidden outside it. WHAT NEITHER ARM PAYS: the write that produced the arrival and the walk of `slot.effects` that carried it, which are `OIMChannel.write`'s and identical on both sides.

measured 2026-10-23no explanation yetalt.frame-dedup.stamp-vs-set.fan-in-8
Shippedslot = map.get(key); slot.entity = row; stamp and deliver
Alternativerows.set(key, row); then identities.get(key) because that map is no longer empty
24 ns shipped31 ns alternative0.78×alternative timed twice: 0.2% apart
What the two sides do differently

WHERE THE BILL FOR TWO MAPS ARRIVES. One subscriber stands on one key, mounted before the clock, so the identity map is not empty and EVERY write on the floor pays a second hash to learn whether its key is watched; ours resolved the slot with the one hash it needed to write, and the subscriber list is a field on it. Exactly one write per pass lands on the watched row and is delivered on both sides, so the difference is the per-row probe and not the delivery. Values alternate between two prepared sets, so no write re-sends what the store holds. Below one is the shipped shape winning.

measured 2026-10-23no explanation yetalt.identity-store.one-map-vs-two.overwrite-while-one-subscriber-stands
Shippedmap.set(key, slot) — mint the identity and put the row on it, one map
Alternativerows.set(key, row) — and skip an identity map that is still empty
56 ns shipped47 ns alternative1.21×alternative timed twice: 0.1% apart
What the two sides do differently

A FIRST LOAD INTO AN EMPTY STORE, THE ROW THE TWO-MAP SHAPE WINS. Ours mints a slot per row and files it; the floor files the bare row and tests the identity map's size, which is zero, so it mints nothing. Both stores are rebuilt between passes, untimed, and the minted slots are collected outside the clock. Above one is expected and is the case for the rejected shape; read it with the overwrite row.

measured 2026-10-23no explanation yetalt.identity-store.one-map-vs-two.write-with-nobody-subscribed
ShippedopenContentSubframe/closeContentSubframe through OIMContentChangeDeliveryService
Alternativeevery step by hand
95 ns shipped100 ns alternative0.95×alternative timed twice: 8.0% apart
What the two sides do differently

One rung of a ladder from the insert path written by hand, step by step, around the shipped pieces, to entityService.slotContentService.upsertEntity on the same service. Every rung swaps exactly one hand-written step for the shipped piece's own method — the content service's private slotOwnerService or its private write methods, reached through a cast (`as unknown as {…}`), or OIMContentChangeDeliveryService — so the gap a rung shows is what that method costs beyond the hand step. The service inserts without a copy (the default) under the AtEmpty policy. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock and ends its pass with db.flush(). This rung adds: the content subframe — the channel call, the channel slot's content subframe depth and the delivery check at its outermost close — instead of the channel call and a counter.

measured 2026-10-23no explanation yetalt.ladder.insert-door.1-subframe
ShippedassertWritable through the slot owner service
Alternativethe step below by hand
89 ns shipped99 ns alternative0.91×alternative timed twice: 12.4% apart
What the two sides do differently

One rung of a ladder from the insert path written by hand, step by step, around the shipped pieces, to entityService.slotContentService.upsertEntity on the same service. Every rung swaps exactly one hand-written step for the shipped piece's own method — the content service's private slotOwnerService or its private write methods, reached through a cast (`as unknown as {…}`), or OIMContentChangeDeliveryService — so the gap a rung shows is what that method costs beyond the hand step. The service inserts without a copy (the default) under the AtEmpty policy. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock and ends its pass with db.flush(). This rung adds: the slot owner service's assertWritable.

measured 2026-10-23no explanation yetalt.ladder.insert-door.2-assert-writable
ShippedslotContentService.writeEntityWithoutSubframe
Alternativethe writer and the channel called by hand
90 ns shipped87 ns alternative1.03×alternative timed twice: 3.0% apart
What the two sides do differently

One rung of a ladder from the insert path written by hand, step by step, around the shipped pieces, to entityService.slotContentService.upsertEntity on the same service. Every rung swaps exactly one hand-written step for the shipped piece's own method — the content service's private slotOwnerService or its private write methods, reached through a cast (`as unknown as {…}`), or OIMContentChangeDeliveryService — so the gap a rung shows is what that method costs beyond the hand step. The service inserts without a copy (the default) under the AtEmpty policy. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock and ends its pass with db.flush(). This rung adds: writeEntityWithoutSubframe: the entity-undefined check, fillEntity, dispatchColumnsChanged and its column-store check.

measured 2026-10-23no explanation yetalt.ladder.insert-door.3-write
ShippedupdateEntitySlotEmptiness through the content service and the slot owner service
Alternativethe step by hand
93 ns shipped91 ns alternative1.02×alternative timed twice: 2.1% apart
What the two sides do differently

One rung of a ladder from the insert path written by hand, step by step, around the shipped pieces, to entityService.slotContentService.upsertEntity on the same service. Every rung swaps exactly one hand-written step for the shipped piece's own method — the content service's private slotOwnerService or its private write methods, reached through a cast (`as unknown as {…}`), or OIMContentChangeDeliveryService — so the gap a rung shows is what that method costs beyond the hand step. The service inserts without a copy (the default) under the AtEmpty policy. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock and ends its pass with db.flush(). This rung adds: the slot owner service's settleEmptiness and settleWrite.

measured 2026-10-23no explanation yetalt.ladder.insert-door.4-emptiness
ShippeddispatchContentChange through the slot owner service
Alternativeno content-change call
93 ns shipped87 ns alternative1.07×alternative timed twice: 6.7% apart
What the two sides do differently

One rung of a ladder from the insert path written by hand, step by step, around the shipped pieces, to entityService.slotContentService.upsertEntity on the same service. Every rung swaps exactly one hand-written step for the shipped piece's own method — the content service's private slotOwnerService or its private write methods, reached through a cast (`as unknown as {…}`), or OIMContentChangeDeliveryService — so the gap a rung shows is what that method costs beyond the hand step. The service inserts without a copy (the default) under the AtEmpty policy. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock and ends its pass with db.flush(). This rung adds: the slot owner service's dispatchContentChange with no listener.

measured 2026-10-23no explanation yetalt.ladder.insert-door.5-content-changed
ShippedreleaseSlotIfUnheldAfterListeners through the slot owner service
Alternativethe check by hand
93 ns shipped102 ns alternative0.91×alternative timed twice: 9.8% apart
What the two sides do differently

One rung of a ladder from the insert path written by hand, step by step, around the shipped pieces, to entityService.slotContentService.upsertEntity on the same service. Every rung swaps exactly one hand-written step for the shipped piece's own method — the content service's private slotOwnerService or its private write methods, reached through a cast (`as unknown as {…}`), or OIMContentChangeDeliveryService — so the gap a rung shows is what that method costs beyond the hand step. The service inserts without a copy (the default) under the AtEmpty policy. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock and ends its pass with db.flush(). This rung adds: the slot owner service's release check after the write.

measured 2026-10-23no explanation yetalt.ladder.insert-door.6-release-check
ShippedslotOwnerService.createSlot
AlternativecreateOIMEntitySlot called by hand
97 ns shipped95 ns alternative1.02×alternative timed twice: 1.1% apart
What the two sides do differently

One rung of a ladder from the insert path written by hand, step by step, around the shipped pieces, to entityService.slotContentService.upsertEntity on the same service. Every rung swaps exactly one hand-written step for the shipped piece's own method — the content service's private slotOwnerService or its private write methods, reached through a cast (`as unknown as {…}`), or OIMContentChangeDeliveryService — so the gap a rung shows is what that method costs beyond the hand step. The service inserts without a copy (the default) under the AtEmpty policy. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock and ends its pass with db.flush(). This rung adds: slotOwnerService.createSlot: the content service's private slotContentStrategy.createSlot behind the owner.

measured 2026-10-23no explanation yetalt.ladder.insert-door.7-create-slot
ShippedentityService.slotContentService.upsertEntity(storeSlot, entity)
Alternativeevery step through the service's internal pieces, chained by hand
76 ns shipped89 ns alternative0.85×alternative timed twice: 2.6% apart
What the two sides do differently

One rung of a ladder from the insert path written by hand, step by step, around the shipped pieces, to entityService.slotContentService.upsertEntity on the same service. Every rung swaps exactly one hand-written step for the shipped piece's own method — the content service's private slotOwnerService or its private write methods, reached through a cast (`as unknown as {…}`), or OIMContentChangeDeliveryService — so the gap a rung shows is what that method costs beyond the hand step. The service inserts without a copy (the default) under the AtEmpty policy. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock and ends its pass with db.flush(). This rung adds: upsertEntity's selectKey and insertEntity itself: the store lookup, ownKey, createSlot, the isOnFastPath read and the fast-path insert, which on this fixture opens no subframe, runs no contentChanged and no release check and calls entityWriter.fillEntity directly, so the floor carries steps the door does not run.

measured 2026-10-23no explanation yetalt.ladder.insert-door.8-door
Shippedmap.set(id, oimCopyEntitySanitized(entity))
Alternativemap.set(id, { ...entity })
68 ns shipped59 ns alternative1.15×alternative timed twice: 1.9% apart
What the two sides do differently

One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: oimCopyEntitySanitized instead of the bare spread: the spread plus the own-`__proto__` probe and its delete.

measured 2026-10-23no explanation yetalt.ladder.insert.1-copy
Shippedthe release check after filing
Alternativethe steps below without it
97 ns shipped92 ns alternative1.05×alternative timed twice: 1.4% apart
What the two sides do differently

One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: releaseSlotIfUnheldAfterListeners: the subframe-tail check, isReleasable and the policy question. The shipped insert runs no release check on its fast path, and on its subframe path calls releaseWrittenSlotIfUnheld instead.

measured 2026-10-23no explanation yetalt.ladder.insert.10-release-check
Shippedevery step inside OIMChannelService.INSTANCE.openSubframe/closeSubframe with try/catch, as insertEntityInSubframe runs them
Alternativethe same steps without a subframe
102 ns shipped95 ns alternative1.08×alternative timed twice: 0.7% apart
What the two sides do differently

One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: the subframe the insert opens around itself, and the try/catch around it.

measured 2026-10-23no explanation yetalt.ladder.insert.11-subframe
ShippedentityService.upsertEntity(entityStoreSlot, entity); db.flush() per pass
Alternativethe same steps written by hand around the shipped pieces
99 ns shipped104 ns alternative0.95×alternative timed twice: 0.1% apart
What the two sides do differently

One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: the shipped door, which on this fixture takes its fast path (insertEntity): no subframe, no dispatchContentChange and no release check, so the floor carries three steps the door does not run.

measured 2026-10-23no explanation yetalt.ladder.insert.12-collection-door
Shippedmap.set(id, slot) with slot = createOIMEntitySlot(id, owner), slot.entity = the copy
Alternativemap.set(id, oimCopyEntitySanitized(entity))
72 ns shipped71 ns alternative1.01×alternative timed twice: 4.2% apart
What the two sides do differently

One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: the fourteen-field slot object the copy is stored in.

measured 2026-10-23no explanation yetalt.ladder.insert.2-slot
Shippedmap.get(id) first, then map.set(id, slot)
Alternativemap.set(id, slot)
82 ns shipped79 ns alternative1.04×alternative timed twice: 2.7% apart
What the two sides do differently

One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: the probe writeContentByKey opens with, on the bare Map.

measured 2026-10-23no explanation yetalt.ladder.insert.3-probe
Shippedthe store service: get, ownKey, set
Alternativemap.get(id), then map.set(id, slot)
83 ns shipped81 ns alternative1.02×alternative timed twice: 0.9% apart
What the two sides do differently

One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: the store service in place of the bare Map for the probe and the filing (setByKey).

measured 2026-10-23no explanation yetalt.ladder.insert.4-identity-store
Shippedthe key read through a selectKey function
Alternativethe key read as row.id
83 ns shipped85 ns alternative0.98×alternative timed twice: 0.2% apart
What the two sides do differently

One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: the selectKey call upsertEntity makes before writeContentByKey.

measured 2026-10-23no explanation yetalt.ladder.insert.5-key-of
Shippedthe shipped writer fills the slot, then OIMChannelService.INSTANCE.writeWithoutFlushCheck(channelSlot, slot); db.flush() per pass
Alternativethe copy assigned by hand, no channel
86 ns shipped82 ns alternative1.05×alternative timed twice: 1.4% apart
What the two sides do differently

One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: what insertEntity runs to land the entity: the shipped writer's fillEntity and the channel write that stamps the slot.

measured 2026-10-23no explanation yetalt.ladder.insert.6-writer-and-channel
ShippedOIMChannelService.INSTANCE.assertNotFlushing(channelSlot) and the released check before filing
Alternativethe writer and the channel
88 ns shipped87 ns alternative1.01×alternative timed twice: 1.3% apart
What the two sides do differently

One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: assertWritable.

measured 2026-10-23no explanation yetalt.ladder.insert.7-assert-writable
Shippedthe emptiness check and the release policy notified, as settleEmptiness does
Alternativethe assert, the writer and the channel
93 ns shipped91 ns alternative1.03×alternative timed twice: 1.9% apart
What the two sides do differently

One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: settleEmptiness: the emptiness strategy, the slot-stamp check, onSlotWritten, and the idle check of a slot nobody subscribes to.

measured 2026-10-23no explanation yetalt.ladder.insert.8-emptiness
Shippedthe content-change step with no listener
Alternativethe steps below without it
94 ns shipped94 ns alternative1.00×alternative timed twice: 2.0% apart
What the two sides do differently

One rung of a ladder from `map.set(id, { ...entity })` to `entityService.upsertEntity(entityStoreSlot, entity)` for a key the population has never seen. Every rung inserts the same priceDataset.batch distinct rows into an empty world rebuilt outside the clock, and adds exactly one step of the insert branch of OIMSlotContentEntityService.insertEntity to the rung below it, written by hand around the shipped pieces: oimCopyEntitySanitized, createOIMEntitySlot, OIMSlotStoreServiceMapDriven, an in-place writer with oimInsertEntityWithSanitizedCopy, the channel, the emptiness check, the AtEmpty release policy. Each pair re-measures the rung below as its floor in its own run, so a ratio prices only what its rung adds. From the writer-and-channel rung on, each pass ends with db.flush(). This rung adds: dispatchContentChange, which returns at once when the collection has no listener. The shipped insert calls it only on its subframe path (insertEntityInSubframe), not on the fast path this fixture takes.

measured 2026-10-23no explanation yetalt.ladder.insert.9-content-changed
Shippeda member leaves a bucket of 100 and joins another, membership in a Set (OIMSlotContentBucketServiceSetDriven)
Alternativethe same move, membership in a list kept in the caller's order (OIMSlotContentBucketServiceArrayDriven)
6.42 µs shipped1.60 µs alternative4.02×alternative timed twice: 0.3% apart
What the two sides do differently

A BUCKET OF 100, and the size is in the id because the answer is a function of it on BOTH halves. THE COUNT THIS PREDICTS, per member moved, through `slotContentService.writeBucketMemberSlots`: on the ordered half, `reconcileSlots` compares the held list against the one handed in up to the swapped band, finds them unequal, drains all 100 members and pushes all 100 back, and the collection holds 100 arrivals and unholds 100 departures. On the unordered half: `reconcileSlots` builds one Set of the 100 slots handed in, probes it once per held member, deletes the one departure and adds the one arrival, and one hold is taken and one given back. The ordered half's sequence comparison stops at the swapped band, which is why the sweep over 16 positions (0, 6, 12, … 90) exists: it averages that comparison length. ONE FLUSH IS SPREAD OVER 64 OPERATIONS, since a frame swaps one band in every lane at once; `flush.empty-vs-noop` prices a flush directly, for a reader who wants it out of the figure. WHAT AN OPERATION IS: one member moves from one bucket to another, through the only door the engine offers for it — two array stores that exchange the member between the two lists this file holds, `slotContentService.writeBucketMemberSlots` of each of those lists, a flush, and a read of every bucket in the frame through `getBucketMemberSlots`. Both halves run the identical body; the only difference in the process is which slot content bucket service object the bucket service was created with.READINGS RECORDED BEFORE 2026-08-23 priced a re-file reached through a derived membership source and are not this operation. EVERY OPERATION REALLY MOVES A MEMBER, which is the failure this suite has already published a wrong number for: `writeBucketMemberSlots` RETURNS without a wake when `reconcileSlots` finds nothing arrived and nothing departed, and both halves would then time a frame in which no container was touched. Here the two lists handed in differ from what the buckets hold by exactly one member each, and `assertBandsAreWhereTheyAreExpected` checks each bucket holds exactly the members this file holds for it before the clock starts. The two rows of a swap are the two members of one band, one in each page of the lane, and the swap exchanges them — which is why this needs no `reset` at all: sizes, positions and the sweep are exactly what they were when the pass started, so an empty reset here is a steady state rather than a forgotten one. DIRECTION, three ways. (1) The two array stores, the mark, the flush and the read call are identical in SHAPE on both halves and inside both numbers, which pulls the RATIO toward 1.00, so the two printed nanosecond figures are the numbers to read. (2) ONLY THE SET HALF DIFFS: `OIMSlotContentBucketServiceSetDriven.reconcileSlots` takes the set difference (one Set of the list handed in, one probe per held member) and moves one hold each way, while the ordered half's `reconcileSlots` compares the two sequences up to the first mismatch, then drains the whole list and re-adds every member, so every member it holds is unheld and held again. READINGS RECORDED BEFORE 2026-10-17 timed a set half that drained and refilled the whole set and an ordered half that kept a rank sorter and took a multiset difference, and are not this operation. (3) Both containers are walked every frame and stay in cache, which flatters both. A PASS IS WHOLE FRAMES, because half a swap would leave both members of a band in one page and every position after it would be a lie; so a pass may overshoot the operation count the prober asked for by fewer operations than there are pages, out of the tens of thousands it asks for.

measured 2026-10-23no explanation yetalt.remove-member.unordered-vs-ordered.100
Shippeda member leaves a bucket of 10000 and joins another, membership in a Set (OIMSlotContentBucketServiceSetDriven)
Alternativethe same move, membership in a list kept in the caller's order (OIMSlotContentBucketServiceArrayDriven)
924.15 µs shipped203.32 µs alternative4.55×alternative timed twice: 1.4% apart
What the two sides do differently

A BUCKET OF 10000, and the size is in the id because the answer is a function of it on BOTH halves. THE COUNT THIS PREDICTS, per member moved, through `slotContentService.writeBucketMemberSlots`: on the ordered half, `reconcileSlots` compares the held list against the one handed in up to the swapped band, finds them unequal, drains all 10000 members and pushes all 10000 back, and the collection holds 10000 arrivals and unholds 10000 departures. On the unordered half: `reconcileSlots` builds one Set of the 10000 slots handed in, probes it once per held member, deletes the one departure and adds the one arrival, and one hold is taken and one given back. The ordered half's sequence comparison stops at the swapped band, which is why the sweep over 16 positions (0, 625, 1250, … 9375) exists: it averages that comparison length. ONE FLUSH IS SPREAD OVER 8 OPERATIONS, since a frame swaps one band in every lane at once; `flush.empty-vs-noop` prices a flush directly, for a reader who wants it out of the figure. WHAT AN OPERATION IS: one member moves from one bucket to another, through the only door the engine offers for it — two array stores that exchange the member between the two lists this file holds, `slotContentService.writeBucketMemberSlots` of each of those lists, a flush, and a read of every bucket in the frame through `getBucketMemberSlots`. Both halves run the identical body; the only difference in the process is which slot content bucket service object the bucket service was created with.READINGS RECORDED BEFORE 2026-08-23 priced a re-file reached through a derived membership source and are not this operation. EVERY OPERATION REALLY MOVES A MEMBER, which is the failure this suite has already published a wrong number for: `writeBucketMemberSlots` RETURNS without a wake when `reconcileSlots` finds nothing arrived and nothing departed, and both halves would then time a frame in which no container was touched. Here the two lists handed in differ from what the buckets hold by exactly one member each, and `assertBandsAreWhereTheyAreExpected` checks each bucket holds exactly the members this file holds for it before the clock starts. The two rows of a swap are the two members of one band, one in each page of the lane, and the swap exchanges them — which is why this needs no `reset` at all: sizes, positions and the sweep are exactly what they were when the pass started, so an empty reset here is a steady state rather than a forgotten one. DIRECTION, three ways. (1) The two array stores, the mark, the flush and the read call are identical in SHAPE on both halves and inside both numbers, which pulls the RATIO toward 1.00, so the two printed nanosecond figures are the numbers to read. (2) ONLY THE SET HALF DIFFS: `OIMSlotContentBucketServiceSetDriven.reconcileSlots` takes the set difference (one Set of the list handed in, one probe per held member) and moves one hold each way, while the ordered half's `reconcileSlots` compares the two sequences up to the first mismatch, then drains the whole list and re-adds every member, so every member it holds is unheld and held again. READINGS RECORDED BEFORE 2026-10-17 timed a set half that drained and refilled the whole set and an ordered half that kept a rank sorter and took a multiset difference, and are not this operation. (3) Both containers are walked every frame and stay in cache, which flatters both. A PASS IS WHOLE FRAMES, because half a swap would leave both members of a band in one page and every position after it would be a lie; so a pass may overshoot the operation count the prober asked for by fewer operations than there are pages, out of the tens of thousands it asks for.

measured 2026-10-23no explanation yetalt.remove-member.unordered-vs-ordered.10k
Shippeda member leaves a bucket of 1000 and joins another, membership in a Set (OIMSlotContentBucketServiceSetDriven)
Alternativethe same move, membership in a list kept in the caller's order (OIMSlotContentBucketServiceArrayDriven)
71.31 µs shipped27.34 µs alternative2.61×alternative timed twice: 0.1% apart
What the two sides do differently

A BUCKET OF 1000, and the size is in the id because the answer is a function of it on BOTH halves. THE COUNT THIS PREDICTS, per member moved, through `slotContentService.writeBucketMemberSlots`: on the ordered half, `reconcileSlots` compares the held list against the one handed in up to the swapped band, finds them unequal, drains all 1000 members and pushes all 1000 back, and the collection holds 1000 arrivals and unholds 1000 departures. On the unordered half: `reconcileSlots` builds one Set of the 1000 slots handed in, probes it once per held member, deletes the one departure and adds the one arrival, and one hold is taken and one given back. The ordered half's sequence comparison stops at the swapped band, which is why the sweep over 16 positions (0, 62, 124, … 930) exists: it averages that comparison length. ONE FLUSH IS SPREAD OVER 64 OPERATIONS, since a frame swaps one band in every lane at once; `flush.empty-vs-noop` prices a flush directly, for a reader who wants it out of the figure. WHAT AN OPERATION IS: one member moves from one bucket to another, through the only door the engine offers for it — two array stores that exchange the member between the two lists this file holds, `slotContentService.writeBucketMemberSlots` of each of those lists, a flush, and a read of every bucket in the frame through `getBucketMemberSlots`. Both halves run the identical body; the only difference in the process is which slot content bucket service object the bucket service was created with.READINGS RECORDED BEFORE 2026-08-23 priced a re-file reached through a derived membership source and are not this operation. EVERY OPERATION REALLY MOVES A MEMBER, which is the failure this suite has already published a wrong number for: `writeBucketMemberSlots` RETURNS without a wake when `reconcileSlots` finds nothing arrived and nothing departed, and both halves would then time a frame in which no container was touched. Here the two lists handed in differ from what the buckets hold by exactly one member each, and `assertBandsAreWhereTheyAreExpected` checks each bucket holds exactly the members this file holds for it before the clock starts. The two rows of a swap are the two members of one band, one in each page of the lane, and the swap exchanges them — which is why this needs no `reset` at all: sizes, positions and the sweep are exactly what they were when the pass started, so an empty reset here is a steady state rather than a forgotten one. DIRECTION, three ways. (1) The two array stores, the mark, the flush and the read call are identical in SHAPE on both halves and inside both numbers, which pulls the RATIO toward 1.00, so the two printed nanosecond figures are the numbers to read. (2) ONLY THE SET HALF DIFFS: `OIMSlotContentBucketServiceSetDriven.reconcileSlots` takes the set difference (one Set of the list handed in, one probe per held member) and moves one hold each way, while the ordered half's `reconcileSlots` compares the two sequences up to the first mismatch, then drains the whole list and re-adds every member, so every member it holds is unheld and held again. READINGS RECORDED BEFORE 2026-10-17 timed a set half that drained and refilled the whole set and an ordered half that kept a rank sorter and took a multiset difference, and are not this operation. (3) Both containers are walked every frame and stay in cache, which flatters both. A PASS IS WHOLE FRAMES, because half a swap would leave both members of a band in one page and every position after it would be a lie; so a pass may overshoot the operation count the prober asked for by fewer operations than there are pages, out of the tens of thousands it asks for.

measured 2026-10-23no explanation yetalt.remove-member.unordered-vs-ordered.1k
Shippeda member leaves a bucket of 50000 and joins another, membership in a Set (OIMSlotContentBucketServiceSetDriven)
Alternativethe same move, membership in a list kept in the caller's order (OIMSlotContentBucketServiceArrayDriven)
4.471 ms shipped1.793 ms alternative2.49×alternative timed twice: 0.8% apart
What the two sides do differently

A BUCKET OF 50000, and the size is in the id because the answer is a function of it on BOTH halves. THE COUNT THIS PREDICTS, per member moved, through `slotContentService.writeBucketMemberSlots`: on the ordered half, `reconcileSlots` compares the held list against the one handed in up to the swapped band, finds them unequal, drains all 50000 members and pushes all 50000 back, and the collection holds 50000 arrivals and unholds 50000 departures. On the unordered half: `reconcileSlots` builds one Set of the 50000 slots handed in, probes it once per held member, deletes the one departure and adds the one arrival, and one hold is taken and one given back. The ordered half's sequence comparison stops at the swapped band, which is why the sweep over 16 positions (0, 3125, 6250, … 46875) exists: it averages that comparison length. ONE FLUSH IS SPREAD OVER 2 OPERATIONS, since a frame swaps one band in every lane at once; `flush.empty-vs-noop` prices a flush directly, for a reader who wants it out of the figure. WHAT AN OPERATION IS: one member moves from one bucket to another, through the only door the engine offers for it — two array stores that exchange the member between the two lists this file holds, `slotContentService.writeBucketMemberSlots` of each of those lists, a flush, and a read of every bucket in the frame through `getBucketMemberSlots`. Both halves run the identical body; the only difference in the process is which slot content bucket service object the bucket service was created with.READINGS RECORDED BEFORE 2026-08-23 priced a re-file reached through a derived membership source and are not this operation. EVERY OPERATION REALLY MOVES A MEMBER, which is the failure this suite has already published a wrong number for: `writeBucketMemberSlots` RETURNS without a wake when `reconcileSlots` finds nothing arrived and nothing departed, and both halves would then time a frame in which no container was touched. Here the two lists handed in differ from what the buckets hold by exactly one member each, and `assertBandsAreWhereTheyAreExpected` checks each bucket holds exactly the members this file holds for it before the clock starts. The two rows of a swap are the two members of one band, one in each page of the lane, and the swap exchanges them — which is why this needs no `reset` at all: sizes, positions and the sweep are exactly what they were when the pass started, so an empty reset here is a steady state rather than a forgotten one. DIRECTION, three ways. (1) The two array stores, the mark, the flush and the read call are identical in SHAPE on both halves and inside both numbers, which pulls the RATIO toward 1.00, so the two printed nanosecond figures are the numbers to read. (2) ONLY THE SET HALF DIFFS: `OIMSlotContentBucketServiceSetDriven.reconcileSlots` takes the set difference (one Set of the list handed in, one probe per held member) and moves one hold each way, while the ordered half's `reconcileSlots` compares the two sequences up to the first mismatch, then drains the whole list and re-adds every member, so every member it holds is unheld and held again. READINGS RECORDED BEFORE 2026-10-17 timed a set half that drained and refilled the whole set and an ordered half that kept a rank sorter and took a multiset difference, and are not this operation. (3) Both containers are walked every frame and stay in cache, which flatters both. A PASS IS WHOLE FRAMES, because half a swap would leave both members of a band in one page and every position after it would be a lie; so a pass may overshoot the operation count the prober asked for by fewer operations than there are pages, out of the tens of thousands it asks for.

measured 2026-10-23no explanation yetalt.remove-member.unordered-vs-ordered.50k
Shippedmint one slot, cycling the four shipped shapes
Alternativemint one slot whose common fields live in a sub-object (every mint allocates two objects)
15 ns shipped15 ns alternative0.94×alternative timed twice: 0.1% apart
What the two sides do differently

Both arms allocate inside the clock; the candidate allocates the common sub-object on every mint.

measured 2026-10-23no explanation yetalt.slot-layout.mint-four-shapes-against-common-part
Shippedmint one slot, cycling the four shipped shapes
Alternativemint one slot of the one shape; bucket and computed also allocate their content object
15 ns shipped15 ns alternative0.96×alternative timed twice: 0.0% apart
What the two sides do differently

Both arms allocate inside the clock; the candidate allocates a second object for a bucket or a computed slot (two of every four mints), which is the price the one-shape layout pays.

measured 2026-10-23no explanation yetalt.slot-layout.mint-four-shapes-against-one-shape
Shippedmint one slot of each of the three shipped shapes
Alternativemint three slots of the one unified shape
25 ns shipped33 ns alternative0.77×alternative timed twice: 0.1% apart
What the two sides do differently

THE HALF OF THE UNIFIED-SHAPE ARGUMENT THAT PAYS FOR IT. One operation mints three literals; the unified one carries every field of every kind, so it is larger than every shipped kind, and a first load pays that once per entity. Both arms allocate inside the clock and the young-generation collections that follow are charged to whichever arm allocated more, which is the honest direction. Divide this pair's difference by the write pair's difference to get the writes per slot at which the unified shape breaks even.

measured 2026-10-23no explanation yetalt.slot-shape.three-shapes-against-one-at-the-mint

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

Per read​

ShippedgetValueForSlot on a computed slot over 1 source slot, refreshed against the channel clock — nothing written since
Alternativesettle it against one reading per source, held in an array beside the source list
10 ns shipped10 ns alternative1.02×alternative timed twice: 0.1% apart
What the two sides do differently

THE QUIET READ, AND ON THE SHIPPED ENGINE IT DOES NOT WALK THE SOURCES AT ALL. `oimRefreshComputedSlot` returns on the slot's `checkedAt` pair matching the channel clock, which is only possible because the clock is ONE scale: nothing was written anywhere, so nothing a derivation reads can have moved. The per-slot arm has no such question to ask and must compare every source reading. At one source that walk is one element, so this row is the narrowest the gap can be. 1024 derivations are settled before the clock starts and read in rotation. RESIDUALS. Both arms derive the same sum over the same entity slots of two fixtures built alike, and the build throws unless every derivation answers the same on both. AGAINST US: our comparison is a CALL to `oimIsRevisionAfter` and walks an EMPTY `sourceComputeds` array first, where the rejected arm compares inline with `!==` — a per-slot counter cannot wrap inside a process and needs no epoch, which is the one structural advantage that design has and it is granted in full. AGAINST THE REJECTED ARM: its readings are an array object per derivation, so every settle chases one more pointer than our two inline fields. OURS IS READ THROUGH ITS OWNER: the 1024 derivations are the held slots of one `OIMComputedService` store slot keyed by derivation, and each read is `getValueForSlot`, which pays `assertNotReleased` and a call into `oimRefreshComputedSlot` before the clock compare — charged to us. A derive looks its source list up by the slot's key, which only a write that lands in a source list would reach, and no row here makes one. NO ROW MEASURES BYTES; `src/retained/retainedPairsDerivations.ts` is where that half lives.

measured 2026-10-23no explanation yetalt.clock.global-pair-vs-per-slot.quiet-read.fan-in-1
ShippedgetValueForSlot on a computed slot over 3 source slots, refreshed against the channel clock — nothing written since
Alternativesettle it against three readings, held in an array beside the source list
10 ns shipped13 ns alternative0.75×alternative timed twice: 0.2% apart
What the two sides do differently

THE QUIET READ AT THREE SOURCES. Ours still returns on the two-field `checkedAt` comparison whatever the fan-in; the rejected arm walks three readings. The recovered table put fan-in 3 at 1.14x to 1.18x in our favour [NO RUN BEHIND THIS FIGURE], measured on an engine that walked the sources on every settle, so it is not a prediction for this row. RESIDUALS. Both arms derive the same sum over the same entity slots of two fixtures built alike, and the build throws unless every derivation answers the same on both. AGAINST US: our comparison is a CALL to `oimIsRevisionAfter` and walks an EMPTY `sourceComputeds` array first, where the rejected arm compares inline with `!==` — a per-slot counter cannot wrap inside a process and needs no epoch, which is the one structural advantage that design has and it is granted in full. AGAINST THE REJECTED ARM: its readings are an array object per derivation, so every settle chases one more pointer than our two inline fields. OURS IS READ THROUGH ITS OWNER: the 1024 derivations are the held slots of one `OIMComputedService` store slot keyed by derivation, and each read is `getValueForSlot`, which pays `assertNotReleased` and a call into `oimRefreshComputedSlot` before the clock compare — charged to us. A derive looks its source list up by the slot's key, which only a write that lands in a source list would reach, and no row here makes one. NO ROW MEASURES BYTES; `src/retained/retainedPairsDerivations.ts` is where that half lives.

measured 2026-10-23no explanation yetalt.clock.global-pair-vs-per-slot.quiet-read.fan-in-3
ShippedgetValueForSlot on a computed slot over 8 source slots, refreshed against the channel clock — nothing written since
Alternativesettle it against eight readings, held in an array beside the source list
10 ns shipped20 ns alternative0.49×alternative timed twice: 0.1% apart
What the two sides do differently

THE WIDE END. 1024 derivations of eight sources use all 8192 rows of the fixture, so every row is a source of exactly one derivation. Ours compares two inline fields; the rejected arm indexes eight elements off a heap array it allocated per derivation. IF THIS ROW COMES BACK NEAR 1.00 THE QUIET-READ CLAIM IS DEAD [FIGURE STATED IN ADVANCE]. RESIDUALS. Both arms derive the same sum over the same entity slots of two fixtures built alike, and the build throws unless every derivation answers the same on both. AGAINST US: our comparison is a CALL to `oimIsRevisionAfter` and walks an EMPTY `sourceComputeds` array first, where the rejected arm compares inline with `!==` — a per-slot counter cannot wrap inside a process and needs no epoch, which is the one structural advantage that design has and it is granted in full. AGAINST THE REJECTED ARM: its readings are an array object per derivation, so every settle chases one more pointer than our two inline fields. OURS IS READ THROUGH ITS OWNER: the 1024 derivations are the held slots of one `OIMComputedService` store slot keyed by derivation, and each read is `getValueForSlot`, which pays `assertNotReleased` and a call into `oimRefreshComputedSlot` before the clock compare — charged to us. A derive looks its source list up by the slot's key, which only a write that lands in a source list would reach, and no row here makes one. NO ROW MEASURES BYTES; `src/retained/retainedPairsDerivations.ts` is where that half lives.

measured 2026-10-23no explanation yetalt.clock.global-pair-vs-per-slot.quiet-read.fan-in-8
Shippedwrite an entity no derivation reads, then getValueForSlot on a computed slot over 3 source slots
Alternativethe same write, then settle against three per-source readings
31 ns shipped34 ns alternative0.91×alternative timed twice: 0.0% apart
What the two sides do differently

THE QUIET ROWS' OTHER HALF, AND THE ONE TO READ BESIDE THEM. Any write anywhere moves the channel clock, so the `checkedAt` short-circuit misses and ours walks its three sources through `oimIsRevisionAfter` exactly as the rejected arm walks its readings — neither re-derives, because the written row is outside every source list. The write is the shipped `entityService.slotContentService.updateEntity` on BOTH arms and moves `title` on every call, so it is in both numbers alike. Without this row the quiet rows would price the short-circuit as if every frame were silent. RESIDUALS. Both arms derive the same sum over the same entity slots of two fixtures built alike, and the build throws unless every derivation answers the same on both. AGAINST US: our comparison is a CALL to `oimIsRevisionAfter` and walks an EMPTY `sourceComputeds` array first, where the rejected arm compares inline with `!==` — a per-slot counter cannot wrap inside a process and needs no epoch, which is the one structural advantage that design has and it is granted in full. AGAINST THE REJECTED ARM: its readings are an array object per derivation, so every settle chases one more pointer than our two inline fields. OURS IS READ THROUGH ITS OWNER: the 1024 derivations are the held slots of one `OIMComputedService` store slot keyed by derivation, and each read is `getValueForSlot`, which pays `assertNotReleased` and a call into `oimRefreshComputedSlot` before the clock compare — charged to us. A derive looks its source list up by the slot's key, which only a write that lands in a source list would reach, and no row here makes one. NO ROW MEASURES BYTES; `src/retained/retainedPairsDerivations.ts` is where that half lives.

measured 2026-10-23no explanation yetalt.clock.global-pair-vs-per-slot.read-after-an-unrelated-write.fan-in-3
Shippedread a surviving column off an in-place row the engine deleted a column from
AlternativeREJECTED: the same read off a row whose departed column was set to undefined
7 ns shipped7 ns alternative1.02×alternative timed twice: 0.3% apart
What the two sides do differently

EXPECTED TO GO AGAINST THE SHIPPED DESIGN. The blanked form keeps the hidden class its population settled on; the shipped in-place `putEntity` `delete`s and every later read pays for it. ONE OPERATION IS ONE PROPERTY READ of a SURVIVING column (`c07`) off one stored row, walked through the whole population with a mask. Both populations were loaded identically and given the same whole-row `upsertEntity` missing `c15`; ours ran the shipped in-place `putEntity`, which `delete`s it, the rejected one set it to `undefined`. The stored object is the SAME OBJECT on the in-place path on both arms. WHAT THE BLANKED FORM CANNOT DO, and it is not visible in this number: `c15` stays an own property, so the next whole-row `upsertEntity` finds the same column leaving again, reports it removed again and wakes its subscribers again — and a column a caller deliberately stored as `undefined` would stop being distinguishable from one that left. THIS PAIR DOES NOT DECLARE `isolate`, AND THAT IS A DECISION RATHER THAN A DEFAULT. The timed body on each arm is a hand-written read loop belonging to that arm alone — no library code is entered by either, so there is no shared compiled function whose inline caches the two arms could spoil for each other. Each loop's property access therefore sees exactly the row shape its own design produces, for the life of the process, which is the whole thing being measured. The populations ARE built through the shipped `upsertEntity` with two different writers, and that build is outside the clock; nothing timed here touches it. Keeping the ordinary single-process form buys the floor-twice bracket, which is the stronger drift check and is what these rows want.

measured 2026-10-23no explanation yetalt.column-left.delete-vs-blank.read-every-row-lost-a-column
Shippedthe same read where one row in eight was deleted from — two shapes in one population
AlternativeREJECTED: the same population blanked instead — one shape throughout
6 ns shipped7 ns alternative0.88×alternative timed twice: 0.6% apart
What the two sides do differently

THE POPULATION AN APPLICATION ACTUALLY HAS, AND THE SECOND THING THE SHIPPED `delete` COSTS. Here one row in eight has lost a column and seven have not, so ours reads through a site that sees two shapes while the floor's sees one — a blanked population cannot fragment. ONE OPERATION IS ONE PROPERTY READ of `c07` off one stored row, over the whole population with a mask. Both arms read the same column of the same rows in the same order and differ only in what the removal did. READ AGAINST THE ROW ABOVE: that one isolates the cost of the shape, this one adds the cost of two shapes at one site. THIS PAIR DOES NOT DECLARE `isolate`, AND THAT IS A DECISION RATHER THAN A DEFAULT. The timed body on each arm is a hand-written read loop belonging to that arm alone — no library code is entered by either, so there is no shared compiled function whose inline caches the two arms could spoil for each other. Each loop's property access therefore sees exactly the row shape its own design produces, for the life of the process, which is the whole thing being measured. The populations ARE built through the shipped `upsertEntity` with two different writers, and that build is outside the clock; nothing timed here touches it. Keeping the ordinary single-process form buys the floor-twice bracket, which is the stronger drift check and is what these rows want.

measured 2026-10-23no explanation yetalt.column-left.delete-vs-blank.read-one-row-in-eight-lost-a-column
Shippedmap.get(key)?.entity
Alternativerows.get(key)
20 ns shipped18 ns alternative1.10×alternative timed twice: 0.1% apart
What the two sides do differently

ONE INDIRECTION MORE ON OUR SIDE: the row sits on the slot, so a read by key is a hash and a field load where the two-map store answers with the hash alone. Every key hits on both sides, and both stores were checked to hand back the same row object for every key before the clock started.

measured 2026-10-23no explanation yetalt.identity-store.one-map-vs-two.read-the-row-by-key
Shippedfor (const slot of slotContentService.getBucketMemberSlots(bucket)) slot.entity — a Set of 10000, per member
Alternativethe same walk of the same members, kept as a list, per member
3 ns shipped2 ns alternative1.65×alternative timed twice: 0.2% apart
What the two sides do differently

THE SENTENCE UNDER TEST is the one printed above the published removal table: "Both iterate at around [NO RUN BEHIND THIS FIGURE] 2 ns per element, and the difference between them is a fraction of that." It is the half of the bucket service argument that says the choice is NOT an iteration question, and it had no measurement behind it either. THE BODY IS THE SAME ON BOTH HALVES, character for character: one `getBucketMemberSlots`, one for-of, one field load and one store into the sink per member. The only difference in the process is what `getBucketMemberSlots` hands back — a `Set` on ours, the service's own array on the floor — so this row is a property of two JavaScript containers reached through one library, which is exactly what the sentence claims to be about. NOTHING IS WRITTEN, NO MEMBERSHIP IS SET AND NO FRAME IS CLOSED, and neither service orders anything on a read: the list hands back the array `priceGroupIndex` filled, in the order it was written. What a pass pays outside the walk is one service call and one iterator, spread over 10000 members. DIRECTION, three ways: (1) ours is measured on a set that was FILLED and never deleted from, so its entry table has no tombstones to walk — a bucket that has churned iterates worse, and this row therefore flatters the unordered half; (2) `slot.entity` is loaded per member on both halves, because a reader that visits members without looking at them is not a reader, and it is the same monomorphic field load on each side; (3) a pass is a whole walk of the bucket, so the operation count may overshoot what the prober asked for by fewer than 10000 members out of the millions a [NO RUN BEHIND THIS FIGURE] 25 ms pass visits.

measured 2026-10-23no explanation yetalt.iterate-members.unordered-vs-ordered
ShippedpublicService.holdSlot(slot), forwarding to internalService.holdSlot
AlternativeinternalService.holdSlot(slot): holdCount++
1 ns shipped1 ns alternative1.13×alternative timed twice: 15.1% apart
What the two sides do differently

A self-contained model, importing nothing from core, of the public/internal split Andrey approved on 2026-10-21: the public service holds the internal one in a private readonly field and each door forwards to the same internal method. Ours goes through the public door; the floor calls the internal method directly, on the same pool of 1024 slots. Both arms see one receiver class each, so the only difference is the forwarding call and its field load. No channel assert is in either arm, so this prices the hop and nothing the real door adds. Each arm runs in its own process. The door is a hold: one increment.

measured 2026-10-23no explanation yetalt.layer-hop.hold-through-public-layer-vs-internal
ShippedpublicService.getBucketMemberSlotCount(slot), forwarding to the internal service
AlternativeinternalService.getBucketMemberSlotCount(slot): one field load
1 ns shipped1 ns alternative1.08×alternative timed twice: 0.1% apart
What the two sides do differently

A self-contained model, importing nothing from core, of the public/internal split Andrey approved on 2026-10-21: the public service holds the internal one in a private readonly field and each door forwards to the same internal method. Ours goes through the public door; the floor calls the internal method directly, on the same pool of 1024 slots. Both arms see one receiver class each, so the only difference is the forwarding call and its field load. No channel assert is in either arm, so this prices the hop and nothing the real door adds. Each arm runs in its own process. The door is a read: one field load, summed into a sink.

measured 2026-10-23no explanation yetalt.layer-hop.read-through-public-layer-vs-internal
ShippedentityService.getSlotByKey(entityStoreSlot, id).entity
AlternativeslotById.get(id).entity — a bare Map.get over the same slots
28 ns shipped27 ns alternative1.01×alternative timed twice: 0.5% apart
What the two sides do differently

Both sides run on the same population of priceDataset.batch entities and visit the same ids in the same order. The floor reaches the same slots through a hand-built Map<id, slot>; the engine reaches them through its store service. No write and no flush: only the lookup and one property read.

measured 2026-10-23no explanation yetalt.lookup.get-slot-by-key-vs-map-get
ShippedgetValueForSlot — a held computed slot of an OIMComputedService store slot over the list slot, derived once per write
Alternativebody(list.rows) — the same body, called on every read, no node
18 ns shipped4 ns alternative4.34×alternative timed twice: 1.5% apart
What the two sides do differently

THE SHAPE `churnChain` HAS: one field of one row, one read per write. The body is cheaper than the node's own bookkeeping, so ours loses by roughly the bookkeeping; no verdict about derivation can be taken from this cell alone. BOTH ARMS WRITE THE SAME LIST THROUGH `OIMChannelService.INSTANCE.write` before each run of reads, so the stamp is charged equally and only the reads differ. Ours asks the node, which compares its clock, walks its one source's stamp and runs the body once after each write; the floor calls the body on every read. Nothing is subscribed, so no frame runs on either side. The list does not change between writes, so the node's guard finds the value equal and keeps it — the cheapest outcome for ours after a derive. The node is a computed slot resolved before the clock, and every read goes through its owner's `getValueForSlot`, which pays `assertNotReleased` before the clock compare; its derive finds the list by the slot's key, one array index the floor's direct `list.rows` does not pay.

measured 2026-10-23no explanation yetalt.memo.node-vs-recompute.cheap-body.1-reads-per-write
ShippedgetValueForSlot — a held computed slot of an OIMComputedService store slot over the list slot, derived once per write
Alternativebody(list.rows) — the same body, called on every read, no node
4 ns shipped1 ns alternative6.02×alternative timed twice: 0.4% apart
What the two sides do differently

THE CHEAP BODY READ SIXTEEN TIMES: what a memo saves is a field load, and what it costs per read is a clock compare, so the reads-per-write axis alone cannot rescue it here. BOTH ARMS WRITE THE SAME LIST THROUGH `OIMChannelService.INSTANCE.write` before each run of reads, so the stamp is charged equally and only the reads differ. Ours asks the node, which compares its clock, walks its one source's stamp and runs the body once after each write; the floor calls the body on every read. Nothing is subscribed, so no frame runs on either side. The list does not change between writes, so the node's guard finds the value equal and keeps it — the cheapest outcome for ours after a derive. The node is a computed slot resolved before the clock, and every read goes through its owner's `getValueForSlot`, which pays `assertNotReleased` before the clock compare; its derive finds the list by the slot's key, one array index the floor's direct `list.rows` does not pay.

measured 2026-10-23no explanation yetalt.memo.node-vs-recompute.cheap-body.16-reads-per-write
ShippedgetValueForSlot — a held computed slot of an OIMComputedService store slot over the list slot, derived once per write
Alternativebody(list.rows) — the same body, called on every read, no node
216 ns shipped155 ns alternative1.39×alternative timed twice: 0.1% apart
What the two sides do differently

THE MEMO WITH NOTHING TO AMORTISE OVER: a filter and a sum over the list, read once per write, so ours derives on every read exactly as the floor does and pays the node on top. Above one is expected; this is the worst cell of the two axes for the shipped design. BOTH ARMS WRITE THE SAME LIST THROUGH `OIMChannelService.INSTANCE.write` before each run of reads, so the stamp is charged equally and only the reads differ. Ours asks the node, which compares its clock, walks its one source's stamp and runs the body once after each write; the floor calls the body on every read. Nothing is subscribed, so no frame runs on either side. The list does not change between writes, so the node's guard finds the value equal and keeps it — the cheapest outcome for ours after a derive. The node is a computed slot resolved before the clock, and every read goes through its owner's `getValueForSlot`, which pays `assertNotReleased` before the clock compare; its derive finds the list by the slot's key, one array index the floor's direct `list.rows` does not pay.

measured 2026-10-23no explanation yetalt.memo.node-vs-recompute.dear-body.1-reads-per-write
ShippedgetValueForSlot — a held computed slot of an OIMComputedService store slot over the list slot, derived once per write
Alternativebody(list.rows) — the same body, called on every read, no node
17 ns shipped152 ns alternative0.11×alternative timed twice: 0.1% apart
What the two sides do differently

THE CASE A MEMO IS FOR: the dear body, sixteen reads between two writes — or sixteen consumers reading once each, which is the same axis. Ours derives once and answers fifteen reads from the node; the floor walks the list sixteen times. BOTH ARMS WRITE THE SAME LIST THROUGH `OIMChannelService.INSTANCE.write` before each run of reads, so the stamp is charged equally and only the reads differ. Ours asks the node, which compares its clock, walks its one source's stamp and runs the body once after each write; the floor calls the body on every read. Nothing is subscribed, so no frame runs on either side. The list does not change between writes, so the node's guard finds the value equal and keeps it — the cheapest outcome for ours after a derive. The node is a computed slot resolved before the clock, and every read goes through its owner's `getValueForSlot`, which pays `assertNotReleased` before the clock compare; its derive finds the list by the slot's key, one array index the floor's direct `list.rows` does not pay.

measured 2026-10-23no explanation yetalt.memo.node-vs-recompute.dear-body.16-reads-per-write
ShippedslotContentService.getBucketMemberSlotPosition(bucket, member) in a list of 1024 — a scan
Alternativethe same question answered by a Map to positions — one hash
115 ns shipped7 ns alternative16×alternative timed twice: 2.4% apart
What the two sides do differently

THE ONE ROW IN THIS FILE WHERE THE DESIGN WE REJECTED WINS, and it should: a hash against a scan of five hundred on average. It is here because a pair that only shows a rejected design losing is an argument and not a measurement. WHAT IT DOES NOT SHOW is the call site: `remove` asks for a position and splices with it immediately, and that splice is the same memmove for both designs, so the row above is what it costs to have the hash at all. The members are cycled through with a mask so the scan length is uniform over the list, and the build throws unless both designs place every member at the same position. The reading in `packages/bench/measurements/2026-08-20-alternatives/positions` was taken on the removed positional index and is not re-attributed here.

measured 2026-10-23no explanation yetalt.position-of-a-member-vs-positions-map
Shippedread a surviving column off a replacement built empty and filled with survivors
AlternativeREJECTED: the same read off a replacement spread and then deleted from
2 ns shipped7 ns alternative0.25×alternative timed twice: 0.1% apart
What the two sides do differently

THE SECOND READING, AND THE ONE THE SHIPPED SIDE IS BUYING. `delete` on a plain object takes it out of the shape its population shares, and the rejected rebuild would hand readers a replacement born in that state on every removal. That cost is paid PER READ, for the life of the row. ONE OPERATION IS ONE PROPERTY READ of a SURVIVING column (`c07`) off one stored row, walked through the whole population with a mask. Every row of both populations has been through the same whole-row `upsertEntity` missing `c15`; ours built the replacement in the shipped replacing `putEntity`, the rejected one spread it and `delete`d `c15`. THE WORK IS IDENTICAL AND THE SHAPES ARE NOT. A SURVIVING COLUMN AND NOT THE REMOVED ONE, deliberately: `c15` reads `undefined` on both sides and would measure a miss. EVERY ROW LOST THE COLUMN, so each arm sees exactly one shape — the conservative form. THIS PAIR DOES NOT DECLARE `isolate`, AND THAT IS A DECISION RATHER THAN A DEFAULT. The timed body on each arm is a hand-written read loop belonging to that arm alone — no library code is entered by either, so there is no shared compiled function whose inline caches the two arms could spoil for each other. Each loop's property access therefore sees exactly the row shape its own design produces, for the life of the process, which is the whole thing being measured. The populations ARE built through the shipped `upsertEntity` with two different writers, and that build is outside the clock; nothing timed here touches it. Keeping the ordinary single-process form buys the floor-twice bracket, which is the stronger drift check and is what these rows want.

measured 2026-10-23no explanation yetalt.replacement-rebuild.survivors-vs-spread-and-delete.read-after
Shippedslot.bucketSlotsStore on shipped bucket slots
Alternativeslot.content.bucketSlotsStore on one-shape slots (one extra load)
2 ns shipped3 ns alternative0.58×alternative timed twice: 0.2% apart
What the two sides do differently

The bucket hot read: every bucket door reads its store first. One operation is one read.

measured 2026-10-23no explanation yetalt.slot-layout.read-bucket-store-direct-against-content
Shippedmap.get(key).entity on shipped entity slots
Alternativemap.get(key).content on one-shape slots
14 ns shipped15 ns alternative0.99×alternative timed twice: 1.9% apart
What the two sides do differently

The find path: a key lookup and one field load. Same keys; only the slot layout and the field name differ. Every key hits.

measured 2026-10-23no explanation yetalt.slot-layout.read-entity-field-against-content-field

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