@abide/abide 0.48.0 → 0.50.0

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()
-        },
-    }
-}

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

@@ -1,69 +0,0 @@
-import { canonicalJson } from '../../shared/canonicalJson.ts'
-import { outboxProbeSlot } from '../../shared/outboxProbeSlot.ts'
-import type { OutboxQueue } from './createOutboxQueue.ts'
-
-/* One registered durable RPC: its url, the RemoteFunction it belongs to (tag for the
-   global aggregate), and its live queue. */
-type RegisteredOutbox = { url: string; rpc: unknown; queue: OutboxQueue<unknown> }
-
-/*
-Client registry of every durable RPC's outbox queue, keyed by url. A durable RPC
-(`outbox: true`) registers on first use so the global `outbox()` aggregate can
-flatten every queue and `pending()` can see queued entries. App-scoped, not component-
-scoped — the queues outlive any mount.
-*/
-const registered = new Map<string, RegisteredOutbox>()
-
-export const outboxRegistry = {
-    register(url: string, queue: OutboxQueue<unknown>, rpc: unknown): void {
-        registered.set(url, { url, rpc, queue })
-    },
-    get(url: string): OutboxQueue<unknown> | undefined {
-        return registered.get(url)?.queue
-    },
-    all(): RegisteredOutbox[] {
-        return [...registered.values()]
-    },
-    /* Drop every registered queue. App-scoped state outlives any mount, so tests that
-       park writes share one process-global registry; reset() gives each its own clean
-       slate. Only the in-memory registry is dropped — `queue.dispose()` keeps the
-       persisted snapshot (a reload rehydrates it), so a sign-out that must abandon
-       unsynced work has to clear persistence separately. */
-    reset(): void {
-        for (const { queue } of registered.values()) {
-            queue.dispose?.()
-        }
-        registered.clear()
-    },
-}
-
-/* The queues a pending() selector spans: a durable rpc selector carries the queue's
-   `url`, so it narrows to that one; the bare form spans every registered queue; any
-   other selector (producer fn, tags, subscribable) carries no url and matches none. */
-const queuesFor = (selector: unknown): OutboxQueue<unknown>[] => {
-    if (selector === undefined) {
-        return outboxRegistry.all().map(({ queue }) => queue)
-    }
-    const url = (selector as { url?: unknown }).url
-    if (typeof url !== 'string') {
-        return []
-    }
-    const queue = outboxRegistry.get(url)
-    return queue === undefined ? [] : [queue]
-}
-
-/* Prober for the shared pending() probe (see outboxProbeSlot). A parked write has no
-   value yet, so it counts as pending. Reads queue.entries() (doc-backed), so the probe
-   re-runs as writes park, drain, fail, or cancel; optional args narrow to one parked
-   call by structural compare — the double-submit guard for a form. The compare uses
-   canonicalJson (key-sorted, the encoder keyForRemoteCall keys body args with), not
-   JSON.stringify, so a selector's args match a parked entry regardless of key order —
-   the same equality the cache-side selector grammar already uses. */
-outboxProbeSlot.probe = (selector, args): boolean => {
-    const entries = queuesFor(selector).flatMap((queue) => queue.entries())
-    if (args === undefined) {
-        return entries.length > 0
-    }
-    const key = canonicalJson(args)
-    return entries.some((entry) => canonicalJson(entry.args) === key)
-}

package/src/lib/ui/runtime/PATCH_BUS.ts

@@ -1,28 +0,0 @@
-import type { PatchEvent } from './types/PatchEvent.ts'
-
-/*
-Process-global tap for every document mutation. `createDoc` emits a `PatchEvent`
-here on each applied patch; cross-cutting consumers (undo history, persistence,
-sync) subscribe. One chokepoint means those features journal a single uniform
-stream instead of each re-deriving change detection. `active` lets the emitter
-skip computing an inverse — its only real cost — when nobody is listening.
-*/
-const listeners = new Set<(event: PatchEvent) => void>()
-
-export const PATCH_BUS = {
-    /* True only while at least one consumer is attached; gates inverse capture. */
-    get active(): boolean {
-        return listeners.size > 0
-    },
-    emit(event: PatchEvent): void {
-        for (const listener of listeners) {
-            listener(event)
-        }
-    },
-    subscribe(listener: (event: PatchEvent) => void): () => void {
-        listeners.add(listener)
-        return () => {
-            listeners.delete(listener)
-        }
-    },
-}

package/src/lib/ui/runtime/captureModelDoc.ts

@@ -1,28 +0,0 @@
-import { PATCH_BUS } from './PATCH_BUS.ts'
-import type { Doc } from './types/Doc.ts'
-
-/*
-Runs a component `build` and returns its result (the mount handle / disposer)
-alongside the component's own `model` document — the serializable `state` doc,
-needed so a hot swap can carry its value across (see `hotReplace`). The model is
-found, not threaded: a component seeds its `model` first (the desugared
-`const $$model = scope()` + its init `replace` patches (state slots lowered by `lowerDocAccess`) run before any child mounts or
-control-flow blocks), so the FIRST patch announced on the bus during the build names
-it. A component with no `state` mints no model and emits nothing first — `model` is
-then `undefined` and there is nothing to preserve. Used only on the hot path; the
-subscription is torn down with the build.
-*/
-export function captureModelDoc<T>(build: () => T): {
-    value: T
-    model: Doc | undefined
-} {
-    let model: Doc | undefined
-    const unsubscribe = PATCH_BUS.subscribe((event) => {
-        model ??= event.doc
-    })
-    try {
-        return { value: build(), model }
-    } finally {
-        unsubscribe()
-    }
-}

package/src/lib/ui/runtime/hotInstances.ts

@@ -1,10 +0,0 @@
-import type { HotInstance } from './types/HotInstance.ts'
-
-/*
-Live component instances grouped by module id (`UiComponent.__abideId`).
-`mountChild` adds each instance it mounts while hot reload is active; `hotReplace`
-walks a module's set to swap every instance when that module is edited. The set's
-remove callback (filed with the mounting owner) drops an instance on unmount, so
-no stale record survives to be swapped into a detached host.
-*/
-export const hotInstances: Map<string, Set<HotInstance>> = new Map()

package/src/lib/ui/runtime/hotReloadEnabled.ts

@@ -1,8 +0,0 @@
-/*
-Whether abide-ui hot-module replacement is active. Off by default, so production
-and ordinary dev render exactly as before — `mountChild` takes the plain path.
-The dev client sets it true once the hot bridge is in place, switching every
-child mount onto the path that records its instance so an edited component can be
-disposed and re-run where it stands.
-*/
-export const hotReloadEnabled: { current: boolean } = { current: false }

package/src/lib/ui/runtime/hotReplace.ts

@@ -1,38 +0,0 @@
-import { fillRange } from '../dom/fillRange.ts'
-import { captureModelDoc } from './captureModelDoc.ts'
-import { hotInstances } from './hotInstances.ts'
-import { seedModelDoc } from './seedModelDoc.ts'
-import type { UiComponent } from './types/UiComponent.ts'
-
-/*
-Swaps every live instance of an edited component to its new factory. Per instance:
-snapshot its model, dispose the current scope and clear its DOM range (the disposer
-leaves the `start`/`end` markers in place), re-fill the SAME range with the new
-module's `build` and the same props, then re-seed the fresh model from the snapshot —
-so the user's in-progress `state` survives the edit (state above the boundary already
-survives: props are thunks re-reading the parent's live signals). The hot module
-calls this on load with its freshly compiled `next`. Returns whether it swapped at
-least one instance: false (the edited component has none mounted — e.g. a
-router-mounted page, or a hidden branch) tells the caller to fall back to a full
-reload, since nothing on screen would update.
-*/
-export function hotReplace(moduleId: string, next: UiComponent): boolean {
-    const set = hotInstances.get(moduleId)
-    if (set === undefined || set.size === 0) {
-        return false
-    }
-    for (const instance of set) {
-        const saved = instance.model?.snapshot()
-        instance.dispose()
-        instance.factory = next
-        const { value: handle, model } = captureModelDoc(() =>
-            fillRange(instance.start, instance.end, next.build, instance.props, instance.label),
-        )
-        instance.dispose = handle.dispose
-        instance.model = model
-        if (saved !== undefined && model !== undefined) {
-            seedModelDoc(model, saved)
-        }
-    }
-    return true
-}

package/src/lib/ui/runtime/liveScopes.ts

@@ -1,15 +0,0 @@
-import type { Scope } from '../types/Scope.ts'
-
-/*
-Dev-only registry of every live scope, for the inspector's Reactive tab. `scopes`
-stays empty and untouched unless installInspectorBridge flips `enabled` (gated by
-the server-injected `__abideInspect`), so production allocates and tracks nothing.
-createScope adds on construction and removes on dispose; the bridge reconstructs
-the scope forest from each entry's `id` + `parent.id` (the Scope surface exposes
-no children accessor, so the flat set + parent links is the traversal path). One
-mutable singleton object — mirrors `reactiveAbortState`, reached without a barrel.
-*/
-export const liveScopes: { enabled: boolean; scopes: Set<Scope> } = {
-    enabled: false,
-    scopes: new Set(),
-}

package/src/lib/ui/runtime/localStoragePersistence.ts

@@ -1,47 +0,0 @@
-import { decodeRefJson } from '../../shared/decodeRefJson.ts'
-import { encodeRefJson } from '../../shared/encodeRefJson.ts'
-import type { PersistenceStore } from '../types/PersistenceStore.ts'
-
-/*
-The default `persist` backend: `localStorage` keyed by the persistence key, using
-the ref-json codec as the wire form (which also clones on decode, so a stored
-snapshot can't alias the live tree). ref-json over plain JSON because a doc
-snapshot can hold the types JSON silently coerces (Date), drops (undefined) or
-throws on (bigint, cycles, shared references) — a throw here is a swallowed save,
-i.e. silent persistence loss. Returns `undefined` where there is no `localStorage`
-— the server, or a browser with storage disabled — which `persist` reads as "stay
-inert". A corrupt or unreadable entry (including one written by an older JSON
-build) loads as `undefined` rather than throwing, so one bad write can't wedge
-boot; the next save rewrites it in ref-json form.
-*/
-export function localStoragePersistence(): PersistenceStore | undefined {
-    if (typeof localStorage === 'undefined') {
-        return undefined
-    }
-    return {
-        load: (key) => {
-            const raw = localStorage.getItem(key)
-            if (raw === null) {
-                return undefined
-            }
-            try {
-                return decodeRefJson(raw)
-            } catch {
-                return undefined
-            }
-        },
-        save: (key, snapshot) => {
-            /* Swallow a failed write (QuotaExceededError, storage disabled mid-session) —
-               it fires from a debounced flush / pagehide handler with no caller to catch it,
-               and a dropped persist must not crash the app. */
-            try {
-                localStorage.setItem(key, encodeRefJson(snapshot))
-            } catch {
-                // best-effort persistence
-            }
-        },
-        remove: (key) => {
-            localStorage.removeItem(key)
-        },
-    }
-}

package/src/lib/ui/runtime/registerHotInstance.ts

@@ -1,23 +0,0 @@
-import { hotInstances } from './hotInstances.ts'
-import type { HotInstance } from './types/HotInstance.ts'
-
-/*
-Records a live component instance under its module id and returns a remove
-callback. `mountChild` files the remove with the mounting owner, so the instance
-leaves the registry when its parent (or branch/row) tears down — the module's set
-is dropped once empty, leaving no orphan keys.
-*/
-export function registerHotInstance(moduleId: string, instance: HotInstance): () => void {
-    let set = hotInstances.get(moduleId)
-    if (set === undefined) {
-        set = new Set()
-        hotInstances.set(moduleId, set)
-    }
-    set.add(instance)
-    return () => {
-        set.delete(instance)
-        if (set.size === 0) {
-            hotInstances.delete(moduleId)
-        }
-    }
-}