@abide/abide 0.58.0 → 0.100.0

package/src/lib/shared/cacheEntryFromSnapshot.ts

@@ -1,77 +0,0 @@
-import { bodyValueForKind } from './bodyValueForKind.ts'
-import { contentBodyKind } from './contentBodyKind.ts'
-import { contentTypeOf } from './contentTypeOf.ts'
-import { DEFER } from './DEFER.ts'
-import type { CacheEntry } from './types/CacheEntry.ts'
-import type { CacheSnapshotEntry } from './types/CacheSnapshotEntry.ts'
-
-/*
-Rebuilds a warm cache entry from a wire snapshot: an already-resolved Response
-plus the synchronously-decoded warm value, so cache() reads it without a network
-round-trip or a microtask hop. Shared by the initial inline snapshot hydration
-and the streamed resolution path. `settled` is true — the body shipped fully
-resolved either way. `hydrated` marks that the wrap options didn't travel:
-the first cache() read adopts its call site's ttl (see CacheEntry).
-*/
-export function cacheEntryFromSnapshot(entry: CacheSnapshotEntry): CacheEntry {
-    const headers = new Headers(entry.headers)
-    /* Body text for async readers / shareable clones. A json body arrives PARSED as `data`
-       (ADR-0051): re-stringify it (compact JSON — value-identical to the server body, whose
-       `json()` also emits compact JSON) so a later `.json()`/`.text()`/`.clone()` still works.
-       A text (or parse-failed json) body arrives raw as `body`. */
-    const bodyText = 'data' in entry ? JSON.stringify(entry.data) : (entry.body ?? '')
-    const response = new Response(bodyText, {
-        status: entry.status,
-        statusText: entry.statusText,
-        headers,
-    })
-    return {
-        key: entry.key,
-        promise: Promise.resolve(response),
-        request: new Request(entry.url, { method: entry.method }),
-        ttl: undefined,
-        expiresAt: undefined,
-        value: warmValueFromSnapshot(entry, headers, bodyText),
-        settled: true,
-        hydrated: true,
-    }
-}
-
-/*
-Synchronously decodes a snapshot body so the warm entry reads without a
-microtask hop on first render. The json/text branches go through the shared
-`bodyValueForKind` — the same mapping the live read (`decodeResponse`) uses — so
-the two cannot disagree about how a body becomes a value, returning a value
-identical to what awaiting the Response would yield. Every non-warmable case —
-non-2xx, 204 (the status gate below), streaming, binary (the DEFER sentinel) —
-yields no warm value and defers to the async path, which throws HttpError /
-returns the streaming error / blobs exactly as a live call would.
-*/
-function warmValueFromSnapshot(entry: CacheSnapshotEntry, headers: Headers, body: string): unknown {
-    /* Status gate is side-specific: an error/204 has no warm value here, but the live
-       read throws HttpError / returns undefined for the same status — so it stays out of
-       the shared kind mapping. */
-    if (entry.status === 204 || entry.status < 200 || entry.status >= 300) {
-        return undefined
-    }
-    const kind = contentBodyKind(contentTypeOf(headers))
-    const value = bodyValueForKind(
-        kind,
-        /* Pre-parsed json body (`data`, ADR-0051) IS the value — no second parse. A raw json
-           body may still be malformed; fall back to the async path rather than throwing a
-           SyntaxError synchronously during hydration. */
-        () => {
-            if ('data' in entry) {
-                return entry.data
-            }
-            try {
-                return JSON.parse(body)
-            } catch {
-                return undefined
-            }
-        },
-        () => body,
-    )
-    /* streaming and binary defer to the async path (the live decode throws / blobs). */
-    return value === DEFER ? undefined : value
-}

package/src/lib/shared/cacheManagedSlot.ts

@@ -1,10 +0,0 @@
-/*
-Set while cache() synchronously invokes the underlying remote/producer, so the
-client's currentAbortSignal skips scope-binding for cache-managed calls. The cache
-coalesces one in-flight request across every reader and owns its lifetime (it
-evicts the entry when the request rejects), so a single reader navigating away must
-not abort a flight the others still depend on. A plain boolean — cache invokes the
-underlying call synchronously and never re-enters across an await. Harmless on the
-server, where there is no reactive observer to bind anyway.
-*/
-export const cacheManagedSlot: { active: boolean } = { active: false }

package/src/lib/shared/cacheReaderSocketSlot.ts

@@ -1,11 +0,0 @@
-import { createResolverSlot } from './createResolverSlot.ts'
-import type { CacheReaderHook } from './types/CacheReaderHook.ts'
-
-/*
-Client-only seam for the reactive-reader lifecycle (ADR-0043). No fallback: unresolved,
-get() is undefined and the store's engage/disengage calls are inert — so the server's
-request store and isolated unit tests do nothing. The client entry (startClient) installs
-a hook that opens a per-key amend value subscription on a key's first reader and closes it
-on its last, keeping the subscription set congruent with what this tab is reading.
-*/
-export const cacheReaderSocketSlot = createResolverSlot<CacheReaderHook>()

package/src/lib/shared/cacheStalenessSlot.ts

@@ -1,21 +0,0 @@
-import { applyCacheStalenessLocally } from './applyCacheStalenessLocally.ts'
-import { createResolverSlot } from './createResolverSlot.ts'
-import type { CacheStalenessApply } from './types/CacheStalenessApply.ts'
-
-/*
-The one side-swap seam for the isomorphic staleness verbs (ADR-0041), mirroring
-cacheStoreSlot exactly. `invalidate()` and `refresh()` route through this after their
-async-cell short-circuit, so their sources stay byte-identical on both sides — the
-resolver decides the side:
-
-  - client entry (startClient): installs applyCacheStalenessLocally — drop/refetch
-    this tab's cache.
-  - server entry (serverEntry): installs a broadcaster — serialize the selector and
-    publish it to every connected client over the reserved __abide/cache socket.
-
-With no resolver registered the fallback is applyCacheStalenessLocally too, so
-isolated unit tests keep today's local behaviour without booting a runtime.
-*/
-export const cacheStalenessSlot = createResolverSlot<CacheStalenessApply>(
-    () => applyCacheStalenessLocally,
-)

package/src/lib/shared/cacheStoreSlot.ts

@@ -1,12 +0,0 @@
-import { createCacheStore } from './createCacheStore.ts'
-import { createResolverSlot } from './createResolverSlot.ts'
-import type { CacheStore } from './types/CacheStore.ts'
-
-/*
-The active-CacheStore slot. The server entry installs an ALS-backed resolver
-(request-scoped); the client entry a module-singleton one. With no resolver
-registered, a single fallback store is created lazily so isolated tests work
-without booting the runtime; test helpers snapshot/poke `.resolver` and
-`.fallback` directly. activeCacheStore is the public read.
-*/
-export const cacheStoreSlot = createResolverSlot<CacheStore>(createCacheStore)

package/src/lib/shared/cacheStores.ts

@@ -1,10 +0,0 @@
-import { activeCacheStore } from './activeCacheStore.ts'
-import { sharedCacheStore } from './sharedCacheStore.ts'
-import type { CacheStore } from './types/CacheStore.ts'
-
-/* Active + process-level stores, deduped (one tab store on the client). */
-export function cacheStores(): CacheStore[] {
-    const active = activeCacheStore()
-    const shared = sharedCacheStore()
-    return active === shared ? [active] : [active, shared]
-}

package/src/lib/shared/canonicalJson.ts

@@ -1,86 +0,0 @@
-/*
-Deterministic key string for a value. Object keys (and Map keys, Set members)
-are sorted so values differing only in insertion order produce identical
-strings, and every recognised type carries a tag so distinct types never
-collide — a Date never equals the string of its ISO form, a Map never equals a
-plain object. Used to derive cache keys from producer args and from auto-keyed
-POST/PUT/PATCH bodies; the output is a key, not a request body, so it is free to
-encode types JSON.stringify would silently flatten (Map/Set → {}), coerce
-(Date → its ISO string, via toJSON before any replacer sees it) or drop
-(undefined). Covers the value types commonly passed as rpc args: primitives,
-arrays, plain objects, Date, Map, Set, bigint, and FormData/File/Blob (the
-multipart upload path). Functions and symbols can't
-key anything meaningful but are tagged rather than dropped so a stray one can't
-silently collapse two distinct argument sets onto the same key.
-*/
-export function canonicalJson(value: unknown): string {
-    if (value === null) {
-        return 'null'
-    }
-    if (value === undefined) {
-        return 'undefined'
-    }
-    const type = typeof value
-    if (type === 'string') {
-        return JSON.stringify(value)
-    }
-    if (type === 'bigint') {
-        return `${value}n`
-    }
-    if (type === 'number') {
-        // -0 and 0 stringify alike but are distinct keys; NaN/Infinity stay stable (JSON drops them to null).
-        return Object.is(value, -0) ? '-0' : String(value)
-    }
-    if (type === 'boolean') {
-        return String(value)
-    }
-    if (type !== 'object') {
-        // function | symbol — not serialisable; tag by type so the key can't crash or alias a real value.
-        return `${type}()`
-    }
-    if (value instanceof Date) {
-        return `Date(${value.getTime()})`
-    }
-    if (Array.isArray(value)) {
-        return `[${value.map(canonicalJson).join(',')}]`
-    }
-    if (value instanceof Map) {
-        // Sort by encoded entry so key order doesn't change the result.
-        const entries = Array.from(
-            value,
-            ([key, val]) => `${canonicalJson(key)}=>${canonicalJson(val)}`,
-        ).sort()
-        return `Map{${entries.join(',')}}`
-    }
-    if (value instanceof Set) {
-        const members = Array.from(value, canonicalJson).sort()
-        return `Set{${members.join(',')}}`
-    }
-    /* FormData is the documented multipart escape hatch for body rpcs. Its fields are
-       NOT own enumerable keys, so the generic object branch below would return `{}` for
-       every distinct upload — collapsing them onto one cache key and coalescing unrelated
-       uploads onto each other. Encode its entries (sorted, so field order doesn't change
-       the key) with File/Blob distinguished by identity attributes below. */
-    if (typeof FormData !== 'undefined' && value instanceof FormData) {
-        const entries: string[] = []
-        value.forEach((entryValue, entryKey) => {
-            entries.push(`${JSON.stringify(entryKey)}=>${canonicalJson(entryValue)}`)
-        })
-        entries.sort()
-        return `FormData{${entries.join(',')}}`
-    }
-    /* File extends Blob — check it first so a named upload keys on its name too. Contents
-       can't be read synchronously, so identity attributes are the best available key;
-       distinct files (name/size/type/mtime) get distinct keys, which is the fix. */
-    if (typeof File !== 'undefined' && value instanceof File) {
-        return `File(${JSON.stringify(value.name)},${value.size},${JSON.stringify(value.type)},${value.lastModified})`
-    }
-    if (typeof Blob !== 'undefined' && value instanceof Blob) {
-        return `Blob(${value.size},${JSON.stringify(value.type)})`
-    }
-    const record = value as Record<string, unknown>
-    const entries = Object.keys(record)
-        .sort()
-        .map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`)
-    return `{${entries.join(',')}}`
-}

package/src/lib/shared/carriesBodyArgs.ts

@@ -1,13 +0,0 @@
-import type { HttpMethod } from './types/HttpMethod.ts'
-
-/*
-Whether a rpc carries its args in the request body (POST/PUT/PATCH) vs
-on the query string (GET/DELETE/HEAD). Single source for the split so the
-synthesized Request (buildRpcRequest), the handler-side parse (parseArgs),
-the cache key (keyForRemoteCall), and the OpenAPI doc can't disagree.
-*/
-const BODY_METHODS = new Set<HttpMethod>(['POST', 'PUT', 'PATCH'])
-
-export function carriesBodyArgs(method: HttpMethod): boolean {
-    return BODY_METHODS.has(method)
-}

package/src/lib/shared/changeAffectsClient.ts

@@ -1,40 +0,0 @@
-import { PROXIED_SERVER_SUBDIRS } from './PROXIED_SERVER_SUBDIRS.ts'
-
-/*
-Classifies a watcher change (a path relative to the project's `src/`, with
-either OS separator) by whether it can alter the client bundle. The dev
-orchestrator uses this to skip the full client `Bun.build` for changes that
-only reach the server or MCP runtimes, while still restarting the SSR worker.
-
-Server/MCP-only — client unaffected, skip the client rebuild:
-- `server/rpc/**`     — the client only ships proxy stubs derived from the file
-                        path (rpc url) and the `<METHOD>(...)` wrapper, not the
-                        handler body; the rpc manifest is server-only. A body
-                        edit produces an identical stub. (Risk: changing the
-                        method or the export name does change the stub — those
-                        need a manual full rebuild.)
-- `server/sockets/**` — name-only `socketProxy` stubs derived from the file
-                        path; socket opts are server-side. Body edits don't
-                        change the stub.
-- `mcp/**`            — prompts/resources are MCP-only; the client bundle never
-                        imports them (it emits empty stubs defensively).
-- `server/config.ts`  — server boot-time env validation (`abide:config`); never
-                        reaches the client.
-
-Everything else (`.abide` templates, `ui/**`, `shared/**`, `app.ts`, state
-files, the rest of `server/`) is treated as client-affecting. Conservative by
-default: an unrecognised path returns true so an ambiguous change still pays the
-full rebuild rather than risking a stale client.
-*/
-export function changeAffectsClient(relativePath: string): boolean {
-    const path = relativePath.split('\\').join('/')
-    /* The proxied server dirs (rpc/sockets) ship path-derived stubs, so a body edit can't change the
-       client bundle. Read from the shared PROXIED_SERVER_SUBDIRS authority so this stays in lockstep
-       with the resolver's side-classifier. mcp/** and server/config.ts are additional server-only
-       skips specific to this classifier (not proxied — never imported by the client at all). */
-    const proxiedServerOnly = PROXIED_SERVER_SUBDIRS.some((subdir) =>
-        path.startsWith(`server/${subdir}/`),
-    )
-    const serverOnly = proxiedServerOnly || path.startsWith('mcp/') || path === 'server/config.ts'
-    return !serverOnly
-}

package/src/lib/shared/clearLastConnection.ts

@@ -1,7 +0,0 @@
-import { rm } from 'node:fs/promises'
-import { lastConnectionPath } from './lastConnectionPath.ts'
-
-// Forgets the saved connection (the `/disconnect` reset). Missing file is a no-op.
-export async function clearLastConnection(programName: string): Promise<void> {
-    await rm(lastConnectionPath(programName), { force: true })
-}

package/src/lib/shared/commandNameForUrl.ts

@@ -1,17 +0,0 @@
-/*
-Derives the MCP tool name / CLI subcommand name from an rpc URL. Strips
-the framework's `/rpc/` mount and joins nested folder segments with `-`
-so `users/list.ts` (mounted at `/rpc/users/list`) becomes `users-list`
-across both surfaces. Folder prefixing prevents collisions when two
-files in different folders share the same stem (e.g. `users/list.ts`
-and `posts/list.ts`); `/` is not a valid character in MCP tool names or
-typical CLI subcommands, so the join uses `-`.
-*/
-const RPC_PREFIX = '/rpc/'
-
-export function commandNameForUrl(url: string): string {
-    const trimmed = url.startsWith(RPC_PREFIX)
-        ? url.slice(RPC_PREFIX.length)
-        : url.replace(/^\//, '')
-    return trimmed.replaceAll('/', '-')
-}

package/src/lib/shared/contentBodyKind.ts

@@ -1,27 +0,0 @@
-import { STREAMING_CONTENT_TYPES } from './STREAMING_CONTENT_TYPES.ts'
-
-/*
-The single classification of a Content-Type into the body kind that decides how
-its bytes become a value. One ordering, read by every decoder, so the live read
-(`decodeResponse`) and the synchronous warm read (`warmValueFromSnapshot`) cannot
-classify the same body differently — the divergence that shipped a warm value a
-live read rejected (the streaming-guard-in-one-but-not-the-other bug).
-
-`streaming` is tested FIRST and the order is load-bearing: `application/jsonl`
-and `application/x-ndjson` both contain `json`, so a json-first scan would
-mis-bucket a stream as parseable JSON.
-*/
-export type ContentBodyKind = 'streaming' | 'json' | 'text' | 'binary'
-
-export function contentBodyKind(contentType: string): ContentBodyKind {
-    if (STREAMING_CONTENT_TYPES.some((type) => contentType.startsWith(type))) {
-        return 'streaming'
-    }
-    if (contentType.includes('json')) {
-        return 'json'
-    }
-    if (contentType.startsWith('text/')) {
-        return 'text'
-    }
-    return 'binary'
-}

package/src/lib/shared/contentTypeOf.ts

@@ -1,6 +0,0 @@
-/* The `content-type` header, lowercased, or '' when absent — the canonical shape
-   every content-type comparison in the codebase reads (case-insensitive match,
-   no undefined to guard). */
-export function contentTypeOf(headers: Headers): string {
-    return (headers.get('content-type') ?? '').toLowerCase()
-}

package/src/lib/shared/createCacheStore.ts

@@ -1,147 +0,0 @@
-import { REACTIVE_CONTEXT } from '../ui/runtime/REACTIVE_CONTEXT.ts'
-import { cacheReaderSocketSlot } from './cacheReaderSocketSlot.ts'
-import { createLifecycleChannel } from './createLifecycleChannel.ts'
-import { createSubscriber } from './createSubscriber.ts'
-import { keyMatchesPrefix } from './keyMatchesPrefix.ts'
-import type { CacheEntry } from './types/CacheEntry.ts'
-import type { CacheInvalidation } from './types/CacheInvalidation.ts'
-import type { CacheStore } from './types/CacheStore.ts'
-
-/*
-Returns a fresh cache store. On the server, every request gets its own
-store via the AsyncLocalStorage RequestStore. On the client, a single
-module-level store is created at startup and shared across the tab.
-
-Each key gets a lazily-created subscriber. Reading a key from a
-tracking scope (derived / effect) subscribes that scope; invalidating
-the key dispatches an 'invalidate' event whose detail is a Set of affected
-keys so each listener's lookup is O(1). The subscriber outlives entry
-eviction — invalidating/refetching a key reuses the same subscriber, so
-there's no listener churn or duplicate registration as cache values come
-and go. It's evicted only when its last reactive reader tears down (the
-client store is module-level/tab-scoped, so retaining a thunk per distinct
-key would otherwise grow unbounded across a session), identity-guarded so
-a concurrent re-subscribe isn't clobbered — mirroring tail.ts.
-*/
-export function createCacheStore(): CacheStore {
-    const entries = new Map<string, CacheEntry>()
-    const events = new EventTarget()
-    const subscribers = new Map<string, () => void>()
-    const pendingRefresh = new Set<string>()
-
-    function subscribe(key: string): void {
-        /* An untracked read (an event handler, a setup-time `await getFoo()`, any
-           server render) subscribes to nothing: `track` inside createSubscriber no-ops,
-           node.subsHead stays empty, and the resource never opens. Skip the bookkeeping
-           too — otherwise a bare read would pin an entry in `subscribers` for the tab's
-           lifetime, growing the map and leaving hasReader() over-reporting a reader that
-           isn't there. Honouring the tracking seam here makes hasReader() mean exactly
-           "a live tracking reader exists". */
-        if (REACTIVE_CONTEXT.observer === undefined) {
-            return
-        }
-        const existing = subscribers.get(key)
-        if (existing) {
-            existing()
-            return
-        }
-        const registered = createSubscriber((update) => {
-            const onInvalidate = (event: Event) => {
-                if ((event as CustomEvent<CacheInvalidation>).detail.has(key)) {
-                    update()
-                }
-            }
-            events.addEventListener('invalidate', onInvalidate)
-            return () => {
-                events.removeEventListener('invalidate', onInvalidate)
-                if (subscribers.get(key) === registered) {
-                    subscribers.delete(key)
-                    /* The reload marker is only ever consumed by the NEXT read of this
-                       key (registerEntry). With the last reactive reader gone there is
-                       no scope left to show refreshing() for it, and a future remount
-                       reads with nothing on screen — a first-ever load, not a reload.
-                       Drop the marker so the tab-scoped store can't accrete one per
-                       invalidated-but-never-reread key over a session. */
-                    pendingRefresh.delete(key)
-                    /* Last reader gone: close any per-key amend subscription opened on engage
-                       (ADR-0043). Inert unless the client entry installed the hook. */
-                    cacheReaderSocketSlot.get()?.disengage(key)
-                }
-            }
-        })
-        subscribers.set(key, registered)
-        /* First reader for this key: open a per-key amend value subscription (ADR-0043), so a
-           server amend(args, value) push lands on a key this tab is actually reading. Inert on
-           the server / in unit tests (slot unresolved). Paired with disengage in the cleanup. */
-        cacheReaderSocketSlot.get()?.engage(key)
-        registered()
-    }
-
-    /* Store-wide in-flight tap for the probes; semantics live in createLifecycleChannel. */
-    const lifecycle = createLifecycleChannel()
-    /*
-    Per-prefix channels arm fn-selector probes (pending(fn) / refreshing(fn))
-    without waking them on unrelated cache events. Keyed by selector prefix
-    (method+url / producer reference id — see selectorPrefix). Probes carry the
-    FULL call key when args are given (pending(fn, args) / peek(fn, args)), so a
-    long session that probes many distinct ids would otherwise accrete one map
-    entry per id on the tab-scoped store forever and make markLifecycle's forEach
-    O(distinct-keys-ever-probed). Each channel evicts its own entry once its last
-    reader tears down (identity-guarded against a concurrent re-track).
-    */
-    const prefixLifecycles = new Map<string, ReturnType<typeof createLifecycleChannel>>()
-
-    function trackLifecycle(keyPrefix?: string): void {
-        if (keyPrefix === undefined) {
-            lifecycle.track()
-            return
-        }
-        let channel = prefixLifecycles.get(keyPrefix)
-        if (channel === undefined) {
-            const created = createLifecycleChannel(() => {
-                /* Drop the entry only if it's still THIS channel — a concurrent re-track may have
-                   replaced it, and createSubscriber's own reader-count guard means onIdle fires
-                   only when genuinely reader-less. */
-                if (prefixLifecycles.get(keyPrefix) === created) {
-                    prefixLifecycles.delete(keyPrefix)
-                }
-            })
-            channel = created
-            prefixLifecycles.set(keyPrefix, channel)
-        }
-        channel.track()
-    }
-
-    /*
-    Marks the store-wide channel always (bare/scope probes scan everything)
-    plus any probed prefix channel owning the changed key — a new entry's key
-    starts with its fn's prefix, so prefix probes see membership too.
-    */
-    function markLifecycle(key?: string): void {
-        lifecycle.mark()
-        if (key === undefined) {
-            return
-        }
-        prefixLifecycles.forEach((channel, prefix) => {
-            if (keyMatchesPrefix(key, prefix)) {
-                channel.mark()
-            }
-        })
-    }
-
-    return {
-        entries,
-        events,
-        subscribe,
-        /* True iff a live tracking scope is reading this key — i.e. someone is holding
-           its value on screen right now. An untracked read never registers (subscribe
-           gates on the tracking seam), so a bare handler/setup read does not make this
-           true. invalidate()/refresh() gate on this: a key with no live reader has
-           nothing to reload into, so the next read is a first-ever load, not a refresh. */
-        hasReader: (key: string) => subscribers.has(key),
-        trackLifecycle,
-        markLifecycle,
-        pendingRefresh,
-        stats: { hits: 0, misses: 0, coalesced: 0 },
-    }
-}

package/src/lib/shared/createChannelLog.ts

@@ -1,146 +0,0 @@
-import { emitLogRecord } from './emitLogRecord.ts'
-import { isDebugEnabled } from './isDebugEnabled.ts'
-import { isDebugNegated } from './isDebugNegated.ts'
-import { randomHexId } from './randomHexId.ts'
-import type { ChannelLog } from './types/ChannelLog.ts'
-
-/*
-Channel gating source. Server: the DEBUG env var, npm-debug conventions via
-isDebugEnabled. Browser: the `abide-debug` localStorage key with the same
-pattern syntax, read per call so toggling it in devtools takes effect without
-a reload. localStorage access is guarded — privacy modes throw on read.
-*/
-function channelPatterns(): string | undefined {
-    if (typeof process !== 'undefined' && process.env.DEBUG) {
-        return process.env.DEBUG
-    }
-    if (typeof localStorage !== 'undefined') {
-        try {
-            return localStorage.getItem('abide-debug') ?? undefined
-        } catch {
-            return undefined
-        }
-    }
-    return undefined
-}
-
-/* One line for an AggregateError sub-error: its message, prefixed with the source
-   position when it carries one. A thrown `Bun.build` failure holds a `BuildMessage`
-   per diagnostic, each with a `position.file` — naming that file is the point, since
-   without it a codegen/parse failure reads as a detail-free "Bundle failed". */
-function formatAggregateEntry(entry: unknown): string {
-    if (typeof entry === 'object' && entry !== null && 'message' in entry) {
-        const message = String((entry as { message: unknown }).message)
-        const position = (entry as { position?: { file?: string; line?: number; column?: number } })
-            .position
-        if (position?.file) {
-            return `  ${position.file}:${position.line ?? 0}:${position.column ?? 0} — ${message}`
-        }
-        return `  ${message}`
-    }
-    return `  ${String(entry)}`
-}
-
-// Prefers a full stack trace when the value is an Error so logs include the call site.
-// An AggregateError (a thrown Bun.build failure among them) carries the real diagnostics
-// in `.errors` — its own message is only a summary ("Bundle failed") — so expand each one,
-// or every per-file position is dropped and the failure reads with zero detail.
-function errorParts(value: unknown): { msg: string; stack?: string } {
-    if (value instanceof AggregateError && value.errors.length > 0) {
-        const details = value.errors.map(formatAggregateEntry).join('\n')
-        return { msg: `${value.message}\n${details}` }
-    }
-    if (value instanceof Error) {
-        return { msg: value.message, stack: value.stack }
-    }
-    return { msg: String(value) }
-}
-
-/* Times `work` under an operation name, minting the record's span id so a future exporter can materialise it as a span. */
-async function traceWork<Return>(
-    name: string,
-    work: () => Return | Promise<Return>,
-    channel: string,
-): Promise<Return> {
-    const spanId = randomHexId(8)
-    const startMs = performance.now()
-    try {
-        const result = await work()
-        emitLogRecord({
-            level: 'info',
-            msg: '',
-            name,
-            spanId,
-            durationMs: performance.now() - startMs,
-            channel,
-        })
-        return result
-    } catch (error) {
-        const { msg, stack } = errorParts(error)
-        emitLogRecord({
-            level: 'error',
-            msg,
-            stack,
-            name,
-            spanId,
-            durationMs: performance.now() - startMs,
-            channel,
-        })
-        throw error
-    }
-}
-
-/*
-Builds the callable-with-levels log shape bound to a channel. Every record
-carries the channel; `getChannel` is a thunk because the default (app-name)
-channel resolves after module init. `always` channels — the app's own and
-abide's framework voice — emit unless a `-name` DEBUG pattern explicitly
-shuts them off; everything else is a diagnostic channel gated by DEBUG
-(browser: the abide-debug localStorage key). Levels never gate: a silenced
-channel is silent at every level, an enabled one shows them all.
-*/
-export function createChannelLog(
-    getChannel: () => string,
-    always: boolean,
-): ChannelLog & { enabled(): boolean } {
-    const enabled = () =>
-        always
-            ? !isDebugNegated(getChannel(), channelPatterns())
-            : isDebugEnabled(getChannel(), channelPatterns())
-    const call = (message: string, data?: unknown): void => {
-        if (enabled()) {
-            emitLogRecord({ level: 'info', msg: message, data, channel: getChannel() })
-        }
-    }
-    return Object.assign(call, {
-        /* Exposed so wrappers (abideLog's styling voices) emit through the same gate. */
-        enabled,
-        warn(message: string, data?: unknown): void {
-            if (enabled()) {
-                emitLogRecord({ level: 'warn', msg: message, data, channel: getChannel() })
-            }
-        },
-        error(value: unknown, data?: unknown): void {
-            if (enabled()) {
-                emitLogRecord({ level: 'error', ...errorParts(value), data, channel: getChannel() })
-            }
-        },
-        trace<Return>(name: string, work: () => Return | Promise<Return>): Promise<Return> {
-            if (enabled()) {
-                return traceWork(name, work, getChannel())
-            }
-            /*
-            No span: skip the async-wrapper allocation that every other method
-            already gates away, and hand back work()'s own promise untouched so
-            a coalesced cache join keeps the shared promise's identity. A
-            synchronous throw still surfaces as a rejection, matching traceWork.
-            */
-            try {
-                const result = work()
-                return result instanceof Promise ? result : Promise.resolve(result)
-            } catch (error) {
-                return Promise.reject(error)
-            }
-        },
-    })
-}