@abide/abide 0.104.0 → 0.105.1

package/src/ui/applyHead.ts

@@ -4,32 +4,57 @@
 // the document. Nothing is added to the head to mark ownership — a marker would be a fact about
 // the framework in a document an author writes, and the key is already what decides.
 //
-// 39.5 — A CONTRIBUTION WITH NO KEY APPENDS. It cannot replace anything, because there is nothing
-// it could be said to be the same as, and dropping it instead would lose the one kind of
-// contribution a page makes several of.
+// 39.5 — A CONTRIBUTION WITH NO KEY APPENDS. It cannot replace anything ANOTHER contributor wrote,
+// because there is nothing it could be said to be the same as, and dropping it instead would lose
+// the one kind of contribution a page makes several of. What its OWN contributor wrote last is
+// another matter: a head written again puts its keyless nodes where the last ones stood (39.15),
+// and a head withdrawn takes them with it (39.16). Found the way a key is — off the document, by
+// the markup the contributor last wrote — so a head the server painted is found the same as one
+// written here.
 
 import { headKeyOf } from '#shared/headKeyOf.ts'
-import { MOUNTING_LEVEL } from './MOUNTING_LEVEL.ts'
 import { markupNodes } from './parseMarkup.ts'
-import { isEmptyRegion, type Region } from './regions.ts'
-import type { Scope } from './Scope.ts'
 
-export function applyHead(markup: string): void {
+/**
+ * Writes `markup`'s contributions into the document head, a key `below` holds excepted.
+ *
+ * 39.4 — `below` is the head of every contributor deeper than the one writing, which a head
+ * re-applied live (39.13) must not undo: the deepest contributor wins whichever of them moved last.
+ *
+ * 39.15 — `last` is what the same contributor wrote before, whose keyless nodes this replaces in
+ * place, in order, rather than adding beside them. 39.14 — a key `last` held that `markup` does not
+ * is withdrawn to `outer`'s value for it, as a leaving contributor's is; a key list that did not
+ * move withdraws nothing and never asks `outer`.
+ */
+export function applyHead(
+    markup: string,
+    below = '',
+    last = '',
+    outer: () => string = () => '',
+): void {
     const head = document.head
     if (markup === '') return
     const incoming = markupNodes(head, markup)
     const standingByKey = standingKeys(head)
+    const deeper = below === '' ? undefined : keyedIn(head, below)
+    const replaced: Node[] = []
+    const withdrawn = keyedIn(head, last, replaced)
+    let next = 0
     for (const node of incoming) {
-        if (node.nodeType !== 1) {
-            head.appendChild(node)
-            continue
-        }
-        const element = node as Element
-        const key = headKey(element)
+        const key = node.nodeType === 1 ? headKey(node as Element) : undefined
         if (key === undefined) {
-            head.appendChild(element)
+            const standing = replaced[next]
+            next += 1
+            if (standing === undefined) head.appendChild(node)
+            // The same node left standing, as a key's is: a `<style>` put back as itself is not
+            // re-parsed into the cascade.
+            else if (!standing.isEqualNode(node))
+                head.replaceChild(node, standing)
             continue
         }
+        const element = node as Element
+        withdrawn.delete(key)
+        if (deeper?.has(key) === true) continue
         const standing = standingByKey.get(key)
         if (standing === undefined) {
             head.appendChild(element)
@@ -45,31 +70,52 @@ export function applyHead(markup: string): void {
         head.replaceChild(element, standing)
         standingByKey.set(key, element)
     }
+    for (; next < replaced.length; next += 1)
+        (replaced[next] as Node).parentNode?.removeChild(replaced[next] as Node)
+    if (withdrawn.size === 0) return
+    if (deeper !== undefined)
+        for (const key of deeper.keys()) withdrawn.delete(key)
+    restoreKeys(head, withdrawn, outer())
 }
 
 /**
  * Puts back, or removes, what the leaving levels keyed and the arriving ones do not.
  *
- * 39.14 — THE NEXT-OUTER CONTRIBUTOR'S VALUE, OR NONE. `leaving` and `arriving` are the heads of
- * the levels a navigation stopped and mounted; `outer` is every contributor standing above them,
- * outermost first — the shell's keyed entries, then each kept layout's — so the LAST entry for a
- * key in it is the one the server would paint there (39.4). What the arriving levels key they have
- * already written (39.6), so only the keys they are silent on are touched.
+ * 39.14 — THE NEXT-OUTER CONTRIBUTOR'S VALUE, OR NONE. `leaving` is the head of the levels a
+ * navigation stopped; `around` answers `outer`, every contributor standing above them, and
+ * `arriving`, the heads of the levels it mounted. `outer` runs outermost first — the shell's keyed
+ * entries, then each kept layout's — so the LAST entry for a key in it is the one the server would
+ * paint there (39.4). A component leaving its region is withdrawn the same way, its level's
+ * contributors either side of it standing in for the two (`Level.headsAround`). What the arriving levels key they have
+ * already written (39.6), so only the keys they are silent on are touched — and 39.16, the leaving
+ * levels' keyless nodes leave with them.
  *
- * THE COMMON NAVIGATION ENDS AT THE FIRST RETURN: two pages that both key a `<title>` withdraw
- * nothing, and `outer` is neither built nor parsed.
+ * THE COMMON NAVIGATION WITHDRAWS NOTHING BY KEY: two pages that both key a `<title>` leave
+ * `outer` built but never parsed, and a head keying nothing never asks `around`.
  */
 export function withdrawHead(
     leaving: string,
-    arriving: string,
-    outer: () => string,
+    around: () => [outer: string, arriving: string],
 ): void {
     if (leaving === '') return
     const head = document.head
-    const withdrawn = keyedIn(head, leaving)
+    const keyless: Node[] = []
+    const withdrawn = keyedIn(head, leaving, keyless)
+    for (const node of keyless) node.parentNode?.removeChild(node)
+    if (withdrawn.size === 0) return
+    const [outer, arriving] = around()
     for (const key of keyedIn(head, arriving).keys()) withdrawn.delete(key)
+    restoreKeys(head, withdrawn, outer)
+}
+
+/** 39.14 — each of `withdrawn`'s keys back to `outer`'s last value for it, or removed. */
+function restoreKeys(
+    head: HTMLHeadElement,
+    withdrawn: Map<string, Element>,
+    outer: string,
+): void {
     if (withdrawn.size === 0) return
-    const restored = keyedIn(head, outer())
+    const restored = keyedIn(head, outer)
     const standingByKey = standingKeys(head)
     for (const key of withdrawn.keys()) {
         const standing = standingByKey.get(key)
@@ -82,15 +128,29 @@ export function withdrawHead(
     }
 }
 
-/** The keyed elements `markup` parses to, by key, the last holding each (39.4). */
-function keyedIn(head: HTMLHeadElement, markup: string): Map<string, Element> {
+/**
+ * The keyed elements `markup` parses to, by key, the last holding each (39.4).
+ *
+ * Where `standing` is given, each keyless node is matched to the first node standing in the head
+ * equal to it and not already matched, and the match pushed there (39.15, 39.16).
+ */
+function keyedIn(
+    head: HTMLHeadElement,
+    markup: string,
+    standing?: Node[],
+): Map<string, Element> {
     const keyed = new Map<string, Element>()
     if (markup === '') return keyed
-    for (const node of markupNodes(head, markup))
-        if (node.nodeType === 1) {
-            const key = headKey(node as Element)
-            if (key !== undefined) keyed.set(key, node as Element)
-        }
+    for (const node of markupNodes(head, markup)) {
+        const key = node.nodeType === 1 ? headKey(node as Element) : undefined
+        if (key !== undefined) keyed.set(key, node as Element)
+        else if (standing !== undefined)
+            for (let at = head.firstChild; at !== null; at = at.nextSibling)
+                if (at.isEqualNode(node) && !standing.includes(at)) {
+                    standing.push(at)
+                    break
+                }
+    }
     return keyed
 }
 
@@ -130,50 +190,3 @@ function headKey(element: Element): string | undefined {
         element.getAttribute(name),
     )
 }
-
-/**
- * Keeps a level's head written from `markup` for as long as `scope` lives.
- *
- * 39.13 — A HEAD THAT READS A VALUE FOLLOWS IT for as long as its level is mounted, which is the
- * scope's life. The first run only subscribes: the head it would write is already there, written
- * by the server or applied by the level's mount ahead of its fill (39.6).
- */
-export function liveHead(scope: Scope, markup: () => string): void {
-    let subscribing = true
-    scope.watch(() => {
-        const text = markup()
-        if (subscribing) subscribing = false
-        else applyHead(text)
-    })
-}
-
-/**
- * A component's `<head>`, added to the page or layout the router is mounting it under (39.1).
- *
- * Joined to that level's head, so it is withdrawn as the level's is when it leaves (39.14), and
- * deeper than the level's own, so it wins by key (39.4). Applied where the component builds its own
- * markup, once the level is mounted (`MOUNTING_LEVEL.unapplied`); a region the server painted
- * already carries the head the server wrote. Nothing where no level is mounting — a row grown after
- * the fact titles nothing.
- *
- * A LIST, NOT A CLOSURE PER CONTRIBUTION: a `{#for}` of components with a `<head>` contributes once a
- * row, and a chain of them is read through as deep a stack.
- */
-export function contributeHead(region: Region, head: () => string): void {
-    const level = MOUNTING_LEVEL.current
-    if (level === undefined) return
-    let contributed = level.contributed
-    if (contributed === undefined) {
-        const own = level.head
-        const joined: (() => string)[] = []
-        contributed = joined
-        level.contributed = joined
-        level.head = () => {
-            let markup = own?.() ?? ''
-            for (const one of joined) markup += one()
-            return markup
-        }
-    }
-    contributed.push(head)
-    if (isEmptyRegion(region)) MOUNTING_LEVEL.unapplied += head()
-}

package/src/ui/index.ts

@@ -39,15 +39,16 @@ export {
 } from './adoptWalk.ts'
 // 39.6 — a module mounted into an empty region applies its own head, from inside its instance
 // (`emitClient`); only a module that carries its own markup and a `<head>` imports it.
-export { applyHead, contributeHead, liveHead } from './applyHead.ts'
+export { applyHead } from './applyHead.ts'
 export { bindElement } from './bindElement.ts'
 export { bindProperty } from './bindProperty.ts'
 export { bindSpread } from './bindSpread.ts'
 export { escapeless } from './escapeless.ts'
+// 39.1 — a component's `<head>`, joined to the routed level mounting it.
+export { contributeHead } from './Level.ts'
 export { listAt, updateList } from './List.ts'
 export { warnMismatch } from './Mismatch.ts'
 export { markupNodes } from './parseMarkup.ts'
-export { replaceRow } from './reconcile.ts'
 export {
     fillEmpty,
     fillRegion,
@@ -55,6 +56,7 @@ export {
     type Region,
 } from './regions.ts'
 export { rowKeyOf } from './rowKeyOf.ts'
+export { replaceRow } from './rows.ts'
 export { EMPTY_SCOPE, Scope } from './Scope.ts'
 export { setAttribute } from './setAttribute.ts'
 export { setClass } from './setClass.ts'

package/src/ui/leave.ts

@@ -23,6 +23,11 @@ export function holdWhileLeaving(
     settling.then(done, done)
 }
 
+/** Whether any element is leaving, so a removal has to ask each node whether it holds one. */
+export function anyLeaving(): boolean {
+    return LEAVING.size !== 0
+}
+
 /** Removes `node`, or holds it where it is while an element it holds is leaving. */
 export function leave(node: ChildNode): void {
     if (LEAVING.size !== 0)

package/src/ui/reconcile.ts

@@ -1,71 +1,20 @@
 import { PATCHES } from '#shared/reactive/PATCHES.ts'
 import { LAYER_RECONCILE } from './LAYER_NAMES.ts'
-import type { List, RowBuilders } from './List.ts'
+import type { List } from './List.ts'
 import { HYDRATE_LOG } from './Mismatch.ts'
 import { beginLayer, endLayer } from './measureLayer.ts'
-import { moveRow, removeRow } from './rows.ts'
-import { EMPTY_SCOPE, type Scope } from './Scope.ts'
+import { emptyRegion } from './regions.ts'
+import { dropRow, makeRow, moveRow, type Row } from './rows.ts'
 
 // 41.8 — a KEYED list, reconciled by moving the nodes that are already there rather than by
 // rebuilding them. A rebuild produces the right screen and the wrong document: focus, selection,
 // scroll position and anything a row was in the middle of go with the nodes that were replaced.
 //
-// What a row is in the document — its element, or its anchored range — is `rows.ts`'s. Most lists
+// What a row is — its record and its nodes, an element or an anchored range — is `rows.ts`'s. Most lists
 // carry no per-row marker at all: the nodes between the region's anchors ARE the rows, and only a
 // body with several top-level nodes gets one anchor per ROW. That is ~2.5 bytes gzipped a row, not
 // the per-SLOT marker `benchGrid.ts` measured doubling a page.
 
-export type Row = {
-    key: unknown
-    /**
-     * The value the row was built from.
-     *
-     * A row that survives a reorder keeps its NODES, which is the whole point — but if the value
-     * behind that key is a different object, its content is stale and the row is remade. Identity
-     * is the signal here, the inverse of the case where a freshly built wrapper defeats one.
-     */
-    data: unknown
-    /**
-     * The row's first node: its element, or its `ROW_OPEN` anchor where the body has several —
-     * the start of a range, not the nodes `make` handed back (`rows.ts`).
-     */
-    node: ChildNode
-    /** The row's bindings, stopped when it leaves. */
-    scope: Scope
-    /**
-     * Where this row stood in the list the document currently shows.
-     *
-     * The placement walk needs "already in order" to be a question about POSITIONS rather than
-     * about nodes, and asking the document — `compareDocumentPosition`, or counting siblings — is
-     * the walk this exists to avoid. Written by every reconcile, so it is a fact about the last one
-     * rather than about the caller, and a hydration seed sets it because that IS the order the
-     * server painted.
-     */
-    at: number
-    /**
-     * The patch epoch the row was made at (32.33).
-     *
-     * Its item written past this is content the row never saw, under the same object a kept row is
-     * matched by.
-     */
-    seen: number
-}
-
-/**
- * Rebuilds a row in place from `next`, keeping its record.
- *
- * 41.10 — a row that cannot be hydrated is rebuilt: the fresh nodes go where the row stood and the
- * row's record takes the new first node, so the reconcile still reaches all of it.
- */
-export function replaceRow(row: Row, next: Node[]): void {
-    const first = row.node
-    const parent = first.parentNode
-    if (parent === null) return
-    for (const node of next) parent.insertBefore(node, first)
-    removeRow(first)
-    row.node = next[0] as ChildNode
-}
-
 /**
  * Reconciles a keyed list's rows to `data`, moving survivors rather than remaking them.
  *
@@ -73,6 +22,10 @@ export function replaceRow(row: Row, next: Node[]): void {
  * survive are MOVED, never remade.
  */
 export function reconcile(list: List, data: unknown[]): void {
+    if (data.length === 0) {
+        clear(list)
+        return
+    }
     const region = list.region
     const current = list.rows
     const wanted = data.length
@@ -193,7 +146,7 @@ export function reconcile(list: List, data: unknown[]): void {
             const existing = survivor[at]
             if (existing === undefined || existing === null) {
                 const row = makeRow(
-                    list,
+                    list.setUp,
                     parent,
                     anchor,
                     keys[at],
@@ -234,48 +187,24 @@ export function reconcile(list: List, data: unknown[]): void {
     }
 }
 
-/** A new row, built and inserted before `before`. */
-export function makeRow(
-    list: List,
-    parent: Node,
-    before: Node,
-    key: unknown,
-    item: unknown,
-    at: number,
-): Row {
-    // 14.8 — set up ONCE for the row, and the same builders make it and mount it.
-    const builders = list.setUp(item, at)
-    const nodes = builders.make(parent.ownerDocument as Document, item, at)
-    for (const node of nodes) parent.insertBefore(node, before)
-    return rowOf(builders, key, item, nodes[0] as ChildNode, at)
-}
-
 /**
- * A row record over nodes already in the document, mounted.
+ * Drops every row, emptying the region in one write rather than one removal a row.
  *
- * The one place a row's record is written, so its shape is fixed once for every path that makes one
- * — a made row and a hydrated one alike. The mount is handed the RECORD, because a row it rebuilds
- * (41.10) has a new first node to write back.
+ * NOTHING WANTED IS ITS OWN SHAPE: there is no key to match and no order to keep, so the map,
+ * the survivor walk and the placement walk all answer nothing. Every row is still STOPPED first,
+ * as `dropRow` would, so a binding cannot wake over a node that is already gone.
  */
-export function rowOf(
-    builders: RowBuilders,
-    key: unknown,
-    item: unknown,
-    node: ChildNode,
-    at: number,
-): Row {
-    const row: Row = {
-        key,
-        data: item,
-        node,
-        // A `Scope` rather than `undefined` until the mount returns, so the field holds one class
-        // for the record's whole life.
-        scope: EMPTY_SCOPE,
-        at,
-        seen: PATCHES.epoch,
+function clear(list: List): void {
+    const parent = list.region.close.parentNode
+    if (parent === null) return
+    beginLayer(LAYER_RECONCILE)
+    try {
+        for (const row of list.rows) row.scope.stop()
+        list.rows = []
+        emptyRegion(list.region, parent)
+    } finally {
+        endLayer(LAYER_RECONCILE)
     }
-    row.scope = builders.mount(row, item, at)
-    return row
 }
 
 /**
@@ -291,16 +220,6 @@ function patchedSince(row: Row): boolean {
     return (PATCHES.written.get(item) ?? 0) > row.seen
 }
 
-/**
- * Stops a row's bindings, then removes its nodes.
- *
- * Stopped first, so a binding cannot wake over a node that is already gone.
- */
-export function dropRow(row: Row): void {
-    row.scope.stop()
-    removeRow(row.node)
-}
-
 /**
  * Warns about a repeated `{#for}` key, once per block.
  *

package/src/ui/regions.ts

@@ -1,6 +1,6 @@
 import { REGION_CLOSE, REGION_OPEN } from '#shared/ANCHORS.ts'
 import { LAYER_FILL } from './LAYER_NAMES.ts'
-import { leave } from './leave.ts'
+import { anyLeaving, leave } from './leave.ts'
 import { Mismatch } from './Mismatch.ts'
 import { beginLayer, endLayer } from './measureLayer.ts'
 
@@ -97,7 +97,7 @@ export function fillRegion(
         throw new Mismatch(
             `abide: this region is not in a document, so the client and the server disagree about this region's shape (41.10).`,
         )
-    removeUntil(region.open.nextSibling, region.close)
+    emptyRegion(region, parent)
     if (build === undefined) return
     beginLayer(LAYER_FILL)
     try {
@@ -126,6 +126,31 @@ export function fillEmpty(
     return true
 }
 
+/**
+ * Removes everything between a region's anchors, which stay.
+ *
+ * ONE WRITE WHERE THE REGION IS ALL ITS PARENT HOLDS — a `<tbody>` or a `<ul>` around one
+ * `{#for}`, the common shape of a list emptied — and the anchors put back after it. A removal per
+ * node is a crossing into the engine per node; the engine's own clear is one.
+ *
+ * NODE BY NODE WHILE ANYTHING IS LEAVING (32.38), because a node holding a leaving element has to
+ * stay where it stands, and only `leave` asks.
+ */
+export function emptyRegion(region: Region, parent: ParentNode): void {
+    const { open, close } = region
+    if (
+        anyLeaving() ||
+        parent.firstChild !== open ||
+        parent.lastChild !== close
+    ) {
+        removeUntil(open.nextSibling, close)
+        return
+    }
+    if (open.nextSibling === close) return
+    parent.textContent = ''
+    parent.append(open, close)
+}
+
 /** Removes `from` and every sibling after it, up to and not including `end`. */
 export function removeUntil(from: ChildNode | null, end: Node | null): void {
     let node = from

package/src/ui/rows.ts

@@ -1,9 +1,12 @@
 import { REGION_CLOSE, ROW_OPEN } from '#shared/ANCHORS.ts'
+import { PATCHES } from '#shared/reactive/PATCHES.ts'
 import { leave } from './leave.ts'
 import { moveNode } from './moveNode.ts'
 import { closeOf, opensRegion, type Region, removeUntil } from './regions.ts'
+import { EMPTY_SCOPE, type Scope } from './Scope.ts'
 
-// WHAT A ROW IS IN THE DOCUMENT, decided here and nowhere else. A row is its ELEMENT where the
+// WHAT A ROW IS — its record, how it is made, mounted, rebuilt and dropped, and what it is in the
+// document — decided here and nowhere else. `reconcile.ts` decides only WHICH rows move. A row is its ELEMENT where the
 // body has one; a body with several top-level nodes — `<dt>{k}</dt><dd>{v}</dd>` — is the RANGE
 // from its `ROW_OPEN` anchor to the next row's anchor or the region's close, as a region is its
 // pair. A range rather than the nodes `make` handed back: a region at the row's top level fills
@@ -12,6 +15,55 @@ import { closeOf, opensRegion, type Region, removeUntil } from './regions.ts'
 // AN ANCHOR IS A COMMENT AND A SINGLE ROOT IS AN ELEMENT, so a row's first node says which kind of
 // row it is and no flag is carried beside it.
 
+export type Row = {
+    key: unknown
+    /**
+     * The value the row was built from.
+     *
+     * A row that survives a reorder keeps its NODES, which is the whole point — but if the value
+     * behind that key is a different object, its content is stale and the row is remade. Identity
+     * is the signal here, the inverse of the case where a freshly built wrapper defeats one.
+     */
+    data: unknown
+    /**
+     * The row's first node: its element, or its `ROW_OPEN` anchor where the body has several —
+     * the start of a range, not the nodes `make` handed back.
+     */
+    node: ChildNode
+    /** The row's bindings, stopped when it leaves. */
+    scope: Scope
+    /**
+     * Where this row stood in the list the document currently shows.
+     *
+     * The placement walk needs "already in order" to be a question about POSITIONS rather than
+     * about nodes, and asking the document — `compareDocumentPosition`, or counting siblings — is
+     * the walk this exists to avoid. Written by every reconcile, so it is a fact about the last one
+     * rather than about the caller, and a hydration seed sets it because that IS the order the
+     * server painted.
+     */
+    at: number
+    /**
+     * The patch epoch the row was made at (32.33).
+     *
+     * Its item written past this is content the row never saw, under the same object a kept row is
+     * matched by.
+     */
+    seen: number
+}
+
+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
+}
+
 /**
  * The anchor ending the anchored row whose first node is `first`: the next `ROW_OPEN` or
  * `REGION_CLOSE` at the row's own depth, or null where there is none in this parent.
@@ -37,7 +89,7 @@ function rowEnd(first: Node): Comment | null {
 }
 
 /** Removes a row's nodes, from its first node to its end. */
-export function removeRow(first: ChildNode): void {
+function removeRow(first: ChildNode): void {
     if (first.nodeType !== 8) {
         leave(first)
         return
@@ -97,3 +149,72 @@ export function rowsIn(region: Region, anchored: boolean): ChildNode[] {
         if (node.nodeType === 1) found.push(node)
     return found
 }
+
+/**
+ * Rebuilds a row in place from `next`, keeping its record.
+ *
+ * 41.10 — a row that cannot be hydrated is rebuilt: the fresh nodes go where the row stood and the
+ * row's record takes the new first node, so the reconcile still reaches all of it.
+ */
+export function replaceRow(row: Row, next: Node[]): void {
+    const first = row.node
+    const parent = first.parentNode
+    if (parent === null) return
+    for (const node of next) parent.insertBefore(node, first)
+    removeRow(first)
+    row.node = next[0] as ChildNode
+}
+
+/** A new row, built and inserted before `before`. */
+export function makeRow(
+    setUp: (item: unknown, at: number) => RowBuilders,
+    parent: Node,
+    before: Node,
+    key: unknown,
+    item: unknown,
+    at: number,
+): Row {
+    // 14.8 — set up ONCE for the row, and the same builders make it and mount it.
+    const builders = setUp(item, at)
+    const nodes = builders.make(parent.ownerDocument as Document, item, at)
+    for (const node of nodes) parent.insertBefore(node, before)
+    return rowOf(builders, key, item, nodes[0] as ChildNode, at)
+}
+
+/**
+ * A row record over nodes already in the document, mounted.
+ *
+ * The one place a row's record is written, so its shape is fixed once for every path that makes one
+ * — a made row and a hydrated one alike. The mount is handed the RECORD, because a row it rebuilds
+ * (41.10) has a new first node to write back.
+ */
+export function rowOf(
+    builders: RowBuilders,
+    key: unknown,
+    item: unknown,
+    node: ChildNode,
+    at: number,
+): Row {
+    const row: Row = {
+        key,
+        data: item,
+        node,
+        // A `Scope` rather than `undefined` until the mount returns, so the field holds one class
+        // for the record's whole life.
+        scope: EMPTY_SCOPE,
+        at,
+        seen: PATCHES.epoch,
+    }
+    row.scope = builders.mount(row, item, at)
+    return row
+}
+
+/**
+ * Stops a row's bindings, then removes its nodes.
+ *
+ * Stopped first, so a binding cannot wake over a node that is already gone.
+ */
+export function dropRow(row: Row): void {
+    row.scope.stop()
+    removeRow(row.node)
+}