@abide/abide 0.57.1 → 0.100.0

package/src/lib/shared/prepareRemoteExport.ts

@@ -1,40 +0,0 @@
-import { type ExportCallSite, findExportCallSite } from './findExportCallSite.ts'
-import { importNamesToStrip } from './importNamesToStrip.ts'
-import { stripImport } from './stripImport.ts'
-
-export type RemoteExport = {
-    /* The source with the user's dead server-helper import removed. */
-    stripped: string
-    /* The one exported `helper(...)` call the surface must rewrite. */
-    site: ExportCallSite
-}
-
-/*
-The scan-once envelope every file-based remote surface ($rpc, $sockets) shares:
-strip the user's server-helper import under both the project's chosen name and
-the canonical package name (so the dead import can't side-effect-load the stub
-into the server bundle), then locate the single exported helper call. Each
-surface passes the subpaths it places under a name (`server/GET`…/`server/socket`)
-and the ident predicate that recognizes its call; the character-by-character
-walk still happens exactly once. Returns undefined when the module declares no
-matching export (a plain `.ts` helper alongside the surface), and throws the
-surface's own single-export error when it declares more than one.
-*/
-export function prepareRemoteExport(
-    source: string,
-    importName: string,
-    subpathsForName: (name: string) => string[],
-    identMatches: (ident: string) => boolean,
-    singleExportError: string,
-): RemoteExport | undefined {
-    const stripped = importNamesToStrip(importName).reduce(
-        (current, name) =>
-            subpathsForName(name).reduce((acc, subpath) => stripImport(acc, subpath), current),
-        source,
-    )
-    const site = findExportCallSite(stripped, identMatches, singleExportError)
-    if (!site) {
-        return undefined
-    }
-    return { stripped, site }
-}

package/src/lib/shared/prepareRpcModule.ts

@@ -1,240 +0,0 @@
-import { HTTP_METHODS } from './HTTP_METHODS.ts'
-import { prepareRemoteExport } from './prepareRemoteExport.ts'
-import { DEFINE_RPC_GLOBAL, REMOTE_PROXY_GLOBAL } from './RPC_SHIM_GLOBALS.ts'
-import { skipNonCode } from './skipNonCode.ts'
-import type { HttpMethod } from './types/HttpMethod.ts'
-import type { RpcBuildStamps } from './types/RpcBuildStamps.ts'
-
-const RPC_NAMES = HTTP_METHODS
-const RPC_SET = new Set<string>(RPC_NAMES)
-
-const SINGLE_EXPORT_ERROR =
-    '[abide] $rpc module contains more than one `<METHOD>(...)` export — each file must declare exactly one remote function'
-
-export type PreparedRpcModule = {
-    method: HttpMethod
-    /* The handler calls jsonl()/sse() — the client proxy is emitted streaming (bare call
-       returns the NamedAsyncIterable). Congruent with the RemoteCallable conditional by construction. */
-    streaming: boolean
-    exportName: string
-    rewriteForServer: (url: string) => string
-    rewriteForClient: (url: string) => string
-}
-
-/*
-Scans an `$rpc/**` module once and returns its declared method + export
-name plus a closure that, given the route URL, emits the server-side
-rewrite (`__abideDefineRpc__("METHOD", "<url>", … )` spliced into the
-original source). The single scan replaces the prior separate
-extract + rewrite passes, so the resolver plugin only walks each source
-character-by-character once.
-
-A regex pass would be tidier but it can't tell a `GET` mention inside a
-docstring or template literal from the real call, and it can't follow
-nested generics like `GET<Map<K, V>>(`.
-*/
-export function prepareRpcModule(
-    source: string,
-    importName: string,
-    stamps: RpcBuildStamps = {},
-): PreparedRpcModule | undefined {
-    /*
-    The "no barrels" surface places each method at its own path
-    (`abide/server/GET`, `abide/server/POST`, …), so the strip subpaths are
-    every method under each import name — the user's method import must not
-    linger and side-effect-load the stub module into the server bundle.
-    */
-    const prepared = prepareRemoteExport(
-        source,
-        importName,
-        (name) => RPC_NAMES.map((method) => `${name}/server/${method}`),
-        (ident) => RPC_SET.has(ident),
-        SINGLE_EXPORT_ERROR,
-    )
-    if (!prepared) {
-        return undefined
-    }
-    const { stripped, site } = prepared
-    const method = site.ident as HttpMethod
-    /* Streaming is decided by the warm server program's return-type query when it resolved a
-       verdict (ADR-0025 D2 — it sees the wrapper-indirection case the scan misses); undefined
-       (no warm program / unresolvable node) falls open to the char-scan, byte-identical to before. */
-    const streaming = stamps.streaming ?? detectStreaming(stripped, site.parenStart, site.parenEnd)
-    /* The call's top-level args (handler + optional opts), dropping a trailing-comma empty
-       part. The handler is elided on the client; `opts` (schemas/cache/stream) rides through as
-       a LIVE expression in the kept module (ADR-0022 D2) — evaluated in its real scope, so it can
-       reference imported constants, composed values, and separate modules. */
-    const argParts = splitTopLevelArgs(stripped, site.parenStart, site.parenEnd)
-    return {
-        method,
-        streaming,
-        exportName: site.exportName,
-        rewriteForServer(url: string): string {
-            const binding = `${DEFINE_RPC_GLOBAL}(${JSON.stringify(method)}, ${JSON.stringify(url)}, `
-            const head = stripped.slice(0, site.callStart) + binding
-            /* Build-injected server opts: `streaming` (from the handler body / return type), the
-               `coerce` plan (numeric/boolean query fields → typed, ADR-0028), `inputJsonSchema` (the
-               handler's input args projected to JSON Schema, ADR-0030 input side), `outputJsonSchema`
-               (the handler return type projected to JSON Schema, ADR-0030 D2), and `errorJsonSchemas`
-               (the handler's typed-error branches as a status-keyed schema map, ADR-0030). All are
-               stamped into a fresh opts object that spreads the author's opts, so policy stays live.
-               With none present the original args pass through untouched. */
-            const injected: string[] = []
-            if (streaming) {
-                injected.push('streaming: true')
-            }
-            if (stamps.coercion !== undefined) {
-                injected.push(`coerce: ${JSON.stringify(stamps.coercion)}`)
-            }
-            if (stamps.inputSchema !== undefined) {
-                injected.push(`inputJsonSchema: ${JSON.stringify(stamps.inputSchema)}`)
-            }
-            if (stamps.outputSchema !== undefined) {
-                injected.push(`outputJsonSchema: ${JSON.stringify(stamps.outputSchema)}`)
-            }
-            if (stamps.errorSchemas !== undefined) {
-                injected.push(`errorJsonSchemas: ${JSON.stringify(stamps.errorSchemas)}`)
-            }
-            if (injected.length === 0) {
-                return head + stripped.slice(site.parenStart + 1)
-            }
-            /* Reuse the top-level arg split (handler + optional opts) so a trailing comma or absent
-               opts can't produce `...()`. `head` ends after the METHOD( paren; keep everything from
-               `)` onward. */
-            const [handler, opts] = argParts
-            const optsObject = opts
-                ? `{ ${injected.join(', ')}, ...(${opts}) }`
-                : `{ ${injected.join(', ')} }`
-            return `${head}${handler}, ${optsObject}${stripped.slice(site.parenEnd)}`
-        },
-        /*
-        Client rewrite, symmetric with rewriteForServer: keep the real module, swap the
-        METHOD( call for a remoteProxy( call, and ELIDE the handler argument. The handler and
-        the imports only it used become dead code the bundler tree-shakes out of the client
-        bundle (proven safe by the D3 reachability guard). `method`/`url` are the build-time
-        scalars; `opts` is left VERBATIM as a live expression, so endpoint policy (cache/stream)
-        can reference imports; `streaming` is the only genuinely build-injected flag — it's
-        derived from the elided handler body (returns jsonl()/sse()), so it can't ride `opts`.
-        remoteProxy reads only streaming/cache/stream off the opts and ignores the rest.
-        */
-        rewriteForClient(url: string): string {
-            const opts = argParts[1]
-            /* Build-injected CLIENT opts: `streaming` (build-derived from the elided handler body)
-               and the `outputWirePlan` (the handler's structured success fields → the client revives
-               a `Set`/`Map`/`bigint`/`Date` off the decoded response, ADR-0029). Both are stamped
-               into a fresh opts object that spreads the author's live `opts`, so endpoint policy
-               (cache/stream/schemas) still rides through verbatim. */
-            const injected: string[] = []
-            if (streaming) {
-                injected.push('streaming: true')
-            }
-            if (stamps.outputWirePlan !== undefined) {
-                injected.push(`outputWirePlan: ${JSON.stringify(stamps.outputWirePlan)}`)
-            }
-            let argsText: string
-            if (injected.length === 0) {
-                argsText = opts === undefined ? '' : `, ${opts}`
-            } else {
-                const injectedText = injected.join(', ')
-                argsText =
-                    opts === undefined
-                        ? `, { ${injectedText} }`
-                        : `, { ${injectedText}, ...(${opts}) }`
-            }
-            const remoteCall = `${REMOTE_PROXY_GLOBAL}(${JSON.stringify(method)}, ${JSON.stringify(url)}${argsText})`
-            /*
-            Minimal emit (ADR-0022 addendum): the warm program resolved which top-level statements
-            the live `opts` actually reaches, so emit ONLY those plus the `remoteProxy` export. The
-            handler and every declaration/import only it used are never emitted — nothing server-side
-            is loaded, tree-shaken, or flagged, matching "the client is only ever a fetch". An empty
-            plan (no opts, or opts references nothing top-level) emits the bare call alone.
-            */
-            const clientKeep = stamps.clientKeep
-            if (clientKeep !== undefined) {
-                const exportLine = `export const ${site.exportName} = ${remoteCall}`
-                return clientKeep.length > 0
-                    ? `${clientKeep.join('\n')}\n${exportLine}\n`
-                    : `${exportLine}\n`
-            }
-            /*
-            Fallback (no warm program): keep the real module, swap the METHOD( call for the
-            remoteProxy( call, and elide the handler argument — leaning on the bundler's DCE to drop
-            the dead server imports. `stripped.slice(0, site.callStart)` keeps the imports + the
-            `export const <name> = ` head; `stripped.slice(site.parenEnd)` keeps any trailing content.
-            */
-            const callHead = `${stripped.slice(0, site.callStart)}${REMOTE_PROXY_GLOBAL}(${JSON.stringify(method)}, ${JSON.stringify(url)}`
-            return `${callHead}${argsText}${stripped.slice(site.parenEnd)}`
-        },
-    }
-}
-
-const STREAM_HELPERS = new Set(['jsonl', 'sse'])
-const IDENT_START = /[A-Za-z_$]/
-const IDENT_PART = /[A-Za-z0-9_$]/
-
-/* True when the handler returns a streaming body — it calls abide's jsonl()/sse(), the only
-   constructors of a `TypedResponse<AsyncIterable<Frame>>`. Congruent by construction with the
-   RemoteCallable conditional (Return is an AsyncIterable iff the handler calls jsonl/sse). Scans
-   the whole call-arg region depth-blind (the opts never mention jsonl/sse), skipping
-   strings/comments/regex via skipNonCode so a mention in a literal can't misfire. A
-   literal-only limit: an indirection through a wrapper function isn't seen (the warm server
-   program's return-type query covers that case). */
-function detectStreaming(source: string, parenStart: number, parenEnd: number): boolean {
-    let i = parenStart + 1
-    while (i < parenEnd) {
-        const skipped = skipNonCode(source, i)
-        if (skipped !== undefined) {
-            i = skipped
-            continue
-        }
-        if (IDENT_START.test(source[i] ?? '') && !IDENT_PART.test(source[i - 1] ?? '')) {
-            let j = i + 1
-            while (j < parenEnd && IDENT_PART.test(source[j] ?? '')) {
-                j += 1
-            }
-            if (STREAM_HELPERS.has(source.slice(i, j))) {
-                let k = j
-                while (k < parenEnd && /\s/.test(source[k] ?? '')) {
-                    k += 1
-                }
-                /* `jsonl(` a call, `jsonl<` a generic call — either is the streaming constructor. */
-                if (source[k] === '(' || source[k] === '<') {
-                    return true
-                }
-            }
-            i = j
-            continue
-        }
-        i += 1
-    }
-    return false
-}
-
-/* The call's top-level arguments, trimmed, with empty parts (a trailing comma) dropped —
-   `[handler]` or `[handler, opts]`. Depth-aware and skips strings/comments/regex so commas
-   inside the handler body or opts don't miscount. */
-function splitTopLevelArgs(source: string, parenStart: number, parenEnd: number): string[] {
-    const parts: string[] = []
-    let depth = 0
-    let start = parenStart + 1
-    let i = parenStart + 1
-    while (i < parenEnd) {
-        const skipped = skipNonCode(source, i)
-        if (skipped !== undefined) {
-            i = skipped
-            continue
-        }
-        const c = source[i]
-        if (c === '(' || c === '{' || c === '[') {
-            depth += 1
-        } else if (c === ')' || c === '}' || c === ']') {
-            depth -= 1
-        } else if (c === ',' && depth === 0) {
-            parts.push(source.slice(start, i).trim())
-            start = i + 1
-        }
-        i += 1
-    }
-    parts.push(source.slice(start, parenEnd).trim())
-    return parts.filter((part) => part.length > 0)
-}

package/src/lib/shared/prepareSocketModule.ts

@@ -1,46 +0,0 @@
-import { prepareRemoteExport } from './prepareRemoteExport.ts'
-import { DEFINE_SOCKET_GLOBAL } from './RPC_SHIM_GLOBALS.ts'
-
-const SINGLE_EXPORT_ERROR =
-    '[abide] $sockets module contains more than one `socket(...)` export — each file must declare exactly one socket'
-
-export type PreparedSocketModule = {
-    exportName: string
-    rewriteForServer: (name: string) => string
-}
-
-/*
-Scans a `$sockets/**` module once and returns its declared export name
-plus a closure that, given the socket name, emits the server-side
-rewrite (`__abideDefineSocket__("<name>"[, opts])` spliced into the
-original source). The strip + find envelope is the shared prepareRemoteExport
-scan; this module only supplies the socket import subpath and ident, then
-splices its own binding.
-*/
-export function prepareSocketModule(
-    source: string,
-    importName: string,
-): PreparedSocketModule | undefined {
-    const prepared = prepareRemoteExport(
-        source,
-        importName,
-        (name) => [`${name}/server/socket`],
-        (ident) => ident === 'socket',
-        SINGLE_EXPORT_ERROR,
-    )
-    if (!prepared) {
-        return undefined
-    }
-    const { stripped, site } = prepared
-    return {
-        exportName: site.exportName,
-        rewriteForServer(name: string): string {
-            const inner = stripped.slice(site.parenStart + 1, site.parenEnd).trim()
-            const binding =
-                inner.length === 0
-                    ? `${DEFINE_SOCKET_GLOBAL}(${JSON.stringify(name)})`
-                    : `${DEFINE_SOCKET_GLOBAL}(${JSON.stringify(name)}, ${stripped.slice(site.parenStart + 1, site.parenEnd)})`
-            return stripped.slice(0, site.callStart) + binding + stripped.slice(site.parenEnd + 1)
-        },
-    }
-}

package/src/lib/shared/probeRegistries.ts

@@ -1,68 +0,0 @@
-import { cacheStores } from './cacheStores.ts'
-import { isSubscribable } from './isSubscribable.ts'
-import { selectorMatcher } from './selectorMatcher.ts'
-import { selectorPrefix } from './selectorPrefix.ts'
-import { tailProbeSlot } from './tailProbeSlot.ts'
-import type { CacheEntry } from './types/CacheEntry.ts'
-import type { CacheSelector } from './types/CacheSelector.ts'
-import type { CacheStore } from './types/CacheStore.ts'
-import type { NamedAsyncIterable } from './types/NamedAsyncIterable.ts'
-
-/*
-Shared scan behind the pending() / refreshing() probes: one selector
-interpretation and one tap order — the lifecycle channel is tapped before
-any check, so short-circuiting can't skip a subscription and a $derived
-re-runs whenever a matching call or stream changes state. The tap is scoped
-to the selector: a fn selector taps only its own prefix channel, so reading
-`pending(fn)` in an effect can't be re-woken by unrelated cache events (an
-effect that probes one fn and invalidates another no longer feeds itself);
-bare and tag selectors scan many entries and tap the store-wide channel. A
-producer never cached resolves no prefix yet and taps store-wide — its first
-cache() marks that channel, the re-derive resolves the prefix, and the scope
-re-tracks narrowed. `matchesEntry` is the probe's cache-side question;
-`field` selects the stream-side answer; `unprobed` is the answer for a
-stream no prober can see (server, or tail never imported) — matching what
-tail() itself reports there. The bare form (no selector) spans every
-registry; fn/tag selectors are cache identities only. Outside a tracking scope
-the taps are no-ops and the current value returns.
-*/
-export function probeRegistries<Args, Return>(
-    arg: CacheSelector<Args, Return> | NamedAsyncIterable<unknown> | undefined,
-    args: Args | undefined,
-    field: 'pending' | 'refreshing',
-    matchesEntry: (entry: CacheEntry) => boolean,
-    unprobed: boolean,
-): boolean {
-    if (isSubscribable(arg)) {
-        return tailProbeSlot.probe?.(arg.name)?.[field] ?? unprobed
-    }
-    /* fn + args narrows further: the exact key is a one-entry "prefix" (its === branch). */
-    const prefix = selectorPrefix(arg, args)
-    const stores = cacheStores()
-    stores.forEach((store) => {
-        store.trackLifecycle(prefix)
-    })
-    const streams = arg === undefined ? tailProbeSlot.probe?.() : undefined
-    const matches = selectorMatcher(arg, args, prefix)
-    return (
-        stores.some((store) => anyEntryMatches(store, matchesEntry, matches)) ||
-        streams?.[field] === true
-    )
-}
-
-/*
-A plain for-of over the entries Map rather than .values().some() — Iterator
-Helpers are too new for this module's browser baseline (see producerKey).
-*/
-function anyEntryMatches(
-    store: CacheStore,
-    matchesEntry: (entry: CacheEntry) => boolean,
-    matches: (entry: CacheEntry) => boolean,
-): boolean {
-    for (const entry of store.entries.values()) {
-        if (matchesEntry(entry) && matches(entry)) {
-            return true
-        }
-    }
-    return false
-}

package/src/lib/shared/producerKey.ts

@@ -1,32 +0,0 @@
-import { canonicalJson } from './canonicalJson.ts'
-
-/*
-Producers have no wire identity, so each is assigned a stable id on first use,
-kept in a WeakMap so it's collected with the function. The cache key is that id
-plus the canonicalised args — a hoisted producer dedupes across calls; an inline
-arrow gets a fresh id every call and never does.
-
-`producerKey.existing` reads the id without assigning one — selectors matching
-prior entries must not mint identities for producers never cached.
-*/
-const producerIds = new WeakMap<object, string>()
-let producerCounter = 0
-
-export function producerKey(producer: object, args: unknown): string {
-    /* Not getOrInsertComputed: shared module ships to the browser, where support is too new (Safari 26.2 / Chrome 145). */
-    let id = producerIds.get(producer)
-    if (id === undefined) {
-        id = `@producer:${++producerCounter}`
-        producerIds.set(producer, id)
-    }
-    return args === undefined ? id : `${id} ${canonicalJson(args)}`
-}
-
-/* With `args`, the exact entry key for that call (same format as producerKey) — still never minting. */
-producerKey.existing = function existing(producer: object, args?: unknown): string | undefined {
-    const id = producerIds.get(producer)
-    if (id === undefined || args === undefined) {
-        return id
-    }
-    return `${id} ${canonicalJson(args)}`
-}

package/src/lib/shared/programNameForPackage.ts

@@ -1,16 +0,0 @@
-import { fileName } from './fileName.ts'
-
-/*
-Derives the CLI program/binary name from a package.json `name` field.
-Scoped names (`@scope/tool`) keep only the final segment so the value is
-safe as a filesystem path, tar entry name, and CLI display name — a raw
-`/` would otherwise nest the binary into an unexpected directory and break
-the `/__abide/cli/<platform>` download route's path lookup. Falls back to
-`app` when the name is absent or empty.
-*/
-export function programNameForPackage(name: string | undefined): string {
-    if (name === undefined || name === '') {
-        return 'app'
-    }
-    return fileName(name) || 'app'
-}

package/src/lib/shared/promptNameForFile.ts

@@ -1,10 +0,0 @@
-/*
-Translates a prompt file path under `src/mcp/prompts/` into the prompt's
-MCP name. Strips `.md` and joins nested folder segments with `-` (e.g.
-`code/review.md` → `code-review`) so two prompts with the same stem in
-different folders don't collide and the name stays a single valid MCP
-prompt identifier.
-*/
-export function promptNameForFile(relativePath: string): string {
-    return relativePath.replace(/\.md$/, '').replaceAll('/', '-')
-}

package/src/lib/shared/queryStringFromArgs.ts

@@ -1,38 +0,0 @@
-/*
-Canonical query-string encoding for a query-carrying rpc's args bag. The
-single definition both the synthesized Request (buildRpcRequest) and its
-cache key (keyForRemoteCall) build their query from, so the request URL and
-the key encode every value identically and can't drift. `undefined` values
-are dropped; each surviving value is coerced with String() and percent-
-encoded with encodeURIComponent on both name and value. Keys come in
-insertion order for the request and sorted for the key (`sort`), so the key
-is stable under arg reordering. Returns the query body without a leading
-`?` (empty string when nothing survives the filter). Concatenated in one
-walk — no entries / filtered / URLSearchParams intermediates — to keep the
-hot GET-cache path allocation-light. Callers validate that `args` is a
-plain object first; this assumes that.
-
-A non-primitive VALUE throws: String() would flatten every object to
-'[object Object]', so distinct calls would collide onto one request URL and
-one cache key — the first call's data silently served for the second.
-*/
-export function queryStringFromArgs(args: Record<string, unknown>, sort: boolean): string {
-    const keys = sort ? Object.keys(args).sort() : Object.keys(args)
-    let query = ''
-    for (const key of keys) {
-        const value = args[key]
-        if (value === undefined) {
-            continue
-        }
-        const kind = typeof value
-        if (value !== null && (kind === 'object' || kind === 'function' || kind === 'symbol')) {
-            const got = Array.isArray(value) ? 'array' : kind
-            throw new TypeError(
-                `[abide] query arg "${key}" must be a primitive — got ${got} (query-carrying methods can't encode structured values; move the arg to a POST body)`,
-            )
-        }
-        query += query ? '&' : ''
-        query += `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`
-    }
-    return query
-}

package/src/lib/shared/randomHexId.ts

@@ -1,14 +0,0 @@
-/*
-Mints a random lowercase-hex id of `bytes` length via the web-standard
-crypto.getRandomValues — trace ids (16 bytes) and span ids (8 bytes). Loops on
-the all-zero value, which W3C Trace Context reserves as invalid.
-*/
-export function randomHexId(bytes: number): string {
-    const buffer = new Uint8Array(bytes)
-    let id = ''
-    do {
-        crypto.getRandomValues(buffer)
-        id = Array.from(buffer, (byte) => byte.toString(16).padStart(2, '0')).join('')
-    } while (/^0+$/.test(id))
-    return id
-}

package/src/lib/shared/reachable.ts

@@ -1,99 +0,0 @@
-import { createReachable } from './createReachable.ts'
-import { parseBoundedEnvInt } from './parseBoundedEnvInt.ts'
-
-/*
-Isomorphic outbound reachability. `await reachable(host)` HEADs the host's
-origin: the first call awaits a real probe (faithful — a down host costs the
-full timeout, an up host one handshake) and caches the verdict for one TTL, so
-every later call within the TTL resolves instantly off the cached value. The
-first call after the TTL expires re-probes; a host going down (or recovering) is
-noticed on the next read past its cached verdict, not continuously.
-
-  if (!(await reachable('api.example.com'))) return error(503)
-
-No host asks about the app's own backend: constant true on the server (the
-server IS the backend — health()'s rule) and on a loopback origin (`abide
-dev`, a desktop bundle's embedded server — this machine, reachable by
-construction even with the network gone); a deployed origin probes like any
-other host.
-
-A bare host defaults to https; pass an explicit http://… for a non-TLS host.
-Answers "can I connect to this host," NOT "is my endpoint healthy": any
-completed HTTP response (even 4xx/5xx, even a 405 to HEAD) counts as reachable;
-only a connection failure or timeout reads as unreachable.
-
-Same callable both sides. The server has no ambient connectivity signal, so
-this is the honest way to fail a doomed outbound call fast — see online() for
-the inbound/client-reported counterpart. The browser probes no-cors (a
-completed opaque response proves connectivity without the host's CORS
-blessing) and composes navigator.onLine in at read time, so a lost network
-reports false instantly instead of waiting out the cached value — except for
-loopback hosts, which need no network.
-
-ABIDE_REACHABLE_TTL (cache freshness, ms) and ABIDE_REACHABLE_TIMEOUT
-(per-HEAD bound, ms) tune the server defaults; the browser has no env, so it
-runs the defaults. The timeout is deliberately generous so a healthy-but-
-distant host over a slow link is not mis-read as down.
-*/
-const env = typeof process === 'undefined' ? undefined : process.env
-const TTL_MS = parseBoundedEnvInt(env?.ABIDE_REACHABLE_TTL, 1_000, 600_000) ?? 30_000
-const TIMEOUT_MS = parseBoundedEnvInt(env?.ABIDE_REACHABLE_TIMEOUT, 100, 60_000) ?? 3_000
-
-/* Status-agnostic HEAD: a completed response proves connectivity; reject/timeout does not.
-   The browser probes no-cors — an opaque response still completes, so a foreign origin
-   without CORS headers can't mis-read an up host as down. */
-async function probeOrigin(origin: string): Promise<boolean> {
-    try {
-        await fetch(origin, {
-            method: 'HEAD',
-            mode: typeof window === 'undefined' ? undefined : 'no-cors',
-            signal: AbortSignal.timeout(TIMEOUT_MS),
-        })
-        return true
-    } catch {
-        return false
-    }
-}
-
-const registry = createReachable({
-    probe: probeOrigin,
-    ttlMs: TTL_MS,
-})
-
-/* Loopback = this machine: no network between, so no probe and no offline gate. */
-function isLoopbackHost(hostname: string): boolean {
-    return (
-        hostname === 'localhost' ||
-        hostname.endsWith('.localhost') ||
-        hostname.startsWith('127.') ||
-        hostname === '[::1]'
-    )
-}
-
-/* Mirrors the registry's normalization: a bare host defaults to https. */
-function hostnameOf(host: string | URL): string {
-    const url = typeof host === 'string' && !/^https?:\/\//i.test(host) ? `https://${host}` : host
-    return new URL(url).hostname
-}
-
-// @documentation observability
-export function reachable(host?: string | URL): Promise<boolean> {
-    if (typeof window === 'undefined') {
-        /* No host = the app's own backend, and the server IS the backend. */
-        return host === undefined ? Promise.resolve(true) : registry.reachable(host)
-    }
-    if (host === undefined) {
-        /* The app's own backend = the page's origin. Loopback served this very page
-           from this machine — reachable by construction, never worth a poll. */
-        if (isLoopbackHost(location.hostname)) {
-            return Promise.resolve(true)
-        }
-        host = location.origin
-    }
-    /* window-gated because Bun defines a partial navigator; `=== false` because only an
-       explicit offline report is reliable. A loopback host is exempt — no network needed. */
-    if (navigator.onLine === false && !isLoopbackHost(hostnameOf(host))) {
-        return Promise.resolve(false)
-    }
-    return registry.reachable(host)
-}

package/src/lib/shared/readEnvFile.ts

@@ -1,15 +0,0 @@
-import { existsSync } from 'node:fs'
-import { parseEnv } from './parseEnv.ts'
-
-/*
-Reads a `.env` at `path` into a key→value record, or {} when it doesn't exist.
-The shared read-and-parse primitive: loadEnvFile builds on it to merge into
-process.env, and the bundle launcher uses the record directly to resolve config
-form pre-fills.
-*/
-export async function readEnvFile(path: string): Promise<Record<string, string>> {
-    if (!existsSync(path)) {
-        return {}
-    }
-    return parseEnv(await Bun.file(path).text())
-}

package/src/lib/shared/readLastConnection.ts

@@ -1,18 +0,0 @@
-import { lastConnectionPath } from './lastConnectionPath.ts'
-import type { LastConnection } from './types/LastConnection.ts'
-
-/*
-Reads the saved connection intent, or undefined when none is recorded or the file
-is unreadable/corrupt — callers treat undefined as "nothing to resume".
-*/
-export async function readLastConnection(programName: string): Promise<LastConnection | undefined> {
-    const file = Bun.file(lastConnectionPath(programName))
-    if (!(await file.exists())) {
-        return undefined
-    }
-    try {
-        return (await file.json()) as LastConnection
-    } catch {
-        return undefined
-    }
-}

package/src/lib/shared/readPackageJson.ts

@@ -1,9 +0,0 @@
-/*
-Reads and parses a project's `package.json`, or undefined when absent. Callers
-apply their own field defaults — this centralizes only the exists-check + parse
-boilerplate. Bun.file().json() so no Node fs.
-*/
-export async function readPackageJson(cwd: string): Promise<Record<string, unknown> | undefined> {
-    const file = Bun.file(`${cwd}/package.json`)
-    return (await file.exists()) ? ((await file.json()) as Record<string, unknown>) : undefined
-}

package/src/lib/shared/recordRemoteMeta.ts

@@ -1,5 +0,0 @@
-import { remoteMetaStore } from './remoteMetaStore.ts'
-
-export function recordRemoteMeta(promise: Promise<unknown>, getRequest: () => Request): void {
-    remoteMetaStore.set(promise, getRequest)
-}