@abide/abide 0.123.1 → 0.123.3

package/src/compiler/serveLanguage.ts

@@ -1,18 +1,19 @@
-import { existsSync, type FSWatcher, watch } from 'node:fs' // bun exposes no file watcher or sync existence check of its own
+import { existsSync } from 'node:fs' // bun exposes no sync existence check of its own
 import { dirname } from 'node:path' // bun exposes no path helpers of its own
 
 import { realOrAsGiven } from '#server/realOrAsGiven.ts'
 
 import { checkSource, lowerApp } from './checkApp.ts'
 import { citedClauses } from './citedClauses.ts'
-import { type AppChecker, openChecker } from './compileApp.ts'
+import type { AppChecker } from './compileApp.ts'
+import { type Diagnosis, formatDiagnosis } from './Diagnostics.ts'
 import { DOCS_SITE } from './DOCS_SITE.ts'
 import { formatAbide } from './formatAbide.ts'
-import { formatDiagnosis } from './formatDiagnosis.ts'
 import { isNamedAlone } from './isNamedAlone.ts'
+import { KeptChecker } from './KeptChecker.ts'
 import { lineOf, offsetOf } from './lineOf.ts'
 import { nearest } from './nearest.ts'
-import type { Diagnosis, Inspection, Place } from './TypeSession.ts'
+import type { Inspection, Place } from './TypeSession.ts'
 
 // 38.11 — `abide lsp`: THE `.abide` LANGUAGE SERVER, OVER STDIO. It is `abide check` (38.3) asked
 // about one open document at a time, so the squiggle an editor draws and the line CI fails on are
@@ -64,8 +65,7 @@ export async function serveLanguage(
 ): Promise<void> {
     const documents = new Map<string, Document>()
     const timers = new Map<string, ReturnType<typeof setTimeout>>()
-    const checkers = new Map<string, AppChecker>()
-    const watchers = new Map<string, FSWatcher>()
+    const checkers = new Map<string, KeptChecker>()
     // Each app's real root, to the root the editor reached it by.
     const links = new Map<string, string>()
     let queue: Promise<void> = Promise.resolve()
@@ -133,37 +133,19 @@ export async function serveLanguage(
     const held = (path: string): string | undefined =>
         documents.get(Bun.pathToFileURL(spelled(path)).href)?.text
 
-    // An app's checker, opened on first use and kept for the session — and TOLD WHAT MOVED ON DISK,
-    // or it answers every check from the text it read when it opened: an export added to a `lib`
-    // module the page imports is "no exported member" until the editor restarts this. A project whose
-    // tsconfig or package.json moved is opened again.
-    const checkerOf = async (app: string): Promise<AppChecker> => {
+    // An app's checker, kept for the session — and TOLD WHAT MOVED ON DISK, or it answers every
+    // check from the text it read when it opened: an export added to a `lib` module the page
+    // imports is "no exported member" until the editor restarts this (`KeptChecker`).
+    const checkerOf = (app: string): KeptChecker => {
         let checker = checkers.get(app)
-        if (checker !== undefined && !checker.current()) {
-            checkers.delete(app)
-            await checker.close().catch(() => {})
-            checker = undefined
-        }
         if (checker === undefined) {
-            checker = await openChecker(app)
+            checker = new KeptChecker(app, () => {
+                // What an open page says may be decided by the file that moved.
+                for (const uri of documents.keys())
+                    if (placed(uri)?.app === app) check(uri)
+            })
             checkers.set(app, checker)
         }
-        if (!watchers.has(app))
-            watchers.set(
-                app,
-                watch(app, { recursive: true }, (_event, filename) => {
-                    checkers
-                        .get(app)
-                        ?.saw(
-                            filename === null
-                                ? undefined
-                                : `${app}/${filename}`,
-                        )
-                    // What an open page says may be decided by the file that moved.
-                    for (const uri of documents.keys())
-                        if (placed(uri)?.app === app) check(uri)
-                }),
-            )
         return checker
     }
 
@@ -172,11 +154,9 @@ export async function serveLanguage(
     // keeps one for the session. Queued behind the checks, so none is in flight when it closes.
     const closeIfUnopened = async (app: string): Promise<void> => {
         for (const uri of documents.keys()) if (placed(uri)?.app === app) return
-        watchers.get(app)?.close()
-        watchers.delete(app)
         const checker = checkers.get(app)
         checkers.delete(app)
-        await checker?.close().catch(() => {})
+        await checker?.close()
     }
 
     const run = async (uri: string): Promise<void> => {
@@ -189,17 +169,11 @@ export async function serveLanguage(
         const { app, path } = at
         let found: Diagnosis[]
         try {
-            found = await checkSource(
-                await checkerOf(app),
-                path,
-                document.text,
-                held,
+            found = await checkerOf(app).run((checker) =>
+                checkSource(checker, path, document.text, held),
             )
         } catch (thrown) {
             // The checker's own failure, not the page's: the next check opens another.
-            const failed = checkers.get(app)
-            checkers.delete(app)
-            await failed?.close().catch(() => {})
             found = [
                 {
                     path,
@@ -269,7 +243,7 @@ export async function serveLanguage(
             const at = placed(uri)
             if (document === undefined || at === undefined) return undefined
             return question(
-                await checkerOf(at.app),
+                await checkerOf(at.app).live(),
                 at.path,
                 document.text,
                 offsetOf(document.text, position),
@@ -544,24 +518,16 @@ export async function serveLanguage(
             ) as Message
             buffer = buffer.slice(start + length)
             if (!(await handle(message))) {
-                await closeAll(checkers, watchers)
+                await closeAll(checkers)
                 return
             }
         }
     }
-    await closeAll(checkers, watchers)
+    await closeAll(checkers)
 }
 
-async function closeAll(
-    checkers: Map<string, AppChecker>,
-    watchers: Map<string, FSWatcher>,
-): Promise<void> {
-    for (const watcher of watchers.values()) watcher.close()
-    await Promise.all(
-        [...checkers.values()].map((checker) =>
-            checker.close().catch(() => {}),
-        ),
-    )
+async function closeAll(checkers: Map<string, KeptChecker>): Promise<void> {
+    await Promise.all([...checkers.values()].map((checker) => checker.close()))
 }
 
 /**

package/src/compiler/sharedModuleWrites.ts

@@ -9,7 +9,7 @@ import type {
 } from 'typescript/unstable/async'
 
 import { classifyRead, FUNCTIONS } from './classifyRead.ts'
-import type { Finding } from './Finding.ts'
+import type { Finding } from './Diagnostics.ts'
 import type { Span } from './projectShadow.ts'
 
 // 34.18 — A PLAIN `let` IN A `<script module>` THAT A `<script>` WRITES AS IT SETS UP. The block is

package/src/compiler/templateWarnings.ts

@@ -1,8 +1,8 @@
 import type { CheckerAnswer } from './CheckerAnswer.ts'
 import type { Read } from './classifyRead.ts'
 import { isComponentTag } from './classifyTemplate.ts'
+import { type Diagnosis, diagnosisAt } from './Diagnostics.ts'
 import { isNamedAlone } from './isNamedAlone.ts'
-import { diagnosisAt } from './lineOf.ts'
 import { Lowering } from './Lowering.ts'
 import type { AbideFile } from './parseAbide.ts'
 import {
@@ -12,7 +12,6 @@ import {
     type TemplateNode,
     visitBodies,
 } from './TemplateNode.ts'
-import type { Diagnosis } from './TypeSession.ts'
 
 // 32.14 — A `{#for}` WITH NO KEY OVER A BODY THAT HOLDS STATE. Unkeyed, a row is matched to the
 // item at its index, so a reorder hands one row's state — a component's own values, a field's text,

package/src/compiler/trackingWarnings.ts

@@ -16,7 +16,7 @@ import {
 } from 'typescript/unstable/ast/is'
 
 import { FUNCTIONS, TRANSPARENT } from './classifyRead.ts'
-import type { Finding } from './Finding.ts'
+import type { Finding } from './Diagnostics.ts'
 import type { PositionKind, PositionTable } from './PositionTable.ts'
 
 // 14.14, 14.15, 14.16 — WHERE A READ STANDS IN A BODY THAT TRACKS, and the three ways it can stand

package/src/server/CLIENT_BUILD.ts

@@ -1,13 +1,9 @@
-// WHERE THE BROWSER BUNDLE LANDS, named once for the commands that have to agree about it:
-// `abide build` writes it, `abide start` answers it, and `abide dev` builds it into memory
-// (38.16, 38.20). A leaf, with no imports of its own, for the reason every constant crossing a
-// seam is one — the build is in `bin/` and the server is in `src/server/`, and a string spelled out
-// in both is a build that silently serves nothing. The addresses it is answered at are
+// WHAT THE BROWSER BUNDLE IS NAMED, once for the seams that have to agree about it: the compiler
+// writes the entry, `abide build` precompresses every file, and the server answers both (38.5,
+// 38.20). A leaf, with no imports of its own, for the reason every constant crossing a seam is one.
+// Where the bundle lands in a build is `appBuild.ts`'s; the addresses it is answered at are
 // `#shared/ADDRESSES.ts`.
 
-/** The directory the bundle lands in, below the build's own output directory. */
-export const CLIENT_DIRECTORY = 'client'
-
 /**
  * The module that mounts the app — the one bundle file whose name the shell writes out.
  *
@@ -19,21 +15,6 @@ export const CLIENT_DIRECTORY = 'client'
  */
 export const CLIENT_ENTRY = 'entry'
 
-/**
- * The manifest file `abide build` writes beside the client directory.
- *
- * 38.5 — the manifest `manifestOf` reads off the bundle, below the build's own output directory
- * and BESIDE the client directory rather than in it: everything in there is answered under
- * `CLIENT_ADDRESS` (38.20), and the manifest is the server's, not the browser's.
- */
-export const MANIFEST = 'manifest.json'
-
-/**
- * The compilation `abide build` keeps beside the client directory: every `.abide` compiled, and
- * the build's own tables (`Compilation`), which `abide start` serves without the compiler.
- */
-export const COMPILATION = 'compilation.json'
-
 /**
  * The encodings a response can be compressed in, each with its precompressed file's suffix.
  *
@@ -43,12 +24,3 @@ export const COMPILATION = 'compilation.json'
  * a build that precompresses into files nothing ever serves.
  */
 export const ENCODING_SUFFIX = { br: '.br', gzip: '.gz' } as const
-
-/**
- * Where `abide build` copies every `public` directory, each file at its address, below its own
- * output directory. The source's own name for one is `#shared/RESERVED_DIRECTORIES.ts`'s.
- *
- * 38.18 — a directory rather than the source tree: `abide start` boots what the build produced and
- * reaches for nothing an app might have moved since.
- */
-export const PUBLIC_DIRECTORY = 'public'

package/src/server/RESUME_MILLISECONDS.ts

@@ -0,0 +1,2 @@
+/** How long a pairing whose stream dropped waits to be resumed. 44.26. */
+export const RESUME_MILLISECONDS = 60_000

package/src/server/answerRequest.ts

@@ -8,75 +8,43 @@
 
 import {
     ABIDE_ADDRESS,
-    APP_MANIFEST_ADDRESS,
     BRIDGE_ADDRESS,
-    CLIENT_ADDRESS,
     HEALTH_ADDRESS,
     MCP_ADDRESS,
     OPENAPI_ADDRESS,
     PRIVATE_HANDLERS_ADDRESS,
-    WORKER_ADDRESS,
 } from '#shared/ADDRESSES.ts'
-import { APP_META } from '#shared/APP_META.ts'
-import { DEBUG_META } from '#shared/DEBUG_META.ts'
 import { decodedOrKept } from '#shared/decodedOrKept.ts'
-import { ERROR_META } from '#shared/ERROR_META.ts'
-import { escapeAttribute } from '#shared/escapeText.ts'
 import { isFailed } from '#shared/Failed.ts'
 import { HandlerRoute } from '#shared/HandlerRoute.ts'
 import { health } from '#shared/health.ts'
 import { KEEP_HEADER } from '#shared/KEEP_HEADER.ts'
 import { KEEP_OPENED } from '#shared/KEEP_OPENED.ts'
-import { ICON_ADDRESSES } from '#shared/LAUNCHER_FILES.ts'
-import { appName } from '#shared/log.ts'
 import { matchOf, type Params, partsOf } from '#shared/matchRoute.ts'
 import { compose } from '#shared/Middleware.ts'
-import { MOUNT, mounted } from '#shared/mount.ts'
-import { MOUNT_META } from '#shared/MOUNT_META.ts'
+import { mounted } from '#shared/mount.ts'
 import { NAVIGATION_HEADER } from '#shared/NAVIGATION_HEADER.ts'
-import { OFFLINE_META } from '#shared/OFFLINE_META.ts'
 import { notFound as refusedNotFound, refuse } from '#shared/refuse.ts'
 import { arrive } from '#shared/route.ts'
-import {
-    parseRoutePattern,
-    rankRoutes,
-    type Segment,
-} from '#shared/routePattern.ts'
+import type { Segment } from '#shared/routePattern.ts'
 import type { Method, Rpc } from '#shared/rpc.ts'
 import { rpcRequest } from '#shared/rpcRequest.ts'
 
 import { answerFailure, laneFailure } from './answerFailure.ts'
-import {
-    answerRpc,
-    type Mounted,
-    mountedOwn,
-    mountHandlers,
-    type MountRow,
-} from './answerRpc.ts'
-import { answerBlobTagged, answerValue, contentEtag } from './answerValue.ts'
-import { answerWorker } from './answerWorker.ts'
-import { appManifest } from './appManifest.ts'
+import { answerRpc, type Mounted, mountedOwn } from './answerRpc.ts'
+import { answerBlobTagged, answerValue } from './answerValue.ts'
 import { answerBridge } from './bridgeRelay.ts'
 import { callerOrMint } from './callerOf.ts'
-import { CLIENT_ENTRY } from './CLIENT_BUILD.ts'
 import { compressAnswer } from './compressAnswer.ts'
-import { settingOn } from './config.ts'
 import { noteCallInRender } from './deferredBuilds.ts'
 import { DOCUMENT_HEADERS } from './DOCUMENT_HEADERS.ts'
 import { answerMcp, openApi } from './generatedSurfaces.ts'
-import { failureOf, type LaneRung, rungsOver } from './hooks.ts'
-import { chunksOf, type Manifest } from './manifestOf.ts'
+import { failureOf, type LaneRung } from './hooks.ts'
 import { muxAdmission } from './muxUpgrade.ts'
 import { OFFLINE_STALE } from './OFFLINE_STALE.ts'
 import { plainAnswer } from './plainAnswer.ts'
 import { PRINCIPAL_MOUNT } from './principal.ts'
-import {
-    boundPage,
-    type Component,
-    DEFAULT_DOCUMENT,
-    intoHead,
-    renderDocument,
-} from './render.ts'
+import { boundPage, type Component, renderDocument } from './render.ts'
 import {
     adoptRequest,
     type AnsweringApp,
@@ -107,9 +75,9 @@ type ServerRoute = {
 // 35.2 — an error page, and the directory it answers for.
 type ServerError = Omit<ServerRoute, 'clientModules'>
 
-type RankedError = ServerError & { segments: Segment[] }
+export type RankedError = ServerError & { segments: Segment[] }
 
-type Ranked = RankedError & {
+export type Ranked = RankedError & {
     // The document this route is painted into, with the tags that load the app already in its
     // head (38.22, 38.23) and the preloads for this route's own modules (38.28). One per route and
     // built at boot, so a request pays for none of it.
@@ -122,7 +90,7 @@ type Ranked = RankedError & {
  * 19.1 — one file per method per route, so a route is a row and a method is a column, and 19.20's
  * "the most specific route answering the method" is a walk down the rows asking each column.
  */
-type RouteRow = {
+export type RouteRow = {
     pattern: string
     matchers: Record<string, string>
     segments: Segment[]
@@ -141,7 +109,7 @@ type RouteRow = {
 }
 
 /** A public file, read once at boot: where the bytes are, the etag off them, and its type. */
-type PublicFile = { path: string; etag: string; type: string }
+export type PublicFile = { path: string; etag: string; type: string }
 
 /** Everything `answerRequest` answers from: the ranked routes, the lanes and the handlers. */
 export type AppSources = {
@@ -486,168 +454,8 @@ export function reachedInRender(
  */
 export type ServerTable = { routes: ServerRoute[]; errors: ServerError[] }
 
-/**
- * What a command hands `appSources`: the parts it read, built or compiled, and the client lane.
- *
- * ONE SHAPE FOR EVERY SUPPLIER — `abide start` off disk, a compiled app out of itself, `abide dev` out
- * of memory, and a test handing over modules it already holds — so what differs between them is
- * where a part came from and never how the app is assembled from it.
- */
-export type SourceParts = {
-    table: ServerTable
-    /** The handler table the build wrote, each row with its module's loader. 16.2. */
-    handlers: MountRow[]
-    /** Every public file, by its name below the directory to its path. 38.18, 38.19. */
-    published: Map<string, string>
-    /**
-     * The bundle's manifest, its lane, and `head` — `abide dev`'s reload client (38.17), after the
-     * app's own tags.
-     *
-     * A PROMISE WHERE THE BUNDLE IS STILL BUILDING: `abide dev`'s handlers mount and its public files
-     * hash while the bundler runs, rather than after it — ~40 ms of a docs-app reload.
-     */
-    client: ClientLane | Promise<ClientLane>
-    explained: AppSources['explained']
-}
-
-type ClientLane = {
-    manifest: Manifest
-    framework: AppSources['framework']
-    head: string
-    /**
-     * 45.1, 45.9 — whether the worker saves `manifest`'s bundle and the pages register it: `abide
-     * build`'s, unless `ABIDE_OFFLINE` is off. Where not, the worker address answers the removing one.
-     */
-    offline: boolean
-}
-
-/**
- * The sources an `App` is booted over, off the parts a command supplies.
- *
- * 30.9 — MOST SPECIFIC FIRST, ranked off the table rather than in it. The ordering IS the client
- * router's own: both seams compile through `rankRoutes` and walk a route with `matchOf` — the
- * server past a route that has no answer for the method asked, which the router never is — so
- * "the two cannot resolve one address differently" is a grep rather than a promise. 35.2 — the
- * error pages deepest directory first, so the nearest answers.
- */
-export async function appSources(parts: SourceParts): Promise<AppSources> {
-    const [mounted, published, client] = await Promise.all([
-        mountHandlers(parts.handlers),
-        publicFilesAt(parts.published),
-        parts.client,
-    ])
-    // 35.6 — every page is served in abide's own document; what it carries beyond that, the root
-    // `layout.abide` writes (35.15).
-    // 45.15 — installable where the pages are kept offline and the app has an icon to install by.
-    const icon = published.get(ICON_ADDRESSES.png)
-    const install =
-        icon !== undefined && settingOn('ABIDE_OFFLINE', true)
-            ? await appManifest(icon.path)
-            : undefined
-    const documentOf = (modules: string[]): string =>
-        intoHead(
-            DEFAULT_DOCUMENT,
-            clientTags(client.manifest, modules) +
-                (client.offline ? `<meta name="${OFFLINE_META}">` : '') +
-                (install?.tags ?? '') +
-                client.head,
-        )
-    const pages: Omit<Ranked, 'segments'>[] = []
-    for (const route of parts.table.routes)
-        pages.push({
-            pattern: route.pattern,
-            load: route.load,
-            layouts: route.layouts,
-            matchers: route.matchers,
-            document: documentOf(route.clientModules),
-        })
-    // 19.1 — the build refused two files at one route and method, so a route is one row however
-    // many methods answer at it — and 23.27 one matcher per position, so whichever file opens the
-    // row brings what every file at it would.
-    const rows = new Map<string, Omit<RouteRow, 'segments'>>()
-    const rowAt = (
-        pattern: string,
-        matchers: Record<string, string>,
-    ): Omit<RouteRow, 'segments'> => {
-        let row = rows.get(pattern)
-        if (row === undefined) {
-            row = {
-                pattern,
-                matchers,
-                page: undefined,
-                handlers: new Map(),
-                answers: new Map(),
-            }
-            rows.set(pattern, row)
-        }
-        return row
-    }
-    for (const page of rankRoutes(pages))
-        rowAt(page.pattern, page.matchers).page = page
-    for (const handler of mounted.handlers.values())
-        rowAt(handler.address, handler.matchers).handlers.set(
-            handler.method,
-            handler,
-        )
-    const errors: RankedError[] = []
-    for (const error of parts.table.errors)
-        errors.push({
-            ...error,
-            segments: parseRoutePattern(error.pattern, error.matchers),
-        })
-    errors.sort((a, b) => b.segments.length - a.segments.length)
-    const sources: AppSources = {
-        routes: rankRoutes([...rows.values()]),
-        errors,
-        // 35.18 — marked, so the browser hydrates no page over what an error page painted.
-        errorDocument: intoHead(documentOf([]), `<meta name="${ERROR_META}">`),
-        framework: (pathname, request) => {
-            if (pathname === WORKER_ADDRESS)
-                return answerWorker(
-                    client.offline ? client.manifest : undefined,
-                )
-            if (pathname === APP_MANIFEST_ADDRESS && install !== undefined)
-                return new Response(install.body, {
-                    headers: {
-                        'content-type': 'application/manifest+json',
-                        'cache-control': 'no-cache',
-                    },
-                })
-            return client.framework(pathname, request)
-        },
-        published,
-        explained: parts.explained,
-        offline: client.offline,
-        ...mounted,
-    }
-    for (const row of sources.routes) {
-        if (row.page !== undefined)
-            row.answers.set(
-                row.page,
-                answerInside(
-                    sources,
-                    row.page,
-                    // 37.14 — a page's lane paints a refusal as its error page does (35.2).
-                    rungsOver(row.pattern, (failure, request) =>
-                        answerFailure(
-                            sources,
-                            new URL(request.url).pathname,
-                            failure,
-                        ),
-                    ),
-                ),
-            )
-        for (const handler of row.handlers.values())
-            row.answers.set(
-                handler,
-                answerInside(sources, handler, handler.rungs),
-            )
-    }
-    return sources
-}
-
 /** `found`'s answer inside the rungs filed over its route. 16.14, 37.2. */
-function answerInside(
+export function answerInside(
     app: AppSources,
     found: Ranked | Mounted,
     rungs: LaneRung[],
@@ -655,103 +463,6 @@ function answerInside(
     return compose(rungs, ({ request }) => answerMatched(app, request, found))
 }
 
-/**
- * The head tags that load the app: its metas, stylesheet, entry script and the route's preloads.
- *
- * 38.22, and 38.23 for the stylesheet beside it. An app does not write either: the bundle's
- * address is the build's, and a hand-written one is a path that goes stale the first time the
- * output layout moves.
- *
- * THE STYLESHEET GOES FIRST, and ahead of the page's own head contributions for the same reason:
- * a document that parses its script before its styles paints once unstyled. It is a plain `<link>`
- * rather than anything the client does, so a page the server painted is styled with no JS at all.
- *
- * ONE STYLESHEET FOR THE APP: the bundler collects every stylesheet reachable from the entry — each
- * component's scoped `<style>` (34.4) and each one a component imports (34.6) — into one file, so a
- * page that renders none of those components is served them too. For a `<style>` block that costs
- * bytes rather than correctness: every rule requires its component's scope token, so on a page the
- * component is not on it matches nothing. An imported stylesheet carries no token and applies as
- * written, wherever it is served.
- *
- * 38.28 — THE ROUTE'S CHUNKS ARE PRELOADED BESIDE THE ENTRY. Left to the client, the page's chunk
- * and the shared runtime it imports are only asked for once the entry has arrived and run the
- * router — a whole round trip after the document, for the largest file in the bundle. Named here,
- * they are requested while the document is still being parsed.
- *
- * EVERY NAME IS THE MANIFEST'S, the entry's included: a build hashes it (38.5). A manifest with no
- * entry is a bundle that failed under `abide dev` (38.17), and gets no tags rather than a
- * `<script>` at a 404.
- */
-export function clientTags(manifest: Manifest, modules: string[]): string {
-    if (manifest.entry === undefined) return ''
-    // 28.10 — `DEBUG`, through the document rather than the bundle, where the server has one.
-    const debug = process.env.DEBUG
-    let tags =
-        debug === undefined || debug === ''
-            ? ''
-            : `<meta name="${DEBUG_META}" content="${escapeAttribute(debug)}">`
-    // 28.4 — the app's name, so a browser's `log.named` prefixes the one the server's does.
-    tags += `<meta name="${APP_META}" content="${escapeAttribute(appName())}">`
-    // 16.10 — the mount the browser resolves every address against, the root's `''` included: a
-    // lookup that finds no tag has walked the whole document to say so.
-    tags += `<meta name="${MOUNT_META}" content="${escapeAttribute(MOUNT.current())}">`
-    const client = mounted(CLIENT_ADDRESS)
-    tags +=
-        manifest.stylesheet === undefined
-            ? ''
-            : `<link rel="stylesheet" href="${client}/${manifest.stylesheet}">`
-    tags += `<script type="module" src="${client}/${manifest.entry}"></script>`
-    for (const chunk of chunksOf([`${CLIENT_ENTRY}.ts`, ...modules], manifest))
-        tags += `<link rel="modulepreload" href="${client}/${chunk}">`
-    return tags
-}
-
-/**
- * The public files by address, off each file's name and where its bytes are.
- *
- * 38.18 and 38.19's directory, as an address per file — or a compiled app's, whose bytes are
- * inside itself. Read at boot rather than per request, and the ETAG IS READ WITH IT: 21.13
- * derives it from the bytes, so there is no cheaper moment than the one read that is happening
- * anyway. The bytes are hashed and dropped — `Bun.file` streams the body when somebody asks, so a
- * large file is not held in memory for the life of the process.
- */
-async function publicFilesAt(
-    paths: Map<string, string>,
-): Promise<Map<string, PublicFile>> {
-    const files = new Map<string, PublicFile>()
-    // THE READS OVERLAP. They are independent, and `abide dev` runs this again on every
-    // reload rather than once at boot — so it is reload latency an author waits on, not just
-    // a boot cost. Each is hashed as it lands, so no more than the reads in flight are held.
-    const names = [...paths.keys()]
-    const etags = await Promise.all(
-        names.map(async (name) =>
-            contentEtag(await Bun.file(paths.get(name) as string).bytes()),
-        ),
-    )
-    for (let index = 0; index < names.length; index += 1) {
-        const name = names[index] as string
-        files.set(`/${name}`, {
-            path: paths.get(name) as string,
-            etag: etags[index] as string,
-            type: publicType(name),
-        })
-    }
-    return files
-}
-
-/**
- * A public file's content type, off its name's extension.
- *
- * 36.14, 36.17 — a text type without a charset is given UTF-8's rather than whatever a browser
- * guesses.
- */
-function publicType(name: string): string {
-    const type = Bun.file(name).type
-    return type.startsWith('text/') && !type.includes('charset')
-        ? `${type}; charset=utf-8`
-        : type
-}
-
 function notFound(): Response {
     return plainAnswer('not found', 404)
 }