@abide/abide 0.57.1 → 0.100.0

package/src/lib/shared/streamedCellsSlot.ts

@@ -1,14 +0,0 @@
-import { createResolverSlot } from './createResolverSlot.ts'
-import type { StreamedCells } from './types/StreamedCells.ts'
-
-/*
-The active streamed-cells slot — mirrors `resolvedCellsSlot`/`pendingAsyncCellsSlot`. The server
-entry installs an ALS-backed resolver (a fresh list per request, so concurrent SSR renders never
-mix their streamed values); with no resolver a single fallback list is created lazily so isolated
-tests work without booting the runtime. `createAsyncCell` pushes a `{ key, promise }` when a
-STREAMING cell constructs server-side; the page renderer drains it during the stream, awaiting each
-promise and streaming an `__abideResolve({ cellKey, value })` chunk (ADR-0035).
-*/
-export const streamedCellsSlot = createResolverSlot<StreamedCells>(() => ({
-    entries: [],
-}))

package/src/lib/shared/stripImport.ts

@@ -1,29 +0,0 @@
-import { escapeRegex } from './escapeRegex.ts'
-
-/*
-Strips the user's `import { … } from '<moduleName>'` declaration from a
-module source. Used by the $rpc / $sockets rewriters to remove the
-rpc / `socket` import after its call site has been replaced by the
-runtime-injected binding (defineRpc / defineSocket). Without this
-strip the dead import would still side-effect-load the rpc/socket
-helper module into the server bundle for every $rpc / $sockets file.
-
-The braced body is `[^}]*` rather than `[\s\S]*?` so the lazy match
-can't backtrack across a `}` and accidentally swallow a preceding
-import whose `from` clause doesn't match (e.g. stripping
-`import { GET } from '@abide/abide/server/GET'` from a file that also has
-`import { json } from '@abide/abide/server/json'` on the line above). `[^}]`
-includes newlines, so multi-line braced imports like
-  import {
-    GET,
-  } from '@abide/abide/server/GET'
-still match — the body just can't contain another `}` to bound it.
-*/
-export function stripImport(source: string, moduleName: string): string {
-    const escaped = escapeRegex(moduleName)
-    const pattern = new RegExp(
-        `^\\s*import\\s*\\{[^}]*\\}\\s*from\\s*['"]${escaped}['"]\\s*;?\\s*$`,
-        'gm',
-    )
-    return source.replace(pattern, '')
-}

package/src/lib/shared/subscribableFromResponse.ts

@@ -1,51 +0,0 @@
-import { streamResponse } from './streamResponse.ts'
-import type { NamedAsyncIterable } from './types/NamedAsyncIterable.ts'
-
-/*
-Builds the NamedAsyncIterable returned by `fn.stream(args)`. The carried
-`name` is the cache-style key for (method, url, args) so tail()
-dedupes multiple readers of identical args into one underlying
-fetch. The fetch is deferred until the first iterator pull so
-constructing the NamedAsyncIterable (which happens on every $derived
-re-evaluation) doesn't open a connection — tail()'s registry
-short-circuits the second instance before it iterates.
-*/
-export function subscribableFromResponse<T>(
-    name: string,
-    fetchResponse: () => Promise<Response>,
-): NamedAsyncIterable<T> {
-    return {
-        name,
-        [Symbol.asyncIterator]() {
-            let inner: AsyncIterator<T, void, undefined> | undefined
-            let cancelled = false
-            return {
-                async next() {
-                    if (cancelled) {
-                        return { value: undefined, done: true }
-                    }
-                    if (!inner) {
-                        const response = await fetchResponse()
-                        inner = streamResponse<T>(response)[Symbol.asyncIterator]()
-                        /*
-                        If return() landed while we were awaiting the
-                        fetch, `inner` was still undefined then so its
-                        reader was never cancelled — release the body now
-                        rather than leaving the HTTP stream open.
-                        */
-                        if (cancelled) {
-                            await inner.return?.(undefined)
-                            return { value: undefined, done: true }
-                        }
-                    }
-                    return inner.next()
-                },
-                async return() {
-                    cancelled = true
-                    await inner?.return?.(undefined)
-                    return { value: undefined, done: true }
-                },
-            }
-        },
-    }
-}

package/src/lib/shared/subscribableProbes.ts

@@ -1,111 +0,0 @@
-import { createLifecycleChannel } from './createLifecycleChannel.ts'
-import { tailProbeSlot } from './tailProbeSlot.ts'
-
-type StreamStatus = 'pending' | 'open' | 'done' | 'error'
-
-/* One registered consumption of a named subscribable — the stream-side analog of a
-   cache-store entry. Populated by the consume path (cache.on / watch(socket)), read
-   by the pending()/refreshing()/done()/error() probes. No window/value here: the
-   value flows through the consumer (watch handler / for-await), the registry only
-   holds probe state. */
-type StreamEntry = {
-    source: string
-    status: StreamStatus
-    refreshing: boolean
-    error: Error | undefined
-    /* Reconnect only counts as refreshing once a value has been seen (probe contract:
-       value held, fresher source in flight — never a first-ever open). */
-    everFramed: boolean
-}
-
-const registry = new Set<StreamEntry>()
-
-/*
-Registry-wide lifecycle channel for the subscribable probes — the stream-side
-counterpart of the cache store's. Probes match entries by source name (or all)
-without creating them, so they tap one "membership or state changed" signal and
-re-derive by scanning.
-*/
-const lifecycle = createLifecycleChannel()
-
-/*
-Installs the prober the shared probes call for a NamedAsyncIterable (probeRegistries →
-tailProbeSlot). Register-on-consume: an entry exists only while something is
-consuming the stream, exactly as a cache entry exists only while a call is
-retained. A name with no entry reads as "no value yet" (pending) without opening
-anything — probes report, never act. This install replaces tail()'s: the registrar
-moved from the (removed) tail() reader to the consume path.
-*/
-tailProbeSlot.probe = (name) => {
-    lifecycle.track()
-    const entries = [...registry].filter((entry) => name === undefined || entry.source === name)
-    return {
-        pending:
-            (name !== undefined && entries.length === 0) ||
-            entries.some((entry) => entry.status === 'pending'),
-        refreshing: entries.some((entry) => entry.refreshing),
-        /* Terminal only when there is at least one entry and all of them have closed. */
-        done: entries.length > 0 && entries.every((entry) => entry.status === 'done'),
-        error: entries.find((entry) => entry.error !== undefined)?.error,
-    }
-}
-
-export type StreamProbe = {
-    frame(): void
-    reconnecting(): void
-    done(): void
-    errored(error: Error): void
-    close(): void
-}
-
-/*
-Opens a probe entry for a consumed named subscribable and returns the handle the
-consume loop drives: `frame()` on each delivered value (pending → open), plus the
-terminal/lifecycle transitions. `close()` evicts on teardown. Reactivity is the
-registry lifecycle channel, marked on every transition.
-*/
-export function openStreamProbe(source: string): StreamProbe {
-    const entry: StreamEntry = {
-        source,
-        status: 'pending',
-        refreshing: false,
-        error: undefined,
-        everFramed: false,
-    }
-    registry.add(entry)
-    lifecycle.mark()
-    return {
-        frame() {
-            /* Only ping on a real transition (pending→open, or refreshing clearing) so a
-               chatty stream doesn't re-derive every bare probe reader on each value. */
-            const transitioned = entry.status !== 'open' || entry.refreshing
-            entry.status = 'open'
-            entry.refreshing = false
-            entry.everFramed = true
-            if (transitioned) {
-                lifecycle.mark()
-            }
-        },
-        reconnecting() {
-            entry.refreshing = entry.everFramed
-            lifecycle.mark()
-        },
-        done() {
-            if (entry.status !== 'error') {
-                entry.status = 'done'
-            }
-            entry.refreshing = false
-            lifecycle.mark()
-        },
-        errored(error: Error) {
-            entry.error = error
-            entry.status = 'error'
-            entry.refreshing = false
-            lifecycle.mark()
-        },
-        close() {
-            registry.delete(entry)
-            lifecycle.mark()
-        },
-    }
-}

package/src/lib/shared/tailProbeSlot.ts

@@ -1,23 +0,0 @@
-/*
-Internal slot the browser tail() registry registers its prober into, so the
-shared probes (pending / refreshing) can answer for NamedAsyncIterables without
-shared/ importing browser/. The prober taps the registry's lifecycle channel
-(reactive inside $derived / $effect) and reports one stream by source name —
-spanning its latest-wins and window entries — or, with no name, whether any
-registered stream matches. When no prober is registered (server render, or
-tail was never imported) the probes fall back to the same answers tail()
-itself gives on the server: a named stream has no value yet (pending true),
-and nothing is reconnecting (refreshing false).
-*/
-export const tailProbeSlot: {
-    probe:
-        | ((name?: string) => {
-              pending: boolean
-              refreshing: boolean
-              done: boolean
-              error: Error | undefined
-          })
-        | undefined
-} = {
-    probe: undefined,
-}

package/src/lib/shared/toTagSet.ts

@@ -1,4 +0,0 @@
-/* Normalizes a tags option to a Set for O(1) membership. */
-export function toTagSet(tags: string[]): Set<string> {
-    return new Set(tags)
-}

package/src/lib/shared/trace.ts

@@ -1,16 +0,0 @@
-import { formatTraceparent } from './formatTraceparent.ts'
-import { requestScopeSlot } from './requestScopeSlot.ts'
-
-/*
-The current request's W3C `traceparent`, or undefined outside any request
-scope (boot scripts, build, background work). Isomorphic: the server resolves
-it from the ALS request scope, the browser from the trace stamped into
-__SSR__ — so a client-side read returns the trace of the request that
-rendered the page. The string is propagation-ready: hand it to your own logs,
-error reports, or `propagation.extract` when attaching OpenTelemetry spans.
-*/
-// @documentation observability
-export function trace(): string | undefined {
-    const scope = requestScopeSlot.resolver?.()
-    return scope ? formatTraceparent(scope.trace) : undefined
-}

package/src/lib/shared/types/AmendApply.ts

@@ -1,15 +0,0 @@
-import type { CacheSelector } from './CacheSelector.ts'
-
-/*
-The side-swappable applier stored in amendBroadcastSlot (ADR-0043). Given a selector,
-its args, whether the payload is a concrete value (vs. an updater closure), and the
-payload itself, either apply it to this side's store (client / fallback) or broadcast
-the keyed value to every authorized reader (server). Only the value form is
-broadcastable; the server resolver throws on an updater (a closure has no wire form).
-*/
-export type AmendApply = <Args, Return>(
-    selector: CacheSelector<Args, Return>,
-    args: Args | undefined,
-    isValue: boolean,
-    payload: Return | ((current: Return) => Return),
-) => void

package/src/lib/shared/types/AsyncComputed.ts

@@ -1,20 +0,0 @@
-import type { ASYNC_CELL } from '../ASYNC_CELL.ts'
-
-/*
-A read-only async cell — what `computed(await …)` / `computed(getStream())` produce.
-It *tracks* an async source (a promise it unwrapped, or a NamedAsyncIterable whose
-frames it follows) rather than holding a value. Unlike sync `Computed<T>` it has NO
-`.value`; it is read through the probe family, always method-form — `peek()` (the
-retained value or latest frame, or `undefined`), `pending()` (no value yet),
-`refreshing()` (a value held while a fresher source is in flight), `error()` (the
-last rejection), `refresh()` (re-invoke the source). The standalone probes route
-here too: `peek(cell)` ≡ `cell.peek()`. Branded so those probes recognise it.
-*/
-export interface AsyncComputed<T> {
-    readonly [ASYNC_CELL]: true
-    peek(): T | undefined
-    pending(): boolean
-    refreshing(): boolean
-    error(): unknown
-    refresh(): void
-}

package/src/lib/shared/types/AsyncState.ts

@@ -1,13 +0,0 @@
-import type { AsyncComputed } from './AsyncComputed.ts'
-
-/*
-A writable async cell — what `linked(await …)` / `linked(getStream())` produce. Same
-probe surface as `AsyncComputed<T>` plus `set(value)`, following the normal `linked`
-write rule: a local write latches until the next *reseed* (a dependency change that
-produces a new source). An arriving frame or a settling promise updates the value only
-while unwritten, so a high-frequency stream never clobbers an in-progress edit; a
-reseed clears the write and snaps the cell back to the live source.
-*/
-export interface AsyncState<T> extends AsyncComputed<T> {
-    set(value: T): void
-}

package/src/lib/shared/types/CacheEntry.ts

@@ -1,100 +0,0 @@
-/*
-Stored shape per cache key. The stored promise resolves to the raw Response for
-a remote function (the snapshot reads its status/headers/body and the cache
-layer hands callers a decoded view derived from it) or to the producer's value
-for a plain producer — hence `Promise<unknown>`.
-
-`request` is retained for remote entries so SSR snapshot serialization can
-record the URL and method without re-deriving them from the function. Producer
-entries have no wire request, so it is absent — and the snapshot readers skip
-any entry lacking it (a producer value has no rpc identity to rehydrate against).
-
-`ttl`/`expiresAt` drive eviction: expiresAt = undefined means "no TTL" (lives
-forever); ttl = 0 means "dedupe only" (entry is pruned as soon as the promise
-settles).
-
-`value` is the decoded warm value served synchronously by the read path
-(cloned per read). It is set at hydration — the SSR snapshot body is
-pre-decoded so the first client render reads it without a microtask hop and
-byte-matches the SSR DOM. Live fetches leave it undefined and take the async
-decode path.
-
-`hydrated` marks an entry built from the SSR snapshot, which ships no wrap
-options — the first read consumes the flag and adopts its call site's `ttl`
-(omitted = forever, as shipped; ttl > 0 = expiry clock starts at that read;
-ttl = 0 = the warm value exists only to complete the hydration render and is
-evicted a macrotask later). Live entries never carry it; their ttl was fixed
-at registration.
-
-`tags` holds the cache() call's tags as a Set so
-`cache.invalidate({ tags })` can drop every entry sharing any tag with O(1)
-membership; a re-read merges new tags in rather than replacing them.
-
-`settled` flips true once the stored promise resolves. SSR snapshot
-serialization reads it after `render()` returns to partition entries: ones
-settled by then were consumed via `await` (render blocked on them) and inline
-into `__SSR__`; ones still pending were consumed via `{#await}` (render emitted
-the pending branch without blocking) and stream a resolve chunk instead.
-
-`refreshing` flips true while this entry is reloading data it already held —
-either a keep-stale refetch (stale value still visible) or the default
-drop-then-reload (the prior entry was invalidated and dropped, this is its
-replacement read). It backs refreshing(), distinguishing a reload from a
-first-ever load; cleared when the read settles.
-
-`invalidation` holds the entry's refetch policy: the refetch thunk (the call
-captured with its args) plus its optional throttle/debounce window and runtime
-timer state, so invalidate() keeps the stale value and revalidates this key —
-rate-limited by the window — instead of dropping the entry. Set at registration
-for a smart retained read (SWR unconditional for a replayable read — ADR-0020) or
-a producer declaring a throttle/debounce window, or attached by a later read on an
-entry that lacks it (hydrated snapshot entries always start without one) — first
-wins. An armed `timer` is cleared if the entry is evicted, so a dead key never
-refetches.
-*/
-export type CacheEntry = {
-    key: string
-    promise: Promise<unknown>
-    request?: Request
-    ttl: number | undefined
-    expiresAt: number | undefined
-    value?: unknown
-    tags?: Set<string>
-    settled?: boolean
-    hydrated?: boolean
-    refreshing?: boolean
-    invalidation?: InvalidationState
-    /*
-    Set by the smart bare call (a replayable read routed through cache.read): the
-    display value is retained unconditionally and `ttl` marks a staleness deadline
-    (the next read past it revalidates in the background, stale stays visible) rather
-    than driving the hard eviction an explicit cache() ttl triggers. Distinguishes the
-    smart-read lifecycle from the explicit cache()/invalidate old surface, which keeps
-    its drop-on-ttl / drop-on-invalidate behaviour.
-    */
-    retain?: boolean
-    /*
-    A retained failed load (negative cache — opt in with `errorTtl`). Holds a
-    pristine Response clone (re-served per read by cloning it, never consumed) or
-    the network Error, so reads within the window re-surface the same failure with
-    no network round-trip. `expiresAt` (armed via the ttl sweep) hard-evicts it when
-    the window elapses, so the next read retries. Unset on a successful entry; its
-    presence is what the read path checks to short-circuit to the retained error.
-    */
-    errorResult?: Response | Error
-}
-
-/* Per-key invalidate coalescing: the throttle/debounce policy plus the timer/in-flight state. */
-type InvalidationState = {
-    refetch: () => Promise<unknown>
-    throttle?: number
-    debounce?: number
-    lastFiredAt?: number
-    timer?: ReturnType<typeof setTimeout>
-    /*
-    An invalidation that arrived while a refetch was already in flight: fireRefetch
-    can't run concurrently, so it sets this flag and re-schedules once the
-    in-flight refetch settles, rather than dropping the newer invalidation.
-    */
-    pending?: boolean
-}

package/src/lib/shared/types/CacheInvalidation.ts

@@ -1,9 +0,0 @@
-/*
-Detail payload of the cache store's 'invalidate' event — the set of cache
-keys one invalidation touched. A Set so each subscriber's membership check
-is O(1) regardless of how many keys a single invalidate spans. Shared
-between the dispatcher (cache.invalidate) and the cache store's listener,
-so the event's shape has one definition instead of an inline cast repeated
-at every site.
-*/
-export type CacheInvalidation = Set<string>

package/src/lib/shared/types/CacheOnContext.ts

@@ -1,15 +0,0 @@
-import type { CacheSelector } from './CacheSelector.ts'
-
-/*
-Capabilities handed to a cache.on handler — exactly what behaves differently
-inside a binding. `invalidate` is the binding-scoped copy of cache.invalidate
-(same selector grammar, same effect): calls through it are recorded in the
-binding's coverage set by function identity, so attribution survives awaits
-and the coverage replays after a reconnect gap; the global cache.invalidate
-still works inside a handler but is not covered. `signal` aborts when the binding
-is disposed, so an async handler mid-flight can bail or cancel its own fetches.
-*/
-export type CacheOnContext = {
-    invalidate: <Args, Return>(arg?: CacheSelector<Args, Return>, args?: Args) => void
-    signal: AbortSignal
-}

package/src/lib/shared/types/CacheOptions.ts

@@ -1,53 +0,0 @@
-/*
-Options for the explicit `cache(producer, args, options?)` call over a plain
-producer, and the value-shape of an endpoint's `cache` policy (CachePolicy adds
-only the arg-derived `tags` function form on top). A remote rpc has no options
-argument any more — its policy lives on the definition (ADR-0020); this type is
-the producer's only policy home. The key is always auto-derived
-(producer-reference+args): hoist a producer to a stable reference to share its
-entry across calls.
-
-`ttl` is the milliseconds-past-resolve the entry stays live: 0 = dedupe only
-(entry dropped once the promise settles — in-flight coalescing and pending()
-visibility, nothing retained), any other number = TTL. Omitted = forever for a
-producer.
-
-`tags` is an array of free-form labels grouping unrelated calls so one
-`cache.invalidate({ tags })` drops every entry sharing any of them — list
-multiple when a call belongs to multiple invalidation groups. A unique tag (e.g.
-a uuid) shared by a set of calls gives them their own private invalidation group.
-
-`shared` opts the entry into the process-level store instead of the default
-request-scoped one (server) — a store that outlives every request. It selects
-the store only; it does NOT retain (pair it with `ttl` to memoise across
-requests). The shared store is keyed by producer-reference+args, never by user,
-so do not put per-user data in it — it would be served to other users. Omit
-`shared` for per-request data. Write only `shared: true`; there is no `false`
-form. On the client there is a single tab store, so the flag is a no-op there.
-
-`throttle`/`debounce` arm the keep-stale-and-revalidate refetch clock for a
-producer: with one set, a `cache.invalidate` hit keeps the stale value visible
-and coalesces a background refetch (leading-edge-then-coalesce, or
-fire-after-quiet respectively) instead of dropping the entry. Set one, not both.
-SWR is otherwise unconditional for replayable remote reads; there is no `swr`
-toggle.
-
-`errorTtl` opts a failed load into the negative cache: without it a failure
-evicts immediately so the next read retries (the default); with it, the failure
-is retained for that many ms — reads within the window re-surface the same
-rejection with no network round-trip, backing off a failing/rate-limited backend
-instead of hammering it — then hard-evicts so the next read retries. A function
-form receives the failed response's HTTP status (0 for a network-level fault with
-no response) and returns a per-status window, or `undefined` to fall back to the
-immediate-retry default for that status (e.g. back off a 429/503, retry a 500 at
-once). A `Retry-After` header on the response overrides the number as the
-authoritative delay. Off (evict-and-retry) when unset.
-*/
-export type CacheOptions = {
-    ttl?: number
-    tags?: string[]
-    shared?: boolean
-    throttle?: number
-    debounce?: number
-    errorTtl?: number | ((status: number) => number | undefined)
-}

package/src/lib/shared/types/CachePolicy.ts

@@ -1,31 +0,0 @@
-/*
-Endpoint cache policy, declared once on the rpc definition (ADR-0020). Same value
-shape as the producer-side `CacheOptions` (`ttl` / `tags` / `throttle` / `debounce`
-/ `shared` / `errorTtl`, no `swr` — SWR is unconditional for replayable reads),
-except `tags` also accepts an arg-derived function so the group can vary by call.
-That makes the type generic over the rpc's `Args`: `(args) => ['rates:' + args.base]`
-is typed against the endpoint's own argument shape.
-
-- `ttl` — retention/staleness in ms. Default Infinity: the entry is retained for its
-  store's lifetime — the request on the server (a non-shared read dies with the request,
-  regardless of ttl), the tab on the client (until invalidate/refresh). An explicit ttl
-  is a hard expiry on the server, a staleness deadline (SWR) on the client.
-- `tags` — static invalidation-group labels, or a function of the call's args.
-- `throttle` / `debounce` — the background refetch clock (set one, not both).
-- `shared` — opt the entry into the process-level store (never per-user data — the store
-  is keyed by method+url+args, not by user). With the default Infinity ttl this memoises
-  across requests; an explicit ttl bounds it. A client no-op (one tab store).
-- `errorTtl` — negative-cache window in ms: retain a failed load for that long (reads
-  within it re-surface the rejection with no network) instead of the default
-  evict-and-retry, then hard-evict. A function of the failed status (0 = network fault)
-  returns a per-status window or `undefined` to keep the immediate-retry default for that
-  status; a `Retry-After` header overrides the number. Off when unset.
-*/
-export type CachePolicy<Args> = {
-    ttl?: number
-    tags?: string[] | ((args: Args) => string[])
-    throttle?: number
-    debounce?: number
-    shared?: boolean
-    errorTtl?: number | ((status: number) => number | undefined)
-}

package/src/lib/shared/types/CacheReaderHook.ts

@@ -1,11 +0,0 @@
-/*
-The client-installed reactive-reader lifecycle hook stored in cacheReaderSocketSlot
-(ADR-0043). The cache store calls engage(key) when a key gains its first live reader
-and disengage(key) when it loses its last, so the client can open/close a per-key
-amend value subscription whose lifetime tracks "a reader is holding this key on
-screen". Inert (slot unresolved) on the server and in isolated unit tests.
-*/
-export interface CacheReaderHook {
-    engage(key: string): void
-    disengage(key: string): void
-}

package/src/lib/shared/types/CacheSelector.ts

@@ -1,17 +0,0 @@
-import type { CacheOptions } from './CacheOptions.ts'
-import type { RawRemoteFunction } from './RawRemoteFunction.ts'
-import type { RemoteFunction } from './RemoteFunction.ts'
-
-/*
-Selector grammar shared by cache.invalidate(), pending(), and refreshing():
-  undefined   → every entry
-  remote fn   → that function's calls (method+url prefix); fn and fn.raw match
-                the same set since they share wire identity
-  producer fn → that producer's calls (reference-id prefix)
-  { tags }    → any entry sharing one of the requested tags
-*/
-export type CacheSelector<Args, Return> =
-    | RemoteFunction<Args, Return>
-    | RawRemoteFunction<Args>
-    | ((args?: Args) => Promise<Return>)
-    | Pick<CacheOptions, 'tags'>

package/src/lib/shared/types/CacheSnapshotEntry.ts

@@ -1,32 +0,0 @@
-import type { HttpMethod } from './HttpMethod.ts'
-
-/*
-Wire format for a single cached response shipped from SSR to client hydration.
-Any entry called inline during render (any method) with a textual Content-Type is
-emitted, so the client hydrates warm instead of re-firing the call after render;
-binary bodies don't survive a JSON round-trip. The seeded value is read warm once
-— it is never auto-replayed (that stays GET-only, see REPLAYABLE_METHODS).
-
-The body travels in ONE of two shapes, never both (ADR-0051): a json-kind body
-ships PARSED as `data` — a live JSON value nested directly in the payload — so the
-whole snapshot serialises once (the payload's own `JSON.stringify`) instead of the
-body being pre-serialised to a string and then re-escaped as a nested string
-literal (the double-encoding that ~2.35×'d the wire and forced the client to parse
-the body a second time). A text-kind body — or a json body the server couldn't
-parse — ships raw as `body`. The client re-derives which from the presence of
-`data` (`cacheEntryFromSnapshot`).
-*/
-export type CacheSnapshotEntry = {
-    key: string
-    url: string
-    method: HttpMethod
-    status: number
-    statusText: string
-    headers: Array<[string, string]>
-    /* Raw body text — present for a text-kind body, or a json body that failed to parse
-       server-side (shipped raw, decoded async client-side as before). Absent when `data` is. */
-    body?: string
-    /* Pre-parsed json-kind body, single-encoded. Present iff the body was json and parsed;
-       `'data' in entry` is the discriminator (a `null` json body still keys present). */
-    data?: unknown
-}

package/src/lib/shared/types/CacheStalenessApply.ts

@@ -1,13 +0,0 @@
-import type { CacheSelector } from './CacheSelector.ts'
-
-/*
-The side-swappable staleness applier stored in cacheStalenessSlot (ADR-0041): given
-a verb and a (non-async-cell) selector, either apply it locally (client / fallback)
-or broadcast it (server). The async-cell short-circuit is handled in invalidate() /
-refresh() before the slot, so this only ever sees a real CacheSelector.
-*/
-export type CacheStalenessApply = <Args, Return>(
-    op: 'invalidate' | 'refresh',
-    selector: CacheSelector<Args, Return>,
-    args?: Args,
-) => void

package/src/lib/shared/types/CacheStalenessFrame.ts

@@ -1,24 +0,0 @@
-/*
-The on-wire envelope for a cross-client staleness signal (ADR-0041). A single
-monomorphic shape — every field always present so the JIT keeps it a stable
-hidden class — carried as the `message` of a standard socket frame on the
-reserved `__abide/cache` topic.
-
-  op    — which local verb each subscriber runs: drop (`invalidate`) or refetch
-          (`refresh`).
-  mode  — how `match`/`tags` select entries, mapping 1:1 onto selectorMatcher's
-          three real branches: an exact call key, a fn key prefix, or a tag set.
-  match — the exact cache key (`mode: 'key'`), the key prefix (`mode: 'prefix'`),
-          or `''` (`mode: 'tags'`, unused).
-  tags  — the requested tag list (`mode: 'tags'`), or `[]` otherwise.
-
-Producer/closure selectors and the bare match-all form are NOT expressible here
-— they are rejected at encode time (serializeSelector), so this envelope only
-ever carries a cross-client-stable selector.
-*/
-export interface CacheStalenessFrame {
-    op: 'invalidate' | 'refresh'
-    mode: 'key' | 'prefix' | 'tags'
-    match: string
-    tags: string[]
-}

package/src/lib/shared/types/CacheStats.ts

@@ -1,13 +0,0 @@
-/*
-Per-store cache read tallies, frozen into the request's closing log record at
-settle. hit = a read served from a settled retained entry (including the warm
-SSR sync path); coalesced = a read that joined an in-flight call; miss = a
-read that invoked its producer/remote. Reads against the process-level shared
-store count into the requesting scope's store, so a request's record reflects
-everything that request asked the cache for.
-*/
-export type CacheStats = {
-    hits: number
-    misses: number
-    coalesced: number
-}