@abide/abide 0.48.0 → 0.50.0

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