@abide/abide 0.49.0 → 0.50.1

package/src/lib/ui/compile/markupTokens.ts

@@ -1,313 +0,0 @@
-import type { SemanticToken } from './types/SemanticToken.ts'
-
-/*
-Lexical highlighting for the HTML-shaped markup of a `.abide` component — element
-and component tag names, attribute names and string values, comments, and the
-`<`/`>`/`=` punctuation. A pure scan of raw source (independent of a successful
-parse, so it survives mid-edit), it exists so the LSP owns the *structure* too,
-not just `{…}` interiors: editors reuse tree-sitter-html as the grammar of record,
-which has no production for abide's `attr={expr}` values — a multiline
-template-literal attribute (`code={`…`}`) drops it into error recovery that never
-re-syncs, miscoloring every element below. Emitting these tokens overrides that
-broken parse wherever real structure sits.
-
-`{…}` expression regions (attribute values, interpolations, `{#…}` block heads) and
-the raw bodies of `<script>`/`<style>` are skipped here — those are the shadow
-type-checker's and the structural block tokenizer's jobs. Lowercase tags get the
-`tag` type, uppercase (components) get `type` (a constructor), mirroring the
-tree-sitter highlight split.
-*/
-
-/* Raw-text elements whose body is JS/CSS, not markup, so the scan jumps past it. */
-const RAW_ELEMENTS = new Set(['script', 'style'])
-
-const operator = (start: number, length: number): SemanticToken => ({
-    start,
-    length,
-    type: 'operator',
-    modifiers: [],
-})
-
-const isNameStart = (char: string): boolean => /[A-Za-z]/.test(char)
-
-/* Characters that end a tag or attribute name. */
-const isNameBreak = (char: string): boolean => /[\s=/>{}"'<]/.test(char)
-
-export function markupTokens(source: string): SemanticToken[] {
-    const tokens: SemanticToken[] = []
-    let cursor = 0
-    while (cursor < source.length) {
-        const char = source.charAt(cursor)
-        /* An expression region — interiors are the shadow classifier's job. */
-        if (char === '{') {
-            cursor = skipExpression(source, cursor)
-            continue
-        }
-        if (char === '<') {
-            if (source.startsWith('<!--', cursor)) {
-                const end = source.indexOf('-->', cursor + 4)
-                const close = end === -1 ? source.length : end + 3
-                tokens.push({
-                    start: cursor,
-                    length: close - cursor,
-                    type: 'comment',
-                    modifiers: [],
-                })
-                cursor = close
-                continue
-            }
-            const isClose = source.charAt(cursor + 1) === '/'
-            const nameStart = cursor + (isClose ? 2 : 1)
-            if (isNameStart(source.charAt(nameStart))) {
-                tokens.push(operator(cursor, isClose ? 2 : 1))
-                const name = readName(source, nameStart)
-                const type = /[A-Z]/.test(name.charAt(0)) ? 'type' : 'tag'
-                tokens.push({ start: nameStart, length: name.length, type, modifiers: [] })
-                const afterName = nameStart + name.length
-                if (isClose) {
-                    cursor = scanToClose(source, afterName, tokens)
-                    continue
-                }
-                const { end, selfClosed } = scanAttributes(source, afterName, tokens)
-                cursor =
-                    RAW_ELEMENTS.has(name) && !selfClosed ? skipRawBody(source, end, name) : end
-                continue
-            }
-        }
-        cursor += 1
-    }
-    return tokens
-}
-
-/* Reads a tag/element name from `start` (letters, digits, `-`, `_`). */
-function readName(source: string, start: number): string {
-    let cursor = start
-    while (cursor < source.length && /[A-Za-z0-9_-]/.test(source.charAt(cursor))) {
-        cursor += 1
-    }
-    return source.slice(start, cursor)
-}
-
-/* From after a close tag's name, emits the `>` operator and returns past it. */
-function scanToClose(source: string, from: number, tokens: SemanticToken[]): number {
-    let cursor = from
-    while (cursor < source.length && source.charAt(cursor) !== '>') {
-        cursor += 1
-    }
-    if (cursor < source.length) {
-        tokens.push(operator(cursor, 1))
-        return cursor + 1
-    }
-    return cursor
-}
-
-/* Scans an open tag's attributes from after its name to the closing `>`/`/>`,
-   emitting an `attribute` token per name, `operator` for `=`, and string tokens
-   for quoted values; `{…}` values and spreads are left to the shadow. */
-function scanAttributes(
-    source: string,
-    from: number,
-    tokens: SemanticToken[],
-): { end: number; selfClosed: boolean } {
-    let cursor = from
-    while (cursor < source.length) {
-        const char = source.charAt(cursor)
-        if (/\s/.test(char)) {
-            cursor += 1
-            continue
-        }
-        if (char === '>') {
-            tokens.push(operator(cursor, 1))
-            return { end: cursor + 1, selfClosed: false }
-        }
-        if (char === '/' && source.charAt(cursor + 1) === '>') {
-            tokens.push(operator(cursor, 2))
-            return { end: cursor + 2, selfClosed: true }
-        }
-        /* `{…code}` spread / expression attribute — shadow's job. */
-        if (char === '{') {
-            cursor = skipExpression(source, cursor)
-            continue
-        }
-        const nameStart = cursor
-        while (cursor < source.length && !isNameBreak(source.charAt(cursor))) {
-            cursor += 1
-        }
-        if (cursor === nameStart) {
-            /* No progress on a stray delimiter — advance to avoid a stall. */
-            cursor += 1
-            continue
-        }
-        tokens.push({
-            start: nameStart,
-            length: cursor - nameStart,
-            type: 'attribute',
-            modifiers: [],
-        })
-        let eq = cursor
-        while (eq < source.length && /\s/.test(source.charAt(eq))) {
-            eq += 1
-        }
-        if (source.charAt(eq) === '=') {
-            tokens.push(operator(eq, 1))
-            eq += 1
-            while (eq < source.length && /\s/.test(source.charAt(eq))) {
-                eq += 1
-            }
-            cursor = scanAttributeValue(source, eq, tokens)
-        } else {
-            cursor = eq
-        }
-    }
-    return { end: cursor, selfClosed: false }
-}
-
-/* Scans an attribute value: a `{…}` expression (skipped), a quoted string (split
-   around any `{…}` interpolations), or a bare unquoted run. Returns past it. */
-function scanAttributeValue(source: string, from: number, tokens: SemanticToken[]): number {
-    const char = source.charAt(from)
-    if (char === '{') {
-        return skipExpression(source, from)
-    }
-    if (char === '"' || char === "'") {
-        return scanQuotedValue(source, from, tokens)
-    }
-    let cursor = from
-    /* Unquoted values run to whitespace or `>`; a `/` is part of the value (a URL)
-       UNLESS it's the self-close `/>`, so stop before that `/` and leave it for the
-       attribute scanner to read as the self-close marker. */
-    while (cursor < source.length) {
-        const valueChar = source.charAt(cursor)
-        if (/[\s>]/.test(valueChar) || (valueChar === '/' && source.charAt(cursor + 1) === '>')) {
-            break
-        }
-        cursor += 1
-    }
-    if (cursor > from) {
-        tokens.push({ start: from, length: cursor - from, type: 'string', modifiers: [] })
-    }
-    return cursor
-}
-
-/* Emits string tokens for the literal runs of a quoted value (delimiters
-   included), skipping `{…}` interpolations so the shadow colors their interiors. */
-function scanQuotedValue(source: string, start: number, tokens: SemanticToken[]): number {
-    const quote = source.charAt(start)
-    let segmentStart = start
-    let cursor = start + 1
-    const flush = (end: number): void => {
-        if (end > segmentStart) {
-            tokens.push({
-                start: segmentStart,
-                length: end - segmentStart,
-                type: 'string',
-                modifiers: [],
-            })
-        }
-    }
-    while (cursor < source.length) {
-        const char = source.charAt(cursor)
-        if (char === quote) {
-            flush(cursor + 1)
-            return cursor + 1
-        }
-        if (char === '{') {
-            flush(cursor)
-            cursor = skipExpression(source, cursor)
-            segmentStart = cursor
-            continue
-        }
-        cursor += 1
-    }
-    flush(cursor)
-    return cursor
-}
-
-/* From the close `>` of a raw-text element's open tag, returns the index of its
-   `</tag` so the close tag is scanned as markup but the body is left untouched. */
-function skipRawBody(source: string, from: number, tag: string): number {
-    const close = source.indexOf(`</${tag}`, from)
-    return close === -1 ? source.length : close
-}
-
-/* From the opening `{` at `start`, returns the index past the matching `}`,
-   tracking nested braces and skipping strings, template literals (with `${…}`),
-   and JS comments so their contents never sway the depth. A regex literal holding
-   an unbalanced brace is the one unhandled case — rare, accepted for a highlighter. */
-function skipExpression(source: string, start: number): number {
-    let depth = 0
-    let cursor = start
-    while (cursor < source.length) {
-        const char = source.charAt(cursor)
-        if (char === '"' || char === "'") {
-            cursor = skipString(source, cursor)
-            continue
-        }
-        if (char === '`') {
-            cursor = skipTemplate(source, cursor)
-            continue
-        }
-        if (char === '/' && source.charAt(cursor + 1) === '/') {
-            const newline = source.indexOf('\n', cursor)
-            cursor = newline === -1 ? source.length : newline
-            continue
-        }
-        if (char === '/' && source.charAt(cursor + 1) === '*') {
-            const end = source.indexOf('*/', cursor + 2)
-            cursor = end === -1 ? source.length : end + 2
-            continue
-        }
-        if (char === '{') {
-            depth += 1
-        } else if (char === '}') {
-            depth -= 1
-            if (depth === 0) {
-                return cursor + 1
-            }
-        }
-        cursor += 1
-    }
-    return cursor
-}
-
-/* From the opening quote at `start`, returns the index past the matching quote;
-   a backslash escapes the next character. */
-function skipString(source: string, start: number): number {
-    const quote = source.charAt(start)
-    let cursor = start + 1
-    while (cursor < source.length) {
-        const char = source.charAt(cursor)
-        if (char === '\\') {
-            cursor += 2
-            continue
-        }
-        if (char === quote) {
-            return cursor + 1
-        }
-        cursor += 1
-    }
-    return cursor
-}
-
-/* From the opening backtick at `start`, returns the index past the matching
-   backtick. `${…}` re-enters expression scanning so its inner braces balance;
-   braces in the literal text are ignored. */
-function skipTemplate(source: string, start: number): number {
-    let cursor = start + 1
-    while (cursor < source.length) {
-        const char = source.charAt(cursor)
-        if (char === '\\') {
-            cursor += 2
-            continue
-        }
-        if (char === '`') {
-            return cursor + 1
-        }
-        if (char === '$' && source.charAt(cursor + 1) === '{') {
-            cursor = skipExpression(source, cursor + 1)
-            continue
-        }
-        cursor += 1
-    }
-    return cursor
-}

package/src/lib/ui/compile/structuralBlockTokens.ts

@@ -1,100 +0,0 @@
-import type { SemanticToken } from './types/SemanticToken.ts'
-
-/*
-Lexical highlighting for `{#…}`/`{:…}`/`{/…}` control-flow framing — the part the
-HTML grammar sees only as text and the shadow program lowers away. A pure scan of
-raw source (independent of a successful parse, so it survives mid-edit), it emits
-an `operator` token for the `{`+sigil opener and a `keyword` token for the block
-word, plus the `of`/`by` connectors inside a `{#for …}` head. Expression interiors
-and bare `{expr}` interpolations are NOT touched here — those are the shadow's job.
-A keyword allowlist after the sigil prevents matching arbitrary `{:foo}` text.
-Longest phrases first so `for await` beats `for` and `else if` beats `else`.
-*/
-const BLOCK_KEYWORDS = [
-    'for await',
-    'else if',
-    'if',
-    'for',
-    'await',
-    'switch',
-    'case',
-    'default',
-    'try',
-    'catch',
-    'finally',
-    'then',
-    'else',
-]
-
-const BLOCK_HEAD = new RegExp(`\\{([#:/])\\s*(${BLOCK_KEYWORDS.join('|')})\\b`, 'g')
-
-export function structuralBlockTokens(source: string): SemanticToken[] {
-    const tokens: SemanticToken[] = []
-    for (const match of source.matchAll(BLOCK_HEAD)) {
-        const braceStart = match.index
-        const sigil = match[1]
-        const keyword = match[2]
-        if (keyword === undefined) {
-            continue
-        }
-        const keywordStart = braceStart + match[0].length - keyword.length
-        tokens.push({ start: braceStart, length: 2, type: 'operator', modifiers: [] })
-        tokens.push({ start: keywordStart, length: keyword.length, type: 'keyword', modifiers: [] })
-        /* A `{#for …}` head carries abide-only connectors `of`/`by` that the shadow
-           lowers away (`of`) or never emits (`by`), so color them here. */
-        if (sigil === '#' && (keyword === 'for' || keyword === 'for await')) {
-            tokens.push(...forHeadConnectors(source, keywordStart + keyword.length))
-        }
-    }
-    return tokens
-}
-
-/*
-Scans a `{#for …}` head from `from` to its closing `}`, emitting `keyword` tokens
-for the `of`/`by` connectors at brace depth 0 — skipping any `of`/`by` nested in a
-destructure, call, or string so an identifier or object key is never miscolored.
-*/
-function forHeadConnectors(source: string, from: number): SemanticToken[] {
-    const tokens: SemanticToken[] = []
-    let depth = 0
-    let cursor = from
-    while (cursor < source.length) {
-        const char = source.charAt(cursor)
-        if (char === '"' || char === "'" || char === '`') {
-            cursor += 1
-            while (cursor < source.length && source.charAt(cursor) !== char) {
-                if (source.charAt(cursor) === '\\') {
-                    cursor += 1
-                }
-                cursor += 1
-            }
-        } else if (char === '{' || char === '(' || char === '[') {
-            depth += 1
-        } else if (char === ')' || char === ']') {
-            depth -= 1
-        } else if (char === '}') {
-            if (depth === 0) {
-                break
-            }
-            depth -= 1
-        } else if (depth === 0 && (char === 'o' || char === 'b')) {
-            const word = source.startsWith('of', cursor)
-                ? 'of'
-                : source.startsWith('by', cursor)
-                  ? 'by'
-                  : undefined
-            const isWordBoundary = (offset: number): boolean => /\s/.test(source.charAt(offset))
-            if (
-                word !== undefined &&
-                isWordBoundary(cursor - 1) &&
-                isWordBoundary(cursor + word.length)
-            ) {
-                tokens.push({ start: cursor, length: word.length, type: 'keyword', modifiers: [] })
-                cursor += word.length
-                continue
-            }
-        }
-        cursor += 1
-    }
-    return tokens
-}

package/src/lib/ui/dom/applyResolved.ts

@@ -1,87 +0,0 @@
-import { seedResolved } from '../seedResolved.ts'
-import { isComment } from './isComment.ts'
-
-/*
-Bundle-side consumer of an SSR stream chunk, the counterpart of the doc stream's inline
-vanilla scripts (`SSR_SWAP_SCRIPT`'s `__abideSwap` and `CACHE_RESOLVE_SCRIPT`'s `__abideResolve`) for a stream the
-running bundle consumes itself — streaming SPA navigation, socket-delivered SSR. It routes
-the two chunk kinds the stream interleaves:
-
-  - `<abide-cache>{StreamedResolution}</abide-cache>` → seed the streamed cache partition.
-    A script set via innerHTML never runs, so the cache channel rides a data frame here
-    (not the doc stream's `<script>__abideResolve(…)</script>`); seeding it keeps the
-    pending {#await} read warm instead of cold-missing to the network.
-  - `<abide-resolve data-id="ID"><script type="application/json">…</script>…</abide-resolve>`
-    → register the value in the resume manifest (for hydration), find the matching
-    `<!--abide:await:ID-->…<!--/abide:await:ID-->` boundary in `root`, remove the pending
-    nodes between the markers, and insert the resolved content in their place.
-
-The pending shell painted instantly; this swaps in each value as it arrives — completing
-the out-of-order streaming loop on the client.
-*/
-// @documentation plumbing
-export function applyResolved(root: Element, frame: string): void {
-    const holder = document.createElement('div')
-    holder.innerHTML = frame
-    const resolved = holder.firstChild as Element | null
-    if (resolved === null || resolved.getAttribute === undefined) {
-        return
-    }
-    /* A cache-seed frame warms the streamed cache partition — paired with the DOM swap so a
-       bundle-consumed stream can't adopt a resolved branch while dropping its cache key. */
-    if (resolved.nodeName === 'ABIDE-CACHE') {
-        try {
-            seedResolved({ kind: 'cache', resolution: JSON.parse(resolved.textContent ?? 'null') })
-        } catch {
-            /* malformed payload — leave unseeded; the read falls back to a live fetch */
-        }
-        return
-    }
-    const id = resolved.getAttribute('data-id')
-    if (id === null) {
-        return
-    }
-    /* The resolved value rides in a leading <script type=application/json> as ref-json
-       text; store it raw and remove the node so only the resolved markup moves into the
-       boundary. Decoding is deferred to the read in `awaitBlock` (which has the codec);
-       recording it lets a later hydrate adopt this branch (no re-fetch). */
-    const payload = resolved.firstChild as Element | null
-    if (payload !== null && payload.nodeName === 'SCRIPT') {
-        seedResolved({ kind: 'resume', id: Number(id), resume: payload.textContent ?? '' })
-        payload.remove()
-    }
-    const open = `abide:await:${id}`
-    const close = `/abide:await:${id}`
-    const boundary = findBoundary(root, open)
-    if (boundary === undefined) {
-        return
-    }
-    const { parent, start } = boundary
-    /* Remove the pending nodes between the markers (exclusive of the markers). */
-    let node = start.nextSibling
-    while (node !== null && !isComment(node, close)) {
-        const next = node.nextSibling
-        parent.removeChild(node)
-        node = next
-    }
-    /* Insert resolved content after the open marker. */
-    let anchor = start.nextSibling
-    for (const child of [...resolved.childNodes]) {
-        parent.insertBefore(child, anchor)
-        anchor = child.nextSibling
-    }
-}
-
-/* Depth-first search for the parent + open-marker comment of a boundary. */
-function findBoundary(node: Node, open: string): { parent: Node; start: Node } | undefined {
-    for (const child of [...node.childNodes]) {
-        if (isComment(child, open)) {
-            return { parent: node, start: child }
-        }
-        const nested = findBoundary(child, open)
-        if (nested !== undefined) {
-            return nested
-        }
-    }
-    return undefined
-}

package/src/lib/ui/dom/mutateDocArray.ts

@@ -1,38 +0,0 @@
-import type { Doc } from '../runtime/types/Doc.ts'
-import { readCall } from './readCall.ts'
-
-/*
-An in-place-mutating array method lowered on a reactive-document array. The
-doc-access lowering rewrites e.g. `model.items.splice(i, 1)` to
-`$$mutateDocArray(model, "items", "splice", [i, 1])` rather than the bare
-`$$readCall(model.read("items"), …)` it emits for non-mutating calls. The reason:
-`read` returns the live tree array by reference, so a bare `.splice()`/`.sort()`/…
-would mutate the document in place while never emitting a patch — no reader would
-re-render and undo/persistence/multiplayer sync (all keyed off `apply`) would
-never see the change (`.push` is the one already-handled exception, lowered to
-`add` patches). Cloning the array, applying the mutation to the copy, and writing
-it back through `replace` emits a real patch: readers wake and the change is
-journalled. Element identity is preserved for untouched entries (a shallow
-`slice`), so a keyed `{#for}` reconciles instead of rebuilding. The native
-method's return value (spliced-out elements, the new length, …) is returned
-unchanged.
-*/
-// @documentation plumbing
-export function mutateDocArray(doc: Doc, path: string, member: string, args: unknown[]): unknown {
-    const current = doc.read<unknown>(path)
-    /* Not an array — nothing patchable to clone. Fall back to the guarded in-place
-       call so the author still gets readCall's authored-scope error message. */
-    if (!Array.isArray(current)) {
-        return readCall(current, path, member, args)
-    }
-    const copy = current.slice()
-    const method = (copy as unknown as Record<string, unknown>)[member]
-    if (typeof method !== 'function') {
-        throw new TypeError(
-            `abide: cannot call .${member}() — "${path}".${member} is not a function (got ${typeof method})`,
-        )
-    }
-    const returned = (method as (...callArgs: unknown[]) => unknown).apply(copy, args)
-    doc.replace(path, copy)
-    return returned
-}

package/src/lib/ui/dom/scopeLabel.ts

@@ -1,21 +0,0 @@
-/*
-The human-readable name for the scope the direct-mount entry (`mount`/`hydrate`)
-establishes, derived from its host element's tag. The router instead fills layers into
-marker boundaries with no host element, so it passes each layer's route key as an
-explicit label (`fillBoundary`); a nested child likewise passes its component name (see
-`mountRange`). The `abide-` prefix strip turns a framework host tag like `abide-resolve`
-into `resolve`; any other host yields its lowercased tag. Feeds the inspector's
-Reactive tab a readable scope name; computed and stored in all builds (only the
-inspector surface is dev-only). Returns undefined when there's no element to name from.
-*/
-import { COMPONENT_WRAPPER_PREFIX } from '../COMPONENT_WRAPPER_PREFIX.ts'
-
-export function scopeLabel(host: Element): string | undefined {
-    const tag = host.tagName?.toLowerCase()
-    if (tag === undefined) {
-        return undefined
-    }
-    return tag.startsWith(COMPONENT_WRAPPER_PREFIX)
-        ? tag.slice(COMPONENT_WRAPPER_PREFIX.length)
-        : tag
-}

package/src/lib/ui/dom/text.ts

@@ -1,20 +0,0 @@
-import { effect } from '../effect.ts'
-
-/*
-A text node whose content tracks `read()`. The effect captures whatever reactive
-cells `read` touches, so the node — and only this node — re-renders when they
-change: one text node, one effect — fine-grained granularity.
-
-Plain-text only — `read()` is coerced with String(). For a `{expr}` interpolation
-that may yield an `html\`…\`` or snippet value the compiler emits `appendText`,
-which branches on the branded value and inserts raw markup; `text` cannot host
-multiple nodes and would stringify such a value to `[object Object]`.
-*/
-// @documentation plumbing
-export function text(read: () => unknown): Text {
-    const node = document.createTextNode('')
-    effect(() => {
-        node.data = String(read())
-    })
-    return node
-}

package/src/lib/ui/history.ts

@@ -1,108 +0,0 @@
-import { PATCH_BUS } from './runtime/PATCH_BUS.ts'
-import type { Doc } from './runtime/types/Doc.ts'
-import type { Patch } from './runtime/types/Patch.ts'
-import type { History } from './types/History.ts'
-
-/*
-Undo/redo for a document. Subscribes the `PATCH_BUS`, filters to this `doc`, and
-journals each applied patch's `inverse` into a bounded stack — O(size of the
-change) per step, never a tree snapshot. `undo`/`redo` replay inverses through
-`doc.apply`; the patches that replay itself emits are routed into a `sink` so a
-replay never opens a fresh entry nor clears the opposite stack (it instead fills
-it, keeping the move reversible). A genuine new edit clears the redo stack.
-`transaction(fn)` groups every patch `fn` emits into one entry. `limit` caps
-depth — the oldest entry drops. Inert (but harmless) on the server.
-*/
-// @documentation plumbing
-export function history(doc: Doc, { limit = 100 }: { limit?: number } = {}): History {
-    const undoStack: Patch[][] = []
-    const redoStack: Patch[][] = []
-    /* When set, captured inverses accumulate here instead of opening a new undo entry
-       — held by an in-progress transaction and by an undo/redo replay. */
-    let sink: Patch[] | undefined
-
-    /* Push one finished entry, evicting the oldest past `limit`. */
-    const push = (stack: Patch[][], entry: Patch[]): void => {
-        stack.push(entry)
-        if (stack.length > limit) {
-            stack.shift()
-        }
-    }
-
-    const unsubscribe = PATCH_BUS.subscribe((event) => {
-        if (event.doc !== doc || event.inverse === undefined) {
-            return
-        }
-        if (sink !== undefined) {
-            sink.push(event.inverse)
-            return
-        }
-        push(undoStack, [event.inverse])
-        redoStack.length = 0
-    })
-
-    /* Apply an entry's inverses in reverse application order (LIFO), capturing the
-       inverses they emit — the original forward patches — onto `target`, so the move
-       is itself reversible and lands on the opposite stack. */
-    const replay = (entry: Patch[], target: Patch[][]): void => {
-        const captured: Patch[] = []
-        sink = captured
-        try {
-            for (let index = entry.length - 1; index >= 0; index -= 1) {
-                doc.apply(entry[index] as Patch)
-            }
-        } finally {
-            sink = undefined
-            /* Push captured inverses even if `apply` threw mid-loop: the already-popped
-               entry is gone, so the forward patches for what DID apply must land on the
-               opposite stack or a partial replay becomes irreversible. */
-            if (captured.length > 0) {
-                push(target, captured)
-            }
-        }
-    }
-
-    return {
-        undo: () => {
-            const entry = undoStack.pop()
-            if (entry !== undefined) {
-                replay(entry, redoStack)
-            }
-        },
-        redo: () => {
-            const entry = redoStack.pop()
-            if (entry !== undefined) {
-                replay(entry, undoStack)
-            }
-        },
-        canUndo: () => undoStack.length > 0,
-        canRedo: () => redoStack.length > 0,
-        transaction: (run: () => void) => {
-            /* A nested transaction folds into the one already collecting. */
-            if (sink !== undefined) {
-                run()
-                return
-            }
-            const entry: Patch[] = []
-            sink = entry
-            try {
-                run()
-            } finally {
-                sink = undefined
-                /* Commit whatever was applied even if `run` threw partway: those patches are
-                   already live in the doc, so their inverses must reach the undo stack or the
-                   committed changes are left with no way to undo them. The throw still
-                   propagates after this. */
-                if (entry.length > 0) {
-                    push(undoStack, entry)
-                    redoStack.length = 0
-                }
-            }
-        },
-        dispose: () => {
-            unsubscribe()
-            undoStack.length = 0
-            redoStack.length = 0
-        },
-    }
-}