@abide/abide 0.58.0 → 0.100.0

package/src/shared/reactive/share.ts

@@ -0,0 +1,91 @@
+import type { Reactive } from './Reactive.ts'
+
+// 10 — `reactive.share(key, create)`: get-or-create by key, in the component instance and its
+// descendants (10.5). One call does both (10.1), so there is no "has it" to race with a "make it".
+//
+// 10.7 REFUSES A PROCESS-WIDE ONE, and that is what makes this a scope rather than a map. Two
+// `<Shelf/>` instances each holding `queued` are two values; a `<TrackRow/>` under a page that
+// holds `nowPlaying` finds the page's. The difference is the CHAIN, and the chain is the
+// component tree — which exists now that a component is invoked rather than written as markup.
+//
+// A SCOPE PER COMPONENT THAT SHARES, not per component. A file that never calls this needs no node
+// of its own: it is a link nothing is filed under, and a descendant's walk passes straight through
+// it to the ancestor that does hold the key. The emitters open one exactly where the call is, so
+// what a page pays for the mechanism is nothing unless it uses it.
+
+export type ShareScope = {
+    parent: ShareScope | null
+    values: Map<string, unknown>
+}
+
+// The instance being rendered or mounted, or `null` outside one. A dynamic scope like
+// `TRACKING.reader` is, and for the same reason: the call is made in an author's own setup, which
+// cannot be handed a parameter.
+let CURRENT: ShareScope | null = null
+
+/**
+ * The app's registry of shared keys, declaration-merged (10.3).
+ *
+ * Empty here: an app widens it, and a key it declares is checked against it where a key it does
+ * not is inferred from the thunk.
+ */
+// biome-ignore lint/suspicious/noEmptyInterface: 10.3 — an app merges its own keys into this.
+export interface Shared {}
+
+/** The value held under `key` by this component or its nearest ancestor, or one created here. */
+export function share<Key extends string, Value>(
+    key: Key,
+    create: () => Reactive<Value>,
+): Key extends keyof Shared ? Reactive<Shared[Key]> : Reactive<Value> {
+    const scope = CURRENT
+    if (scope === null)
+        throw new Error(
+            `abide: reactive.share('${key}') was called outside a component instance, and the scope it would get or create in is that instance. RULEBOOK 10.5.`,
+        )
+    for (let at: ShareScope | null = scope; at !== null; at = at.parent) {
+        const held = at.values.get(key)
+        // 10.4 — held for the life of the scope, so a second call in a descendant finds this one
+        // rather than building a second value the first one's readers never hear from.
+        if (held !== undefined) return held as never
+    }
+    // 10.6 — created HERE where no ancestor holds it, which is what makes two siblings two values.
+    const made = create()
+    scope.values.set(key, made)
+    return made as never
+}
+
+/**
+ * Opens a share scope around an emitted component's body, and returns the previous one.
+ *
+ * The PREVIOUS scope comes back rather than the new one: restoring is the whole of the close
+ * (`leaveShare`), and a component that threw still has to restore it.
+ */
+export function enterShare(): ShareScope | null {
+    const previous = CURRENT
+    CURRENT = { parent: previous, values: new Map() }
+    return previous
+}
+
+export function leaveShare(previous: ShareScope | null): void {
+    CURRENT = previous
+}
+
+/**
+ * The share scope current now, for an instance to capture at mount and a deferred mount to resume.
+ *
+ * 10.5 THROUGH A MOUNT THAT HAPPENS LATER. A row the list grows by is mounted from a `watch`
+ * effect, not from inside its caller's mount — so nothing is on the stack and `CURRENT` is null,
+ * and a child that shares would open a chain of its own and miss the key its page holds. The
+ * instance captures its own scope at mount and the deferred mount resumes it, which is what makes
+ * a row added after the click a descendant of the same page as the rows the server wrote.
+ */
+export function currentShare(): ShareScope | null {
+    return CURRENT
+}
+
+/** Makes a captured share scope current again, and returns the previous one to restore. */
+export function resumeShare(scope: ShareScope | null): ShareScope | null {
+    const previous = CURRENT
+    CURRENT = scope
+    return previous
+}

package/src/shared/reactive/structural.ts

@@ -0,0 +1,62 @@
+/**
+ * The by-value comparator an app passes as `identity`: deep equality over arrays and plain objects.
+ *
+ * Not the default: the default is the reference, and this is what a value whose producer
+ * RE-MATERIALISES declares — `reactive(() => getInvoice({ id }), { identity: structural })`. A
+ * fresh-but-equal payload waking every reader is why it exists at all; what it stops being is the
+ * price every other value pays.
+ *
+ * 5.5: it answers "not equal" wherever it cannot decide. A comparator that guessed would collapse
+ * a production a reader needed, and the failure is silent — the value stays right while the wake
+ * goes missing.
+ */
+export function structural(next: unknown, previous: unknown): boolean {
+    if (Object.is(next, previous)) return true
+    if (
+        next === null ||
+        previous === null ||
+        typeof next !== 'object' ||
+        typeof previous !== 'object'
+    )
+        return false
+
+    const nextIsArray = Array.isArray(next)
+    if (nextIsArray !== Array.isArray(previous)) return false
+    if (nextIsArray) {
+        const one = next as unknown[]
+        const two = previous as unknown[]
+        if (one.length !== two.length) return false
+        for (let index = 0; index < one.length; index += 1)
+            if (!structural(one[index], two[index])) return false
+        return true
+    }
+
+    // Anything exotic — a Map, a Date, a class instance — is where 5.5 bites. Walking
+    // own enumerable keys on one of those compares nothing that decides it.
+    if (
+        Object.getPrototypeOf(next) !== Object.prototype ||
+        Object.getPrototypeOf(previous) !== Object.prototype
+    )
+        return false
+
+    // `Object.keys` ALLOCATES TWO ARRAYS PER COMPARE and it is still the fast arm.
+    // Replacing both with `for...in` walks — no allocation, one counting pass for the
+    // other side — measured SLOWER under JSC on the shape this runs on: 45.8 ns became
+    // 48.6 ns and 56.7 ns across two runs. Per-iteration cost in `for...in` exceeds what the
+    // allocation saves at this object size, so the allocation stays.
+    const keys = Object.keys(next as Record<string, unknown>)
+    if (keys.length !== Object.keys(previous as Record<string, unknown>).length)
+        return false
+    for (let index = 0; index < keys.length; index += 1) {
+        const key = keys[index] as string
+        if (!Object.hasOwn(previous, key)) return false
+        if (
+            !structural(
+                (next as Record<string, unknown>)[key],
+                (previous as Record<string, unknown>)[key],
+            )
+        )
+            return false
+    }
+    return true
+}

package/src/shared/reactive/tracking.ts

@@ -0,0 +1,418 @@
+// RULEBOOK 14: a `Reactive` is tracked only where something downstream will be rebuilt
+// from it, and 14.11 has the value push its own subscriber when it evaluates, whoever
+// reached it. 14.13 makes tracking SYNCHRONOUS, which is what keeps the cost to one
+// variable save and restore rather than a context propagated across every promise in
+// the process.
+//
+// THE READER IS A FIELD ON A MODULE-SCOPE RECORD rather than a module-scope `let` with
+// an accessor, so a read can test it INLINE. A read is the hottest path in the design —
+// per template slot, per row — and an exported getter puts a call frame in front of the
+// null check that skips the work.
+//
+// SOURCES ARE AN ARRAY AND A CURSOR, not a set rebuilt per run. A body reads the same
+// values in the same order on almost every run, so the common shape is "the source at
+// the cursor is the one we already had" — a pointer compare and an increment, with no
+// set operation at all. The general algorithm is the fallback: the first read that does
+// not match detaches everything from the cursor on and rebuilds it.
+//
+// DIVERGENCE IS SAID BY THE CURSOR, not by a flag beside it. `cursor === sources.length`
+// IS the diverged state — a run that diverges truncates to its cursor and appends from
+// there, so the two stay equal for the rest of the run and the cursor can never match
+// again. The flag that used to carry this was a second field load and a second branch on
+// the read path, which is the hottest path in the design.
+
+/**
+ * The first of the three states a reader can be in: nothing it read has moved.
+ *
+ * THE THREE STATES A READER CAN BE IN, and the whole of push-pull is that there are three rather
+ * than two. `DIRTY` says a source of mine PRODUCED and I must run. `CHECK` says a source of mine
+ * may have — something further up produced, and whether it reached me is not known until the
+ * sources between us have been asked.
+ *
+ * Two states cannot carry that distinction, and the distinction is the design: a write marks its
+ * direct readers `DIRTY` and everything beyond them `CHECK`, so the mark walk is O(V) flag writes
+ * and runs no body at all. A `CHECK` node asked for its value resolves its sources first and runs
+ * only where one of them produced — which is what keeps 5.2 true through a chain that eager kept
+ * by running every body and comparing.
+ *
+ * The ORDER matters: a mark never weakens, so `state >= wanted` is the skip test. Annotated
+ * `number` rather than left as literals on purpose: the field is mutated by a resolution the
+ * compiler cannot see through, so a literal type would narrow `state === CHECK` to `1` and then
+ * call the `state === DIRTY` beneath it unreachable.
+ */
+export const CLEAN: number = 0
+/** A source of mine may have produced; ask the sources between us before running. See `CLEAN`. */
+export const CHECK: number = 1
+/** A source of mine produced, and I must run. See `CLEAN`. */
+export const DIRTY: number = 2
+
+export type Subscriber = {
+    notify(): void
+    /**
+     * `CLEAN`, `CHECK` or `DIRTY`.
+     *
+     * Set on every transitive reader before anything runs, so a body that reads a source the
+     * resolution has not reached yet pulls it forward rather than reading a value the write has
+     * passed by.
+     */
+    state: number
+    /** The re-entrancy guard for a body already on the stack. */
+    running: boolean
+    isEffect: boolean
+    /**
+     * Whether this reader runs in the mark walk rather than the drain.
+     *
+     * A MIRROR RUNS IN THE MARK WALK, NOT THE DRAIN, and must not be batched with an effect. An
+     * adoption's mirror moves a VALUE — it is the outer value's production, arriving from the inner
+     * one — so deferring it to the end of the turn would leave a read between the two answering
+     * with what the outer held before, and reads pulling correctly is the whole reason the drain
+     * can be deferred at all. A keyed entry's lifetime is the one mirror with no adopter: it runs
+     * in the walk so its clock read is the production's own moment.
+     */
+    isMirror: boolean
+    /**
+     * The value an adoption's mirror mirrors into, and `null` on every other reader.
+     *
+     * A probe move on the adopted value mints nothing, so it never reaches the mirror as a value —
+     * this is the edge `markProbes` follows to reach the adopter's guards instead (11.50).
+     */
+    adopter: Tracked | null
+    /** Read on the last run, in order. Rebuilt only from the point a run diverges. */
+    sources: Tracked[]
+    /**
+     * The values whose PROBES this run asked about — another edge than the values it read (3.3).
+     *
+     * Kept apart so a flip reaches the readers that asked and nobody else: waking a value reader
+     * because a load STARTED is 50 data writes on a 50-row list, every one of them redundant, and
+     * the identity gate that exists to stop exactly that cannot see a production nobody minted.
+     */
+    probeSources: Tracked[]
+    /**
+     * How far into `sources` this run has matched.
+     *
+     * Once it reaches `sources.length` the run has DIVERGED and every read left goes through
+     * `track`. Reset before each run.
+     */
+    cursor: number
+    /**
+     * The distinct values in `sources[0..seenThrough)` once `track` has found them worth a set;
+     * `null` until a body reads that many. See `track`.
+     */
+    seen: Set<Tracked> | null
+    /** The cursor after this reader's last read `track` deduped past `SET_OVER_SCAN`. */
+    seenThrough: number
+    /**
+     * Where the stretch of diverged reads `seenThrough` ends began, while it is still being
+     * scanned — and `-1` once `seen` is what answers for it.
+     */
+    scanningFrom: number
+    alive: boolean
+}
+
+export type Tracked = {
+    readers: Subscriber[]
+    /** Who asked about this value's probes. Apart from `readers` — see `probeSources`. */
+    probeReaders: Subscriber[]
+}
+
+/** The reader whose run is on the stack, or `null` where reads subscribe to nothing. */
+export const TRACKING: { reader: Subscriber | null } = { reader: null }
+
+function unwired(): void {}
+
+/**
+ * A fresh reader over `sources`, its `notify` left for the caller to assign.
+ *
+ * ONE PLACE THE SHAPE IS WRITTEN for every reader in this graph that is not a `Cell`: the tracked
+ * effect and the narrowed one in `watch.ts`, a history cursor, the waiter a `then` parks on a
+ * probe edge, and a keyed entry's lifetime mirror.
+ *
+ * THE FIELD ORDER IS THE PART NO TEST CATCHES. TypeScript refuses a literal that MISSES a field, so
+ * copies could not diverge in content — but it says nothing about the order they are written in,
+ * and each order is its own hidden class for one type. Every `reader.state` and `reader.alive` on
+ * the mark walk is then a polymorphic load, and nothing about the output moves.
+ *
+ * `notify` IS ASSIGNED BY THE CALLER, which is a write to a field that is already there and so
+ * leaves the shape alone — each reader's closes over the reader itself, which a factory parameter
+ * cannot do without a second frame on every wake.
+ */
+export function newSubscriber(
+    sources: Tracked[],
+    adopter: Tracked | null,
+    isMirror: boolean = adopter !== null,
+): Subscriber {
+    return {
+        sources,
+        probeSources: [],
+        cursor: 0,
+        seen: null,
+        seenThrough: 0,
+        scanningFrom: -1,
+        alive: true,
+        state: CLEAN,
+        running: false,
+        isEffect: true,
+        isMirror,
+        adopter,
+        notify: unwired,
+    }
+}
+
+/**
+ * Removes `reader` from `source`'s readers.
+ *
+ * Removal by swap-with-last: order in a reader list is not observable, and a splice is O(n)
+ * copying where this is one write. Exported because readers are registered OUTSIDE the tracking
+ * protocol too — a cursor in `Cursor.ts`, an entry's lifetime in `Keyed.ts` — and a second copy
+ * of the loop beside this one is what CLAUDE.md's sibling-seam rule refuses.
+ */
+export function dropReader(source: Tracked, reader: Subscriber): void {
+    removeFrom(source.readers, reader)
+    if (source.readers.length === 0) unread(source)
+}
+
+/**
+ * What lets go of a value whose owner has stopped, once nothing reads it — `Reactive.ts`'s, set
+ * there because this module cannot import it.
+ */
+export const RELEASING: { unread: ((source: Tracked) => void) | null } = {
+    unread: null,
+}
+
+/**
+ * Hands a value that has just lost its last reader on to `RELEASING`, where its owner has stopped.
+ *
+ * 12.14 — see `orphan` in `Reactive.ts`. Only a `Cell` carries `orphaned`, so
+ * every other source answers `undefined` and stops here.
+ */
+function unread(source: Tracked): void {
+    if ((source as { orphaned?: boolean }).orphaned !== true) return
+    if (source.readers.length !== 0 || source.probeReaders.length !== 0) return
+    RELEASING.unread?.(source)
+}
+
+/**
+ * Calls `run` with no reader on the stack, restoring the reader however it exits.
+ *
+ * 4.7's frame. Arguments rather than a closure, so a caller on a per-write path allocates nothing
+ * to use it.
+ */
+export function untracked<First, Second, Result>(
+    run: (first: First, second: Second) => Result,
+    first: First,
+    second: Second,
+): Result {
+    const previous = TRACKING.reader
+    TRACKING.reader = null
+    try {
+        return run(first, second)
+    } finally {
+        TRACKING.reader = previous
+    }
+}
+
+/**
+ * Removes `reader` from `source`'s probe readers — `dropReader` for the probe edge.
+ *
+ * For a reader registered on it outside a run — a `then` waiter, which settles on a probe moving
+ * rather than on a value.
+ */
+export function dropProbeReader(source: Tracked, reader: Subscriber): void {
+    removeFrom(source.probeReaders, reader)
+    if (source.probeReaders.length === 0) unread(source)
+}
+
+function removeFrom(readers: Subscriber[], reader: Subscriber): void {
+    for (let index = 0; index < readers.length; index += 1) {
+        if (readers[index] !== reader) continue
+        readers[index] = readers[readers.length - 1] as Subscriber
+        readers.pop()
+        return
+    }
+}
+
+/**
+ * Subscribes `reader` to `source`'s probes, once per run.
+ *
+ * A PROBE EDGE IS REBUILT PER RUN rather than cursored. A body reads few probes where it reads
+ * many values, and a guard that stops being taken must stop waking — so the list is dropped at
+ * the start of a run and re-made by the reads that happen.
+ */
+export function trackProbe(source: Tracked, reader: Subscriber): void {
+    const asked = reader.probeSources
+    for (let index = 0; index < asked.length; index += 1)
+        if (asked[index] === source) return
+    asked.push(source)
+    source.probeReaders.push(reader)
+}
+
+/** Drops every probe subscription `reader` holds. */
+export function detachProbes(reader: Subscriber): void {
+    const asked = reader.probeSources
+    for (let index = 0; index < asked.length; index += 1)
+        dropProbeReader(asked[index] as Tracked, reader)
+    asked.length = 0
+}
+
+// How far `kept * dropped` must outgrow `kept + dropped` before `truncate` builds a `Set` over the
+// kept prefix rather than scanning it once per dropped slot.
+const SET_OVER_SCAN = 20
+
+/**
+ * Drops `reader`'s sources from its cursor on, unsubscribing each the kept prefix no longer lists.
+ *
+ * Everything from `cursor` on is a value the previous run read and this one has not.
+ *
+ * A SLOT IS NOT A SUBSCRIPTION. `sources` is POSITIONAL — one slot per read, so a body that reads
+ * one value twice holds two slots for it — where `source.readers` is a SET, deduped by `track`.
+ * Dropping per slot therefore unsubscribed a value a SURVIVING slot still lists, and the shorter
+ * run is what did it: `reactive(() => name() ? name().toUpperCase() : 'anon')` reads `name` twice
+ * on the truthy run and once on the falsy one, so the falsy run's truncation took the whole
+ * subscription with it and the value never recomputed again — right at the moment it looked
+ * right. The kept prefix is what says whether this slot was the last of its value.
+ *
+ * THE SCAN RUNS PER DROPPED SLOT, so what it costs is kept x dropped: a body reading 1000 values
+ * on its wide branch and 500 on its narrow one paid 250,000 pointer compares on every flip — 9.3x
+ * the pre-change truncate, +105 us a flip, which crosses a frame at six. A `Set` over the kept
+ * prefix is the O(kept + dropped) form and is taken WHERE IT WINS rather than always (past
+ * `SET_OVER_SCAN`): at 1000/999 the scan is one probe per dropped slot and building the Set
+ * doubled the flip, so the two are priced against each other instead.
+ *
+ * A duplicate inside the DROPPED tail needs no test — `removeFrom` takes one occurrence and the
+ * second call finds none.
+ *
+ * Exported because a tracked run's end is exactly this and nothing more: the TEST that there is a
+ * tail is the caller's — two field loads, on the rare arm.
+ */
+export function truncate(reader: Subscriber): void {
+    const sources = reader.sources
+    const kept = reader.cursor
+    const dropped = sources.length - kept
+    if (dropped === 0) return
+    if (kept * dropped > (kept + dropped) * SET_OVER_SCAN) {
+        const survives = new Set<Tracked>()
+        for (let index = 0; index < kept; index += 1)
+            survives.add(sources[index] as Tracked)
+        for (let index = kept; index < sources.length; index += 1) {
+            const source = sources[index] as Tracked
+            if (survives.has(source)) continue
+            dropReader(source, reader)
+        }
+        sources.length = kept
+        return
+    }
+    for (let index = kept; index < sources.length; index += 1) {
+        const source = sources[index] as Tracked
+        if (stillRead(sources, source, kept)) continue
+        dropReader(source, reader)
+    }
+    sources.length = kept
+}
+
+function stillRead(sources: Tracked[], source: Tracked, kept: number): boolean {
+    for (let index = 0; index < kept; index += 1)
+        if (sources[index] === source) return true
+    return false
+}
+
+/**
+ * Records a read of `source` by `reader` where its run has diverged from the last one.
+ *
+ * THE READER IS PASSED IN, not re-read. Every call site has already tested `TRACKING.reader` for
+ * null to decide whether to call at all, and re-loading it here made the null check happen twice
+ * on the hottest path in the design.
+ *
+ * The STABLE arm — the source at the cursor is the one the last run had — is inlined at the call
+ * site in `Reactive`, so what is left here is the divergence: this is the fallback, reached on the
+ * first read a run makes that the previous run did not.
+ */
+export function track(source: Tracked, reader: Subscriber): void {
+    const sources = reader.sources
+    const at = reader.cursor
+    // THE FIRST DIVERGENCE OF THIS RUN, and the only one that has anything to drop. The
+    // truncation leaves `sources.length === cursor` and the append below keeps them
+    // equal, so every later read of this run arrives with the test already false — which
+    // is the flag this replaced, read off state the cursor was carrying anyway.
+    if (at < sources.length) truncate(reader)
+    sources.push(source)
+    reader.cursor = at + 1
+    // WHAT STOPS A BODY READING ONE VALUE TWICE FROM HOLDING TWO SUBSCRIPTIONS, asked of
+    // THIS READER'S sources rather than of the source's readers. The two answer the same
+    // question — `track` is the only thing that appends to either, and `truncate` drops from
+    // both in lockstep, so after it `sources[0..cursor)` IS the set this reader is
+    // subscribed to — and they cost differently: the kept prefix is as long as what this
+    // BODY reads (1-5), where `source.readers` is as long as the number of READERS on the
+    // value.
+    //
+    // SO THE SCAN WAS QUADRATIC IN THE ROW COUNT. A fresh reader is on this path, not only a
+    // diverging one: `Reactive`'s inlined stable arm tests `reader.sources[0] === cell`
+    // against an empty array, misses, and lands here. n rows each reading one shared value —
+    // `class:selected={selected() === item.id}`, the canonical shape — paid n²/2 pointer
+    // compares to mount. Measured under JSC, per reader: 446 ns at n=500 rising to 3,872 ns
+    // at n=8000, so mounting crossed a frame at n≈4,000. Asked this way it is ~60 ns FLAT and
+    // n=8000 goes 30.98 ms -> 0.45 ms. `mountingIsLinear` in `benchReactive.ts` is what holds the
+    // SLOPE (16 readers against 112, calibrated bar), `mount 50 readers on one value` holds the
+    // constant, and the subscription count in `reactive.test.ts` holds the dedup this replaced.
+    //
+    // THE THREE READERS REGISTERED ON A VALUE EDGE OUTSIDE THE PROTOCOL are unaffected, and this
+    // asks nothing of them they were not already under: `Cursor`, `Keyed`'s lifetime
+    // mirror and the narrowed `watch(sources, effect)` each DECLARE their sources and push
+    // themselves onto those sources' readers, so the two agree by construction — `settled`'s
+    // waiter is the fourth, and it is on the probe edge, which this never scans — and none of them
+    // tracks, which `truncate` already depends on. A cursor of 0 against a declared `sources`
+    // would have it drop the declared subscription on the first `track`, so a reader that
+    // both declares and tracks is already broken above this line.
+    //
+    // AND THE SCAN IS QUADRATIC IN THE BODY past the first divergence, which is the same bug one
+    // level in: a body summing a thousand rows' values that diverges near the front — a row
+    // inserted at index 0 — scans the kept prefix once per read for the rest of the run, n²/2
+    // compares, 131 ms at n=16,000 under JSC. So a long STRETCH of diverged reads over a long
+    // prefix dedups against a `Set`, priced against the scan the way `truncate` prices its own:
+    // below `SET_OVER_SCAN` on the prefix the scan stays, because a body reads 1-5 values and a set
+    // is an allocation; and a stretch is scanned for its first `SET_OVER_SCAN` reads before the set
+    // is built, because a body that diverges at its LAST read — a thousand stable reads, then a
+    // branch — makes one scan and would pay a thousand inserts for a set it asks once.
+    //
+    // `seenThrough` IS WHAT SAYS THE STRETCH GOES ON. Every read past the threshold comes through
+    // here and moves it to the cursor after it, so a read arriving anywhere else follows a
+    // truncation, a fresh run or a stretch of stable reads — and `sources[0..at)` is then not
+    // what `seen` was last true of, so a new stretch starts. The threshold side cannot alias it:
+    // a run climbing back from below arrives at `SET_OVER_SCAN` exactly, which `seenThrough`,
+    // always one past a read at or above it, never equals.
+    if (at < SET_OVER_SCAN) {
+        for (let index = 0; index < at; index += 1)
+            if (sources[index] === source) return
+        source.readers.push(reader)
+        return
+    }
+    if (reader.seenThrough !== at) reader.scanningFrom = at
+    reader.seenThrough = at + 1
+    let seen = reader.seen
+    const from = reader.scanningFrom
+    if (from !== -1) {
+        if (at - from < SET_OVER_SCAN) {
+            for (let index = 0; index < at; index += 1)
+                if (sources[index] === source) return
+            source.readers.push(reader)
+            return
+        }
+        if (seen === null) {
+            seen = new Set()
+            reader.seen = seen
+        } else seen.clear()
+        for (let index = 0; index < at; index += 1)
+            seen.add(sources[index] as Tracked)
+        reader.scanningFrom = -1
+    }
+    const deduped = seen as Set<Tracked>
+    if (deduped.has(source)) return
+    deduped.add(source)
+    source.readers.push(reader)
+}
+
+/** Drops every subscription `reader` holds, value and probe alike. */
+export function detach(reader: Subscriber): void {
+    reader.cursor = 0
+    truncate(reader)
+    if (reader.probeSources.length !== 0) detachProbes(reader)
+}