@abide/abide 0.58.0 → 0.101.0

package/src/lib/shared/serializeSelector.ts

@@ -1,69 +0,0 @@
-import { keyForRemoteCall } from './keyForRemoteCall.ts'
-import { keyPrefixForRemote } from './keyPrefixForRemote.ts'
-import { REMOTE_FUNCTION } from './REMOTE_FUNCTION.ts'
-import { toTagSet } from './toTagSet.ts'
-import type { CacheSelector } from './types/CacheSelector.ts'
-import type { CacheStalenessFrame } from './types/CacheStalenessFrame.ts'
-import type { RawRemoteFunction } from './types/RawRemoteFunction.ts'
-
-/*
-Encodes a CacheSelector into the cross-client staleness envelope (ADR-0041) — the
-single authoring site for the on-wire selector, reusing the same encoders the read
-path keys with (keyForRemoteCall / keyPrefixForRemote) so it can never drift from
-selectorMatcher. The three real branches map 1:1 onto the envelope's `mode`:
-
-  fn + args → { mode: 'key',    match: keyForRemoteCall(method, url, args) }
-  fn        → { mode: 'prefix', match: keyPrefixForRemote(method, url) }
-  { tags }  → { mode: 'tags',   tags }
-
-A producer/closure selector mints a per-process ref id (selectorPrefix) that no
-other client shares, and a bare/undefined match-all would nuke every client's whole
-cache — both are NOT cross-client serializable, so they THROW here rather than
-broadcast. The caller (the server broadcaster) surfaces the throw as a programming
-error at the mutation site.
-*/
-export function serializeSelector<Args, Return>(
-    op: CacheStalenessFrame['op'],
-    arg?: CacheSelector<Args, Return>,
-    args?: Args,
-): CacheStalenessFrame {
-    if (arg === undefined) {
-        throw new Error(
-            `[abide] ${op}(): a bare match-all selector cannot broadcast across clients — it would drop every client's whole cache. Pass a remote function or { tags }.`,
-        )
-    }
-    if (typeof arg === 'function') {
-        /* Only a remote function carries wire identity (method+url, stable across clients);
-           a plain producer's key is a per-process ref id that no other client shares. */
-        if (!(REMOTE_FUNCTION in arg)) {
-            throw new Error(
-                `[abide] ${op}(): a producer/closure selector is not cross-client serializable (its key is a per-process reference id). Broadcast a remote function or { tags }.`,
-            )
-        }
-        const remote = arg as RawRemoteFunction<Args>
-        if (args === undefined) {
-            return {
-                op,
-                mode: 'prefix',
-                match: keyPrefixForRemote(remote.method, remote.url),
-                tags: [],
-            }
-        }
-        return {
-            op,
-            mode: 'key',
-            match: keyForRemoteCall(remote.method, remote.url, args),
-            tags: [],
-        }
-    }
-    /* Reject an empty tag set too, not just an absent `tags`: an empty-array selector
-       matches nothing locally, so broadcasting it would fan a match-nothing frame out to
-       every peer (a wasted store scan). Compute the set once and reuse it. */
-    const tags = arg.tags === undefined ? undefined : toTagSet(arg.tags)
-    if (tags === undefined || tags.size === 0) {
-        throw new Error(
-            `[abide] ${op}(): a { tags } selector must list at least one tag to broadcast.`,
-        )
-    }
-    return { op, mode: 'tags', match: '', tags: [...tags] }
-}

package/src/lib/shared/setAppName.ts

@@ -1,5 +0,0 @@
-import { appNameSlot } from './appNameSlot.ts'
-
-export function setAppName(name: string | undefined): void {
-    appNameSlot.name = name
-}

package/src/lib/shared/setOwnProperty.ts

@@ -1,19 +0,0 @@
-/*
-Assignment can't create an own `__proto__` key — it invokes the
-Object.prototype accessor instead, silently dropping the key or (on decode of
-attacker-controlled wire data) swapping the object's prototype. defineProperty
-always writes an own enumerable data property, so `__proto__` round-trips as a
-plain key. Plain assignment stays on the fast path for every other key.
-*/
-export function setOwnProperty(target: Record<string, unknown>, key: string, value: unknown): void {
-    if (key === '__proto__') {
-        Object.defineProperty(target, key, {
-            value,
-            writable: true,
-            enumerable: true,
-            configurable: true,
-        })
-        return
-    }
-    target[key] = value
-}

package/src/lib/shared/setsIntersect.ts

@@ -1,15 +0,0 @@
-/*
-True when two sets share at least one member — a plain for-of over the first set
-rather than `.values().some()` (Iterator Helpers are too new for this module's
-browser baseline; see producerKey). Pass the smaller set first. Shared by
-selectorMatcher (local selectors) and matcherFromEnvelope (wire-decoded frames) so
-the two tag predicates can't drift.
-*/
-export function setsIntersect<T>(a: Set<T>, b: Set<T>): boolean {
-    for (const value of a) {
-        if (b.has(value)) {
-            return true
-        }
-    }
-    return false
-}

package/src/lib/shared/sharedCacheStore.ts

@@ -1,14 +0,0 @@
-import { activeCacheStore } from './activeCacheStore.ts'
-import { sharedCacheStoreSlot } from './sharedCacheStoreSlot.ts'
-import type { CacheStore } from './types/CacheStore.ts'
-
-/*
-Resolves the process-level ("shared") CacheStore that `cache(fn, { shared: true })`
-entries live in. The server entry registers a module-singleton resolver so the
-store survives across requests; the client points it at the active tab store.
-When no resolver is registered it falls back to the active store, so `shared`
-degrades to request/tab-scoped rather than throwing.
-*/
-export function sharedCacheStore(): CacheStore {
-    return sharedCacheStoreSlot.resolver?.() ?? activeCacheStore()
-}

package/src/lib/shared/sharedCacheStoreSlot.ts

@@ -1,10 +0,0 @@
-import { createResolverSlot } from './createResolverSlot.ts'
-import type { CacheStore } from './types/CacheStore.ts'
-
-/*
-The process-level ("shared") CacheStore slot that `cache(fn, { shared: true })`
-entries live in. The server entry registers a module-singleton store outliving
-every request; the client points it at the active tab store. When no resolver
-is registered, sharedCacheStore() falls back to the active store.
-*/
-export const sharedCacheStoreSlot = createResolverSlot<CacheStore>()

package/src/lib/shared/skipNonCode.ts

@@ -1,230 +0,0 @@
-import { isAsciiWhitespace } from './isAsciiWhitespace.ts'
-import { isIdentPart } from './isIdentPart.ts'
-
-/*
-The shared "skip a non-code construct" primitive for the source scanners
-(findExportCallSite, prepareRpcModule's arg walker, …). When `i` sits on the
-start of a string, template literal, line/block comment, or regex literal, it
-returns the index immediately after that construct; undefined when `source[i]`
-begins ordinary code — including a `/` that's division rather than a regex.
-
-Centralising the string / template / regex / comment rules here is what lets
-every scanner walk source depth-aware without re-deriving them and getting the
-regex-vs-division or `${…}` edge cases subtly wrong (the bug that made a naive
-arg walker miscount a `{ ratio: a / b }` or a regex literal in the opts).
-*/
-export function skipNonCode(source: string, i: number): number | undefined {
-    const c = source[i]
-    if (c === '"' || c === "'") {
-        return skipString(source, i + 1, c)
-    }
-    if (c === '`') {
-        return skipTemplate(source, i + 1)
-    }
-    if (c === '/') {
-        return skipSlashConstruct(source, i)
-    }
-    return undefined
-}
-
-function skipString(source: string, start: number, quote: string): number {
-    let i = start
-    while (i < source.length) {
-        const c = source[i]
-        if (c === '\\') {
-            i += 2
-            continue
-        }
-        if (c === quote) {
-            return i + 1
-        }
-        if (c === '\n') {
-            return i
-        }
-        i++
-    }
-    return source.length
-}
-
-function skipTemplate(source: string, start: number): number {
-    let i = start
-    while (i < source.length) {
-        const c = source[i]
-        if (c === '\\') {
-            i += 2
-            continue
-        }
-        if (c === '`') {
-            return i + 1
-        }
-        if (c === '$' && source[i + 1] === '{') {
-            i = skipTemplateExpression(source, i + 2)
-            continue
-        }
-        i++
-    }
-    return source.length
-}
-
-function skipTemplateExpression(source: string, start: number): number {
-    let depth = 1
-    let i = start
-    while (i < source.length && depth > 0) {
-        const c = source[i]
-        if (c === '{') {
-            depth++
-            i++
-            continue
-        }
-        if (c === '}') {
-            depth--
-            i++
-            continue
-        }
-        const skipped = skipNonCode(source, i)
-        if (skipped !== undefined) {
-            i = skipped
-            continue
-        }
-        i++
-    }
-    return i
-}
-
-/*
-When `i` sits on a `/` introducing a line comment, block comment, or regex
-literal, returns the index immediately after the construct; undefined when the
-`/` is division (or `i` isn't a `/`). One statement of the skip rules shared by
-every scanner loop so they can't drift.
-*/
-function skipSlashConstruct(source: string, i: number): number | undefined {
-    if (source[i] !== '/') {
-        return undefined
-    }
-    const next = source[i + 1]
-    if (next === '/') {
-        const newline = source.indexOf('\n', i + 2)
-        return newline === -1 ? source.length : newline + 1
-    }
-    if (next === '*') {
-        const end = source.indexOf('*/', i + 2)
-        return end === -1 ? source.length : end + 2
-    }
-    if (isRegexContext(source, i)) {
-        return skipRegex(source, i + 1)
-    }
-    return undefined
-}
-
-/*
-A `/` starts a regex literal when the prior expression context expects an
-expression rather than a value — after an open delimiter, operator, or
-expression-prefix keyword (return, typeof, instanceof, in, of, delete, void,
-await, yield, new, throw, case, do). Otherwise `/` is division. Without this
-disambiguation a regex like `/^\//` reads as `/` (division), then `^`, `\`,
-`/`, `/` — and the final `//` pair fakes a line comment that swallows the rest
-of the line, eating any `)` that closes the enclosing call.
-*/
-const REGEX_PREFIX_KEYWORDS = new Set([
-    'return',
-    'typeof',
-    'instanceof',
-    'in',
-    'of',
-    'delete',
-    'void',
-    'await',
-    'yield',
-    'new',
-    'throw',
-    'case',
-    'do',
-])
-
-const REGEX_PUNCTUATION = new Set([
-    '(',
-    '[',
-    '{',
-    ',',
-    ';',
-    ':',
-    '?',
-    '!',
-    '&',
-    '|',
-    '^',
-    '~',
-    '+',
-    '-',
-    '*',
-    '%',
-    '<',
-    '>',
-    '=',
-    '/',
-])
-
-function isRegexContext(source: string, slashIndex: number): boolean {
-    let i = slashIndex - 1
-    while (i >= 0 && isAsciiWhitespace(source[i])) {
-        i--
-    }
-    if (i < 0) {
-        return true
-    }
-    const prev = source[i] as string
-    if (REGEX_PUNCTUATION.has(prev)) {
-        return true
-    }
-    if (isIdentPart(prev)) {
-        let start = i
-        while (start > 0 && isIdentPart(source[start - 1])) {
-            start--
-        }
-        return REGEX_PREFIX_KEYWORDS.has(source.slice(start, i + 1))
-    }
-    return false
-}
-
-/*
-Walks past a regex literal body, respecting character classes (`[...]` where
-`/` is literal) and backslash escapes, then consumes trailing flag identifiers.
-Returns the index immediately after the regex. An unterminated regex (newline
-before the closing `/`) returns the newline position so the outer scanner can
-resume normally on the next line.
-*/
-function skipRegex(source: string, start: number): number {
-    let i = start
-    let inClass = false
-    while (i < source.length) {
-        const c = source[i]
-        if (c === '\\') {
-            i += 2
-            continue
-        }
-        if (c === '\n') {
-            return i
-        }
-        if (inClass) {
-            if (c === ']') {
-                inClass = false
-            }
-            i++
-            continue
-        }
-        if (c === '[') {
-            inClass = true
-            i++
-            continue
-        }
-        if (c === '/') {
-            let j = i + 1
-            while (j < source.length && isIdentPart(source[j])) {
-                j++
-            }
-            return j
-        }
-        i++
-    }
-    return source.length
-}

package/src/lib/shared/snapshotShippable.ts

@@ -1,23 +0,0 @@
-import { hasSeedableRequest } from './hasSeedableRequest.ts'
-import type { CacheEntry } from './types/CacheEntry.ts'
-
-/*
-The one store-filter predicate selecting which cache entries are candidates for a
-warm snapshot: settled AND carrying a seedable wire request (any method), so an
-inline call hydrates warm on the client instead of re-firing after render. Every
-selection site (serializeCacheSnapshot, the renderer's render-return and
-streaming-drain filters) calls this instead of re-spelling the guard, so they
-cannot drift.
-
-Composed from `hasSeedableRequest` — the request half snapshotEntryFromCache
-also gates on. snapshotEntryFromCache itself uses ONLY the request half (not
-`settled`): the streaming-drain path hands it still-pending entries and awaits
-them, so it can't require `settled` up front.
-
-This is the SYNC half of shippability — what's knowable from the entry without
-awaiting its body. The async response-level half (non-streaming + warmable kind)
-lives in snapshotEntryFromCache, reading the resolved Response.
-*/
-export function snapshotShippable(entry: CacheEntry): boolean {
-    return entry.settled === true && hasSeedableRequest(entry)
-}

package/src/lib/shared/snippet.ts

@@ -1,30 +0,0 @@
-const SNIPPET = Symbol.for('abide.snippet')
-
-/* The internal payload a snippet carries — a DOM builder `(host) => void` on the
-   client, the pre-rendered HTML string on the server. The brand is a registered
-   Symbol so it survives across module/bundle copies (same idiom as `html\`\``). */
-export type SnippetValue = { readonly [SNIPPET]: unknown }
-
-/* The author-facing snippet type: a builder invoked with its arguments, yielding a
-   mountable value. `children` is `Snippet` (no args, invoked `children()`); a row
-   renderer is `Snippet<[Item]>` (invoked `row(item)`). The side-specific payload is
-   hidden behind `SnippetValue`. */
-export type Snippet<Args extends unknown[] = []> = (...args: Args) => SnippetValue
-
-/* Brands a snippet payload so a `{expr}` interpolation mounts it instead of
-   inserting escaped text. The compiler wraps a snippet's body in this — the client
-   builder closes over the defining component's scope, the server string is its SSR
-   render — so a snippet value passes through props like any other value. */
-// @documentation templating
-export function snippet<Payload>(payload: Payload): SnippetValue {
-    return { [SNIPPET]: payload } as SnippetValue
-}
-
-/* The payload of a snippet-branded value, or undefined for anything else — so a
-   text binding fast-paths plain values and only branded ones mount. The client
-   reads a builder function; the server reads the rendered string. */
-export function snippetPayload(value: unknown): unknown {
-    return value !== null && typeof value === 'object' && SNIPPET in value
-        ? (value as SnippetValue)[SNIPPET]
-        : undefined
-}

package/src/lib/shared/socketNameForFile.ts

@@ -1,11 +0,0 @@
-/*
-Translates a socket file path under `src/server/sockets/` into the socket's
-identity used on the wire. The name is the file path minus `.ts` so
-nested paths (e.g. `orders/new.ts`) become `orders/new`. Sockets don't
-need a URL prefix the way rpc routes do — they multiplex over the
-framework-owned `/__abide/sockets` ws and are dispatched by name in the
-registry, not by HTTP path.
-*/
-export function socketNameForFile(relativePath: string): string {
-    return relativePath.replace(/\.ts$/, '')
-}

package/src/lib/shared/socketTailsSlot.ts

@@ -1,13 +0,0 @@
-import { createResolverSlot } from './createResolverSlot.ts'
-import type { SocketTails } from './types/SocketTails.ts'
-
-/*
-The active socket-tail slot — mirrors `resolvedCellsSlot`, but deliberately WITHOUT a lazily-created
-shared fallback. `defineSocket`'s server `peek()` records into it on every retained-frame read, and a
-socket peeked outside a request (a ws message handler, boot, cron) has no request store — a shared
-fallback would then accumulate entries no page render ever drains, a slow leak. With no fallback,
-`get()` returns undefined off-request and the record is skipped. During an SSR render the server
-entry's resolver returns the request store's list, which `createUiPageRenderer` drains into
-`__SSR__.sockets`.
-*/
-export const socketTailsSlot = createResolverSlot<SocketTails>()

package/src/lib/shared/socketTapSlot.ts

@@ -1,12 +0,0 @@
-/*
-Passive observation seam for published socket frames — the socket analogue of
-logTapSlot. defineSocket's publish() calls the tap (when set) with every frame
-it fans out, so an observer sees the same payloads subscribers receive. The
-inspector installs one to fold socket traffic into its feed; unset everywhere
-else, so the call no-ops. One slot, one in-process observer. Mirrors logTapSlot.
-*/
-export const socketTapSlot: {
-    tap: ((frame: { socket: string; message: unknown }) => void) | undefined
-} = {
-    tap: undefined,
-}

package/src/lib/shared/sseErrorFrame.ts

@@ -1,29 +0,0 @@
-/*
-The in-band error sentinel for an SSE stream: when a handler's generator
-throws, `sse()` emits an `event: error` frame whose data is `{ message }`,
-and `streamResponse` re-throws it on the consumer side. Encoder and decoder
-live together here so the sentinel (event name + payload shape) has one
-definition and can't drift between the two ends of the wire.
-*/
-export const sseErrorFrame = {
-    // Full `event: error` frame for a thrown message, including the SSE delimiters.
-    encode(message: string): string {
-        return `event: error\ndata: ${JSON.stringify({ message })}\n\n`
-    },
-    /*
-    The message carried by an error frame, or undefined when `event` isn't
-    the error sentinel. Falls back to the raw data when it isn't the JSON
-    the encoder produces.
-    */
-    decode(event: string, data: string): string | undefined {
-        if (event !== 'error') {
-            return undefined
-        }
-        try {
-            const decoded = JSON.parse(data) as { message?: string }
-            return decoded?.message ?? 'sse stream error'
-        } catch {
-            return data || 'sse stream error'
-        }
-    },
-}

package/src/lib/shared/streamResponse.ts

@@ -1,180 +0,0 @@
-import { contentTypeOf } from './contentTypeOf.ts'
-import { decodeResponse } from './decodeResponse.ts'
-import { httpErrorFor } from './httpErrorFor.ts'
-import { jsonlErrorFrame } from './jsonlErrorFrame.ts'
-import { STREAMING_CONTENT_TYPES } from './STREAMING_CONTENT_TYPES.ts'
-import { sseErrorFrame } from './sseErrorFrame.ts'
-
-/*
-Turns a Response into an AsyncIterable of frames, regardless of the
-handler's chosen body format. Shared by `fn.stream(args)` (via
-subscribableFromResponse), the CLI's streaming print path, and the MCP
-tool dispatcher's stream drain — so every surface consumes sse/jsonl
-identically. Three shapes are handled:
-
-- text/event-stream (SSE): emits the JSON-parsed `data:` payload of
-  each event. The `event: error\ndata: {message}` frame the `sse()`
-  helper emits on generator throws is mapped back to a thrown Error so
-  consumers see the failure mid-iteration.
-- application/jsonl + application/x-ndjson: emits one JSON value per
-  line. The trailing `{"$error":"..."}` line the `jsonl()` helper
-  emits on generator throws is likewise re-thrown.
-- everything else: one-shot — yields the Content-Type-decoded body
-  once, then completes. Lets callers iterate uniformly on every rpc
-  handler, not just the streaming ones.
-
-Non-2xx responses surface as a thrown HttpError on the first pull,
-mirroring the plain `fn(args)` decode path — typed-error body included
-(`.kind` / `.data`), parsed by httpErrorFor when the generator is pulled.
-*/
-export function streamResponse<T>(response: Response): AsyncIterable<T> {
-    if (!response.ok) {
-        return errorIterable<T>(response)
-    }
-    const contentType = contentTypeOf(response.headers)
-    if (contentType.startsWith('text/event-stream')) {
-        return parseSse<T>(response)
-    }
-    if (STREAMING_CONTENT_TYPES.some((type) => contentType.startsWith(type))) {
-        return parseJsonLines<T>(response)
-    }
-    return oneShot<T>(response)
-}
-
-/* Surfaces a non-2xx response as a thrown HttpError on the first pull — awaiting the
-   typed-error body parse here (not in the sync streamResponse body) is what lets the
-   stream path carry `.kind` / `.data` like the plain decode path. */
-// biome-ignore lint/correctness/useYield: throws on first pull; the generator shape is intentional so callers iterate it uniformly
-async function* errorIterable<T>(response: Response): AsyncGenerator<T> {
-    throw await httpErrorFor(response)
-}
-
-/*
-One-shot iterator over a non-streaming Response: decodes the body once
-via the same Content-Type sniffing the plain call uses, yields it, then
-completes. Makes streaming symmetrical across streaming and
-non-streaming handlers — callers can pick the iteration shape without
-worrying about which body the handler returned.
-*/
-async function* oneShot<T>(response: Response): AsyncGenerator<T> {
-    yield (await decodeResponse(response)) as T
-}
-
-/*
-Reads a streaming text Response and yields raw frame strings split on
-`delimiter` (`\n\n` for SSE events, `\n` for JSON lines). Owns the whole
-buffering lifecycle: incremental decode, amortised-O(n) compaction, a
-final flush of the trailing partial frame, and reader cancellation when
-the consumer stops iterating (the generator's `finally` runs on
-`return()`). The SSE and jsonl parsers layer their per-frame parsing on
-top of this single machine so the two can't drift.
-*/
-async function* frameReader(response: Response, delimiter: string): AsyncGenerator<string> {
-    const body = response.body
-    if (!body) {
-        return
-    }
-    const reader = body.pipeThrough(new TextDecoderStream()).getReader()
-    let buffer = ''
-    let bufferStart = 0
-    try {
-        while (true) {
-            const { value, done } = await reader.read()
-            if (done) {
-                if (bufferStart < buffer.length) {
-                    yield buffer.slice(bufferStart)
-                }
-                return
-            }
-            /*
-            Compact only when the unread region is small relative to the
-            consumed prefix — keeps amortised work O(n) instead of
-            quadratic slicing per frame boundary.
-            */
-            if (bufferStart > buffer.length / 2) {
-                buffer = buffer.slice(bufferStart) + value
-                bufferStart = 0
-            } else {
-                buffer += value
-            }
-            let boundary = buffer.indexOf(delimiter, bufferStart)
-            while (boundary !== -1) {
-                yield buffer.slice(bufferStart, boundary)
-                bufferStart = boundary + delimiter.length
-                boundary = buffer.indexOf(delimiter, bufferStart)
-            }
-        }
-    } finally {
-        await reader.cancel().catch(() => undefined)
-    }
-}
-
-/*
-SSE parser: yields the JSON-parsed `data` payload of each `event:`/`data:`
-frame. The error sentinel (`sseErrorFrame`) the `sse()` helper emits on a
-generator throw is surfaced as a thrown Error so consumer loops can react
-to mid-stream failure rather than silently stopping.
-*/
-async function* parseSse<T>(response: Response): AsyncGenerator<T> {
-    for await (const raw of frameReader(response, '\n\n')) {
-        const frame = parseFrame(raw)
-        if (!frame) {
-            continue
-        }
-        const errorMessage = sseErrorFrame.decode(frame.event, frame.data)
-        if (errorMessage !== undefined) {
-            throw new Error(errorMessage)
-        }
-        /* A frame with an empty `data:` value (a keepalive) carries no payload — skip it
-           rather than letting JSON.parse('') throw and tear down the whole iteration. */
-        if (frame.data === '') {
-            continue
-        }
-        yield JSON.parse(frame.data) as T
-    }
-}
-
-function parseFrame(raw: string): { event: string; data: string } | undefined {
-    const lines = raw.split('\n').filter((line) => line.length > 0 && !line.startsWith(':'))
-    if (lines.length === 0) {
-        return undefined
-    }
-    let event = 'message'
-    const dataLines: string[] = []
-    for (const line of lines) {
-        const colon = line.indexOf(':')
-        const field = colon === -1 ? line : line.slice(0, colon)
-        const value = colon === -1 ? '' : line.slice(colon + 1).replace(/^ /, '')
-        if (field === 'event') {
-            event = value
-        } else if (field === 'data') {
-            dataLines.push(value)
-        }
-    }
-    if (dataLines.length === 0) {
-        return undefined
-    }
-    return { event, data: dataLines.join('\n') }
-}
-
-/*
-JSONL/NDJSON parser: parses each non-empty line as JSON and yields the
-value. The error sentinel (`jsonlErrorFrame`) the `jsonl()` helper emits as
-a trailing line on a generator throw is surfaced here as a thrown Error so
-consumer loops can react to mid-stream failure.
-*/
-async function* parseJsonLines<T>(response: Response): AsyncGenerator<T> {
-    for await (const raw of frameReader(response, '\n')) {
-        /* Skip blank lines: a CRLF stream yields a lone `\r` (non-zero length) between
-           records, and JSON.parse('\r') would throw and tear down the whole iteration. */
-        if (raw.trim().length === 0) {
-            continue
-        }
-        const parsed = JSON.parse(raw)
-        const errorMessage = jsonlErrorFrame.decode(parsed)
-        if (errorMessage !== undefined) {
-            throw new Error(errorMessage)
-        }
-        yield parsed as T
-    }
-}