@abide/abide 0.104.0 → 0.105.1

package/src/server/serveDev.ts

@@ -28,12 +28,13 @@ import {
 } from '#compiler/compileApp.ts'
 import { formatDiagnosis } from '#compiler/formatDiagnosis.ts'
 import { DEV_ADDRESS } from '#shared/ADDRESSES.ts'
-import { placeOf } from '#shared/routePattern.ts'
 import type { Compilation } from './abideModules.ts'
 import { DEFAULT_PORT } from './DEFAULT_PORT.ts'
-import type { Ask, FromWorker, ToWorker } from './devWorker.ts'
+import type { FromWorker, ToWorker } from './devWorker.ts'
 import { upgraded } from './muxUpgrade.ts'
+import { placeOf } from './placement.ts'
 import { plainAnswer } from './plainAnswer.ts'
+import { askOver } from './responseRelay.ts'
 import { SETTLE_MILLISECONDS } from './SETTLE_MILLISECONDS.ts'
 
 /** What `abide dev` serves, and where. */
@@ -46,20 +47,6 @@ export type DevOptions = {
     port?: number | undefined
 }
 
-// A request in flight: the request itself — because a worker replaced before it answered answers
-// nothing, and the ask has to be put to the app that exists (38.24) — and, once its head has come
-// back, the stream the body is fed into and the pull waiting on the worker's next chunk (38.35).
-type InFlight = Omit<Ask, 'id' | 'method' | 'url'> & {
-    // 16.22 — the request bun handed the listener, which is the one its idle timeout is raised on.
-    request: Request
-    settle: (response: Response) => void
-    stream: ReadableStreamDefaultController<Uint8Array> | null
-    pulled: (() => void) | null
-    // A failure the worker sent behind a chunk still queued, raised on the pull after it — raising it
-    // at once would discard the chunk, which is the markup saying what broke.
-    failed: string | null
-}
-
 // The app's process, spoken to in its own protocol.
 type DevWorker = {
     postMessage(message: ToWorker): void
@@ -75,9 +62,6 @@ type Compiled = {
 
 const LAST_DEV_PORT = 3099
 
-// 37.3 — the answers the worker said `admitsMux`, which the listener upgrades on.
-const ADMITTED = new WeakSet<Response>()
-
 // An app-mux socket's data: the id the worker knows its connection by, and what `Mux.connect` reads
 // off the upgrade. `undefined` on the reload client's.
 type Carried =
@@ -92,7 +76,11 @@ type Carried =
 export async function serveDev(
     options: DevOptions,
 ): Promise<Bun.Server<undefined>> {
-    const inFlight = new Map<number, InFlight>()
+    // 38.24, 38.35 — every request, asked of the worker there is and streamed back a chunk per read.
+    // 16.22 — a call's idle timeout raised on the request bun handed this listener.
+    const relay = askOver((request, seconds) =>
+        server.timeout(request, seconds),
+    )
     // Every socket this listener holds: the reload client's, with no data, and the app mux's, carrying
     // the connection id the worker knows it by.
     const sockets = new Set<Bun.ServerWebSocket<Carried>>()
@@ -100,12 +88,6 @@ export async function serveDev(
     let nextConnection = 0
     let worker: DevWorker | undefined
     let ready = false
-    let nextId = 0
-    // ASKED BEFORE THERE IS ANYONE TO ASK. A replacement terminates the worker and the next one
-    // does not exist until its compile finishes, so a request arriving in that window has
-    // nowhere to go — posted to the terminated worker it is never answered, and the reader's
-    // tab hangs until they give up. It waits here instead.
-    const queued: InFlight[] = []
 
     // ONE COMPILE AT A TIME, and the worker is started from the LAST one. A save landing while a
     // compile runs marks it stale rather than starting a second: two in flight each started a
@@ -222,11 +204,7 @@ export async function serveDev(
                     if (message.kind === 'ready') ready = true
                     else if (message.kind === 'socket-send')
                         muxed.get(message.connection)?.send(message.text)
-                    else if (message.kind === 'timeout') {
-                        const asked = inFlight.get(message.id)?.request
-                        if (asked !== undefined)
-                            server.timeout(asked, message.seconds)
-                    } else answer(started, message)
+                    else relay.take(message)
                 },
                 // 38.41 — AN APP THAT EXITS ON ITS OWN is replaced, and says so: a listener still
                 // forwarding to it leaves every tab hanging.
@@ -235,7 +213,8 @@ export async function serveDev(
                     console.error(
                         'abide dev: the app exited, so it was restarted',
                     )
-                    endInFlight(false, 'abide dev: the app exited')
+                    // 38.41 — the request in hand may be what ended it, so none is asked again.
+                    relay.endAll('abide dev: the app exited', false)
                     replace()
                 },
             },
@@ -261,25 +240,9 @@ export async function serveDev(
             published,
             failure,
         })
-        // The worker holds every request behind its own compile, so what waited here only had
-        // to wait for one to EXIST.
-        const waiting = queued.splice(0)
-        for (const again of waiting) forward(again)
-    }
-
-    // WHAT AN APP THAT IS GONE WAS HOLDING. A request whose head has not gone out is re-asked of the
-    // replacement (38.24), or answered where the app ended itself — the request in hand may be what
-    // ended it (38.41). 38.37 — one whose head has gone out cannot be answered again, and ends as
-    // `abide start`'s does.
-    function endInFlight(reask: boolean, why: string): void {
-        for (const held of inFlight.values()) {
-            if (held.stream !== null) {
-                held.stream.error(new Error(why))
-                held.pulled?.()
-            } else if (reask) queued.push(held)
-            else held.settle(plainAnswer(why, 500))
-        }
-        inFlight.clear()
+        // The worker holds every request behind its own compile, so what waited for one only had
+        // to wait for it to EXIST.
+        relay.replace(started)
     }
 
     // 38.15 — THE REPLACEMENT. The old worker is terminated, every socket it could still be
@@ -293,10 +256,11 @@ export async function serveDev(
         ready = false
         worker?.terminate()
         worker = undefined
+        relay.replace(undefined)
         for (const socket of sockets) socket.terminate()
         sockets.clear()
         muxed.clear()
-        endInFlight(true, 'abide dev replaced the app mid-response')
+        relay.endAll('abide dev replaced the app mid-response', true)
         if (compiling !== undefined) stale = true
         else compiling = reopen()
     }
@@ -315,127 +279,6 @@ export async function serveDev(
         moved(filename === null ? undefined : `${options.root}/${filename}`),
     )
 
-    // A REQUEST AS A MESSAGE. `Request` does not survive a structured clone, so what crosses is
-    // the four things the worker rebuilds one from — and the request's body is collected here, which
-    // is what lets it be asked again of a replacement (38.24). The answer's body streams (38.35).
-    //
-    // COLLECTED ONCE, HERE, rather than inside `forward`: a body can only be read off a
-    // `Request` once, and a re-asked request is the second read that is not there.
-    async function ask(request: Request): Promise<Response> {
-        const body = request.body === null ? null : await request.arrayBuffer()
-        return await new Promise<Response>((resolve) => {
-            forward({
-                request,
-                headers: identityOnly(request.headers),
-                body,
-                settle: resolve,
-                stream: null,
-                pulled: null,
-                failed: null,
-            })
-        })
-    }
-
-    // 38.38 — ASKED WITHOUT `accept-encoding`, so the app answers uncompressed. A failure after the
-    // head is shown as markup appended to the stream (`pull` in the worker), and markup appended to a
-    // compressed stream is a stream no browser can decode. Localhost buys nothing from the bytes saved.
-    function identityOnly(headers: Headers): [string, string][] {
-        const kept: [string, string][] = []
-        for (const [name, value] of headers)
-            if (name !== 'accept-encoding') kept.push([name, value])
-        return kept
-    }
-
-    // 38.35, 38.36 — THE HEAD SETTLES THE RESPONSE, and its body pulls one chunk from the worker per
-    // read the connection makes: a high-water mark of 0 asks for nothing ahead of the reader.
-    function answer(
-        from: DevWorker,
-        message: Exclude<
-            FromWorker,
-            { kind: 'ready' | 'socket-send' | 'timeout' }
-        >,
-    ): void {
-        const waiting = inFlight.get(message.id)
-        if (waiting === undefined) return
-        const { id } = message
-        if (message.kind === 'head') {
-            if (message.empty || message.whole !== undefined) {
-                inFlight.delete(id)
-                const answered = new Response(message.whole ?? null, {
-                    status: message.status,
-                    statusText: message.statusText,
-                    headers: message.headers,
-                })
-                // The admission has no body, so an admitted answer is always settled here.
-                if (message.admitted) ADMITTED.add(answered)
-                waiting.settle(answered)
-                return
-            }
-            const body = new ReadableStream<Uint8Array>(
-                {
-                    start(controller) {
-                        waiting.stream = controller
-                    },
-                    pull(controller) {
-                        if (waiting.failed !== null) {
-                            inFlight.delete(id)
-                            controller.error(new Error(waiting.failed))
-                            return
-                        }
-                        return new Promise<void>((done) => {
-                            waiting.pulled = done
-                            from.postMessage({ kind: 'pull', id })
-                        })
-                    },
-                    cancel() {
-                        inFlight.delete(id)
-                        from.postMessage({ kind: 'cancel', id })
-                    },
-                },
-                { highWaterMark: 0 },
-            )
-            waiting.settle(
-                new Response(body, {
-                    status: message.status,
-                    statusText: message.statusText,
-                    headers: message.headers,
-                }),
-            )
-            return
-        }
-        const stream = waiting.stream
-        const pulled = waiting.pulled
-        waiting.pulled = null
-        if (stream === null) return
-        if (message.kind === 'chunk')
-            stream.enqueue(new Uint8Array(message.bytes))
-        else if (message.kind === 'end') {
-            inFlight.delete(id)
-            stream.close()
-        } else waiting.failed = message.message
-        pulled?.()
-    }
-
-    // NOT TRANSFERRED. Handing the buffer over detaches it here, and a request re-asked of the
-    // replacement worker would post a body that is no longer there.
-    function forward(waiting: InFlight): void {
-        if (worker === undefined) {
-            queued.push(waiting)
-            return
-        }
-        nextId += 1
-        const id = nextId
-        inFlight.set(id, waiting)
-        worker.postMessage({
-            kind: 'request',
-            id,
-            method: waiting.request.method,
-            url: waiting.request.url,
-            headers: waiting.headers,
-            body: waiting.body,
-        })
-    }
-
     // THE CHECKER AND THE WORKER GO WITH THE COMMAND. Each is a process of its own, and an app with
     // no tsconfig holds a temporary project on disk for as long as the checker is open. The worker
     // is told directly rather than left to its `disconnect`, which a worker busy inside a build
@@ -461,11 +304,11 @@ export async function serveDev(
                 const mux =
                     asked !== DEV_ADDRESS &&
                     request.headers.get('upgrade') === 'websocket'
-                if (!mux && asked !== DEV_ADDRESS) return ask(request)
+                if (!mux && asked !== DEV_ADDRESS) return relay.ask(request)
                 // 37.3 — THE MUX'S UPGRADE IS ASKED OF THE APP FIRST, whose lane runs in the worker.
                 if (mux && ready) {
-                    const answered = await ask(request)
-                    if (!ADMITTED.has(answered)) return answered
+                    const answered = await relay.ask(request)
+                    if (!relay.admitted(answered)) return answered
                 }
                 // NOT WHILE THE APP IS COMPILING. The reload client and the browser's mux both read a
                 // refusal as "still rebuilding" and retry, which is what keeps a reload from racing

package/src/server/streamEvent.ts

@@ -0,0 +1,29 @@
+// 16.32, 18.20 — AN EVENT STREAM, WRITTEN: the one writer of `text/event-stream` behind a streaming
+// handler's sse body and a followed `GET` answered as events. `framing.ts`'s `frameReader` is the
+// one reader.
+
+import type { Problem } from '#shared/Failed.ts'
+import type { Framed } from '#shared/framing.ts'
+import { REFUSAL_KEY } from '#shared/REFUSAL_KEY.ts'
+
+/** AN EVENT STREAM OPENS ON A COMMENT, so a proxy has bytes to pass before the first event. */
+export const EVENT_STREAM_OPENER = ':\n\n'
+
+/**
+ * One event: its `event` name and `id` where it has them, and `data` — one line, which JSON is as
+ * `JSON.stringify` writes it.
+ */
+export function streamEvent(
+    name: string | undefined,
+    id: number | undefined,
+    data: string,
+): string {
+    return `${name === undefined ? '' : `event: ${name}\n`}${id === undefined ? '' : `id: ${id}\n`}data: ${data}\n\n`
+}
+
+/** A framed stream's last frame, as the server writes it for a refusal (16.68). */
+export function refusalFrame(problem: Problem, framing: Framed): string {
+    return framing === 'jsonl'
+        ? `${JSON.stringify({ [REFUSAL_KEY]: problem })}\n`
+        : streamEvent('refusal', undefined, JSON.stringify(problem))
+}

package/src/server/withAbideSources.ts

@@ -1,5 +1,6 @@
 import { relative, resolve } from 'node:path' // bun exposes no path helpers of its own
-import { COMPONENT_NAMESPACE, type Compilation } from './abideModules.ts'
+import type { Compilation } from './abideModules.ts'
+import { COMPONENT_NAMESPACE } from './faceOf.ts'
 import { COMPONENT_QUERY } from './MODULE_QUERIES.ts'
 import {
     decodeMappings,

package/src/shared/HandlerRoute.ts

@@ -0,0 +1,68 @@
+// 16.9, 16.66 — A HANDLER'S ROUTE, COMPILED ONCE: what takes a call's route parameters out of its
+// args and into the path, keeping the rest for the query or the body. Built once per address by
+// what holds the handler — an `Rpc`, a browser's `wire` — and read by every call through it: the
+// request a call is (`rpcRequest`), the in-process call's early refusal, and `abide call`.
+
+import { filledSegments } from './filledPath.ts'
+import { validationError } from './refuse.ts'
+import { parseRoutePattern, type Segment } from './routePattern.ts'
+
+/** 15.8 — a parameter no address carries, refused as args a gate refused. */
+function pathRefusal(name: string, message: string): unknown {
+    return validationError<Record<string, unknown>>({ [name]: [message] })
+}
+
+/** A handler's address, parsed once: its segments and the names its parameters take. */
+export class HandlerRoute {
+    readonly address: string
+    /** The parsed route, or `undefined` where it has no parameters and the path is the address. */
+    readonly segments: Segment[] | undefined
+    readonly names: Set<string>
+
+    constructor(address: string) {
+        this.address = address
+        this.names = new Set()
+        if (!address.includes('[')) {
+            this.segments = undefined
+            return
+        }
+        this.segments = parseRoutePattern(address)
+        for (const segment of this.segments)
+            if (segment.kind !== 'static') this.names.add(segment.name)
+    }
+
+    /**
+     * The path with each parameter `params` names written in.
+     *
+     * 30.3, 30.19 — one no address carries is thrown: by default as args a gate refused, so every
+     * caller answers it as the wire answers a 422.
+     */
+    path(
+        params: Record<string, unknown> | undefined,
+        refused: (name: string, message: string) => unknown = pathRefusal,
+    ): string {
+        return this.segments === undefined
+            ? this.address
+            : filledSegments(this.segments, params ?? {}, this.address, refused)
+    }
+
+    /**
+     * `args` split: the path, and the members no parameter took — `undefined` where none is left —
+     * so the query or body never carries a parameter twice (16.66).
+     */
+    split(args: Record<string, unknown> | undefined): {
+        path: string
+        rest: Record<string, unknown> | undefined
+    } {
+        if (this.segments === undefined)
+            return { path: this.address, rest: args }
+        const path = this.path(args)
+        let rest: Record<string, unknown> | undefined
+        for (const name in args) {
+            if (this.names.has(name)) continue
+            rest ??= {}
+            rest[name] = args[name]
+        }
+        return { path, rest }
+    }
+}

package/src/shared/REFUSAL_KEY.ts

@@ -0,0 +1,5 @@
+/**
+ * The key a jsonl line carries a refusal under (16.68): the server writes it, a browser's wire
+ * reads it.
+ */
+export const REFUSAL_KEY = '$refusal'

package/src/shared/answerOf.ts

@@ -1,13 +1,52 @@
 // 41.21 — A CALL THE PAGE ALREADY STARTED IS TAKEN, NOT MADE AGAIN, and what a call answered is read
 // one way whoever made it: a handler's `wire`, and a handler abide mounts itself (`seededDocument`).
+//
+// ONE CLASSIFIER. The early-call script (41.20) records the `Response` and nothing it decides, so
+// an answer the page started and one fetched here are read by `answerFrom` alike.
 
 import { failedFrom, isProblem } from './Failed.ts'
-import { carriesBytes, framedChunks, framingPrefix } from './framing.ts'
+import {
+    carriesBytes,
+    type Framed,
+    framedChunks,
+    framingOf,
+} from './framing.ts'
 import { principalRotated } from './principalRotated.ts'
 import { refuse } from './refuse.ts'
 import type { RpcRequest } from './rpcRequest.ts'
-import { type Answer, takeEarlyCall } from './takeEarlyCall.ts'
+import { takeEarlyCall } from './takeEarlyCall.ts'
 import { VERSION_HEADER } from './VERSION_HEADER.ts'
+import { versionInEtag } from './versionInEtag.ts'
+
+/** What a call answered, classified once. */
+export type Answer = {
+    status: number
+    statusText: string
+    /** A 2xx. */
+    ok: boolean
+    /** What precedes each chunk's JSON on its line (16.32), or `null` where the answer is not framed. */
+    framing: Framed | null
+    /**
+     * Whether a subscriber may follow it (18.24): a 2xx that is not a binary, whose bytes the mux's
+     * JSON frames cannot carry.
+     */
+    followable: boolean
+    /** The version its `ETag` named (18.5). */
+    version: number | undefined
+    /** The `max-age` its `cache-control` named, in ms (18.14, 21.8). */
+    life: number | undefined
+    text: string | undefined
+    /**
+     * A binary answer's body read to the end (16.34), set in place of `text` — a body read as text
+     * is not the bytes it carried.
+     */
+    bytes: Uint8Array | undefined
+    /**
+     * A streamed answer's body, left unread so its chunks are taken as they land (16.32): framed,
+     * or a binary's where `framing` is `null`.
+     */
+    body: ReadableStream<Uint8Array> | null | undefined
+}
 
 /**
  * A call's answer: the early call's where the page started one, fetched where it did not.
@@ -26,87 +65,77 @@ export function answerOf(
 ): Answer | Promise<Answer> {
     const early = takeEarlyCall(request.key)
     if (early === undefined) return fetched(request, streams, signal)
-    if (early.painted === 1) {
-        const landed = landedAnswer(early)
-        if (landed !== undefined) return landed
-    }
-    return early.promise.then((): Answer | Promise<Answer> => {
-        const landed = landedAnswer(early)
-        if (landed !== undefined) return landed
-        // The early call failed as a request — or read a binary as text, which lost its bytes — so
-        // this one is made again.
-        if (early.body === undefined || early.body === null)
-            return fetched(request, streams, signal)
-        if (streams) return early
-        const read = new Response(early.body)
-        return carriesBytes(early.type) && succeeded(early.status)
-            ? read
-                  .bytes()
-                  .then((bytes) => ({ ...early, bytes, body: undefined }))
-            : read.text().then((text) => ({ ...early, text, body: undefined }))
-    })
-}
-
-/**
- * An early call's answer where it has landed read: as text, or — for one the server painted, whose
- * body the runner reads to the end so hydration waits on it — as bytes, decoded where the answer is
- * not a binary.
- */
-function landedAnswer(early: Answer): Answer | undefined {
-    if (readAsText(early)) return early
-    if (early.bytes === undefined) return undefined
-    return carriesBytes(early.type) && succeeded(early.status)
-        ? early
-        : {
-              ...early,
-              text: new TextDecoder().decode(early.bytes),
-              bytes: undefined,
-          }
-}
-
-/** Whether an early call's answer arrived as text that is what it carried — no binary read as one. */
-function readAsText(early: Answer): boolean {
-    return (
-        early.text !== undefined &&
-        !(carriesBytes(early.type) && succeeded(early.status))
+    if (early.painted === 1 && early.response !== undefined)
+        return answerFrom(early.response, early.bytes, streams)
+    // An early call whose request failed is made again.
+    return early.promise.then(() =>
+        early.response === undefined
+            ? fetched(request, streams, signal)
+            : answerFrom(early.response, early.bytes, streams),
     )
 }
 
-function succeeded(status: number | undefined): boolean {
-    return status !== undefined && status >= 200 && status < 300
-}
-
-/**
- * Fetches a call's answer; a framed answer to a streaming copy keeps its body unread (16.32).
- *
- * Anything else is read to its end: as bytes where it is a binary (16.34), as text otherwise.
- */
+/** Fetches a call's answer. */
 async function fetched(
     request: RpcRequest,
     streams: boolean,
     signal: AbortSignal | undefined,
 ): Promise<Answer> {
-    const answer = await fetch(
+    const response = await fetch(
         request.url,
         signal === undefined ? request.init : { ...request.init, signal },
     )
     // THE HANDLER SIGNED THIS CALLER IN OR OUT, and the cookie is already the browser's.
-    principalRotated(answer)
-    const type = answer.headers.get('content-type')
-    const binary = answer.ok && carriesBytes(type)
-    // A streaming copy reads bytes as they land too (16.46), as it does a framed answer's lines.
-    const unread =
-        streams && answer.ok && (binary || framingPrefix(type) !== null)
-    return {
-        status: answer.status,
-        statusText: answer.statusText,
-        type,
-        version: answer.headers.get(VERSION_HEADER),
-        life: answer.headers.get('cache-control'),
-        text: unread || binary ? undefined : await answer.text(),
-        bytes: !unread && binary ? await answer.bytes() : undefined,
-        body: unread ? answer.body : undefined,
+    principalRotated(response)
+    return answerFrom(response, undefined, streams)
+}
+
+/**
+ * `response`, classified: a body `read` to its end already (an early call the server painted)
+ * decoded as what it carried, and one unread read as bytes where it is a binary (16.34), as text
+ * otherwise — or left unread for a `streams` caller where it is framed or a binary (16.32, 16.46).
+ */
+function answerFrom(
+    response: Response,
+    read: ArrayBuffer | undefined,
+    streams: boolean,
+): Answer | Promise<Answer> {
+    const { status, statusText, headers } = response
+    const type = headers.get('content-type')
+    const ok = status >= 200 && status < 300
+    const framing = framingOf(type)
+    const binary = ok && carriesBytes(type)
+    const seconds = /max-age=(\d+)/.exec(headers.get('cache-control') ?? '')
+    const answer: Answer = {
+        status,
+        statusText,
+        ok,
+        framing,
+        followable: ok && !binary,
+        version: versionInEtag(headers.get(VERSION_HEADER)),
+        life: seconds === null ? undefined : Number(seconds[1]) * 1000,
+        text: undefined,
+        bytes: undefined,
+        body: undefined,
+    }
+    if (read !== undefined) {
+        if (binary) answer.bytes = new Uint8Array(read)
+        else answer.text = new TextDecoder().decode(read)
+        return answer
+    }
+    if (streams && ok && (binary || framing !== null)) {
+        answer.body = response.body
+        return answer
     }
+    return binary
+        ? response.arrayBuffer().then((buffer) => {
+              answer.bytes = new Uint8Array(buffer)
+              return answer
+          })
+        : response.text().then((text) => {
+              answer.text = text
+              return answer
+          })
 }
 
 /**
@@ -120,14 +149,12 @@ async function fetched(
  * value is one production. A marked one reads its body as it lands (`framedStream`).
  */
 export function answered(answer: Answer): unknown {
-    const status = answer.status ?? 0
-    if (status === 204) return undefined
-    const ok = succeeded(status)
-    if (ok) {
+    if (answer.status === 204) return undefined
+    if (answer.ok) {
         // 16.34 — a binary decodes back to the bytes it was.
         if (answer.bytes !== undefined) return answer.bytes
-        const prefix = framingPrefix(answer.type)
-        if (prefix !== null) return framedChunks(answer.text ?? '', prefix)
+        if (answer.framing !== null)
+            return framedChunks(answer.text ?? '', answer.framing)
     }
     let body: unknown
     try {
@@ -135,7 +162,7 @@ export function answered(answer: Answer): unknown {
     } catch {
         body = undefined
     }
-    if (ok) return body
+    if (answer.ok) return body
     if (isProblem(body)) return failedFrom(body)
-    return refuse(status, answer.statusText || undefined)
+    return refuse(answer.status, answer.statusText || undefined)
 }

package/src/shared/filledPath.ts

@@ -18,7 +18,7 @@ export function filledPath(
     return filledSegments(parseRoutePattern(pattern), params, spelled, refused)
 }
 
-/** `filledPath` over a route already parsed, for a caller that fills the same route per call. */
+/** `filledPath` over a route already parsed: a handler's, compiled once (`HandlerRoute`). */
 export function filledSegments(
     segments: Segment[],
     params: Record<string, unknown>,
@@ -50,14 +50,6 @@ export function filledSegments(
     return address === '' ? '/' : address
 }
 
-/** The names of `pattern`'s parameters — what a call takes out of its args and into the path (16.66). */
-export function parametersOf(pattern: string): Set<string> {
-    const names = new Set<string>()
-    for (const segment of parseRoutePattern(pattern))
-        if (segment.kind !== 'static') names.add(segment.name)
-    return names
-}
-
 /**
  * A param value encoded as one path segment; `.` and `..` are refused.
  *