@abide/abide 0.123.1 → 0.123.3

package/src/ui/routing.ts

@@ -16,4 +16,5 @@
 
 export { listenForRoutes } from './listenForRoutes.ts'
 export { registerWorker } from './registerWorker.ts'
-export { type PageMount, type Route, Router, startRouter } from './Router.ts'
+export { type PageMount } from './LevelChain.ts'
+export { type Route, Router, startRouter } from './Router.ts'

package/src/ui/rows.ts

@@ -1,6 +1,6 @@
 import { REGION_CLOSE, ROW_OPEN } from '#shared/ANCHORS.ts'
 import { moveItem, rowItem } from '#shared/reactive/index.ts'
-import { PATCHES } from '#shared/reactive/PATCHES.ts'
+import { patchEpoch } from '#shared/reactive/patchMarks.ts'
 
 import { leave } from './leave.ts'
 import { moveNode } from './moveNode.ts'
@@ -291,7 +291,7 @@ function newRow(key: unknown, data: unknown, node: ChildNode, at: number): Row {
         // for the record's whole life.
         scope: EMPTY_SCOPE,
         at,
-        seen: PATCHES.epoch,
+        seen: patchEpoch(),
     }
 }
 

package/src/ui/setAttribute.ts

@@ -35,10 +35,19 @@ export function setAttribute(
         if (element.hasAttribute(name)) element.removeAttribute(name)
         return
     }
+    writeAttribute(element, name, next)
+}
+
+/** Writes `text` to `element`'s `name` unless it already reads `text` — `setAttribute`'s compare, shared with a spread. */
+export function writeAttribute(
+    element: Element,
+    name: string,
+    text: string,
+): void {
     const standing = element.getAttribute(name)
-    if (standing === next) return
-    if (standing === null) addAttribute(element, name, next)
-    else element.setAttribute(name, next)
+    if (standing === text) return
+    if (standing === null) addAttribute(element, name, text)
+    else element.setAttribute(name, text)
 }
 
 /**

package/src/ui/socketWire.ts

@@ -7,7 +7,7 @@ import { applyPatch } from '#shared/applyPatch.ts'
 import { mounted } from '#shared/mount.ts'
 import type { BrowserFrame, ServerFrame } from '#shared/muxFrames.ts'
 import { onPrincipalRotated } from '#shared/principalRotated.ts'
-import { canonicalKey } from '#shared/reactive/canonicalKey.ts'
+import { canonicalKey } from '#shared/reactive/argsContract.ts'
 import {
     heldGenerationOf,
     loadOf,
@@ -16,7 +16,7 @@ import {
     type Reactive,
     writtenLocally,
 } from '#shared/reactive/index.ts'
-import { PATCHES } from '#shared/reactive/PATCHES.ts'
+import { patchEpoch, writtenSince } from '#shared/reactive/patchMarks.ts'
 
 import { HYDRATE_LOG } from './Mismatch.ts'
 import { undelivered, whenDelivered } from './outboxQueue.ts'
@@ -64,18 +64,13 @@ class Following {
     inStep(): void {
         const copy = this.entry()
         this.generation = loadOf(copy) ?? heldGenerationOf(copy)
-        this.epoch = PATCHES.epoch
+        this.epoch = patchEpoch()
     }
 
     /** Whether the copy was written to since it was last in step. 18.21. */
     diverged(copy: unknown): boolean {
         if (heldGenerationOf(copy) !== this.generation) return true
-        const held = (copy as Reactive<unknown>).peek()
-        return (
-            held !== null &&
-            typeof held === 'object' &&
-            (PATCHES.written.get(held) ?? 0) > this.epoch
-        )
+        return writtenSince((copy as Reactive<unknown>).peek(), this.epoch)
     }
 
     /**
@@ -241,10 +236,17 @@ class Mux {
     receive(frame: ServerFrame): void {
         this.subscriptions.get(frame.id)?.receive(frame)
     }
+
+    /** Lets go of every subscription and the socket, so a sign-in or a retry reaches nothing. */
+    dispose(): void {
+        clearTimeout(this.retrying)
+        this.retrying = undefined
+        this.subscriptions.clear()
+        this.reopen()
+    }
 }
 
-// Exported for a test to forget: a page never does, and a test process outlives one.
-export const MUXES = new Map<string, Mux>()
+const MUXES = new Map<string, Mux>()
 
 /**
  * The mux a handler's address is carried over, made on first use.
@@ -276,6 +278,19 @@ function muxFor(address: string): Mux {
  */
 const FOLLOWING = new Map<string, Following>()
 
+/**
+ * Forgets every mux and follow this page opened, their timers and sockets with them.
+ *
+ * A page never does; a test process outlives one, and a later file's sign-in (18.25) would reopen
+ * every mux an earlier file left standing.
+ */
+export function resetSocketWire(): void {
+    for (const following of FOLLOWING.values()) clearTimeout(following.expiry)
+    FOLLOWING.clear()
+    for (const mux of MUXES.values()) mux.dispose()
+    MUXES.clear()
+}
+
 /**
  * Reads again every followed copy written here, once the outbox holds no call waiting.
  *

package/src/compiler/Finding.ts

@@ -1,2 +0,0 @@
-/** A warning or a refusal at a projection offset. */
-export type Finding = { at: number; message: string }

package/src/compiler/Refusals.ts

@@ -1,65 +0,0 @@
-import { resolve } from 'node:path' // bun exposes no path helpers of its own
-
-import { formatDiagnosis } from './formatDiagnosis.ts'
-import { diagnosisAt } from './lineOf.ts'
-import { PositionedRefusal } from './PositionedRefusal.ts'
-import type { Diagnosis } from './TypeSession.ts'
-
-/**
- * Where everything the compile refuses goes, each at the file it was refused in.
- *
- * TWO MODES AND ONE CALL: a build stops at a refusal, so a throwing sink throws it; `abide
- * check` reports every one at its file and goes on (38.33), so a collecting sink keeps each as a
- * finding at the file's first line. Every stage takes this and nothing else, so no stage decides for
- * itself what a refusal does, and none spells a path its own way: a file is named relative to `root`
- * or absolutely, and kept absolute.
- */
-export class Refusals {
-    /** Every refusal kept, in the order met; empty in a throwing sink. */
-    readonly found: Diagnosis[] = []
-    /** What a file below the root is named relative to. */
-    readonly root: string
-    /** Whether a refusal is kept and the compile goes on, rather than thrown. */
-    readonly collecting: boolean
-
-    constructor(root: string, collecting: boolean) {
-        this.root = root
-        this.collecting = collecting
-    }
-
-    /**
-     * Refuses at `file`, below the root or absolute: `thrown` is thrown, or kept. Handed the file's
-     * `text`, a `PositionedRefusal` is placed on its line and column, and thrown as that line.
-     */
-    at(file: string, thrown: unknown, text?: string): void {
-        const positioned =
-            text !== undefined && thrown instanceof PositionedRefusal
-        if (!this.collecting && !positioned) throw thrown
-        const diagnosis = diagnosisAt(
-            resolve(this.root, file),
-            positioned ? text : undefined,
-            positioned ? thrown.offset : 0,
-            'error',
-            thrown instanceof Error ? thrown.message : String(thrown),
-        )
-        if (!this.collecting)
-            throw new Error(formatDiagnosis(diagnosis, process.cwd()))
-        this.found.push(diagnosis)
-    }
-
-    /**
-     * What another stage kept, as this one takes it: every one kept, or every one thrown as one
-     * error, each at its file — a build that stops names all it found rather than a first one and a
-     * second run (11.37).
-     */
-    adopt(found: readonly Diagnosis[]): void {
-        if (found.length === 0) return
-        if (this.collecting) {
-            this.found.push(...found)
-            return
-        }
-        const lines: string[] = []
-        for (const one of found) lines.push(formatDiagnosis(one, process.cwd()))
-        throw new Error(lines.join('\n'))
-    }
-}

package/src/compiler/formatDiagnosis.ts

@@ -1,20 +0,0 @@
-import { relative } from 'node:path' // bun exposes no path helpers of its own
-
-import type { Diagnosis } from './TypeSession.ts'
-
-/**
- * One finding as one `tsc`-style line.
- *
- * ONE LINE A FINDING, in the shape `tsc` and every editor's problem matcher already read:
- * `file:line:column - error TS2322: …`, the path relative to where the command was run. A finding
- * with no line — a whole-file or whole-app refusal — names the file alone.
- */
-export function formatDiagnosis(diagnosis: Diagnosis, from: string): string {
-    const path = relative(from, diagnosis.path) || diagnosis.path
-    const where =
-        diagnosis.line === 0
-            ? path
-            : `${path}:${diagnosis.line}:${diagnosis.column}`
-    const code = diagnosis.code === 0 ? '' : ` TS${diagnosis.code}`
-    return `${where} - ${diagnosis.category}${code}: ${diagnosis.message}`
-}

package/src/server/appDirectories.ts

@@ -1,9 +0,0 @@
-/**
- * The directories an app's own files stand in: `root`, and the one above it.
- *
- * `root` is the app's root — `src/` — and the one above it is the package beside
- * it. The app's `package.json` and `bunfig.toml` are found in the first that has one.
- */
-export function appDirectories(root: string): string[] {
-    return [root, `${root}/..`]
-}

package/src/server/argsFor.ts

@@ -1,39 +0,0 @@
-// WHAT A CALL'S ARGS ARE BEFORE ITS HANDLER SEES THEM, for every lane that lets a call to a handler in
-// off the wire: over http (16.2) and a `GET` followed over the socket mux (18.3). Each lane reads the
-// args off its own transport and answers a refusal in its own form.
-
-import { DERIVED_ARGS } from '#shared/DERIVED_ARGS.ts'
-import { normalized } from '#shared/reactive/argsContract.ts'
-import { validationError } from '#shared/refuse.ts'
-
-import type { Mounted } from './answerRpc.ts'
-import { coerceArgs } from './coerceArgs.ts'
-
-/**
- * The args a call over the wire is answered with, out of the args it sent: the text a URL or a form
- * carried coerced where `query` says the args are text, the handler's parameter defaults laid in, and
- * the result held to the handler's annotation. Throws the refusal where it is not held.
- *
- * 19.7 — the text as the types the handler's `args` declares. 11.27 — then the defaults, ahead of
- * every key taken after it: the seed a render filed and the `global` entry standing were both filed
- * under them (11.29). 19.9 — THE WIRE HELD TO THE ANNOTATION, where no `args` schema is declared to
- * hold it — the check the handler carries (`derivedArgs`), which its in-process call makes too (15.8).
- */
-export function argsFor(
-    found: Pick<Mounted, 'handler' | 'argsDocument'>,
-    sent: unknown,
-    query: string | undefined,
-): unknown {
-    const coerced =
-        query === undefined
-            ? sent
-            : coerceArgs(
-                  sent as Record<string, string | string[]> | undefined,
-                  found.argsDocument,
-                  query,
-              )
-    const args = normalized(found.handler, coerced)
-    const issues = found.handler[DERIVED_ARGS]?.(args) ?? null
-    if (issues !== null) throw validationError(issues)
-    return args
-}

package/src/server/buildDirectory.ts

@@ -1,10 +0,0 @@
-import { dirname } from 'node:path' // bun exposes no path helpers of its own
-
-/**
- * Where an app's build goes: `.abide` in the directory above its source root.
- *
- * BESIDE THE APP RATHER THAN BESIDE THE SHELL: an app's build belongs to the app.
- */
-export function buildDirectory(root: string): string {
-    return `${dirname(root)}/.abide`
-}

package/src/server/coerceArgs.ts

@@ -1,109 +0,0 @@
-// 19.7 — A `GET` OR `DELETE`'s TEXT ARGS, COERCED FROM THE TYPE THE `JsonSchema` DECLARES, before
-// anything validates them. A URL carries text, so `?id=42` is `'42'` until the schema says the member
-// is a number. Coercion is the pipeline's and not the schema's (19.6): the schema is handed what this
-// made of the text, and refuses what would not coerce.
-//
-// Read off a `Schema` built by `jsonSchema`, where the document is exposed; a schema with no document
-// has declared no types, and its args stay the text they arrived as.
-
-import { numberFromText } from '#shared/numberFromText.ts'
-import { bareName } from '#shared/queryText.ts'
-import { type Gated, gateOf } from '#shared/reactive/argsContract.ts'
-
-export type Document = {
-    type?: string | string[]
-    properties?: Record<string, Document>
-    items?: Document
-}
-
-/** The document a handler's `args` schema declares, or `undefined`. */
-export function argsDocumentOf(handler: Gated<unknown>): Document | undefined {
-    const gate = gateOf(handler) as
-        { '~standard'?: { jsonSchema?: { input?: () => unknown } } } | undefined
-    const document = gate?.['~standard']?.jsonSchema?.input?.()
-    return document !== null && typeof document === 'object'
-        ? (document as Document)
-        : undefined
-}
-
-/**
- * Name and value pairs as args: a name given more than once is a list, one given once its text.
- *
- * 16.18 — a query's and a form's members, and 38.61 — `abide call`'s `name=value` words, alike.
- */
-export function collapsed(
-    entries: URLSearchParams | FormData,
-): Record<string, string | string[]> {
-    const args: Record<string, string | string[]> = {}
-    for (const name of new Set(entries.keys())) {
-        const values = entries.getAll(name) as string[]
-        args[name] = values.length === 1 ? (values[0] as string) : values
-    }
-    return args
-}
-
-/**
- * The text args, each member coerced to the type `document` declares.
- *
- * `query` is the raw `?…` the args were read from: `URLSearchParams` reads `rpcRequest`'s empty
- * list, a bare name, as `''` — the same as `tags=`, the list `['']` — so a declared array tells the
- * two apart there. A text member keeps the `''`.
- */
-export function coerceArgs(
-    args: Record<string, string | string[]> | undefined,
-    document: Document | undefined,
-    query: string,
-): unknown {
-    if (args === undefined || document?.properties === undefined) return args
-    const coerced: Record<string, unknown> = {}
-    for (const [name, text] of Object.entries(args)) {
-        const member = document.properties[name]
-        if (member === undefined) coerced[name] = text
-        else if (
-            text === '' &&
-            typesOf(member).includes('array') &&
-            `&${query.slice(1)}&`.includes(`&${bareName(name)}&`)
-        )
-            coerced[name] = []
-        else coerced[name] = coerceMember(text, member)
-    }
-    return coerced
-}
-
-function typesOf(member: Document): string[] {
-    if (member.type === undefined) return []
-    return Array.isArray(member.type) ? member.type : [member.type]
-}
-
-function coerceMember(text: string | string[], member: Document): unknown {
-    const types = typesOf(member)
-    // A list is its member repeated, and one given once still answers a declared array.
-    if (types.includes('array')) {
-        const items = Array.isArray(text) ? text : [text]
-        const item = member.items
-        return item === undefined
-            ? items
-            : items.map((each) => coerceScalar(each, item))
-    }
-    if (Array.isArray(text)) return text
-    return coerceScalar(text, member)
-}
-
-/**
- * The text as the first declared type it reads as, in the order the schema lists them.
- *
- * Text that reads as none stays text, for the schema to refuse.
- */
-function coerceScalar(text: string, member: Document): unknown {
-    for (const type of typesOf(member)) {
-        if (type === 'string') return text
-        if (type === 'number' || type === 'integer') {
-            const number = numberFromText(text)
-            if (number !== undefined) return number
-        }
-        if (type === 'boolean' && (text === 'true' || text === 'false'))
-            return text === 'true'
-        if (type === 'null' && text === 'null') return null
-    }
-    return text
-}

package/src/server/derivedArgs.ts

@@ -1,95 +0,0 @@
-import { DERIVED_ARGS } from '#shared/DERIVED_ARGS.ts'
-import type { JsonValue } from '#shared/JsonValue.ts'
-import type { Gated } from '#shared/reactive/argsContract.ts'
-import type { HeldToAnnotation } from '#shared/rpc.ts'
-import { validateJson } from '#shared/validateJson.ts'
-
-import { argsDocumentOf } from './coerceArgs.ts'
-
-/**
- * Holds `handler`'s args to `schema`, the one the build derived off its annotation, for every call
- * of it from now on: in process and over the wire (15.8, 19.9).
- *
- * What the module a handler is loaded through calls once its handler is built — a handler file's
- * face and a `<script server>`'s module — so the schema is there wherever the handler can be
- * called, whether or not an app mounted it. Not where its `args` gate publishes a document of its
- * own, which holds the args itself (19.7). Args that did not come are held as an empty record: a
- * schema is only derived where the handler's args are a required record, so a required member
- * missing is refused, not read off nothing. The args are held as SENT (`asSent`): a call in process
- * passing a member `undefined` is the call the wire carries without it.
- */
-export function derivedArgs(
-    handler: HeldToAnnotation & Gated<unknown>,
-    schema: JsonValue,
-): void {
-    if (argsDocumentOf(handler) !== undefined) return
-    handler[DERIVED_ARGS] = (args) => validateJson(schema, asSent(args ?? {}))
-}
-
-/** The records `asSent` is inside of, so a cyclic value is walked once rather than forever. */
-const WALKING: object[] = []
-
-/**
- * `value` as the wire carries it, which drops a member left `undefined` (19.25): a URL omits it
- * (30.28) and JSON leaves it out, at any depth of a body. `value` itself wherever it holds none, so
- * the walk allocates nothing for the call that writes no `undefined` member.
- *
- * AN `undefined` IN A LIST IS KEPT. The two encodings part there — JSON writes `null`, a URL the
- * text `undefined` — so neither is the wire's, and the schema answers the value as given.
- */
-export function asSent(value: unknown): unknown {
-    if (value === null || typeof value !== 'object' || WALKING.includes(value))
-        return value
-    WALKING.push(value)
-    try {
-        return Array.isArray(value)
-            ? listAsSent(value)
-            : recordAsSent(value as Record<string, unknown>)
-    } finally {
-        WALKING.pop()
-    }
-}
-
-function listAsSent(list: unknown[]): unknown[] {
-    let sent: unknown[] | null = null
-    for (let index = 0; index < list.length; index += 1) {
-        const member = list[index]
-        const held = asSent(member)
-        if (sent === null && held !== member) sent = list.slice(0, index)
-        sent?.push(held)
-    }
-    return sent ?? list
-}
-
-function recordAsSent(
-    record: Record<string, unknown>,
-): Record<string, unknown> {
-    let sent: Record<string, unknown> | null = null
-    for (const key in record) {
-        if (!Object.hasOwn(record, key)) continue
-        const member = record[key]
-        const held = member === undefined ? undefined : asSent(member)
-        if (sent === null && (member === undefined || held !== member))
-            sent = membersBefore(record, key)
-        if (sent !== null && held !== undefined) sent[key] = held
-    }
-    return sent ?? record
-}
-
-/**
- * A copy of `record`'s own members ahead of `key`, in their order.
- *
- * NO PROTOTYPE, so an own `__proto__` member JSON parsed stays a member the schema reads rather
- * than becoming the copy's prototype.
- */
-function membersBefore(
-    record: Record<string, unknown>,
-    key: string,
-): Record<string, unknown> {
-    const copy: Record<string, unknown> = Object.create(null)
-    for (const earlier in record) {
-        if (earlier === key) break
-        if (Object.hasOwn(record, earlier)) copy[earlier] = record[earlier]
-    }
-    return copy
-}

package/src/server/runBuild.ts

@@ -1,24 +0,0 @@
-// The CLI, spawned rather than imported: the compiler is not reachable from the server seam.
-const ABIDE_BIN = Bun.fileURLToPath(
-    new URL('../../bin/abide.ts', import.meta.url),
-)
-
-/**
- * `abide build` of the app under `root` into `out`, run as the CLI.
- *
- * SPAWNED RATHER THAN IMPORTED: the compiler is not reachable from the server seam.
- */
-export async function runBuild(root: string, out: string): Promise<void> {
-    const child = Bun.spawn(
-        [process.execPath, ABIDE_BIN, 'build', '--root', root, '--out', out],
-        { stdout: 'ignore', stderr: 'pipe' },
-    )
-    const [exitCode, said] = await Promise.all([
-        child.exited,
-        new Response(child.stderr).text(),
-    ])
-    if (exitCode !== 0)
-        throw new Error(
-            `abide: could not build the app under ${root}.\n${said}`,
-        )
-}

package/src/server/serveBuild.ts

@@ -1,144 +0,0 @@
-// 38.6 and 38.10 — `abide start` and a compiled app: the built app, over http. The request path is
-// `answerRequest`'s, shared with `abide dev`; what this module is, is the SUPPLIER — where each part
-// comes from when the parts are what `abide build` produced.
-//
-// THE ROUTE TABLE IS THE BUILD'S, not this module's. `abide build` walks the tree once and writes
-// what it found, so the addresses the server answers and the addresses the client router knows
-// are two readings of one walk rather than two walks that have to agree (30.8).
-
-import {
-    type Compilation,
-    serveCompilation,
-    servedTable,
-} from './abideModules.ts'
-import {
-    type AppSources,
-    appSources,
-    type SourceParts,
-} from './answerRequest.ts'
-import {
-    CLIENT_DIRECTORY,
-    COMPILATION,
-    ENCODING_SUFFIX,
-    MANIFEST,
-    PUBLIC_DIRECTORY,
-} from './CLIENT_BUILD.ts'
-import { bundleServer, type ServedFile } from './clientBundle.ts'
-import { settingOn } from './config.ts'
-import type { Manifest } from './manifestOf.ts'
-import { namesUnder } from './namesUnder.ts'
-import { ENCODINGS } from './negotiateEncoding.ts'
-import { runBuild } from './runBuild.ts'
-
-/**
- * What `abide build` produced, as the parts an `App` is booted over.
- *
- * Read off disk by `abide start` (`loadBuild`), and out of the executable itself by a compiled app
- * (38.10). ONE SHAPE, so the two are answered by one path and differ only in where a byte is read
- * from — a file is a PATH in both, and `Bun.file` reads the executable's own the same way it reads
- * the disk's.
- */
-export type BuildParts = Omit<SourceParts, 'client' | 'explained'> & {
-    manifest: Manifest
-    /** Every file under `client/`, the precompressed copies among them, by name to its path. */
-    client: Map<string, string>
-}
-
-/**
- * Serves the compilation `abide build` kept in `out` to this process's imports; `false` where there
- * is none, because the app under `root` holds nothing to build.
- *
- * 38.6 — what `abide start` boots: no compiler is loaded, and every `.abide` the app imports is
- * answered out of what the build compiled. 38.100 — AN APP NOBODY BUILT IS BUILT, by `build`, rather
- * than refused, so every caller boots the same way whether or not a build came first. The CLI passes
- * its own build, in-process; anything else spawns it.
- */
-export async function serveBuild(
-    root: string,
-    out: string,
-    build: (root: string, out: string) => Promise<unknown> = runBuild,
-): Promise<boolean> {
-    const path = `${out}/${COMPILATION}`
-    if (!(await Bun.file(path).exists())) {
-        await build(root, out)
-        // A FRESH HANDLE: one taken before the build wrote the file reads it as empty.
-        if (!(await Bun.file(path).exists())) return false
-    }
-    serveCompilation(root, (await Bun.file(path).json()) as Compilation)
-    return true
-}
-
-/**
- * What `abide build` left on disk, as the sources an `App` is booted over — its compilation served
- * already (`serveBuild`).
- */
-export async function loadBuild(options: {
-    /**
-     * The app's source root — the directory its pages sit under.
-     */
-    root: string
-    /** Where `abide build` put its output. */
-    out: string
-}): Promise<AppSources> {
-    // THE BOOT READS OVERLAP: the tables and the manifest are independent of each other. The
-    // manifest names the stylesheet only where the bundler collected one, so an app that imports
-    // none links none.
-    const [table, manifest] = await Promise.all([
-        servedTable(options.root),
-        Bun.file(`${options.out}/${MANIFEST}`).json() as Promise<Manifest>,
-    ])
-    return builtSources({
-        table,
-        handlers: table.handlers,
-        manifest,
-        client: pathsUnder(`${options.out}/${CLIENT_DIRECTORY}`),
-        published: pathsUnder(`${options.out}/${PUBLIC_DIRECTORY}`),
-    })
-}
-
-/** Every file under `directory`, by the name below it to its path. */
-export function pathsUnder(directory: string): Map<string, string> {
-    const paths = new Map<string, string>()
-    for (const name of namesUnder(directory))
-        paths.set(name, `${directory}/${name}`)
-    return paths
-}
-
-/** The sources an `App` is booted over, out of the parts `abide build` produced. */
-export function builtSources(parts: BuildParts): Promise<AppSources> {
-    // THE PRECOMPRESSED COPIES ARE NOT ADDRESSES OF THEIR OWN. They are the same file in another
-    // encoding (38.5), so they are found under the name they encode and served as that name.
-    const suffixes = Object.values(ENCODING_SUFFIX) as string[]
-    const files = new Map<string, ServedFile>()
-    for (const [name, path] of parts.client) {
-        if (suffixes.some((suffix) => name.endsWith(suffix))) continue
-        const encoded: ServedFile['encoded'] = {}
-        for (const encoding of ENCODINGS) {
-            const copy = parts.client.get(name + ENCODING_SUFFIX[encoding])
-            if (copy !== undefined) encoded[encoding] = () => Bun.file(copy)
-        }
-        files.set(name, {
-            // THE TYPE IS THE NAME'S, not the path's: a compiled app's path carries a hash the
-            // bundler put before the extension, and a `.br`'s extension names nothing.
-            type: Bun.file(name).type,
-            body: () => Bun.file(path),
-            encoded,
-        })
-    }
-    return appSources({
-        ...parts,
-        explained: undefined,
-        client: {
-            manifest: parts.manifest,
-            head: '',
-            // 21.5 — EVERY NAME IN THE BUNDLE CARRIES A HASH OF ITS BYTES, the entry's too (38.5), so
-            // a name never answers two different files and a year is safe for all of them. A deploy
-            // is new names in a new document, never new bytes at an old address.
-            framework: bundleServer(
-                files,
-                'public, max-age=31536000, immutable',
-            ),
-            offline: settingOn('ABIDE_OFFLINE', true),
-        },
-    })
-}