@abide/abide 0.49.0 → 0.50.0

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,43 +0,0 @@
-import { PATCH_BUS } from './PATCH_BUS.ts'
-import type { Doc } from './types/Doc.ts'
-
-/* Stack of in-flight captures, innermost last. `mountChild` wraps every hot-tracked child
-   mount in its own `captureModelDoc`, and these NEST inside a parent's build, so a single
-   shared PATCH_BUS would let a parent's listener (subscribed first) grab a nested child's
-   model. Assigning each patch only to the innermost active capture keeps a component's model
-   scoped to its OWN build. */
-const captureStack: { model: Doc | undefined }[] = []
-
-/*
-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 during THIS build (not a nested
-child's) names it. A component with no `state` mints no model and emits nothing first
-— `model` is then `undefined` and there is nothing to preserve. A nested child mount
-pushes its own frame, so its state-init patch names the child's model, not the parent's
-(the M5 stateless-parent/stateful-child fix). 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
-} {
-    const frame: { model: Doc | undefined } = { model: undefined }
-    captureStack.push(frame)
-    const unsubscribe = PATCH_BUS.subscribe((event) => {
-        /* Only the innermost active capture claims a patch — a nested child mounting during
-           this build has pushed a deeper frame, so its patches don't leak up to this one. */
-        if (captureStack[captureStack.length - 1] === frame) {
-            frame.model ??= event.doc
-        }
-    })
-    try {
-        return { value: build(), model: frame.model }
-    } finally {
-        unsubscribe()
-        captureStack.pop()
-    }
-}

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

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

@@ -1,26 +0,0 @@
-import type { Doc } from './types/Doc.ts'
-
-/*
-Loads a `saved` snapshot (from the pre-swap instance) into a freshly-built `model`,
-restoring the user's in-progress state across a hot swap. A shallow per-top-level-key
-merge, not a wholesale root replace: a key present in both is restored from `saved`;
-a key the edit ADDED keeps its fresh default; a key the edit REMOVED is not re-added.
-So editing a component's state shape still loads cleanly instead of resurrecting a
-stale tree. Each restored key is one patch, so only the changed slots re-render.
-*/
-export function seedModelDoc(model: Doc, saved: unknown): void {
-    const current = model.snapshot()
-    if (
-        saved === null ||
-        typeof saved !== 'object' ||
-        current === null ||
-        typeof current !== 'object'
-    ) {
-        return
-    }
-    for (const key of Object.keys(saved)) {
-        if (key in current) {
-            model.replace(key, (saved as Record<string, unknown>)[key])
-        }
-    }
-}

package/src/lib/ui/runtime/types/HotInstance.ts

@@ -1,22 +0,0 @@
-import type { Doc } from './Doc.ts'
-import type { UiComponent } from './UiComponent.ts'
-
-/*
-A live component instance the hot-reload registry tracks: the `start`/`end` markers
-bounding its DOM range (the wrapper-free mount, see `mountRange`), its `label` (the
-scope name), the factory that built it, the props (thunks re-read on a swap so the
-parent's live state still flows through), the disposer for its current scope + DOM,
-and its own `model` document (`undefined` when the component has no `state`) —
-snapshotted before a swap and re-seeded after, so the user's in-progress state
-survives the edit. A swap re-fills the SAME range and mutates `factory`/`dispose`/
-`model` in place (see `hotReplace`).
-*/
-export type HotInstance = {
-    start: Comment
-    end: Comment
-    label: string | undefined
-    factory: UiComponent
-    props: Parameters<UiComponent>[1]
-    dispose: () => void
-    model: Doc | undefined
-}

package/src/lib/ui/runtime/types/PatchEvent.ts

@@ -1,16 +0,0 @@
-import type { Doc } from './Doc.ts'
-import type { Patch } from './Patch.ts'
-
-/*
-A single applied change announced on the `PATCH_BUS`: the `doc` it hit (reference
-identity within the process — a serialization-stable id arrives with sync), the
-forward `patch`, and its `inverse` — the patch that exactly undoes it, or
-`undefined` for a no-op (e.g. removing an absent key). Consumers — undo history,
-persistence, sync — read this one shape; the inverse is what makes a journal
-reversible at O(size of the change), never a retained tree snapshot.
-*/
-export type PatchEvent = {
-    doc: Doc
-    patch: Patch
-    inverse: Patch | undefined
-}

package/src/lib/ui/seedResolved.ts

@@ -1,28 +0,0 @@
-import { RESUME } from './runtime/RESUME.ts'
-import { seedStreamedResolution } from './seedStreamedResolution.ts'
-import type { ResolvedFrame } from './types/ResolvedFrame.ts'
-
-/*
-The single client intake seam for SSR warm-state seeding. Both warm-seed channels —
-the cache-snapshot channel (a settled `cache()` value, keyed by cache key) and the
-await-resume channel (an `await`-block resolved value, keyed by boundary id) — answer
-the same "ship a server-settled value so hydration doesn't re-fetch" question, but land
-in two distinct stores: the cache STORE (read by `cache()`) and the RESUME MANIFEST
-(read by `awaitBlock` on adopt). This routes a discriminated `ResolvedFrame` to the
-matching store so every consumer — startClient's boot drain, the live `__abideResolve`,
-applyResolved's stream swap — registers through ONE call instead of poking each store
-inline. The codecs stay split by source: the cache value is an HTTP body capped at plain
-JSON (it must agree with the live `decodeResponse` read), the resume value is an in-process
-graph carried as ref-json text and decoded lazily at the read site.
-*/
-// @documentation plumbing
-export function seedResolved(frame: ResolvedFrame): void {
-    if (frame.kind === 'cache') {
-        seedStreamedResolution(frame.resolution)
-        return
-    }
-    /* The resume value rides as raw ref-json text; store it unparsed so the inline
-       stream-swap script (vanilla, runs before the bundle's codec loads) can register
-       through this same seam. `awaitBlock` decodes it at the read. */
-    RESUME[frame.id] = frame.resume
-}

package/src/lib/ui/sync.ts

@@ -1,48 +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 { SyncTransport } from './types/SyncTransport.ts'
-
-/*
-Shares a document's state across peers in real time. Two directions over one
-`transport`, both riding the patch bus:
-  - OUTBOUND: every local patch to `doc` is published (`transport.send`);
-  - INBOUND: every peer patch is applied to `doc`.
-An inbound apply emits on the bus like any change, so an `applying` guard stops it
-being echoed straight back — the thing that would otherwise ping-pong forever. The
-transport itself should not deliver a sender its own patch either; together the two
-guards keep a write to a path from looping. Last-write-wins by arrival order;
-edits to *different* paths never conflict, by construction of the doc's wake. A
-late joiner needs a snapshot seed before live patches (a transport concern, out of
-this core). Returns a disposer.
-*/
-// @documentation plumbing
-export function sync(doc: Doc, transport: SyncTransport): () => void {
-    /* The specific inbound patches currently being applied — their own bus echo must not be
-       re-sent. Tracked by IDENTITY (not a blanket `applying` flag): `doc.apply` emits the
-       patch on the bus inside its batch, then flushes effects on batch exit while still
-       synchronously inside this apply. A local effect that writes the doc in reaction emits
-       a DIFFERENT patch during that flush — a genuine new local change peers need — which a
-       blanket flag would wrongly suppress, diverging peers permanently. */
-    const applyingPatches = new Set<Patch>()
-
-    const unsubscribeInbound = transport.subscribe((patch) => {
-        applyingPatches.add(patch)
-        try {
-            doc.apply(patch)
-        } finally {
-            applyingPatches.delete(patch)
-        }
-    })
-
-    const unsubscribeBus = PATCH_BUS.subscribe((event) => {
-        if (event.doc === doc && !applyingPatches.has(event.patch)) {
-            transport.send(event.patch)
-        }
-    })
-
-    return () => {
-        unsubscribeBus()
-        unsubscribeInbound()
-    }
-}

package/src/lib/ui/types/History.ts

@@ -1,14 +0,0 @@
-/*
-The undo/redo handle returned by `history(doc)`. `undo`/`redo` step the journal
-of inverse patches; `canUndo`/`canRedo` report availability; `transaction` groups
-a burst of patches into one reversible step (one user action = one undo); `dispose`
-detaches from the `PATCH_BUS` and drops the journal.
-*/
-export type History = {
-    undo: () => void
-    redo: () => void
-    canUndo: () => boolean
-    canRedo: () => boolean
-    transaction: (run: () => void) => void
-    dispose: () => void
-}

package/src/lib/ui/types/PersistHandle.ts

@@ -1,11 +0,0 @@
-/*
-The handle returned by `persist(doc, key)`. `flush` writes the pending snapshot
-immediately (the debounced writer otherwise coalesces a burst); `clear` removes
-the stored snapshot; `dispose` stops persisting (unsubscribes, drops listeners).
-On the server or a store-less browser, every method is a no-op.
-*/
-export type PersistHandle = {
-    flush: () => void
-    clear: () => void
-    dispose: () => void
-}

package/src/lib/ui/types/PersistenceStore.ts

@@ -1,12 +0,0 @@
-/*
-The durable backend `persist` writes a document snapshot to. Deliberately tiny
-and synchronous — `load` must return the saved value in time to seed the doc
-before first render, which a sync store (localStorage) gives for free. Inject a
-custom one for a different backend (a test memory store; a server data-dir store);
-an async backend (IndexedDB) needs an async-boot wrapper, out of this contract.
-*/
-export type PersistenceStore = {
-    load: (key: string) => unknown
-    save: (key: string, snapshot: unknown) => void
-    remove: (key: string) => void
-}

package/src/lib/ui/types/ResolvedFrame.ts

@@ -1,15 +0,0 @@
-import type { StreamedResolution } from '../../shared/types/StreamedResolution.ts'
-
-/*
-A warm-state-seed frame for the single client intake (`seedResolved`), discriminated by
-`kind`. Both kinds ship a server-settled value so hydration adopts without a re-fetch,
-but route to distinct stores:
-  - `cache`  — a `StreamedResolution` for the cache store, read by a warm `cache()` call.
-  - `resume` — an `await`-block boundary id plus its ref-json-encoded value STRING for the
-               RESUME manifest, decoded lazily by `awaitBlock` when it adopts the branch.
-The payloads stay distinct (cache snapshot vs boundary-keyed value); the unified thing is
-the intake seam, not the payload.
-*/
-export type ResolvedFrame =
-    | { kind: 'cache'; resolution: StreamedResolution }
-    | { kind: 'resume'; id: number; resume: string }

package/src/lib/ui/types/SyncTransport.ts

@@ -1,13 +0,0 @@
-import type { Patch } from '../runtime/types/Patch.ts'
-
-/*
-The bidirectional channel `sync` rides: `send` publishes a local patch to peers,
-`subscribe` delivers patches from peers (returning an unsubscribe). Deliberately
-minimal and patch-shaped — an app adapts it to a `socket` (publish ⇒ `send`, the
-socket's frames ⇒ `subscribe`), and a test adapts it to an in-memory hub. A patch
-is already the serializable wire unit, so nothing else is needed.
-*/
-export type SyncTransport = {
-    send: (patch: Patch) => void
-    subscribe: (onPatch: (patch: Patch) => void) => () => void
-}