@abide/abide 0.49.0 → 0.50.1

package/src/lib/ui/installHotBridge.ts

@@ -1,95 +0,0 @@
-import { snippet } from '../shared/snippet.ts'
-import { anchorCursor } from './dom/anchorCursor.ts'
-import { appendSnippet } from './dom/appendSnippet.ts'
-import { appendStatic } from './dom/appendStatic.ts'
-import { appendText } from './dom/appendText.ts'
-import { appendTextAt } from './dom/appendTextAt.ts'
-import { attach } from './dom/attach.ts'
-import { attr } from './dom/attr.ts'
-import { awaitBlock } from './dom/awaitBlock.ts'
-import { bindSelectValue } from './dom/bindSelectValue.ts'
-import { cloneStatic } from './dom/cloneStatic.ts'
-import { each } from './dom/each.ts'
-import { eachAsync } from './dom/eachAsync.ts'
-import { hydrate } from './dom/hydrate.ts'
-import { mergeProps } from './dom/mergeProps.ts'
-import { mount } from './dom/mount.ts'
-import { mountChild } from './dom/mountChild.ts'
-import { mountSlot } from './dom/mountSlot.ts'
-import { mutateDocArray } from './dom/mutateDocArray.ts'
-import { on } from './dom/on.ts'
-import { outlet } from './dom/outlet.ts'
-import { readCall } from './dom/readCall.ts'
-import { restProps } from './dom/restProps.ts'
-import { skeleton } from './dom/skeleton.ts'
-import { spreadAttrs } from './dom/spreadAttrs.ts'
-import { spreadProps } from './dom/spreadProps.ts'
-import { switchBlock } from './dom/switchBlock.ts'
-import { tryBlock } from './dom/tryBlock.ts'
-import { when } from './dom/when.ts'
-import { effect } from './effect.ts'
-import { enterScope } from './enterScope.ts'
-import { exitScope } from './exitScope.ts'
-import { enterRenderPass } from './runtime/enterRenderPass.ts'
-import { escapeKey } from './runtime/escapeKey.ts'
-import { exitRenderPass } from './runtime/exitRenderPass.ts'
-import { hotReloadEnabled } from './runtime/hotReloadEnabled.ts'
-import { hotReplace } from './runtime/hotReplace.ts'
-import { nextBlockId } from './runtime/nextBlockId.ts'
-import { scope } from './scope.ts'
-import { watch } from './watch.ts'
-
-/*
-Dev-only: exposes the abide-ui runtime plus `hotReplace` on `window.__abide`, and
-flips on `hotReloadEnabled` so `mountChild` records every instance it mounts. A
-hot module (the dev server's standalone recompile of one edited `.abide`) reads
-its runtime from this object instead of importing fresh copies — so it shares the
-one reactive graph and instance registry — then calls `hotReplace` to swap every
-live instance in place. The keys mirror `UI_RUNTIME_IMPORTS` (+ `hotReplace`); a
-test guards that pairing. `startClient` calls this when the server marks the page
-dev (the live-reload script sets `window.__abideDev`).
-*/
-export function installHotBridge(): void {
-    ;(globalThis as { __abide?: Record<string, unknown> }).__abide = {
-        snippet,
-        scope,
-        enterScope,
-        exitScope,
-        effect,
-        watch,
-        mount,
-        appendText,
-        appendTextAt,
-        appendSnippet,
-        appendStatic,
-        cloneStatic,
-        skeleton,
-        anchorCursor,
-        attr,
-        on,
-        attach,
-        bindSelectValue,
-        each,
-        eachAsync,
-        when,
-        awaitBlock,
-        tryBlock,
-        switchBlock,
-        mountSlot,
-        outlet,
-        mountChild,
-        mergeProps,
-        spreadProps,
-        restProps,
-        spreadAttrs,
-        readCall,
-        mutateDocArray,
-        hydrate,
-        escapeKey,
-        nextBlockId,
-        enterRenderPass,
-        exitRenderPass,
-        hotReplace,
-    }
-    hotReloadEnabled.current = true
-}

package/src/lib/ui/installInspectorBridge.ts

@@ -1,140 +0,0 @@
-import { effect } from './effect.ts'
-import { clientPage } from './runtime/clientPage.ts'
-import { historyEntries } from './runtime/historyEntries.ts'
-import { liveScopes } from './runtime/liveScopes.ts'
-import { PATCH_BUS } from './runtime/PATCH_BUS.ts'
-import { runtimePath } from './runtime/runtimePath.ts'
-
-/* Same-origin cross-tab channel the inspector page listens on. The app tab
-   publishes scope + router state; the inspector subscribes. Web-standard, so no
-   server route or buffer is involved — core publishes, the package consumes. */
-const CHANNEL = 'abide:inspector'
-
-/* Coalesce a burst of patches into one snapshot — the post is the cost, the read is cheap. */
-const SNAPSHOT_DEBOUNCE_MS = 60
-
-/* JSON round-trip to strip anything structured-clone can't carry (functions,
-   class instances, DOM nodes) before postMessage, degrading to undefined rather
-   than throwing into the channel. */
-function cloneable(value: unknown): unknown {
-    try {
-        return JSON.parse(JSON.stringify(value))
-    } catch {
-        return undefined
-    }
-}
-
-/* The live scope forest as a flat list — the inspector rebuilds the tree from
-   each node's `parent` id (the Scope surface exposes no children accessor). */
-function scopeNodes(): Array<{
-    id: string
-    label: string | undefined
-    parent: string | undefined
-    state: unknown
-    recorded: boolean
-}> {
-    return Array.from(liveScopes.scopes, (scope) => ({
-        id: scope.id,
-        label: scope.label,
-        parent: scope.parent?.id,
-        state: cloneable(scope.snapshot()),
-        recorded: scope.canUndo() || scope.canRedo(),
-    }))
-}
-
-/* Router state off the existing reactive holders — read, not subscribed, here;
-   the nav effect drives re-reads. */
-function routerState() {
-    const page = clientPage.value
-    return {
-        path: runtimePath.value,
-        route: page.route,
-        /* `page.params` is a reactive Proxy — structuredClone (postMessage) can't carry
-           a Proxy and throws, dropping every router frame. Spread to a plain object. */
-        params: { ...page.params },
-        navigating: page.navigating,
-        url: page.url.href,
-        entry: historyEntries.current,
-    }
-}
-
-/*
-Installs the client→inspector bridge: a BroadcastChannel the inspector page reads
-to render its Reactive + Router tabs. Gated by `__abideInspect` (server-injected
-only when the inspector is enabled) and called from startClient before the router
-builds any scope — so registration is armed before the first scope exists. A
-no-op where BroadcastChannel is absent (SSR, old runtimes). Mirrors
-installHotBridge: dev instrumentation, not public surface.
-*/
-export function installInspectorBridge(): void {
-    /* No BroadcastChannel means no consumer for the scope registry — bail before
-       arming `liveScopes.enabled`, so createScope never pays scope tracking for a
-       set nothing reads. */
-    if (typeof BroadcastChannel === 'undefined') {
-        return
-    }
-    liveScopes.enabled = true
-    const channel = new BroadcastChannel(CHANNEL)
-    const tab = typeof crypto !== 'undefined' ? crypto.randomUUID() : String(performance.now())
-    const post = (message: object) => {
-        try {
-            channel.postMessage({ tab, ...message })
-        } catch {
-            /* A non-cloneable slipped through despite the JSON pass — drop the frame
-               rather than throw into a patch/nav handler. */
-        }
-    }
-
-    const announce = () =>
-        post({
-            kind: 'announce',
-            url: typeof location !== 'undefined' ? location.href : '',
-            app: typeof document !== 'undefined' ? document.title : '',
-        })
-    const sendSnapshot = () =>
-        post({ kind: 'snapshot', scopes: scopeNodes(), router: routerState() })
-
-    let snapshotTimer: ReturnType<typeof setTimeout> | undefined
-    const scheduleSnapshot = () => {
-        clearTimeout(snapshotTimer)
-        snapshotTimer = setTimeout(sendSnapshot, SNAPSHOT_DEBOUNCE_MS)
-    }
-
-    /* Inspector handshakes: `hello` (it just opened — everyone re-announce + push)
-       and `request` (it wants a fresh snapshot of this tab). */
-    channel.onmessage = (event) => {
-        const message = event.data as { kind?: string; tab?: string }
-        if (message.kind === 'hello') {
-            announce()
-            sendSnapshot()
-        } else if (message.kind === 'request' && message.tab === tab) {
-            sendSnapshot()
-        }
-    }
-
-    /* Every doc mutation flows through PATCH_BUS; forward the patch as a live
-       mutation event and re-snapshot (debounced) so values stay current. */
-    PATCH_BUS.subscribe((patchEvent) => {
-        post({ kind: 'patch', op: patchEvent.patch.op, path: patchEvent.patch.path })
-        scheduleSnapshot()
-    })
-
-    /* Reading the page + path States tracks them, so this re-runs on navigation. */
-    effect(() => {
-        clientPage.value
-        runtimePath.value
-        post({ kind: 'nav', router: routerState() })
-    })
-
-    if (typeof addEventListener === 'function') {
-        addEventListener('pagehide', () => {
-            post({ kind: 'bye' })
-            channel.close()
-        })
-    }
-
-    announce()
-    /* First snapshot once the router has built the initial scope tree (this runs
-       before router()). */
-    setTimeout(sendSnapshot, 0)
-}

package/src/lib/ui/outbox.ts

@@ -1,35 +0,0 @@
-import type { OutboxEntry } from '../shared/types/OutboxEntry.ts'
-import type { RemoteFunction } from '../shared/types/RemoteFunction.ts'
-import { outboxRegistry } from './rpcOutbox/outboxRegistry.ts'
-
-/* One entry in the global outbox, tagged with the RPC it belongs to. */
-export type GlobalOutboxEntry = OutboxEntry<unknown> & { rpc: RemoteFunction<unknown, unknown> }
-
-/* The global outbox: callable for the flat entry list, awaitable `retry()` to drain every
-   queue (resolves when every replay settles). */
-export type GlobalOutbox = (() => GlobalOutboxEntry[]) & { retry: () => Promise<void> }
-
-function list(): GlobalOutboxEntry[] {
-    return outboxRegistry.all().flatMap(({ rpc, queue }) =>
-        queue.entries().map((entry) => ({
-            ...entry,
-            rpc: rpc as RemoteFunction<unknown, unknown>,
-        })),
-    )
-}
-
-/*
-The global, reactive view of every durable RPC's outbox — a flat list of undelivered
-entries across all `outbox` rpcs, each tagged with its `rpc`. Reactive: reading it in a
-template/effect subscribes to each registered queue, so it updates as writes park, drain,
-fail, or cancel. Use it for an app-wide "N unsynced" badge or a sync panel; cancel a
-pending write through `entry.controller.abort()`, retry one through `entry.retry()`, or
-drain everything through `outbox.retry()`. A single rpc's slice is `rpc.outbox`. Server-
-side there are no client queues, so it returns an empty list.
-*/
-// @documentation ui
-export const outbox: GlobalOutbox = Object.assign(list, {
-    async retry(): Promise<void> {
-        await Promise.all(outboxRegistry.all().map(({ queue }) => queue.retry()))
-    },
-})

package/src/lib/ui/persist.ts

@@ -1,115 +0,0 @@
-import { escapeKey } from './runtime/escapeKey.ts'
-import { localStoragePersistence } from './runtime/localStoragePersistence.ts'
-import { PATCH_BUS } from './runtime/PATCH_BUS.ts'
-import type { Doc } from './runtime/types/Doc.ts'
-import type { PersistenceStore } from './types/PersistenceStore.ts'
-import type { PersistHandle } from './types/PersistHandle.ts'
-
-/*
-Makes a document durable: seeds it from the saved snapshot on boot, then writes
-its snapshot back (debounced) on every change the patch bus announces — so the
-state survives a reload. The bus is the single tap; `persist` adds no bookkeeping
-to the doc. A store-less environment (the server, or a browser without
-localStorage and no injected store) returns an inert handle, so the same call is
-safe to write isomorphically.
-
-Restore is a per-top-level-key overlay (saved wins, current keeps keys saved
-lacks), so a doc that boots empty fills from the snapshot while a key added in a
-newer app version keeps its fresh default. Writes coalesce into one per `debounce`
-window and flush when the tab is hidden, so the tail of a burst isn't lost.
-*/
-// @documentation plumbing
-export function persist(
-    doc: Doc,
-    key: string,
-    {
-        store = localStoragePersistence(),
-        debounce = 200,
-    }: { store?: PersistenceStore; debounce?: number } = {},
-): PersistHandle {
-    /* No durable store → inert: server render, or a browser without localStorage. */
-    if (store === undefined) {
-        return { flush: () => undefined, clear: () => undefined, dispose: () => undefined }
-    }
-
-    const saved = store.load(key)
-    if (saved !== undefined) {
-        restore(doc, saved)
-    }
-
-    /* Coalesce a burst into one write: the timer is armed by the first patch and
-       writes the latest snapshot when it fires, bounding staleness to `debounce`. */
-    let timer: ReturnType<typeof setTimeout> | undefined
-    const flush = (): void => {
-        if (timer !== undefined) {
-            clearTimeout(timer)
-            timer = undefined
-        }
-        store.save(key, doc.snapshot())
-    }
-    const schedule = (): void => {
-        if (timer === undefined) {
-            timer = setTimeout(flush, debounce)
-        }
-    }
-
-    const unsubscribe = PATCH_BUS.subscribe((event) => {
-        if (event.doc === doc) {
-            schedule()
-        }
-    })
-
-    /* Flush the tail before the tab goes away, so a pending debounced write survives. */
-    const onHidden = (): void => {
-        if (typeof document !== 'undefined' && document.visibilityState === 'hidden') {
-            flush()
-        }
-    }
-    const canListen = typeof window !== 'undefined' && typeof window.addEventListener === 'function'
-    if (canListen) {
-        window.addEventListener('pagehide', flush)
-        document.addEventListener('visibilitychange', onHidden)
-    }
-
-    return {
-        flush,
-        clear: () => {
-            if (timer !== undefined) {
-                clearTimeout(timer)
-                timer = undefined
-            }
-            store.remove(key)
-        },
-        dispose: () => {
-            unsubscribe()
-            if (timer !== undefined) {
-                clearTimeout(timer)
-                timer = undefined
-            }
-            if (canListen) {
-                window.removeEventListener('pagehide', flush)
-                document.removeEventListener('visibilitychange', onHidden)
-            }
-        },
-    }
-}
-
-/* Load `saved` into `doc`: a per-key overlay for object roots (so the doc's own
-   keys that the snapshot lacks keep their value), else a wholesale root replace
-   (a primitive or array root). */
-function restore(doc: Doc, saved: unknown): void {
-    const current = doc.snapshot()
-    if (isPlainObject(saved) && isPlainObject(current)) {
-        /* `replace` takes a `/`-delimited escaped path, so a top-level key containing
-           `/` or `~` must be escaped to a single segment or it'd be mis-routed. */
-        for (const key of Object.keys(saved)) {
-            doc.replace(escapeKey(key), saved[key])
-        }
-        return
-    }
-    doc.replace('', saved)
-}
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-    return value !== null && typeof value === 'object' && !Array.isArray(value)
-}

package/src/lib/ui/rpcOutbox/createOutboxQueue.ts

@@ -1,281 +0,0 @@
-import { decodeResponse } from '../../shared/decodeResponse.ts'
-import type { OutboxEntry, OutboxStatus } from '../../shared/types/OutboxEntry.ts'
-import { UNREACHABLE_STATUSES } from '../../shared/UNREACHABLE_STATUSES.ts'
-import { persist } from '../persist.ts'
-import { createDoc as doc } from '../runtime/createDoc.ts'
-import type { PersistenceStore } from '../types/PersistenceStore.ts'
-
-/* Persisted form of an entry — the Request reduced to its replayable parts (a live
-   Request + AbortController don't serialize). `body`/`contentType` are captured
-   asynchronously just after park (Request.text() is async); they seed empty and fill
-   in before any reload, so a restored entry replays with its original body. */
-type StoredEntry<Args> = {
-    id: string
-    args: Args
-    method: string
-    url: string
-    body: string
-    contentType: string
-    status: OutboxStatus
-}
-
-/* Non-serializable identity for a live entry: its abort handle, the in-session Request
-   (body intact), and the per-entry retry trigger. Rebuilt from the persisted item on a
-   cold read after reload. */
-type Identity = { controller: AbortController; request: Request; retry: () => Promise<void> }
-
-export type OutboxQueue<Args> = {
-    park: (args: Args, request: Request, reason?: unknown) => OutboxEntry<Args>
-    entries: () => OutboxEntry<Args>[]
-    /* Undelivered-entry count — the same reactive read as `entries()`, without building
-       the entry objects. A caller parks straight to the tail when this is non-empty. */
-    size: () => number
-    retry: () => Promise<void>
-    drain: () => Promise<void>
-    dispose: () => void
-}
-
-/* Persistence key per RPC url — the queue's durable identity. */
-const keyFor = (url: string): string => `abide:outbox:${url}`
-
-/*
-A durable, app-owned FIFO retry queue for one RPC. A call fetches directly and throws as
-before while the queue is empty; when the server can't be reached — a transport failure or
-a 502/503/504/520–527/530 — the caller `park`s the request here (a side-effect; the call still
-throws), and once a backlog exists the caller parks every later call at the tail too, so
-FIFO order is preserved on replay. Built on `doc` + `persist`, so the queue IS a persisted
-document that survives a reload. Draining is manual — the app calls `retry()` (per-entry or
-whole-queue) when it decides to replay; nothing drains automatically. The drain re-sends
-head-first: any server response removes the entry — a 2xx (delivered) AND a real 4xx/500
-(the server handled+rejected it; retrying won't help, so it leaves the queue) — while a
-still-unreachable result keeps it `queued` for the next `retry()`, and an abort removes it.
-Resends run under the entry's OWN abort signal alone — scope-abort and the client timeout
-are deliberately not composed in, so a parked write survives an unmount and waits out the
-outage.
-*/
-export function createOutboxQueue<Args>(opts: {
-    url: string
-    send: (request: Request) => Promise<Response>
-    store?: PersistenceStore
-}): OutboxQueue<Args> {
-    const stored = doc({ items: [] as StoredEntry<Args>[] })
-    const persistence = persist(stored, keyFor(opts.url), { store: opts.store, debounce: 0 })
-    /* Live identity (controller + Request + retry) by id, rebuilt from persisted items on
-       a cold read; `errors` is transient last-failure state (never persisted). */
-    const live = new Map<string, Identity>()
-    const errors = new Map<string, unknown>()
-    /* Per-entry `settled` deferreds, created lazily on first read of `entry.settled` (so a
-       never-awaited refusal can't become an unhandled rejection) and resolved/rejected once
-       at the drain exit. Transient — a reload starts fresh. */
-    type Settler = {
-        promise: Promise<unknown>
-        resolve: (value: unknown) => void
-        reject: (error: unknown) => void
-    }
-    const settlers = new Map<string, Settler>()
-
-    /* The lazily-armed `settled` promise for an id: the outcome of this write as if the
-       original call had reached the server. */
-    const settledFor = (id: string): Promise<unknown> => {
-        const existing = settlers.get(id)
-        if (existing !== undefined) {
-            return existing.promise
-        }
-        let resolve!: (value: unknown) => void
-        let reject!: (error: unknown) => void
-        const promise = new Promise<unknown>((res, rej) => {
-            resolve = res
-            reject = rej
-        })
-        settlers.set(id, { promise, resolve, reject })
-        return promise
-    }
-
-    /* Settle an id's deferred (if armed) and drop it — single-shot. */
-    const settle = (id: string, run: (settler: Settler) => void): void => {
-        const settler = settlers.get(id)
-        if (settler !== undefined) {
-            run(settler)
-            settlers.delete(id)
-        }
-    }
-
-    const items = (): StoredEntry<Args>[] => stored.read('items') as StoredEntry<Args>[]
-
-    const remove = (id: string): void => {
-        const index = items().findIndex((item) => item.id === id)
-        if (index !== -1) {
-            stored.remove(`items/${index}`)
-            persistence.flush()
-        }
-        live.delete(id)
-        errors.delete(id)
-        /* A cancel/supersede removal with nobody having delivered first → reject `settled`
-           as a canceled call would. Delivery/refusal settle before calling remove, so this
-           is a no-op for them (single-shot). */
-        settle(id, (s) => s.reject(new DOMException('The outbox entry was canceled', 'AbortError')))
-    }
-
-    const setStatus = (id: string, status: OutboxStatus): void => {
-        const index = items().findIndex((item) => item.id === id)
-        if (index !== -1) {
-            stored.replace(`items/${index}/status`, status)
-            persistence.flush()
-        }
-    }
-
-    /* The non-serializable identity for an id: reuse the live one (Request body intact in
-       session), else rebuild from the persisted parts (fresh controller, cold reload). */
-    const identityFor = (item: StoredEntry<Args>): Identity => {
-        const existing = live.get(item.id)
-        if (existing !== undefined) {
-            return existing
-        }
-        const controller = new AbortController()
-        controller.signal.addEventListener('abort', () => remove(item.id), { once: true })
-        /* `body || undefined` so a bodyless method rebuilds without one (a Request with a
-           body-carrying method + no body is fine; GET/DELETE with a body throws). */
-        const request = new Request(item.url, {
-            method: item.method,
-            body: item.body || undefined,
-            headers: item.contentType ? { 'content-type': item.contentType } : undefined,
-        })
-        /* Per-entry `retry()` kicks a FIFO drain — every entry is `queued`, so it resends
-           head-first and reaches this one in order. */
-        const identity: Identity = { controller, request, retry: () => drain() }
-        live.set(item.id, identity)
-        return identity
-    }
-
-    const toLive = (item: StoredEntry<Args>): OutboxEntry<Args> => {
-        const { controller, request, retry } = identityFor(item)
-        return {
-            id: item.id,
-            controller,
-            request,
-            args: item.args,
-            status: item.status,
-            error: errors.get(item.id),
-            retry,
-            /* Lazy: the deferred is only armed when someone reads `settled`, so an
-               unawaited refusal can't surface as an unhandled rejection. */
-            get settled() {
-                return settledFor(item.id)
-            },
-        }
-    }
-
-    /* Persist the request body + content type just after park (Request.text() is async).
-       The in-session drain replays the LIVE request (body intact) regardless; this fills
-       the persisted form before any reload. A bodyless method leaves the empty seed. */
-    const captureRequest = async (id: string, request: Request): Promise<void> => {
-        const body = request.body === null ? '' : await request.clone().text()
-        const contentType = request.headers.get('content-type') ?? ''
-        const index = items().findIndex((item) => item.id === id)
-        if (index === -1) {
-            return
-        }
-        stored.replace(`items/${index}/body`, body)
-        stored.replace(`items/${index}/contentType`, contentType)
-        persistence.flush()
-    }
-
-    /* Resends run under the entry's OWN signal only — a parked write survives unmount +
-       waits out the outage, so scope-abort + client-timeout are NOT composed in. */
-    const sendable = (entry: OutboxEntry<Args>): Request =>
-        new Request(entry.request, { signal: entry.controller.signal })
-
-    let draining = false
-    let settled: Promise<void> = Promise.resolve()
-    const drain = (): Promise<void> => {
-        if (draining) {
-            return settled
-        }
-        draining = true
-        settled = (async () => {
-            try {
-                while (true) {
-                    const head = items()[0]
-                    if (head === undefined) {
-                        break
-                    }
-                    const entry = toLive(head)
-                    if (entry.controller.signal.aborted) {
-                        remove(head.id) // canceled while queued
-                        continue
-                    }
-                    setStatus(head.id, 'sending')
-                    try {
-                        const response = await opts.send(sendable(entry))
-                        if (UNREACHABLE_STATUSES.has(response.status)) {
-                            setStatus(head.id, 'queued') // still down → wait for the next trigger
-                            break
-                        }
-                        /* The server responded — 2xx OR a real 4xx/500. Either way it
-                           HANDLED the request (the outbox only holds the unreachable), so
-                           the entry leaves the queue and the next proceeds in order. Decode
-                           it exactly as a live call would so `settled` resolves with the
-                           result, or rejects with the real HttpError on a refusal. */
-                        try {
-                            const value = await decodeResponse(response)
-                            settle(head.id, (s) => s.resolve(value))
-                        } catch (responseError) {
-                            settle(head.id, (s) => s.reject(responseError))
-                        }
-                        remove(head.id)
-                        continue
-                    } catch {
-                        if (entry.controller.signal.aborted) {
-                            remove(head.id) // canceled mid-send
-                            continue
-                        }
-                        /* Transport failure on resend — still unreachable, keep queued. */
-                        setStatus(head.id, 'queued')
-                        break
-                    }
-                }
-            } finally {
-                draining = false
-            }
-        })()
-        return settled
-    }
-
-    return {
-        park(args, request, reason) {
-            const id = crypto.randomUUID()
-            const controller = new AbortController()
-            controller.signal.addEventListener('abort', () => remove(id), { once: true })
-            live.set(id, { controller, request, retry: () => drain() })
-            if (reason !== undefined) {
-                errors.set(id, reason)
-            }
-            stored.add('items/-', {
-                id,
-                args,
-                method: request.method,
-                url: request.url,
-                body: '',
-                contentType: '',
-                status: 'queued',
-            })
-            persistence.flush()
-            void captureRequest(id, request)
-            const item = items().find((entry) => entry.id === id) as StoredEntry<Args>
-            return toLive(item)
-        },
-        entries() {
-            return items().map(toLive)
-        },
-        size() {
-            return items().length
-        },
-        retry() {
-            return drain()
-        },
-        drain,
-        dispose() {
-            persistence.dispose()
-        },
-    }
-}