@abide/abide 0.58.0 → 0.100.0

package/src/lib/shared/refresh.ts

@@ -1,39 +0,0 @@
-import { cacheStalenessSlot } from './cacheStalenessSlot.ts'
-import { isAsyncCell } from './isAsyncCell.ts'
-import type { AsyncComputed } from './types/AsyncComputed.ts'
-import type { CacheSelector } from './types/CacheSelector.ts'
-
-/*
-Refetch every cached read matching the selector, keeping the stale value visible
-until the fresh one swaps in (refreshing() true meanwhile) — the smart-call
-refetch. Because the smart read retains its value on the client (SWR
-unconditional there), a refresh always refetches-and-swaps; it never drops to a
-pending blank. Follows the shared selector grammar:
-
-  refresh(getFoo, args)   → that exact call
-  refresh(getFoo)         → every args-variant of that rpc
-  refresh({ tags })       → every entry sharing a tag
-  refresh()               → every entry
-
-Instance sugar `getFoo.refresh(args?)` ≡ `refresh(getFoo, args?)`. Reports, never
-retains a spinner — pair with `refreshing()` to surface the in-flight reload.
-
-Isomorphic (ADR-0041): applied LOCALLY on the client, and on the SERVER it now
-broadcasts to every connected client (each refetches eagerly) instead of mutating a
-throwaway request store that reached no browser. The side-swap rides the
-cacheStalenessSlot resolver — this source is byte-identical on both sides. The
-paired drop verb is `invalidate`.
-*/
-// @documentation cache
-export function refresh<Args, Return>(
-    arg?: CacheSelector<Args, Return> | AsyncComputed<unknown>,
-    args?: Args,
-): void {
-    /* An async cell re-invokes its own seed (`refresh(cell)` ≡ `cell.refresh()`). */
-    if (isAsyncCell(arg)) {
-        arg.refresh()
-        return
-    }
-    /* Side-swap: the client entry applies locally; the server entry broadcasts. */
-    cacheStalenessSlot.get()?.('refresh', arg as CacheSelector<Args, Return>, args)
-}

package/src/lib/shared/refreshing.ts

@@ -1,37 +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 revalidation probe over both registries. Refreshing means "holding a
-value it already had while a fresher source is in flight":
-  refreshing()              → anything reloading data it already had
-  refreshing(fn)            → that function's calls (per-route "updating…" badge)
-  refreshing(fn, args)      → exactly that call (per-row badge)
-  refreshing({ tags })      → a tagged group
-  refreshing(subscribable)  → that stream reconnecting with its last value
-                              retained — never merely `open`; a live stream's
-                              arriving frames are its normal mode, not a reload
-On the cache side this covers a policy stale-while-revalidate refetch (settled,
-value visible, fresh fetch in flight) and the default drop-then-reload (pending
-is also true there). The distinction from pending(): pending answers "is there
-no value yet?", refreshing answers "is a held value being superseded?".
-Probes report, never act. Scan semantics (tap order, selector grammar,
-registry spans) live in probeRegistries.
-*/
-// @documentation probes
-export function refreshing<Args, Return>(
-    arg?: CacheSelector<Args, Return> | NamedAsyncIterable<unknown> | AsyncComputed<unknown>,
-    args?: Args,
-): boolean {
-    /* An async cell answers from its own facet (`refreshing(cell)` ≡ `cell.refreshing()`). */
-    if (isAsyncCell(arg)) {
-        return arg.refreshing()
-    }
-    return probeRegistries(arg, args, 'refreshing', reloading, false)
-}
-
-const reloading = (entry: CacheEntry) => entry.refreshing === true

package/src/lib/shared/remoteMetaStore.ts

@@ -1,16 +0,0 @@
-/*
-WeakMap that records how to obtain the synthesized Request for a rpc
-call. The cache layer reads it to populate an entry's stored request
-without rebuilding from scratch.
-
-Stored as a thunk rather than the Request itself so SSR pages that fire
-dozens of in-process rpc calls without ever reaching cache() don't pay
-the URL + Headers + Request allocation per call. The thunk memoises its
-own first call inside createRemoteFunction, so cache() and any future
-meta reader see the same Request instance.
-
-method/url/key are intentionally not stored — they're derivable from
-the RemoteFunction itself, and cache() does that derivation
-independently.
-*/
-export const remoteMetaStore = new WeakMap<Promise<unknown>, () => Request>()

package/src/lib/shared/requestScopeSlot.ts

@@ -1,13 +0,0 @@
-import { createResolverSlot } from './createResolverSlot.ts'
-import type { RequestScopeInfo } from './types/RequestScopeInfo.ts'
-
-/*
-The request-scope slot. The server installs an ALS-backed resolver
-(createServer, reading the RequestStore); the client a module-singleton seeded
-from __SSR__ (startClient). No fallback creator — an unset resolver (or one
-returning undefined outside any request) means "no scope": callers read
-`.resolver?.()` and treat undefined as absent (trace() returns undefined and
-log lines print without the context prefix). Test helpers snapshot/poke
-`.resolver` directly.
-*/
-export const requestScopeSlot = createResolverSlot<RequestScopeInfo>()

package/src/lib/shared/resolveClientFlags.ts

@@ -1,20 +0,0 @@
-import type { ClientFlags } from './types/ClientFlags.ts'
-
-/*
-Fills in the missing keys of a user-supplied `clients` option. Browser
-always defaults to true (the historical surface). The mcp/cli auto-on
-defaults are decided by the caller and passed in, since the safe default
-differs per declaration: a read-only rpc may auto-expose to MCP while a
-mutating one must not, and sockets gate differently again. Explicit
-values in `flags` always win over the computed defaults.
-*/
-export function resolveClientFlags(
-    flags: Partial<ClientFlags> | undefined,
-    defaults: { mcp: boolean; cli: boolean },
-): ClientFlags {
-    return {
-        browser: flags?.browser ?? true,
-        mcp: flags?.mcp ?? defaults.mcp,
-        cli: flags?.cli ?? defaults.cli,
-    }
-}

package/src/lib/shared/resolvedCellsSlot.ts

@@ -1,13 +0,0 @@
-import { createResolverSlot } from './createResolverSlot.ts'
-import type { ResolvedCells } from './types/ResolvedCells.ts'
-
-/*
-The active resolved-async-cells slot — mirrors `pendingAsyncCellsSlot`. The server entry installs
-an ALS-backed resolver (a fresh list per request, so concurrent SSR renders never mix their warm
-seeds); with no resolver registered a single fallback list is created lazily so isolated tests
-work without booting the runtime. `createAsyncCell` pushes a `{key, value}` when a seed settles
-server-side; the page renderer reads it at render-return to stamp `__SSR__.cells`.
-*/
-export const resolvedCellsSlot = createResolverSlot<ResolvedCells>(() => ({
-    entries: [],
-}))

package/src/lib/shared/responseBodyKind.ts

@@ -1,35 +0,0 @@
-import { contentBodyKind } from './contentBodyKind.ts'
-import { contentTypeOf } from './contentTypeOf.ts'
-
-/*
-Compressible Content-Types — text and structured-text payloads. Binary or
-already-compressed bodies (images, fonts, archives, zstd/gzip blobs) gain
-nothing from a second pass and only burn CPU.
-*/
-const COMPRESSIBLE_TYPE =
-    /^(?:text\/|application\/(?:json|javascript|xml|[\w.-]+\+(?:json|xml))|image\/svg)/
-
-/*
-The post-handler body class that decides a dynamic response's wire handling:
-`streaming` (SSE / JSONL — drained frame-by-frame, never gzip-buffered, opted
-out of the idle timeout), `compressible` (text/structured-text — gzipped when
-the client accepts it), or `opaque` (binary/already-encoded — passed through).
-
-One header read + classify per response, threaded through the dispatch pipeline
-so `gzipResponse` and the idle-timeout opt-out don't each re-derive it from the
-Content-Type (the S2 finding: the same body was classified 3-4×). Mirrors the
-shared `contentBodyKind` streaming bucket so the wire path and the decode path
-can't disagree on what's a stream.
-*/
-export type ResponseBodyKind = 'streaming' | 'compressible' | 'opaque'
-
-export function responseBodyKind(response: Response): ResponseBodyKind {
-    const contentType = contentTypeOf(response.headers)
-    if (contentBodyKind(contentType) === 'streaming') {
-        return 'streaming'
-    }
-    if (COMPRESSIBLE_TYPE.test(contentType)) {
-        return 'compressible'
-    }
-    return 'opaque'
-}

package/src/lib/shared/responseErrorText.ts

@@ -1,9 +0,0 @@
-/*
-Human-readable message for a non-2xx Response: `status statusText: body`.
-Shared by the CLI error path and the MCP tool result so the two frame a
-failed request identically. Consumes the body, so call only on a response
-you're done with.
-*/
-export async function responseErrorText(response: Response): Promise<string> {
-    return `${response.status} ${response.statusText}: ${await response.text()}`
-}

package/src/lib/shared/reviveWireField.ts

@@ -1,49 +0,0 @@
-import type { WireKind } from './types/WireKind.ts'
-
-/*
-One field's honest-JSON wire value → its declared runtime type, fail-open — the decode core
-shared by the rpc RESPONSE revival (`reviveWireOutput`) and the INPUT revival (`parseArgs`), so
-the two ends can't drift on how a wire form decodes (ADR-0029). A `Set`/`Map` already carried by
-an abide ref-json body passes through; a wire array becomes the `Set`/`Map`; an ISO string becomes
-a `Date`; a digit string becomes a `bigint`. An already-typed or non-matching value is returned
-untouched so the codec never throws.
-
-Callers layer their own-side extras on top: the input side additionally accepts a plain object as
-`Map` entries and coerces query/form STRINGS to number/boolean (see `parseArgs`). Top-level fields
-only — a structured value nested deeper is not descended into (deferred, ADR-0029).
-*/
-export function reviveWireField(value: unknown, kind: WireKind): unknown {
-    if (kind === 'set') {
-        if (value instanceof Set) {
-            return value
-        }
-        return Array.isArray(value) ? new Set(value) : value
-    }
-    if (kind === 'map') {
-        if (value instanceof Map) {
-            return value
-        }
-        return Array.isArray(value) ? new Map(value as [unknown, unknown][]) : value
-    }
-    if (kind === 'date') {
-        if (typeof value !== 'string') {
-            return value
-        }
-        const date = new Date(value)
-        return Number.isNaN(date.getTime()) ? value : date
-    }
-    if (kind === 'bigint') {
-        if (typeof value !== 'string' || value.trim() === '') {
-            return value
-        }
-        try {
-            return BigInt(value)
-        } catch {
-            /* A non-integer literal throws — keep the string rather than crash the decode. */
-            return value
-        }
-    }
-    /* number/boolean ride as their JSON type on the wire; nothing to revive here (the input side
-       coerces them from query/form strings separately). */
-    return value
-}

package/src/lib/shared/reviveWireOutput.ts

@@ -1,36 +0,0 @@
-import { reviveWireField } from './reviveWireField.ts'
-import type { OutputWirePlan } from './types/OutputWirePlan.ts'
-
-/*
-The type-directed wire DECODE step for a rpc success response (ADR-0029 output path) — the
-response-side sibling of parseArgs' input revival. The server encoded a handler's structured
-return into honest JSON (`wireJsonReplacer`): a `Set` → array, a `Map` → `[K,V]` entries, a
-`bigint` → digit string, a `Date` → ISO string. A wire array is ambiguous (a real `T[]` vs an
-encoded `Set<T>`), so the abide client revives from the DECLARED kind the warm server program baked
-onto the stub (`OutputWirePlan`), applied to a DECODED response body here. Only the fields named in
-the plan are touched; a genuine array / scalar the plan omits is left as-is.
-
-Mutates the decoded body in place — the value is call-private (a fresh JSON.parse result or a
-freshly cloned warm value), never shared. Fail-open at every branch: no plan, a non-object body, or
-an unrevivable field value keeps the honest-JSON form so a type/runtime mismatch degrades visibly
-rather than throwing. Top-level fields only; a structured value nested deeper is not descended into
-(deferred, ADR-0029).
-*/
-export function reviveWireOutput(value: unknown, plan: OutputWirePlan | undefined): unknown {
-    if (plan === undefined) {
-        return value
-    }
-    /* Only a plain object carries the named fields; a top-level array/scalar/null has none. */
-    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-        return value
-    }
-    const record = value as Record<string, unknown>
-    for (const key in plan) {
-        const fieldPlan = plan[key]
-        if (fieldPlan === undefined || !(key in record)) {
-            continue
-        }
-        record[key] = reviveWireField(record[key], fieldPlan)
-    }
-    return value
-}

package/src/lib/shared/routeParamsShape.ts

@@ -1,20 +0,0 @@
-import { parseRouteSegments } from './parseRouteSegments.ts'
-
-/*
-The TypeScript type literal for a route's path params — `{ "id": string }` for
-`/post/[id]`, `Record<string, never>` for a param-less route. Walks the `[name]` /
-`[[name]]` / `[...rest]` segments; a catch-all maps to `string` under its declared
-name (matchRoute captures it there, `''` when it consumed nothing), and an
-`[[optional]]` maps to an optional key (absent from params when unmatched). The
-single source of truth shared by `writeRoutesDts` (page.params typing) and the
-`.abide` check shadow (page `props()` typing).
-*/
-export function routeParamsShape(routeUrl: string): string {
-    const entries = parseRouteSegments(routeUrl)
-        .filter((segment) => segment.kind === 'param')
-        .map((segment) => `${JSON.stringify(segment.name)}${segment.optional ? '?' : ''}: string`)
-    if (entries.length === 0) {
-        return 'Record<string, never>'
-    }
-    return `{ ${entries.join('; ')} }`
-}

package/src/lib/shared/rpcErrorRegistry.ts

@@ -1,69 +0,0 @@
-import { createSignalNode } from '../ui/runtime/createSignalNode.ts'
-import { track } from '../ui/runtime/track.ts'
-import { trigger } from '../ui/runtime/trigger.ts'
-
-/*
-The rpc's error memory — the last error per call identity (the keyForRemoteCall
-key), recorded at the rpc call boundary and cleared on a later success or
-invalidate. Orthogonal to the cache entry lifecycle (design Fork 1): the cache
-still evicts on error exactly as before; this remembers the error for reactive
-reads. One shared signal node backs reactivity — readers `track` it, writers
-`trigger` it — the same coarse lifecycle-channel pattern the cache probes use.
-*/
-const node = createSignalNode(undefined)
-const errors = new Map<string, unknown>()
-
-/* Insertion order = recency; a re-record moves the key to the tail so readAny returns latest. */
-function bump(key: string, error: unknown): void {
-    errors.delete(key)
-    errors.set(key, error)
-}
-
-export const rpcErrorRegistry = {
-    record(key: string, error: unknown): void {
-        /* Client-only: on the server the boundary runs per request, and this Map is a single
-           module global — recording would leak errors across requests/users and grow unbounded.
-           SSR errors surface through `{:catch}`; the reactive probe is a client feature, so the
-           server keeps the Map empty (reads return undefined there). */
-        if (typeof window === 'undefined') {
-            return
-        }
-        bump(key, error)
-        trigger(node)
-    },
-    clear(key: string): void {
-        if (errors.delete(key)) {
-            trigger(node)
-        }
-    },
-    /* Clears every error whose key is, or is prefixed by, the selector's `method url` —
-       so `invalidate(fn)` resets a whole rpc's errors, and `invalidate(fn, args)` (an exact
-       key prefix) resets just that call. Covers bare-call errors that never became entries. */
-    clearMatching(prefix: string): void {
-        let changed = false
-        for (const key of errors.keys()) {
-            if (key === prefix || key.startsWith(`${prefix} `)) {
-                errors.delete(key)
-                changed = true
-            }
-        }
-        if (changed) {
-            trigger(node)
-        }
-    },
-    read(key: string): unknown {
-        track(node)
-        return errors.get(key)
-    },
-    /* Most-recent error whose key is, or is prefixed by, the fn selector's `method url`. */
-    readAny(prefix: string): unknown {
-        track(node)
-        let latest: unknown
-        for (const [key, error] of errors) {
-            if (key === prefix || key.startsWith(`${prefix} `)) {
-                latest = error
-            }
-        }
-        return latest
-    },
-}

package/src/lib/shared/rpcServerForRoot.ts

@@ -1,25 +0,0 @@
-import { createRpcServerProgram, type RpcServerProgram } from './createRpcServerProgram.ts'
-
-/*
-Warm per-root accessor for the rpc server program (ADR-0025 D1), mirroring the UI shadow's
-`interpolationClassifierForRoot`: the first rpc transform in a root builds the `ts.Program`,
-every later transform (streaming/method query) reuses it. Fails open in two layers — a
-program that can't build stores `undefined` so the root is not retried and every query falls
-back to the char-scan (each query method also catches per-query throws). The cache lives
-in the resolver plugin's `setup` closure, so it persists across a whole build and is dropped
-between plugin instances.
-*/
-export function rpcServerForRoot(
-    cache: Map<string, RpcServerProgram | undefined>,
-    cwd: string,
-    rpcDir: string,
-): RpcServerProgram | undefined {
-    if (!cache.has(cwd)) {
-        try {
-            cache.set(cwd, createRpcServerProgram(cwd, rpcDir))
-        } catch {
-            cache.set(cwd, undefined)
-        }
-    }
-    return cache.get(cwd)
-}

package/src/lib/shared/rpcTimeoutSlot.ts

@@ -1,9 +0,0 @@
-/*
-Slot the client entry registers the env-configured RPC fetch timeout (ms)
-into. The server reads ABIDE_CLIENT_TIMEOUT at boot and ships it via
-__SSR__.clientTimeout, so the value reflects the running server's env rather
-than build time; startClient installs it here and remoteProxy reads it.
-undefined = no timeout (the default — RPC fetches stay unbounded as before).
-Mirrors baseSlot.
-*/
-export const rpcTimeoutSlot: { ms: number | undefined } = { ms: undefined }

package/src/lib/shared/rpcUrlForFile.ts

@@ -1,19 +0,0 @@
-/*
-Maps an rpc-relative path (under `src/server/rpc/`) to its URL. Each file
-is one endpoint at `/rpc/<file path>`, dropping the `.ts` extension.
-$rpc URLs are flat function-call endpoints (args go in query or body), so
-bracket-style `[name]` / `[...rest]` segments are rejected — those belong
-in `src/ui/pages/` where they map to dynamic path params.
-*/
-export function rpcUrlForFile(relPath: string): string {
-    const withoutExt = relPath.replace(/\.ts$/, '')
-    const segments = withoutExt.split('/').filter(Boolean)
-    for (const segment of segments) {
-        if (segment.startsWith('[')) {
-            throw new Error(
-                `[abide] src/server/rpc/${relPath} has a dynamic segment '${segment}' — $rpc URLs are flat; pass identifiers via args, not the path`,
-            )
-        }
-    }
-    return `/rpc/${segments.join('/')}`
-}

package/src/lib/shared/runningAsStandaloneBinary.ts

@@ -1,13 +0,0 @@
-/*
-True when this code runs inside a `bun build --compile` standalone executable
-(the bundle's embedded server, or an install-tarball server binary) rather than
-under the `bun` CLI. Bun mounts a compiled binary's embedded modules under a
-synthetic root — `/$bunfs/…` on posix, `…~BUN…` on Windows — so `Bun.main`
-carries that marker only in a standalone binary; under `bun dev`/`bun start`
-it's a real on-disk path. Used to scope the bundle's data-dir/binary-dir `.env`
-loading to the shipped app, so `bun dev`/`bun start` keep to their project-local
-CWD `.env` alone.
-*/
-export function runningAsStandaloneBinary(): boolean {
-    return Bun.main.includes('$bunfs') || Bun.main.includes('~BUN')
-}

package/src/lib/shared/safeJsonForScript.ts

@@ -1,17 +0,0 @@
-/*
-Escapes characters that could prematurely terminate the surrounding <script>
-tag or be interpreted as HTML comment delimiters when a JSON literal is
-inlined into an HTML document. U+2028 (LS) and U+2029 (PS) are valid in JSON
-but break a `<script>` tag's inline content because the JavaScript lexer
-treats them as line terminators; encode them as Unicode escapes.
-*/
-const LINE_SEPARATOR = String.fromCharCode(0x2028)
-const PARAGRAPH_SEPARATOR = String.fromCharCode(0x2029)
-
-export function safeJsonForScript(value: unknown): string {
-    return JSON.stringify(value)
-        .replace(/</g, '\\u003c')
-        .replace(/-->/g, '--\\u003e')
-        .replaceAll(LINE_SEPARATOR, '\\u2028')
-        .replaceAll(PARAGRAPH_SEPARATOR, '\\u2029')
-}

package/src/lib/shared/scanPages.ts

@@ -1,25 +0,0 @@
-import { existsSync } from 'node:fs'
-import { Glob } from 'bun'
-import { fileName } from './fileName.ts'
-import type { PagesScan } from './types/PagesScan.ts'
-
-/*
-Walks src/ui/pages once and classifies each `.abide` leaf by filename: a
-`page.abide` is a route (its URL is the folder path), a `layout.abide` is a
-layout that wraps every page at or below its folder (keyed by the same folder
-URL). Any other `.abide` file (a shared component) is ignored here — free to
-live anywhere and be imported relatively. Shared by the resolver plugin's
-pages/layouts manifests and generateDeclarations' routes.d.ts so the two never
-diverge on what counts as a route.
-*/
-export async function scanPages(pagesDir: string): Promise<PagesScan> {
-    if (!existsSync(pagesDir)) {
-        return { pageFiles: [], layoutFiles: [] }
-    }
-    const allFiles = await Array.fromAsync(new Glob('**/*.abide').scan({ cwd: pagesDir }))
-    const leafIs = (name: string) => (file: string) => fileName(file) === name
-    return {
-        pageFiles: allFiles.filter(leafIs('page.abide')),
-        layoutFiles: allFiles.filter(leafIs('layout.abide')),
-    }
-}

package/src/lib/shared/selectorMatcher.ts

@@ -1,55 +0,0 @@
-import { keyMatchesPrefix } from './keyMatchesPrefix.ts'
-import { selectorPrefix } from './selectorPrefix.ts'
-import { setsIntersect } from './setsIntersect.ts'
-import { toTagSet } from './toTagSet.ts'
-import type { CacheEntry } from './types/CacheEntry.ts'
-import type { CacheSelector } from './types/CacheSelector.ts'
-
-/*
-Compiles a selector into an entry predicate shared by cache.invalidate(),
-pending(), and refreshing() so all three interpret the call shapes identically:
-  undefined            → every entry
-  remote fn            → that function's calls (method+url prefix). `arg.url` is
-                         the route template; per-call args appear as `?...`
-                         (GET/DELETE) or after a space (canonical-json body) —
-                         see keyForRemoteCall. `fn` and `fn.raw` match the same
-                         set since they share method+url.
-  producer fn          → that producer's calls (reference id prefix). Matches
-                         only if the producer was cached at least once (else it
-                         has no id and nothing matches).
-  { tags }             → any entry sharing one of the requested tags. An
-                         empty selector matches nothing.
-  fn + args            → exactly that call's entry (the key derived from the
-                         same encoders the read path uses); other args
-                         variants of the fn are untouched.
-Fn-selector identity (prefix resolution + the cache()-wrapper throw) lives in
-selectorPrefix, the prefix grammar in keyMatchesPrefix — both shared with the
-probes' scoped lifecycle channels so a probe subscribes to exactly the entries
-this predicate would match. A caller that already resolved the prefix (the
-invalidate/probe paths derive it for their own use) passes it as
-`precomputedPrefix` so the args encoding isn't re-derived per call.
-*/
-export function selectorMatcher<Args, Return>(
-    arg?: CacheSelector<Args, Return>,
-    args?: Args,
-    precomputedPrefix?: string,
-): (entry: CacheEntry) => boolean {
-    if (arg === undefined) {
-        return () => true
-    }
-    if (typeof arg === 'function') {
-        const prefix = precomputedPrefix ?? selectorPrefix(arg, args)
-        if (prefix === undefined) {
-            return () => false
-        }
-        if (args !== undefined) {
-            return (entry) => entry.key === prefix
-        }
-        return (entry) => keyMatchesPrefix(entry.key, prefix)
-    }
-    if (arg.tags === undefined) {
-        return () => false
-    }
-    const requestedTags = toTagSet(arg.tags)
-    return (entry) => entry.tags !== undefined && setsIntersect(requestedTags, entry.tags)
-}

package/src/lib/shared/selectorPrefix.ts

@@ -1,32 +0,0 @@
-import { keyForRemoteCall } from './keyForRemoteCall.ts'
-import { keyPrefixForRemote } from './keyPrefixForRemote.ts'
-import { producerKey } from './producerKey.ts'
-import { REMOTE_FUNCTION } from './REMOTE_FUNCTION.ts'
-import type { CacheSelector } from './types/CacheSelector.ts'
-import type { RawRemoteFunction } from './types/RawRemoteFunction.ts'
-
-/*
-Resolves a fn selector to the key prefix its entries share: a remote keys on
-method+url (fn and fn.raw agree — same wire identity), a producer on the
-reference id minted at first cache. With `args`, the exact entry key for that
-one call instead — derived through the same encoders the read path uses
-(keyForRemoteCall / producerKey format), so selector and entry can't
-disagree. Undefined when no prefix exists — bare and tag selectors (they
-scan, not prefix-match) and producers never cached (no id was minted;
-minting one here would leak identities for probe-only reads).
-*/
-export function selectorPrefix<Args, Return>(
-    arg: CacheSelector<Args, Return> | undefined,
-    args?: Args,
-): string | undefined {
-    if (typeof arg !== 'function') {
-        return undefined
-    }
-    const remote = REMOTE_FUNCTION in arg ? (arg as RawRemoteFunction<Args>) : undefined
-    if (remote) {
-        return args === undefined
-            ? keyPrefixForRemote(remote.method, remote.url)
-            : keyForRemoteCall(remote.method, remote.url, args)
-    }
-    return producerKey.existing(arg, args)
-}

package/src/lib/shared/serializeEnv.ts

@@ -1,30 +0,0 @@
-// Quote any value that wouldn't round-trip bare through parseEnv: empties, anything
-// carrying whitespace/`#` (a comment)/a quote/a backslash, or one that starts or ends with
-// a quote char (parseEnv strips a surrounding quote pair). Everything else stays bare.
-function needsQuoting(value: string): boolean {
-    return value === '' || /[\s#"\\]/.test(value) || /^['"]|['"]$/.test(value)
-}
-
-// Escape a value for inside double quotes: backslash and quote so the closing quote can't
-// be faked, and newlines so an embedded `\n` can't inject a whole new `KEY=value` line
-// (the security fix — an unescaped token newline used to forge extra env entries).
-function escapeQuoted(value: string): string {
-    return value
-        .replace(/\\/g, '\\\\')
-        .replace(/"/g, '\\"')
-        .replace(/\n/g, '\\n')
-        .replace(/\r/g, '\\r')
-}
-
-/*
-Serializes a key→value record to `.env` text — the inverse of parseEnv, used by
-the connect-screen config form to persist the user's answers to the data-dir
-`.env`. One `KEY=value` per line; values that need it are double-quoted and escaped
-so parseEnv reads them back unchanged and a value can never inject extra lines.
-*/
-export function serializeEnv(values: Record<string, string>): string {
-    const lines = Object.entries(values).map(([key, value]) =>
-        needsQuoting(value) ? `${key}="${escapeQuoted(value)}"` : `${key}=${value}`,
-    )
-    return `${lines.join('\n')}\n`
-}