@abide/abide 0.58.0 → 0.100.0

package/src/ui/ArmRegion.ts

@@ -0,0 +1,185 @@
+// A REGION THAT HOLDS ONE ARM AT A TIME — an `{#if}` chain's (32.12), a component a tag chooses by
+// a value (32.34), a `{#try}`'s body or catch (32.16). What changes the arm is the region's watch;
+// what the change DOES is here, once: stop what the old arm bound, fill the region, mount the new
+// one. A record with its methods on the prototype rather than a swap closure per region, because an
+// `{#if}` inside a `{#for}` is one of these per row.
+
+import { namedArm } from '#shared/armAnchor.ts'
+import {
+    leaveShare,
+    resumeShare,
+    type ShareScope,
+} from '#shared/reactive/share.ts'
+import { untracked } from '#shared/reactive/tracking.ts'
+import { HYDRATE_LOG } from './Mismatch.ts'
+import { fillRegion, isEmptyRegion, type Region } from './regions.ts'
+import { Scope, type Stoppable } from './Scope.ts'
+
+/** One arm: what makes its nodes, and what binds them. A `build` of `undefined` makes none. */
+export type Arm = {
+    build: ((document: Document) => Node[]) | undefined
+    mount: (root: Region) => Stoppable | undefined
+}
+
+/**
+ * The arms an emitted region declares, each answering its `Arm` once per swap in.
+ *
+ * An arm with a branch-local `<script>` (14.8) runs it here, which is why it is called inside the
+ * swap — untracked — and not before. A `{#try}`'s catch is handed the failure it binds.
+ */
+export type ArmMakers = readonly ((caught: unknown) => Arm)[]
+
+const NO_ARMS: ArmMakers = []
+
+/** What stands for an absent component (32.36): nothing built, nothing bound. */
+const NOTHING: Arm = { build: undefined, mount: () => undefined }
+
+/**
+ * An `{#if}` chain's region, and the base of every region that holds one arm at a time.
+ *
+ * 32.12 — THE FIRST SWAP HYDRATES the arm the server painted rather than replacing it, and FILLS a
+ * region nobody painted: 41.4 lets a render continue past a subject still in flight, and what the
+ * server writes then is the anchor pair alone. `isEmptyRegion` is asked once, on the first swap —
+ * from the second the region is filled anyway. 41.24 — AND IT HYDRATES ONLY THE ARM THE SERVER
+ * PAINTED: where the client chose another, the arm it chose is filled in rather than bound to
+ * nodes it did not make (`paintedOther`).
+ *
+ * ONE SCOPE FOR THE REGION'S WHOLE LIFE, owned by the region above it and REFILLED on every swap:
+ * a fresh one per swap would have to be handed up per swap too, and a toggle clicked a thousand
+ * times would leave a thousand on the region that outlives it. `undefined` where no arm binds
+ * anything — there is nothing to stop, and the swap only fills.
+ *
+ * 32.16 — `at` IS SET ONCE THE ARM HAS MOUNTED, not before. Under a `{#try}` a swap that throws is
+ * retried by running the watch again; with the arm already recorded that run found nothing to do,
+ * the boundary read it as recovered and remounted the body, which threw again — a loop with no
+ * turn in it.
+ */
+export class ArmRegion {
+    readonly region: Region
+    readonly scope: Scope | undefined
+    readonly arms: ArmMakers
+    /** The arm standing, or `undefined` before one has mounted. */
+    at: unknown
+
+    constructor(
+        region: Region,
+        owner: Scope,
+        arms: ArmMakers,
+        /** Whether any arm binds anything, so the region holds a scope to stop. */
+        binds: boolean,
+    ) {
+        this.region = region
+        this.scope = binds ? owner.own(new Scope()) : undefined
+        this.arms = arms
+        this.at = undefined
+    }
+
+    /**
+     * Puts arm `next` in the region where it is not the arm standing.
+     *
+     * 14.1, 14.7, 14.8 — CALLED FROM THE REGION'S WATCH, and the swap runs untracked: the watch
+     * decides which arm and must wake for nothing else, while the swap sets the arm up, builds it
+     * and mounts it. What the arm reads is kept live by its own mount's bindings.
+     */
+    show(next: unknown): void {
+        if (next !== this.at) untracked(swapTo, this, next)
+    }
+
+    swap(next: unknown): void {
+        const region = this.region
+        const filling =
+            this.at !== undefined ||
+            isEmptyRegion(region) ||
+            this.paintedOther(next)
+        const arm = this.armOf(next)
+        const scope = this.scope
+        if (filling) {
+            scope?.stop()
+            fillRegion(region, arm.build)
+        }
+        scope?.own(arm.mount(region))
+        this.at = next
+    }
+
+    armOf(next: unknown): Arm {
+        return (this.arms[next as number] as ArmMakers[number])(undefined)
+    }
+
+    /**
+     * Whether the region holds an arm the server painted other than `next`, warning where it does.
+     *
+     * 41.24 — asked once, on the first swap of a region holding markup. The open names the arm the
+     * server painted; a region the browser filled names none and is adopted as it stands. A later
+     * swap leaves the open as it is, since nothing reads it again.
+     */
+    paintedOther(next: unknown): boolean {
+        const painted = namedArm(this.region.open.data)
+        if (painted === undefined || painted === next) return false
+        HYDRATE_LOG.warning(
+            `abide: the server painted arm ${painted} of this region and the client chose arm ${String(next)}, so the region is rebuilt (41.24).`,
+        )
+        return true
+    }
+}
+
+function swapTo(region: ArmRegion, next: unknown): void {
+    region.swap(next)
+}
+
+/**
+ * A region holding the component a tag chooses by a value.
+ *
+ * 32.34, 32.35 — AN `{#if}` WHOSE ARMS ARE COMPONENTS: the first swap hydrates what the server
+ * painted, and a later one empties the region for the next child to fill itself — the fill an
+ * invoked component already makes where no server painted (32.17). The props record is the
+ * caller's accessors, so one record serves every child the value chooses.
+ *
+ * 10.5 — a swap after the first runs from the watch, with no instance on the stack, so the child
+ * mounts inside the share scope of the instance that holds it.
+ */
+export class ChosenRegion extends ArmRegion {
+    readonly props: object
+    readonly share: ShareScope | null
+
+    constructor(
+        region: Region,
+        owner: Scope,
+        props: object,
+        share: ShareScope | null,
+    ) {
+        super(region, owner, NO_ARMS, true)
+        this.props = props
+        this.share = share
+    }
+
+    /**
+     * 41.24 — whether the server painted a component where the client chose none.
+     *
+     * A component's open names nothing: the two sides hold the same component as two different
+     * functions, and only the child's own walk can tell one painting from another (41.10). An
+     * absent value is the one choice the region itself can see disagree.
+     */
+    override paintedOther(next: unknown): boolean {
+        if (next != null) return false
+        HYDRATE_LOG.warning(
+            'abide: the server painted a component in this region and the client chose none, so the region is emptied (41.24).',
+        )
+        return true
+    }
+
+    override armOf(next: unknown): Arm {
+        if (next == null) return NOTHING
+        const component = next as (root: Region, props: object) => Stoppable
+        return {
+            build: undefined,
+            mount: (root) => {
+                const back = resumeShare(this.share)
+                try {
+                    return component(root, this.props)
+                } finally {
+                    leaveShare(back)
+                }
+            },
+        }
+    }
+}

package/src/ui/LAYER_NAMES.ts

@@ -0,0 +1,30 @@
+// THE NAMES A LAYER IS MEASURED UNDER, and the whole reason they are a leaf: they cross from the
+// code that EMITS the measure to the spec that reads it, and a string typed twice is a
+// `shares()` call that throws "found no measure named" against a layer that ran.
+//
+// `.` RATHER THAN `:`. `abide:hydrate` and `abide:navigate` are WARNING channels (28.9) and these
+// are performance entries — two namespaces that would otherwise be one grep.
+//
+// ONE NAME PER OP SOMEBODY WAITS ON, never per row. `shares()` sums every measure of a layer
+// inside the op, so a mark per row would cost a `performance.mark` per row to report the same
+// fraction, and CLAUDE.md's hot-path rules apply to the instrument as much as to the code.
+export const LAYER_NAVIGATE = 'abide.navigate'
+export const LAYER_MOUNT = 'abide.mount'
+export const LAYER_RECONCILE = 'abide.reconcile'
+/**
+ * The layer every region fill that runs a build is measured under.
+ *
+ * EVERY REGION THE BROWSER FILLS BY A BUILD — an `{#if}` arm, a navigated-to page building itself
+ * (30.11), a component filling its own region (32.17). A fill with no build merely empties the
+ * region and opens no layer, so the run count is the number of builds a navigation really ran
+ * rather than the number of call sites the build emitted.
+ */
+export const LAYER_FILL = 'abide.fill'
+
+/**
+ * The global that arms layer measures (`measureLayer.ts`).
+ *
+ * Set by the harness before the graph loads — the same string crossing the same seam, so it is a
+ * leaf member for the same reason.
+ */
+export const LAYERS_ARMED = '__ABIDE_LAYERS__'

package/src/ui/List.ts

@@ -0,0 +1,273 @@
+import { listOf } from '#shared/listOf.ts'
+import { untracked } from '#shared/reactive/tracking.ts'
+import { HYDRATE_LOG, Mismatch, warnMismatch } from './Mismatch.ts'
+import { dropRow, makeRow, type Row, reconcile, rowOf } from './reconcile.ts'
+import { isEmptyRegion, type Region, removeUntil } from './regions.ts'
+import { rowsIn } from './rows.ts'
+import type { Scope } from './Scope.ts'
+
+/**
+ * The state of one `{#for}` block, shared by its reconcile and its async append.
+ *
+ * Owned by the emitted block, it holds everything the two arms — the reconcile of a list and the
+ * append of an async subject — have to tell each other: which source is pumping, and whether the
+ * repeated-key warning has fired. Each edge between the two modes is a field here rather than a
+ * patch to a module-level map keyed on the region.
+ */
+export class List {
+    region: Region
+    rows: Row[]
+    /**
+     * The async iterable last started, or null — so a re-run with the same iterable is not a new
+     * source.
+     */
+    pumping: unknown
+    /**
+     * The iterator the pump is parked on, or null.
+     *
+     * 12.13 — RETURNED WHEN THE PUMP IS, rather than left to notice at its next item: a feed that
+     * has gone quiet produces no next item, and a cursor parked on it held its subscription, and
+     * the list and the region with it, for as long as the source stayed silent.
+     */
+    iterator: AsyncIterator<unknown> | null
+    /**
+     * Whether the repeated-key warning has fired.
+     *
+     * 41.15 — once for the block, not once a reconcile.
+     */
+    warned: boolean
+    /**
+     * Whether the rows are still the server's.
+     *
+     * The first update HYDRATES them rather than reconciling, and clears this.
+     */
+    hydrating: boolean
+    /** Whether each row carries its own anchor — a body with several top-level nodes. */
+    anchored: boolean
+    key: (item: unknown, at: number) => unknown
+    /**
+     * Answers the `make` and `mount` a row is built and mounted by; called once per row.
+     *
+     * 14.8 — a row with a branch-local `<script>` runs it here and gets builders closing over its
+     * names; every other list hands back the one record it was built with, so a row allocates
+     * nothing more.
+     */
+    setUp: (item: unknown, at: number) => RowBuilders
+
+    constructor(
+        region: Region,
+        anchored: boolean,
+        key: (item: unknown, at: number) => unknown,
+        setUp: (item: unknown, at: number) => RowBuilders,
+    ) {
+        this.region = region
+        this.rows = []
+        this.pumping = null
+        this.iterator = null
+        this.warned = false
+        this.hydrating = true
+        this.anchored = anchored
+        this.key = key
+        this.setUp = setUp
+    }
+
+    /**
+     * Stops every row's scope; called when the region holding the block leaves.
+     *
+     * 12.13 — a row's bindings are stopped by `dropRow` as the list churns, but a `{#for}` removed
+     * whole — a row above it dropping, an arm swapping out — drops no rows at all, and every row it
+     * still holds would go on waking. The nodes go with the region, so only the scopes are stopped
+     * here.
+     */
+    stop(): void {
+        const rows = this.rows
+        for (const row of rows) row.scope.stop()
+        rows.length = 0
+        stopPump(this)
+    }
+}
+
+/** Stops whatever the list is pumping, returning the iterator it is parked on. */
+function stopPump(list: List): void {
+    list.pumping = null
+    const iterator = list.iterator
+    if (iterator === null) return
+    list.iterator = null
+    // The return is the source's to answer, and an answer that fails is the stream ending anyway.
+    void iterator.return?.()?.catch(() => {})
+}
+
+/**
+ * A `List` over rows the server wrote, hydrated on its first update.
+ *
+ * Nothing is wired until the first update, which is the block's watch running once: the subject is
+ * read there and only there, so the rows are hydrated against the same items the watch then
+ * compares against. Read twice — once to hydrate and again on the watch's first run — a subject
+ * that builds fresh items (`rows.map(…)`) matched no row by identity, and every row the server sent
+ * was dropped and remade on load.
+ */
+export function listAt(
+    region: Region,
+    anchored: boolean,
+    key: (item: unknown, at: number) => unknown,
+    setUp: (item: unknown, at: number) => RowBuilders,
+): List {
+    return new List(region, anchored, key, setUp)
+}
+
+/**
+ * Wires the server's rows to `items`; false where the caller should reconcile instead.
+ *
+ * HYDRATION, NOT RENDERING. The rows are already there; wiring them is all that is left. 41.3 — an
+ * async subject rendered no rows, so it finds none here.
+ *
+ * FALSE WHERE THERE IS NOTHING TO RETURN ON, and the caller reconciles what was hydrated instead.
+ * TWO DIFFERENT QUESTIONS REACH THIS, and answering both with one length compare hid the second:
+ *
+ * NOBODY PAINTED THIS REGION is 41.4 — a render continues past a subject still in flight, which
+ * writes the anchors and no rows. That is not a disagreement, because there is nothing to disagree
+ * with, so it builds in silence. `isEmptyRegion` is the signal the rest of the block machinery
+ * already reads for exactly this (32.17), rather than a zero this function infers on its own.
+ *
+ * THE SERVER'S ROWS ARE NOT THE CLIENT'S ITEMS is 41.10, and it MUST warn. Hydration wires row
+ * `at` to item `at` BY POSITION, so a run where the two lengths disagree has items with no node,
+ * nodes with no item, or both — every one of them a `{#for}` that looks right and is dead, because
+ * `updateList` returned before `reconcile` could fix it. Repairing that silently is the clause
+ * half-applied: the divergence is a document and a client that disagree, which is the one thing
+ * the channel exists to report.
+ *
+ * THE LENGTHS ARE COMPARED BEFORE A ROW IS WIRED, and only the rows both sides hold are. A row the
+ * document holds past the last item has no item to key or set up — handed `undefined`, a keyed
+ * list threw a TypeError out of `item[by]`, which is not a `Mismatch` and so took the page down on
+ * exactly the disagreement this reports. Those rows are removed here, and the reconcile after
+ * builds whatever the document was short.
+ */
+function hydrate(list: List, items: unknown[]): boolean {
+    if (isEmptyRegion(list.region)) return false
+    const found = rowsIn(list.region, list.anchored)
+    const agreed = found.length === items.length
+    if (!agreed) {
+        warnMismatch(
+            new Mismatch(
+                `abide: the document holds ${found.length} rows where this {#for} computes ${items.length}, so the client and the server disagree about this region's shape (41.10).`,
+            ),
+        )
+        if (found.length > items.length)
+            removeUntil(found[items.length] as ChildNode, list.region.close)
+    }
+    const wired = Math.min(found.length, items.length)
+    for (let at = 0; at < wired; at += 1) {
+        const item = items[at]
+        list.rows.push(
+            rowOf(
+                list.setUp(item, at),
+                list.key(item, at),
+                item,
+                found[at] as ChildNode,
+                at,
+            ),
+        )
+    }
+    return agreed
+}
+
+/**
+ * Brings a `{#for}`'s rows up to date with its subject: reconciles an array, appends an async one.
+ *
+ * 32.15 — AN ARRAY RECONCILES AND AN ASYNC SUBJECT APPENDS AS ITEMS ARRIVE. There is no list to
+ * diff an async subject against: the items are not all there, and the arrival of one says nothing
+ * about the ones behind it.
+ *
+ * THE SUBJECT IS READ TRACKED AND THE ROWS ARE BUILT UNTRACKED. `make` evaluates a row's attributes
+ * as it builds them, so under the list's watch a row reading `selected` subscribed the WHOLE list to
+ * it — one full reconcile per write after any row was built here. A row's own reads are its mount's
+ * watches. `listOf` stays outside: spreading an iterable is a read of it.
+ */
+export function updateList(list: List, subject: unknown): void {
+    untracked(settleList, list, listOf(subject))
+}
+
+function settleList(
+    list: List,
+    items: unknown[] | AsyncIterable<unknown>,
+): void {
+    const hydrating = list.hydrating
+    list.hydrating = false
+    if (!Array.isArray(items)) {
+        appendRows(list, items)
+        return
+    }
+    if (hydrating && hydrate(list, items)) return
+    stopPump(list)
+    reconcile(list, items)
+}
+
+/**
+ * Starts pumping an async subject into the list, replacing what an earlier source appended.
+ *
+ * 41.3 IS THE SERVER'S HALF OF 32.15 — the render is not held for an unfinished stream, so an
+ * async subject writes no rows inline and the region arrives empty. The pump fills it.
+ */
+function appendRows(list: List, source: AsyncIterable<unknown>): void {
+    // A RE-RUN IS NOT A NEW SOURCE. The subject is read inside a watch, so any other reactive
+    // the expression touches re-runs it with the SAME iterable — and emptying the list to pump an
+    // async generator that has already run to completion left the region blank for good.
+    if (list.pumping === source) return
+    // A NEW SOURCE IS A NEW LIST. What the last one appended is stopped and removed, or its
+    // readers wake for the life of the page writing into nodes the next source appends after.
+    for (const row of list.rows) dropRow(row)
+    list.rows = []
+    stopPump(list)
+    list.pumping = source
+    // A FLOATING PROMISE IS THE ONE FAILURE THIS SEAM CANNOT WARN ABOUT. `pump` awaits the app's
+    // own iterable and calls `make`/`mount`, so a stream that aborts and a row that cannot be
+    // hydrated both reject it — and with nothing attached that is a fatal `unhandledRejection`
+    // under bun and a bare `unhandledrejection` in a browser, where every other failure in this
+    // seam is one `abide:hydrate` line.
+    pump(list, source).catch((thrown: unknown) => {
+        if (warnMismatch(thrown)) return
+        HYDRATE_LOG.warning(thrown)
+    })
+}
+
+async function pump(list: List, source: AsyncIterable<unknown>): Promise<void> {
+    const region = list.region
+    const iterator = source[Symbol.asyncIterator]()
+    list.iterator = iterator
+    let at = 0
+    for (;;) {
+        const next = await iterator.next()
+        if (list.iterator !== iterator) return
+        if (next.done === true) {
+            list.iterator = null
+            return
+        }
+        const item = next.value
+        // READ PER ITEM, not once before the loop: the region's parent is read again because the
+        // document may have moved on between two arrivals, and a detached region is where this
+        // stops rather than where it throws.
+        const parent = region.close.parentNode
+        if (parent === null) {
+            stopPump(list)
+            return
+        }
+        // Appended, so its position IS the index it arrived at.
+        list.rows.push(
+            makeRow(list, parent, region.close, list.key(item, at), item, at),
+        )
+        at += 1
+    }
+}
+
+export type RowBuilders = {
+    /**
+     * A row's nodes, BUILT in the document the list stands in — handed over by the reconcile
+     * rather than found by the row, which is the one place a row's document is decided.
+     */
+    make: (document: Document, item: unknown, at: number) => Node[]
+    /**
+     * Handed the row's RECORD rather than its nodes: a row it rebuilds (41.10) writes its new
+     * first node back there.
+     */
+    mount: (row: Row, item: unknown, at: number) => Scope
+}

package/src/ui/Mismatch.ts

@@ -0,0 +1,32 @@
+import { namedLogger } from '#shared/log.ts'
+
+/** The browser lane's hydration logger (28.9). */
+export const HYDRATE_LOG = namedLogger('abide:hydrate')
+
+/**
+ * A hydration mismatch, thrown so the enclosing block rebuilds instead of the page dying.
+ *
+ * 41.10 — A HYDRATION MISMATCH REBUILDS THE ENCLOSING BLOCK AND WARNS, and what it must not do is
+ * take the page down. An ordinary throw out of `mount` does exactly that: every binding and every
+ * listener after the one that refused is never installed, so a page whose one slot disagrees is
+ * served looking right and completely dead. Every refusal in this seam cited the clause while
+ * doing the opposite of it.
+ *
+ * THROWN RATHER THAN RETURNED, because the refusal comes from inside a walk several nodes deep and
+ * the block that rebuilds is several frames above it. The BRAND is what a block's catch reads: a
+ * throw from an author's own expression is not a mismatch and is rethrown untouched, which is why
+ * this is a class rather than a string test on a message.
+ */
+export class Mismatch extends Error {}
+
+/**
+ * Whether a throw was a mismatch, warning when it was.
+ *
+ * One call rather than a predicate with a warn beside it: the warning is the other half of 41.10,
+ * and a caller that only asked would have to remember it at every catch.
+ */
+export function warnMismatch(thrown: unknown): boolean {
+    if (!(thrown instanceof Mismatch)) return false
+    HYDRATE_LOG.warning(thrown.message)
+    return true
+}

package/src/ui/RawRun.ts

@@ -0,0 +1,99 @@
+import { RAW_CLOSE, RAW_OPEN } from '#shared/ANCHORS.ts'
+import { Mismatch } from './Mismatch.ts'
+import { parseMarkup } from './parseMarkup.ts'
+import { removeUntil } from './regions.ts'
+
+/**
+ * A live text run while it holds markup: its anchor pair and the markup last parsed between them.
+ *
+ * 32.26 — a run holding text is its text node and nothing else, so this exists only while a `Raw`
+ * is in the run — the ordinary slot allocates none of it (`setText`, `setMarkup`).
+ *
+ * `html` IS UNDEFINED FOR A RUN THE SERVER PAINTED. What is between the anchors is what the server
+ * parsed from the same value, so the first write keeps it (`setMarkup`) the way a hydrated arm keeps
+ * the arm it was painted with — reading markup back out of nodes is a serialisation, and not the
+ * string the server wrote.
+ */
+export class RawRun {
+    open: Comment
+    close: Comment
+    html: string | undefined
+
+    constructor(open: Comment, close: Comment, html: string | undefined) {
+        this.open = open
+        this.close = close
+        this.html = html
+    }
+}
+
+/**
+ * The run the walk found by its CLOSING anchor (`runHere`), read back to its opening one. Null
+ * where the close has no open before it in its parent.
+ */
+export function rawRunEndingAt(close: Comment): RawRun | null {
+    for (
+        let node = close.previousSibling;
+        node !== null;
+        node = node.previousSibling
+    )
+        if (node.nodeType === 8 && (node as Comment).data === RAW_OPEN)
+            return new RawRun(node as Comment, close, undefined)
+    return null
+}
+
+/** The anchor that ends a run holding markup, or null where it is not closed in this parent. */
+export function rawCloseOf(open: Node): Comment | null {
+    for (let node = open.nextSibling; node !== null; node = node.nextSibling)
+        if (node.nodeType === 8 && (node as Comment).data === RAW_CLOSE)
+            return node as Comment
+    return null
+}
+
+/**
+ * A run holding text, turned into one holding `markup`: the text node gives way to the pair and
+ * what the markup parses into.
+ */
+export function textToMarkup(text: Text, markup: string): RawRun {
+    const parent = text.parentNode
+    if (parent === null) throw detached()
+    const document = text.ownerDocument
+    const open = document.createComment(RAW_OPEN)
+    const close = document.createComment(RAW_CLOSE)
+    parent.insertBefore(open, text)
+    parent.insertBefore(parseMarkup(text, markup), text)
+    parent.replaceChild(close, text)
+    return new RawRun(open, close, markup)
+}
+
+/** What stands between the anchors, replaced by what `markup` parses into. */
+export function refillRun(run: RawRun, markup: string): void {
+    const parent = run.close.parentNode
+    if (parent === null) throw detached()
+    clearRun(run)
+    parent.insertBefore(parseMarkup(run.close, markup), run.close)
+    run.html = markup
+}
+
+/**
+ * A run holding markup, turned back into one holding text: the pair and everything between it
+ * give way to one text node.
+ */
+export function markupToText(run: RawRun, text: string): Text {
+    const parent = run.close.parentNode
+    if (parent === null) throw detached()
+    clearRun(run)
+    run.open.remove()
+    const node = run.close.ownerDocument.createTextNode(text)
+    parent.replaceChild(node, run.close)
+    return node
+}
+
+function clearRun(run: RawRun): void {
+    removeUntil(run.open.nextSibling, run.close)
+}
+
+function detached(): Mismatch {
+    return new Mismatch(
+        "abide: this text run is not in a document, so the client and the server disagree about this region's shape (41.10).",
+    )
+}