@abide/abide 0.58.0 → 0.100.0

package/src/lib/shared/matchRoute.ts

@@ -1,165 +0,0 @@
-import { lenientDecode } from './lenientDecode.ts'
-import { normalizePathname } from './normalizePathname.ts'
-import type { RouteSegment } from './parseRouteSegments.ts'
-import { parseRouteSegments } from './parseRouteSegments.ts'
-
-/*
-Per-route parse cache. The route set is stable across a session, so parsing a
-pattern into segments is done once per route rather than on every match. Keyed
-by the pattern string; entries never need eviction since routes don't churn.
-*/
-const PARSED_ROUTES = new Map<string, RouteSegment[]>()
-
-function parsedRoute(route: string): RouteSegment[] {
-    let segments = PARSED_ROUTES.get(route)
-    if (segments === undefined) {
-        segments = parseRouteSegments(route)
-        PARSED_ROUTES.set(route, segments)
-    }
-    return segments
-}
-
-/* One pattern segment's specificity rank — lower is more specific. */
-function segmentRank(segment: RouteSegment): number {
-    if (segment.kind === 'literal') {
-        return 0
-    }
-    if (segment.catchAll) {
-        return 3
-    }
-    return segment.optional ? 2 : 1
-}
-
-/* Positional specificity between two routes that both match a path: walk both
-   patterns left to right, and at the first position where the segment kinds
-   differ the more specific kind wins — literal > `[name]` > `[[name]]` >
-   `[...rest]`. So `/a/[b]` beats `/[a]/b`, and a literal head beats a param
-   head even against a catch-all tail (matching how Bun's own router ranked).
-   Prefix-equal patterns: the shorter one is the exact match. A full tie keeps
-   the earlier-registered route — deterministic, unlike count-based scoring,
-   because kind sequences that differ anywhere are ordered at that position. */
-function moreSpecific(candidate: RouteSegment[], best: RouteSegment[]): boolean {
-    const shared = Math.min(candidate.length, best.length)
-    for (let index = 0; index < shared; index += 1) {
-        const candidateRank = segmentRank(candidate[index] as RouteSegment)
-        const bestRank = segmentRank(best[index] as RouteSegment)
-        if (candidateRank !== bestRank) {
-            return candidateRank < bestRank
-        }
-    }
-    return candidate.length < best.length
-}
-
-/*
-The route matcher — the single grammar of record on both sides: the server's
-fetch dispatch and the client router resolve a pathname through this same
-function, so params decode and precedence agree by construction. Given the
-registered route patterns and a pathname, returns the matching route + decoded
-params, or undefined. Segments are literal / `[name]` / `[[name]]` (optional) /
-`[...rest]` (catch-all), via the shared `parseRouteSegments`. The most specific
-match wins (see moreSpecific).
-*/
-export function matchRoute(
-    routes: string[],
-    pathname: string,
-): { route: string; params: Record<string, string> } | undefined {
-    /* Match the canonical slash form — `//users` and `/users/` both match
-       `/users` — otherwise the extra empty segment rejects the path or lets
-       `/users/[id]` capture an empty id. The server redirects a request whose
-       raw pathname differs from this form before dispatching (see createServer),
-       so its auth middleware guards the same string this matcher routes. */
-    const normalized = normalizePathname(pathname)
-    const pathSegments = normalized.split('/')
-    let best: { route: string; params: Record<string, string>; parsed: RouteSegment[] } | undefined
-    for (const route of routes) {
-        const parsed = parsedRoute(route)
-        const params = matchSegments(parsed, pathSegments)
-        if (params === undefined) {
-            continue
-        }
-        if (best === undefined || moreSpecific(parsed, best.parsed)) {
-            best = { route, params, parsed }
-        }
-    }
-    return best === undefined ? undefined : { route: best.route, params: best.params }
-}
-
-/* Matches one parsed pattern against the path's segments, capturing decoded
-   params; undefined on mismatch. */
-function matchSegments(
-    segments: RouteSegment[],
-    pathSegments: string[],
-): Record<string, string> | undefined {
-    const params: Record<string, string> = {}
-    return matchFrom(segments, pathSegments, 0, 0, params) ? params : undefined
-}
-
-/*
-Depth-first walk over the pattern. An optional segment first tries to consume a
-path segment (greedy — `/[[a]]/[[b]]` on `/x` captures `a`), and on a deeper
-mismatch backtracks to try absence, un-capturing its param so a failed branch
-can't leak into the succeeding one. Recursion depth is bounded by the pattern's
-segment count, not the request path. A catch-all consumes every remaining
-segment (possibly none), decoding each sub-segment while keeping `/` separators
-— so an encoded `%2F` stays inside one sub-segment.
-*/
-function matchFrom(
-    segments: RouteSegment[],
-    pathSegments: string[],
-    segmentIndex: number,
-    pathIndex: number,
-    params: Record<string, string>,
-): boolean {
-    if (segmentIndex === segments.length) {
-        /* Pattern exhausted — the path must be too (no extra segments). */
-        return pathIndex === pathSegments.length
-    }
-    const segment = segments[segmentIndex]
-    if (segment === undefined) {
-        return false
-    }
-    if (segment.kind === 'param' && segment.catchAll) {
-        params[segment.name] = pathSegments.slice(pathIndex).map(lenientDecode).join('/')
-        return true
-    }
-    const value = pathSegments[pathIndex]
-    if (segment.kind === 'literal') {
-        if (value !== segment.value) {
-            return false
-        }
-        return matchFrom(segments, pathSegments, segmentIndex + 1, pathIndex + 1, params)
-    }
-    if (segment.optional) {
-        /* Consume first; on failure restore the prior capture (a same-named
-           earlier `[name]` must survive the backtrack) and retry as absent. An
-           optional never captures an empty segment. */
-        if (value !== undefined && value !== '') {
-            const previous = params[segment.name]
-            params[segment.name] = lenientDecode(value)
-            if (matchFrom(segments, pathSegments, segmentIndex + 1, pathIndex + 1, params)) {
-                return true
-            }
-            if (previous === undefined) {
-                delete params[segment.name]
-            } else {
-                params[segment.name] = previous
-            }
-        }
-        if (matchFrom(segments, pathSegments, segmentIndex + 1, pathIndex, params)) {
-            return true
-        }
-        /* Absent at the bare root: `/` splits into ['', ''] and slash collapsing
-           can't remove that dangling empty segment, so an absent optional also
-           swallows it — `/[[lang]]` must match `/` (the path url() generates). */
-        if (value === '') {
-            return matchFrom(segments, pathSegments, segmentIndex + 1, pathIndex + 1, params)
-        }
-        return false
-    }
-    /* A required `[name]` param never captures an empty segment (e.g. `/users//5`). */
-    if (value === undefined || value === '') {
-        return false
-    }
-    params[segment.name] = lenientDecode(value)
-    return matchFrom(segments, pathSegments, segmentIndex + 1, pathIndex + 1, params)
-}

package/src/lib/shared/matcherFromEnvelope.ts

@@ -1,31 +0,0 @@
-import { keyMatchesPrefix } from './keyMatchesPrefix.ts'
-import { setsIntersect } from './setsIntersect.ts'
-import { toTagSet } from './toTagSet.ts'
-import type { CacheEntry } from './types/CacheEntry.ts'
-import type { CacheStalenessFrame } from './types/CacheStalenessFrame.ts'
-
-/*
-Rebuilds the entry predicate from a decoded staleness envelope (ADR-0041) — the
-decode half of serializeSelector, driving the SAME store loop a local apply does
-(cache.invalidateMatching / cache.refreshMatching). The three modes are
-selectorMatcher's three real branches with the `args !== undefined` discriminant
-replaced by the explicit `mode`, reusing keyMatchesPrefix/toTagSet so a decoded
-predicate can't disagree with what a local selector would have matched:
-
-  key    → exactly that call's entry (args already the canonical string the read
-           path keyed with, so it re-matches by equality — no ref-json codec crosses)
-  prefix → every args-variant of that fn (method+url prefix)
-  tags   → any entry sharing one of the requested tags
-*/
-export function matcherFromEnvelope(frame: CacheStalenessFrame): (entry: CacheEntry) => boolean {
-    if (frame.mode === 'key') {
-        const key = frame.match
-        return (entry) => entry.key === key
-    }
-    if (frame.mode === 'prefix') {
-        const prefix = frame.match
-        return (entry) => keyMatchesPrefix(entry.key, prefix)
-    }
-    const requestedTags = toTagSet(frame.tags)
-    return (entry) => entry.tags !== undefined && setsIntersect(requestedTags, entry.tags)
-}

package/src/lib/shared/memoizeByKey.ts

@@ -1,32 +0,0 @@
-/*
-Memoises an async loader keyed by string: the first call for a key starts the
-load and caches its promise; later calls reuse it. `load` returns undefined when
-the key has no loader, which is passed through (and not cached) so the caller can
-treat "unknown key" distinctly from "loaded value". Used by the rpc-module and
-socket-module load caches, which share this exact shape.
-*/
-export function memoizeByKey<T>(
-    load: (key: string) => Promise<T> | undefined,
-): (key: string) => Promise<T> | undefined {
-    const cache = new Map<string, Promise<T>>()
-    return (key) => {
-        const existing = cache.get(key)
-        if (existing) {
-            return existing
-        }
-        const started = load(key)
-        if (!started) {
-            return undefined
-        }
-        cache.set(key, started)
-        // Evict on rejection so a transient load failure doesn't poison the key
-        // forever; the next call retries. The separate handle doesn't swallow the
-        // rejection seen by the returned promise.
-        void started.catch(() => {
-            if (cache.get(key) === started) {
-                cache.delete(key)
-            }
-        })
-        return started
-    }
-}

package/src/lib/shared/messageFromError.ts

@@ -1,6 +0,0 @@
-/* A thrown value's human message: an Error's `.message`, otherwise the value
-   coerced to a string. The one place the "how a non-Error surfaces to users"
-   rule lives, instead of inlining `x instanceof Error ? x.message : String(x)`. */
-export function messageFromError(error: unknown): string {
-    return error instanceof Error ? error.message : String(error)
-}

package/src/lib/shared/normalizePathname.ts

@@ -1,11 +0,0 @@
-/*
-The canonical slash form of a pathname: duplicate slashes collapsed, one
-trailing slash stripped (except root) — so `//users/` canonicalizes to
-`/users`. matchRoute matches this form on both sides, and the server 308s a
-page request whose raw pathname differs (see createServer), so the app.handle
-auth seam always guards exactly the string the matcher routes.
-*/
-export function normalizePathname(pathname: string): string {
-    const collapsed = pathname.includes('//') ? pathname.replace(/\/{2,}/g, '/') : pathname
-    return collapsed.length > 1 && collapsed.endsWith('/') ? collapsed.slice(0, -1) : collapsed
-}

package/src/lib/shared/normalizeTarget.ts

@@ -1,10 +0,0 @@
-import type { CompileTarget } from './types/CompileTarget.ts'
-
-/*
-Prepends the `bun-` prefix if missing so CLI users can pass either
-`darwin-arm64` or the canonical `bun-darwin-arm64` form to `--target`.
-*/
-export function normalizeTarget(input: string): CompileTarget {
-    const normalized = input.startsWith('bun-') ? input : `bun-${input}`
-    return normalized as CompileTarget
-}

package/src/lib/shared/online.ts

@@ -1,51 +0,0 @@
-import { createSubscriber } from './createSubscriber.ts'
-import { requestScopeSlot } from './requestScopeSlot.ts'
-
-/*
-Reactive network-connectivity probe in the pending()/refreshing() family:
-reading it from a scope().computed() / scope().effect() re-runs that scope when the browser's
-online/offline events fire. navigator.onLine's *offline* signal is reliable
-(a true network loss always reports); its online value can false-positive
-behind captive portals — verified backend reachability is a separate,
-opt-in concern (the bundle launcher's liveness watch owns it for bundles).
-
-On the server it reflects the *calling client's* reported connectivity — the
-OFFLINE_HEADER a abide RPC fetch stamps while offline (read off the request
-scope). In a bundle the client and embedded server share a machine, so this is
-exactly the outbound reachability a handler reaching external sites needs:
-`if (!online()) return error(503)` skips a doomed fetch. True outside any
-request scope (boot, cron) and for non-abide-client requests (no header).
-
-It answers "did the calling client report itself offline," NOT "can this
-server reach the internet." So during SSR it is always true: the initial
-render is a browser document navigation abide didn't issue, carrying no
-header — there's been no client round-trip to report connectivity yet. Gate
-external fetches on online() in the RPC/handler path (a real client called),
-not in SSR; in SSR bound the fetch with AbortSignal.timeout instead, or defer
-the read to the hydrated client where navigator.onLine is live. Bundles feel
-this most — localhost serves the SSR even with the machine offline.
-
-Reports, never acts — reading this opens no fetch and no stream.
-*/
-const subscribeOnline =
-    typeof window === 'undefined'
-        ? undefined
-        : createSubscriber((update) => {
-              const changed = () => update()
-              window.addEventListener('online', changed)
-              window.addEventListener('offline', changed)
-              return () => {
-                  window.removeEventListener('online', changed)
-                  window.removeEventListener('offline', changed)
-              }
-          })
-
-// @documentation probes
-export function online(): boolean {
-    /* window, not navigator: Bun defines a partial navigator with no onLine. */
-    if (typeof window === 'undefined') {
-        return requestScopeSlot.resolver?.()?.online ?? true
-    }
-    subscribeOnline?.()
-    return navigator.onLine
-}

package/src/lib/shared/page.ts

@@ -1,30 +0,0 @@
-import { activePage } from './activePage.ts'
-import type { PageSnapshot } from './types/PageSnapshot.ts'
-
-/*
-The reactive page proxy: the matched route, decoded params, browser-space URL,
-and `navigating` flag for the active page. Isomorphic — the server resolver reads
-the per-request store, the client resolver the router-updated snapshot — so
-`{page.url.pathname}` and `page.params.id` work the same during SSR and after
-hydration. Read inside a abide-ui effect/derived, a field re-runs its reader when
-navigation updates the snapshot (the client resolver reads a abide-ui signal).
-
-`url` is browser-space on both sides: under a mount base the pathname carries the
-prefix (the server re-applies it to the proxy-stripped request URL), so compare
-active state against url() output, e.g. `page.url.pathname.startsWith(url('/x'))`.
-*/
-// @documentation page
-export const page: PageSnapshot = {
-    get route(): string {
-        return activePage().route
-    },
-    get params(): Record<string, string> {
-        return activePage().params
-    },
-    get url(): URL {
-        return activePage().url
-    },
-    get navigating(): boolean {
-        return activePage().navigating
-    },
-}

package/src/lib/shared/pageSlot.ts

@@ -1,17 +0,0 @@
-import { createResolverSlot } from './createResolverSlot.ts'
-import type { PageSnapshot } from './types/PageSnapshot.ts'
-
-/*
-The active-page slot. The server entry installs an ALS-backed resolver
-(request-scoped, so concurrent and streaming renders never share state); the
-client entry a module-singleton one. With no resolver registered, a single
-empty snapshot is created lazily so isolated tests work; test helpers
-snapshot/poke `.resolver` and `.fallback` directly. activePage is the public
-read.
-*/
-export const pageSlot = createResolverSlot<PageSnapshot>(() => ({
-    route: '',
-    params: {},
-    url: new URL('http://localhost/'),
-    navigating: false,
-}))

package/src/lib/shared/pageUrlForFile.ts

@@ -1,14 +0,0 @@
-/*
-Maps a page-relative path (under `src/ui/pages/`) to its URL route. Pages are
-folder-based: every leaf is `page.abide` or `layout.abide`, and the URL
-is the directory path. Pages mount at the directory path; layouts mount at
-the directory prefix. Dynamic segments keep their `[name]` / `[[name]]` / `[...rest]`
-shape — the shared matchRoute resolves them at dispatch on both sides;
-consumers see the readable form in `page.route`.
-*/
-export function pageUrlForFile(relPath: string): string {
-    const segments = relPath.split('/')
-    segments.pop()
-    const path = segments.filter(Boolean).join('/')
-    return path === '' ? '/' : `/${path}`
-}

package/src/lib/shared/parseBoundedEnvInt.ts

@@ -1,20 +0,0 @@
-/*
-Parses an env string into an integer within [min, max], returning undefined for
-missing, empty, or out-of-range/non-integer input so the caller can fall back to
-a default. A bare Number() turns '' into 0 and 'abc' into NaN, both silently
-wrong; this rejects them instead.
-*/
-export function parseBoundedEnvInt(
-    value: string | undefined,
-    min: number,
-    max: number,
-): number | undefined {
-    if (value === undefined || value.trim() === '') {
-        return undefined
-    }
-    const parsed = Number(value)
-    if (!Number.isInteger(parsed) || parsed < min || parsed > max) {
-        return undefined
-    }
-    return parsed
-}

package/src/lib/shared/parseEnv.ts

@@ -1,41 +0,0 @@
-const ENV_LINE = /^\s*([A-Z_][A-Z0-9_]*)\s*=\s*(.*)$/
-
-/*
-Parses `.env` text into a key→value record. Skips blanks, comments, and
-malformed lines; strips a single layer of surrounding single or double quotes.
-Intentionally minimal — no variable expansion, escapes, or multi-line. The pure
-counterpart to loadEnvFile (which merges into process.env) and serializeEnv
-(which writes records back), so all three round-trip the same shape.
-*/
-export function parseEnv(text: string): Record<string, string> {
-    const result: Record<string, string> = {}
-    // Split on CRLF or LF — a Windows-saved (or git autocrlf) .env otherwise leaves a
-    // trailing \r that breaks ENV_LINE's `$` anchor, silently dropping every line.
-    for (const line of text.split(/\r?\n/)) {
-        if (!line || line.startsWith('#')) {
-            continue
-        }
-        const match = ENV_LINE.exec(line)
-        if (!match) {
-            continue
-        }
-        const [, key, rawValue] = match
-        const trimmed = rawValue?.trim() ?? ''
-        let unquoted: string
-        if (trimmed.length >= 2 && trimmed.startsWith('"') && trimmed.endsWith('"')) {
-            // Double-quoted: unescape the sequences serializeEnv writes (`\\`, `\"`, `\n`, `\r`).
-            unquoted = trimmed
-                .slice(1, -1)
-                .replace(/\\([nr"\\])/g, (_, c: string) =>
-                    c === 'n' ? '\n' : c === 'r' ? '\r' : c,
-                )
-        } else if (trimmed.length >= 2 && trimmed.startsWith("'") && trimmed.endsWith("'")) {
-            // Single-quoted: taken verbatim (no escaping applied on the way out).
-            unquoted = trimmed.slice(1, -1)
-        } else {
-            unquoted = trimmed
-        }
-        result[key as string] = unquoted
-    }
-    return result
-}

package/src/lib/shared/parsePromptMarkdown.ts

@@ -1,35 +0,0 @@
-import type { PromptArgument } from './types/PromptArgument.ts'
-
-export type ParsedPromptMarkdown = {
-    description: string | undefined
-    arguments: PromptArgument[]
-    body: string
-}
-
-// Leading YAML frontmatter block fenced by `---` lines (CRLF tolerant).
-const FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/
-
-/*
-Splits a `src/mcp/prompts/**.md` file into its frontmatter metadata and
-template body. The frontmatter (optional) carries `description` and an
-`arguments` list; everything after the closing `---` is the prompt body,
-interpolated at render time via `{{name}}` placeholders. A file with no
-frontmatter is all body. Parsed with Bun.YAML — the resolver plugin runs
-under Bun, so the native parser is always available at build time.
-*/
-export function parsePromptMarkdown(source: string): ParsedPromptMarkdown {
-    const match = FRONTMATTER.exec(source)
-    if (!match) {
-        return { description: undefined, arguments: [], body: source.trim() }
-    }
-    // The pattern makes group 1 mandatory; the '' default exists for noUncheckedIndexedAccess in consumer tsconfigs.
-    const frontmatter = (Bun.YAML.parse(match[1] ?? '') ?? {}) as {
-        description?: string
-        arguments?: PromptArgument[]
-    }
-    return {
-        description: frontmatter.description,
-        arguments: Array.isArray(frontmatter.arguments) ? frontmatter.arguments : [],
-        body: source.slice(match[0].length).trim(),
-    }
-}

package/src/lib/shared/parseRouteSegments.ts

@@ -1,31 +0,0 @@
-export type RouteSegment =
-    | { kind: 'literal'; value: string }
-    | { kind: 'param'; name: string; catchAll: boolean; optional: boolean }
-
-/*
-Splits a abide route URL into typed segments. `[name]` becomes a param,
-`[[name]]` an optional param, `[...rest]` a catch-all param, anything else a
-literal. Used by matchRoute (both the server's fetch dispatch and the client
-router) and writeRoutesDts (client-side `Routes` type augmentation) so the
-consumers can't drift on what counts as a param.
-*/
-export function parseRouteSegments(routeUrl: string): RouteSegment[] {
-    return routeUrl.split('/').map((segment) => {
-        if (segment.startsWith('[[') && segment.endsWith(']]')) {
-            const name = segment.slice(2, -2)
-            /* `[[...rest]]` is redundant — a catch-all already matches zero
-               segments — but normalizing beats mis-parsing brackets into the name. */
-            if (name.startsWith('...')) {
-                return { kind: 'param', name: name.slice(3), catchAll: true, optional: false }
-            }
-            return { kind: 'param', name, catchAll: false, optional: true }
-        }
-        if (segment.startsWith('[...') && segment.endsWith(']')) {
-            return { kind: 'param', name: segment.slice(4, -1), catchAll: true, optional: false }
-        }
-        if (segment.startsWith('[') && segment.endsWith(']')) {
-            return { kind: 'param', name: segment.slice(1, -1), catchAll: false, optional: false }
-        }
-        return { kind: 'literal', value: segment }
-    })
-}

package/src/lib/shared/parseTraceparent.ts

@@ -1,26 +0,0 @@
-import type { TraceContext } from './types/TraceContext.ts'
-
-const TRACEPARENT_PATTERN = /^([0-9a-f]{2})-([0-9a-f]{32})-([0-9a-f]{16})-([0-9a-f]{2})$/
-
-/*
-Parses a W3C `traceparent` header into a TraceContext, or undefined when the
-value is malformed (per spec, an unreadable header is ignored and the receiver
-starts a fresh trace). Rejects the all-zero trace/span ids and the reserved
-version 'ff'. The header's span id lands in `spanId`: from the wire's point of
-view that field is "the id of the step that sent this" — callers minting their
-own step id move it to `parentSpanId` (createTraceContext does).
-*/
-export function parseTraceparent(header: string): TraceContext | undefined {
-    const match = TRACEPARENT_PATTERN.exec(header.trim().toLowerCase())
-    if (!match) {
-        return undefined
-    }
-    /* The pattern makes all four groups mandatory, but consumer tsconfigs with
-       noUncheckedIndexedAccess type-check this shipped source and see them as
-       possibly undefined — default to '' so the zero-id guards reject that path. */
-    const [, version = '', traceId = '', spanId = '', flags = ''] = match
-    if (version === 'ff' || /^0*$/.test(traceId) || /^0*$/.test(spanId)) {
-        return undefined
-    }
-    return { traceId, spanId, flags }
-}

package/src/lib/shared/peek.ts

@@ -1,46 +0,0 @@
-import { cache } from './cache.ts'
-import { isAsyncCell } from './isAsyncCell.ts'
-import { isAsyncIterable } from './isAsyncIterable.ts'
-import type { AsyncComputed } from './types/AsyncComputed.ts'
-import type { RemoteFunction } from './types/RemoteFunction.ts'
-import type { Socket } from './types/Socket.ts'
-
-/*
-The value member of the probe family: the currently-retained value, synchronously,
-without triggering anything — `T | undefined` (undefined when nothing is retained
-yet). For a cached read it is the retained cache value (reactive in a tracking
-scope — re-runs when a refresh lands or an amend mutates it; a one-shot snapshot
-otherwise). For a subscribable (socket / stream) it is the latest frame, read off
-the source's own `.peek()`. Instance sugar `getFoo.peek(args?)` ≡ `peek(getFoo,
-args?)`, `socket.peek()` ≡ `peek(socket)`.
-
-  peek(getFoo, args?)   → the retained value for that call
-  peek(socket)          → the latest frame
-*/
-// @documentation probes
-export function peek<Args, Return>(
-    fn: RemoteFunction<Args, Return>,
-    args?: Args,
-): Return | undefined
-export function peek<T>(source: Socket<T>): T | undefined
-export function peek<T>(cell: AsyncComputed<T>): T | undefined
-export function peek(source: unknown, args?: unknown): unknown {
-    /* Null-tolerant: a promise/iterable subexpression peek-lifts to `undefined` while
-       pending (ADR-0032), so `peek(getFeed())` in a template hands us `undefined` on the
-       first pass — return `undefined` rather than routing a missing source into the cache. */
-    if (source == null) {
-        return undefined
-    }
-    /* An async cell carries its own probe surface — route to its method (`peek(cell)` ≡
-       `cell.peek()`), the same instance/standalone equivalence as an rpc or socket. */
-    if (isAsyncCell(source)) {
-        return source.peek()
-    }
-    /* A subscribable (socket/stream) carries its own latest-frame probe; an rpc does not
-       have Symbol.asyncIterator, so this cleanly splits the two even though both expose a
-       `.peek` method. */
-    if (isAsyncIterable(source)) {
-        return (source as unknown as { peek: () => unknown }).peek()
-    }
-    return cache.peek(source as RemoteFunction<unknown, unknown>, args as never)
-}

package/src/lib/shared/pending.ts

@@ -1,36 +0,0 @@
-import { isAsyncCell } from './isAsyncCell.ts'
-import { probeRegistries } from './probeRegistries.ts'
-import type { AsyncComputed } from './types/AsyncComputed.ts'
-import type { CacheEntry } from './types/CacheEntry.ts'
-import type { CacheSelector } from './types/CacheSelector.ts'
-import type { NamedAsyncIterable } from './types/NamedAsyncIterable.ts'
-
-/*
-Reactive in-flight probe over both registries — the cache (calls) and the
-tail registry (streams). Pending means "no value yet":
-  pending()              → any call in flight, or any registered stream
-                           awaiting its first frame (global activity bar)
-  pending(fn)            → that function's calls (per-route spinner; remote or
-                           producer, same selector grammar as cache.invalidate)
-  pending(fn, args)      → exactly that call (per-row spinner)
-  pending({ tags })      → a tagged group
-  pending(subscribable)  → that stream awaiting its first frame
-                           (tail.status === 'pending'; true when nothing
-                           is reading yet — there is no value either way)
-Probes report, never act: reading one opens no fetch and no stream. SSR
-loading state is driven by {#await}, not this. Scan semantics (tap order,
-selector grammar, registry spans) live in probeRegistries.
-*/
-// @documentation probes
-export function pending<Args, Return>(
-    arg?: CacheSelector<Args, Return> | NamedAsyncIterable<unknown> | AsyncComputed<unknown>,
-    args?: Args,
-): boolean {
-    /* An async cell answers from its own facet (`pending(cell)` ≡ `cell.pending()`). */
-    if (isAsyncCell(arg)) {
-        return arg.pending()
-    }
-    return probeRegistries(arg, args, 'pending', unsettled, true)
-}
-
-const unsettled = (entry: CacheEntry) => entry.settled !== true

package/src/lib/shared/pendingAsyncCellsSlot.ts

@@ -1,13 +0,0 @@
-import { createResolverSlot } from './createResolverSlot.ts'
-import type { PendingAsyncCells } from './types/PendingAsyncCells.ts'
-
-/*
-The active pending-async-cells slot — mirrors `cacheStoreSlot`. The server entry
-installs an ALS-backed resolver (a fresh list per request, so concurrent SSR
-renders never share the drain); with no resolver registered a single fallback
-list is created lazily so isolated tests work without booting the runtime. Read
-through `pendingAsyncCellsSlot.get()`; the SSR barrier (`settleAsyncCells`) drains it.
-*/
-export const pendingAsyncCellsSlot = createResolverSlot<PendingAsyncCells>(() => ({
-    promises: [],
-}))