@abide/abide 0.101.0 → 0.102.0

package/src/compiler/writeTypes.ts

@@ -0,0 +1,82 @@
+// 34.24 — WHAT A `.abide` EXPORTS, AS A PLAIN `.ts` IMPORTING IT IS TYPED. TypeScript reads no
+// `.abide`, and a wildcard declaration can name a default alone, so the names a `<script module>` or
+// a `<script server>` exports were untyped to every `.ts` outside abide's own checker. Each file's
+// projection — its module and server blocks, exactly what that checker answers a `.abide` import
+// with (`TypeSession.standIn`) — is written to `.abide/types`, mirroring the tree, where the app's
+// `tsconfig` reaches it: `rootDirs` for a relative import, `paths` for `#src/*`.
+//
+// THE CHECKER IS NOT ASKED, because the API it answers over emits no declarations, and the
+// projection is a module TypeScript infers the same types from. `@ts-nocheck` because the blocks are
+// read as written — a reactive read by name is the checker's to answer (31.3) and `abide check`'s to
+// report, and reported here too it would be one finding twice, at a path nobody wrote.
+
+import { rmSync } from 'node:fs' // bun has no file removal of its own
+import { dirname, relative } from 'node:path' // bun exposes no path helpers of its own
+import { buildDirectory } from '#server/buildDirectory.ts'
+import { namesUnder } from '#server/namesUnder.ts'
+import { COMPONENT_MODULE } from './checkedShadow.ts'
+import { formatDiagnosis } from './formatDiagnosis.ts'
+import { projectShadow } from './projectShadow.ts'
+import { type ParsedSource, refusal } from './readSources.ts'
+import type { Diagnosis } from './TypeSession.ts'
+
+/**
+ * Writes each source's types beside the build, and removes the ones whose `.abide` is gone.
+ *
+ * A file is written only where its text moved, so an editor watching the directory re-reads what
+ * changed rather than everything. WITH `refused`, A SOURCE WHOSE PROJECTION IS REFUSED (34.3, …) is a
+ * finding at its first line and keeps the types it last had, as `parseSources` treats one that does
+ * not parse; without it the refusal is thrown, naming the file.
+ */
+export async function writeTypes(
+    root: string,
+    sources: readonly Pick<ParsedSource, 'path' | 'file'>[],
+    /** Whether `sources` is every file, so the types of one not among them are stale. */
+    whole = true,
+    refused?: Diagnosis[],
+): Promise<void> {
+    const above = dirname(root)
+    // Mirrored below the directory above `root`, as the scaffold's `tsconfig` names it.
+    const types = `${buildDirectory(root)}/types`
+    const written = new Set<string>()
+    const writes: Promise<unknown>[] = []
+    for (const source of sources) {
+        const path = `${types}/${relative(above, source.path)}.ts`
+        written.add(path)
+        let projected: string
+        try {
+            projected = projectShadow(source.file).text
+        } catch (thrown) {
+            const found = refusal(source.path, thrown)
+            if (refused === undefined)
+                throw new Error(formatDiagnosis(found, process.cwd()))
+            refused.push(found)
+            continue
+        }
+        // The checker's own stand-in for the default: a component taking anything (`COMPONENT_MODULE`).
+        const text = `// @ts-nocheck\n${projected}\n${COMPONENT_MODULE}`
+        if (WRITTEN.get(path) === text) continue
+        writes.push(
+            Bun.file(path)
+                .text()
+                .catch(() => undefined)
+                .then((standing) => {
+                    WRITTEN.set(path, text)
+                    return standing === text ? undefined : Bun.write(path, text)
+                }),
+        )
+    }
+    await Promise.all(writes)
+    if (!whole) return
+    // Only below this root's own mirror: two apps beside one another share the directory above.
+    const mirror = `${types}/${relative(above, root)}`
+    for (const name of namesUnder(mirror))
+        if (!written.has(`${mirror}/${name}`)) {
+            rmSync(`${mirror}/${name}`)
+            WRITTEN.delete(`${mirror}/${name}`)
+        }
+}
+
+// What this process last left at each path, so a compile run again (`abide dev`, the language
+// server) reads back only the files whose text moved since.
+const WRITTEN = new Map<string, string>()

package/src/server/CLIENT_BUILD.ts

@@ -1,6 +1,6 @@
 // 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.17, 38.21). A leaf, with no imports of its own, for the reason every constant crossing a
+// (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
 // `#shared/ADDRESSES.ts`.
@@ -24,10 +24,16 @@ export const CLIENT_ENTRY = 'entry'
  *
  * 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.21), and the manifest is the server's, not the browser's.
+ * `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.
  *
@@ -39,18 +45,10 @@ export const MANIFEST = 'manifest.json'
 export const ENCODING_SUFFIX = { br: '.br', gzip: '.gz' } as const
 
 /**
- * Where `abide build` copies `src/ui/public`, below its own output directory.
+ * 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.19 — a directory rather than the source tree: `abide start` boots what the build produced and
+ * 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'
-
-/**
- * Where the build puts the module a browser gets in place of each handler module.
- *
- * 16.28 — below the build's own output: the source's path, with this in front. One lookup for the
- * client bundle to make (`fenceServer`), and a place a reader can open to see exactly what the
- * browser was handed.
- */
-export const WIRE_DIRECTORY = 'wire'

package/src/server/DEFAULT_PORT.ts

@@ -1,6 +1,6 @@
 /**
  * The port an app listens on where neither `--port` nor `PORT` names one: `Bun.serve`'s own default,
- * so `abide start`'s, the first `abide dev` tries (38.64), and the one a command reaching the local
+ * so `abide start`'s, the first `abide dev` tries (38.63), and the one a command reaching the local
  * app calls.
  */
 export const DEFAULT_PORT = 3000

package/src/server/LAUNCHER_FILES.ts

@@ -0,0 +1,9 @@
+// THE DESKTOP LAUNCHER'S FILES. Its page and the `launcher` options it exports sit at the app's root
+// beside the root layout, a name the framework finds rather than an address (23.14); the icon is a
+// public file, so it is wherever the address it answers at says (36.11).
+
+/** The launcher's page and options. 38.80, 38.82. */
+export const LAUNCHER_PAGE = 'launcher.abide'
+
+/** The addresses of the desktop app's icon, the `.icns` first. 38.79. */
+export const ICON_ADDRESSES = { icns: '/icon.icns', png: '/icon.png' } as const

package/src/server/MODULE_QUERIES.ts

@@ -0,0 +1,18 @@
+// WHAT AN IMPORT OF A `.abide` ASKS FOR, spelled on the specifier: bun hands a plugin no import
+// attributes, so the compiler writes the face it wants where the plugin can read it
+// (`abideModules`). A `.abide` named with none is the face a module abide did not compile gets.
+
+/** The module the file compiles to, as a compiled module imports it. 32.17. */
+export const COMPONENT_QUERY = '?component'
+
+/** The file's scoped stylesheet, which its browser module imports. 34.4. */
+export const STYLE_QUERY = '?style'
+
+/** The file's text. 34.25. */
+export const TEXT_QUERY = '?text'
+
+/**
+ * The file's browser module, asked for outside a browser bundle — a component's hydration tested
+ * under a DOM in `bun test`. Its own `.abide` imports are browser modules too.
+ */
+export const CLIENT_QUERY = '?client'

package/src/server/TABLES.ts

@@ -0,0 +1,7 @@
+// The build's own modules below `__abide` (`abideModules`), beside the client entry (`CLIENT_ENTRY`).
+
+/** The server's tables: routes, error pages, server blocks and handlers. */
+export const SERVER_TABLE = 'server.ts'
+
+/** The client router's table, and the `start` the entry calls. */
+export const ROUTES_TABLE = 'routes.ts'

package/src/server/VIRTUAL_DIRECTORY.ts

@@ -1,6 +1,5 @@
-// Where `abide dev`'s compiled modules pretend to live, below the app's root: the compile points a
-// relative import back at its source from here (34.14), and the worker serves the modules under it.
-// Under the app's own root so that `#ui/…` and a bare package name resolve from here exactly as they
-// resolve from the build tree — both sit inside the app's package — and under a `__abide` directory
-// for the reason the addresses are: no app writes one.
+// Where the build's own modules — the server's tables, the router's and the client entry — are served
+// from, below the app's root (`abideModules`). Under the root so a bare specifier in them resolves as
+// one in the app does, and under a `__abide` directory for the reason the addresses are: no app writes
+// one.
 export const VIRTUAL_DIRECTORY = '__abide'

package/src/server/abideModules.ts

@@ -0,0 +1,391 @@
+// 34.14, 34.16, 32.17 — EVERY `.abide` IS SERVED AT ITS OWN PATH, compiled, by one plugin the runtime
+// and the bundler share. Served there, a compiled module's relative, `#` and bare specifiers resolve
+// from the file that wrote them through bun's own resolver — from the app, from a dependency under
+// `node_modules`, or from a linked package outside the root alike — so nothing about a file's
+// compile depends on where the build would have put it.
+//
+// WHICH FACE AN IMPORT GETS IS SPELLED ON ITS SPECIFIER (`MODULE_QUERIES`), because bun hands a plugin
+// no import attributes: a compiled module asks for `?component`, a browser module for its own
+// `?style`, a text import for `?text`. A `.abide` named bare is a module abide did not compile
+// asking — on a server that is the bound face 34.16 states, beside every name the module exports,
+// and in a browser the component module itself.
+//
+// THE TABLES — the route, error and handler tables, and in a browser the router's table and the
+// entry — are the build's own modules, served from `__abide` below the root, where no app writes.
+//
+// THE RUNTIME'S REGISTRATION IS THE PROCESS'S: a `.abide` filter is answered by the first plugin
+// that registered one, so a second app booted in the same process — a test's — adds its compilation
+// to this one rather than registering a plugin nobody asks.
+
+import { dirname, resolve } from 'node:path' // bun exposes no path helpers of its own
+import type { ServerTable } from './answerRequest.ts'
+import type { MountRow } from './answerRpc.ts'
+import { installSourceMaps, type SourceMaps } from './installSourceMaps.ts'
+import {
+    CLIENT_QUERY,
+    COMPONENT_QUERY,
+    STYLE_QUERY,
+    TEXT_QUERY,
+} from './MODULE_QUERIES.ts'
+import { realOrAsGiven } from './realOrAsGiven.ts'
+import { SERVER_TABLE } from './TABLES.ts'
+import { VIRTUAL_DIRECTORY } from './VIRTUAL_DIRECTORY.ts'
+
+/** One `.abide`, compiled: its server module, its browser module, its stylesheet and their maps. */
+export type CompiledFile = {
+    server: string
+    /** `''` where the file has nothing to hydrate and nothing imports it by name. */
+    client: string
+    sheet: string | undefined
+    /** 38.97 — each module's `mappings` into the `.abide`, or `undefined` where it places nothing. */
+    serverMappings: string | undefined
+    clientMappings: string | undefined
+}
+
+/**
+ * What a compile hands the plugin, and what `abide build` keeps and `abide dev` sends its worker.
+ *
+ * Every path RELATIVE TO THE ROOT, so a build moved to another directory or another machine is
+ * served from wherever its root is then.
+ */
+export type Compilation = {
+    /** Every `.abide` compiled, by its path below the root. */
+    files: Record<string, CompiledFile>
+    /** The build's own modules, by name below `__abide`. */
+    tables: Record<string, string>
+}
+
+// A VIRTUAL FACE'S PATH: its file's, with a suffix that is not a query. Both registries key a module
+// by its path whatever its namespace, and the runtime's drops a query from it — so a file's text, its
+// stylesheet or its bound face under `?…` took the place of the module the file compiles to.
+const BOUND = '::bound'
+const CLIENT = '::client'
+const TEXT = '::text'
+const STYLE = '::style'
+
+/** The namespace a bundle's component module is answered in, at its file's own path. */
+export const COMPONENT_NAMESPACE = 'abide-component'
+/** The namespaces a file's text and a component's stylesheet are loaded in. */
+export const TEXT_NAMESPACE = 'abide-text'
+export const STYLE_NAMESPACE = 'abide-style'
+
+/** What the plugin answers from: a compiled file or a table by absolute path. */
+type Served = {
+    file: (path: string) => CompiledFile | undefined
+    table: (path: string) => string | undefined
+}
+
+/** The plugin serving `compilation`'s files and tables, for one bundle. */
+export function abideModules(
+    root: string,
+    compilation: Compilation,
+): Bun.BunPlugin {
+    const files = new Map<string, CompiledFile>()
+    const tables = new Map<string, string>()
+    addCompilation(realOrAsGiven(root), compilation, files, tables)
+    return modulesPlugin({
+        file: (path) => files.get(path),
+        table: (path) => tables.get(path),
+    })
+}
+
+const RUNTIME_FILES = new Map<string, CompiledFile>()
+const RUNTIME_TABLES = new Map<string, string>()
+let registered = false
+
+/**
+ * Serves `compilation` to this process's imports from now on, and places a stack frame in each of
+ * its files (38.97).
+ */
+export function serveCompilation(root: string, compilation: Compilation): void {
+    const real = realOrAsGiven(root)
+    addCompilation(real, compilation, RUNTIME_FILES, RUNTIME_TABLES)
+    installSourceMaps(serverMapsOf(compilation, real), real)
+    if (registered) return
+    registered = true
+    Bun.plugin(
+        modulesPlugin({
+            file: (path) => RUNTIME_FILES.get(path),
+            table: (path) => RUNTIME_TABLES.get(path),
+        }),
+    )
+}
+
+/** What the server's table exports: its routes and error pages, server blocks and handlers. */
+export type BuiltTable = ServerTable & {
+    /** 37.1 — every module a `<script server>` runs in, imported before the app boots. */
+    servers: (() => Promise<unknown>)[]
+    /** 16.2 — every handler, each row with its module's loader. */
+    handlers: MountRow[]
+}
+
+/** The server's table of the app at `root`, out of the compilation this process serves. */
+export function servedTable(root: string): Promise<BuiltTable> {
+    return import(
+        Bun.pathToFileURL(tablePath(root, SERVER_TABLE)).href
+    ) as Promise<BuiltTable>
+}
+
+/** The path a table is imported at: `name` below `__abide` under `root`. */
+export function tablePath(root: string, name: string): string {
+    return `${realOrAsGiven(root)}/${VIRTUAL_DIRECTORY}/${name}`
+}
+
+/** Each server module's map, by the `.abide` it is served at, below `root`. */
+export function serverMapsOf(
+    compilation: Compilation,
+    root: string,
+): SourceMaps {
+    const maps: SourceMaps = {}
+    for (const [relative, compiled] of Object.entries(compilation.files))
+        if (compiled.serverMappings !== undefined)
+            maps[relative] = [resolve(root, relative), compiled.serverMappings]
+    return maps
+}
+
+function addCompilation(
+    root: string,
+    compilation: Compilation,
+    files: Map<string, CompiledFile>,
+    tables: Map<string, string>,
+): void {
+    // RESOLVED, not joined: a dependency's file is keyed above the root (`../node_modules/…`).
+    for (const [relative, compiled] of Object.entries(compilation.files))
+        files.set(resolve(root, relative), compiled)
+    for (const [name, text] of Object.entries(compilation.tables))
+        tables.set(`${root}/${VIRTUAL_DIRECTORY}/${name}`, text)
+}
+
+// `Bun.resolveSync` asks EVERY abide plugin's `onResolve` again — this one's, and the runtime's, which
+// is registered for the whole process and so answers inside a bundle too. One flag for all of them
+// is what lets the inner ask fall through to bun's resolver rather than be answered again from a
+// directory read as a file.
+let resolving = false
+
+/**
+ * Where `specifier` resolves from the directory `from`, as bun's own resolver answers — never as a
+ * face this plugin serves.
+ *
+ * The compiler asks where a `.abide` IS; in a process serving a compilation, the plugin would
+ * answer with the face an import of it gets instead.
+ */
+export function resolvedFile(specifier: string, from: string): string {
+    resolving = true
+    try {
+        return Bun.resolveSync(specifier, from)
+    } finally {
+        resolving = false
+    }
+}
+
+function modulesPlugin(served: Served): Bun.BunPlugin {
+    return {
+        name: 'abide-modules',
+        setup(build) {
+            // THE LANE IS THE BUILD'S TARGET: a browser bundle gets each file's browser module, and
+            // the runtime — which has no config — and a server bundle get its server module. A
+            // browser module the runtime was asked for (`CLIENT_QUERY`) is the one exception, and
+            // what it imports is in its lane.
+            const bundling: boolean = 'config' in build
+            const browser = bundling && build.config.target === 'browser'
+            const inBrowser = (importer: string): boolean =>
+                browser || pathOf(importer).endsWith(CLIENT)
+            // A BUNDLE'S COMPONENT MODULE IS IN A NAMESPACE OF ITS OWN: the bundler refuses a
+            // `file` path a plugin answers with `..` anywhere in it, which a `[...rest]` directory
+            // writes (23.5). The runtime has no such check, and its stack frames name the path.
+            const componentNamespace = bundling ? COMPONENT_NAMESPACE : 'file'
+            // The module `path` compiles to, in the lane its importer is in.
+            const componentFor = (path: string, importer: string) =>
+                inBrowser(importer) && !browser
+                    ? { path: `${path}${CLIENT}`, namespace: 'abide-client' }
+                    : { path, namespace: componentNamespace }
+            const resolved = (specifier: string, importer: string): string =>
+                resolvedFile(specifier, dirname(pathOf(importer)))
+            // A filter off the query's own constant, so renaming one cannot silently stop a match.
+            const abideWith = (query: string) =>
+                new RegExp(`\\.abide${RegExp.escape(query)}$`)
+
+            build.onResolve(
+                { filter: new RegExp(`${RegExp.escape(TEXT_QUERY)}$`) },
+                (args) => {
+                    if (resolving) return undefined
+                    const specifier = args.path.slice(0, -TEXT_QUERY.length)
+                    // A path of its own (`TEXT`): a file is often imported as code and as text at once
+                    // — an example's Files tab.
+                    return {
+                        path: `${resolved(specifier, args.importer)}${TEXT}`,
+                        namespace: TEXT_NAMESPACE,
+                    }
+                },
+            )
+            build.onResolve({ filter: abideWith(STYLE_QUERY) }, (args) => {
+                if (resolving) return undefined
+                const specifier = args.path.slice(0, -STYLE_QUERY.length)
+                return {
+                    path: `${resolved(specifier, args.importer)}${STYLE}`,
+                    namespace: STYLE_NAMESPACE,
+                }
+            })
+            build.onResolve({ filter: abideWith(COMPONENT_QUERY) }, (args) => {
+                if (resolving) return undefined
+                const specifier = args.path.slice(0, -COMPONENT_QUERY.length)
+                return componentFor(
+                    resolved(specifier, args.importer),
+                    args.importer,
+                )
+            })
+            build.onResolve({ filter: abideWith(CLIENT_QUERY) }, (args) => {
+                if (resolving) return undefined
+                const path = resolved(
+                    args.path.slice(0, -CLIENT_QUERY.length),
+                    args.importer,
+                )
+                return browser
+                    ? { path, namespace: componentNamespace }
+                    : { path: `${path}${CLIENT}`, namespace: 'abide-client' }
+            })
+            build.onResolve({ filter: /\.abide$/ }, (args) => {
+                if (resolving) return undefined
+                const path = resolved(args.path, args.importer)
+                // A bound face's own import of its component, and every browser import, is the
+                // component module.
+                if (
+                    inBrowser(args.importer) ||
+                    pathOf(args.importer) === `${path}${BOUND}`
+                )
+                    return componentFor(path, args.importer)
+                return { path: `${path}${BOUND}`, namespace: 'abide-bound' }
+            })
+            build.onResolve(
+                { filter: new RegExp(`/${VIRTUAL_DIRECTORY}/[^/]+\\.ts$`) },
+                (args) => {
+                    if (resolving) return undefined
+                    const path = resolve(
+                        dirname(pathOf(args.importer)),
+                        args.path,
+                    )
+                    return served.table(path) === undefined
+                        ? undefined
+                        : { path, namespace: 'abide-table' }
+                },
+            )
+
+            // A RELATIVE SPECIFIER A FACE IMPORTS AT RUN TIME is resolved from the file the face
+            // stands for: bun's runtime reads one from an importer in a namespace as no path at
+            // all. A bare one it resolves itself. Registered after every face, so a `.abide` is
+            // still answered as one — and NOT IN A BUNDLE, which needs it for no face it serves,
+            // and where a hook matching every relative import in a package costs the bundle that
+            // package's `sideEffects`: a two-page app grew by 12 KB, the validator one page never
+            // calls moved into the chunk both pages load.
+            if (!bundling)
+                build.onResolve({ filter: /^\.\.?\// }, (args) =>
+                    resolving || pathOf(args.importer) === args.importer
+                        ? undefined
+                        : { path: resolved(args.path, args.importer) },
+                )
+
+            build.onLoad(
+                { filter: /\.abide$/, namespace: componentNamespace },
+                (args) => {
+                    const compiled = compiledAt(served, args.path)
+                    return {
+                        contents: browser ? compiled.client : compiled.server,
+                        loader: 'ts',
+                    }
+                },
+            )
+            build.onLoad(
+                { filter: /.*/, namespace: 'abide-client' },
+                (args) => ({
+                    contents: compiledAt(
+                        served,
+                        args.path.slice(0, -CLIENT.length),
+                    ).client,
+                    loader: 'ts',
+                }),
+            )
+            build.onLoad({ filter: /.*/, namespace: 'abide-bound' }, (args) => {
+                const path = args.path.slice(0, -BOUND.length)
+                return {
+                    contents: boundModule(
+                        path,
+                        compiledAt(served, path).server,
+                    ),
+                    loader: 'js',
+                }
+            })
+            // A stylesheet is the bundle's; outside one there is no document to apply it to.
+            build.onLoad(
+                { filter: /.*/, namespace: STYLE_NAMESPACE },
+                (args) =>
+                    bundling
+                        ? {
+                              contents:
+                                  compiledAt(
+                                      served,
+                                      args.path.slice(0, -STYLE.length),
+                                  ).sheet ?? '',
+                              loader: 'css',
+                          }
+                        : { contents: '', loader: 'js' },
+            )
+            build.onLoad(
+                { filter: /.*/, namespace: TEXT_NAMESPACE },
+                async (args) => ({
+                    contents: `export default ${JSON.stringify(await Bun.file(args.path.slice(0, -TEXT.length)).text())}\n`,
+                    loader: 'js',
+                }),
+            )
+            build.onLoad(
+                { filter: /.*/, namespace: 'abide-table' },
+                (args) => ({
+                    contents: served.table(args.path) ?? '',
+                    loader: 'ts',
+                }),
+            )
+        },
+    }
+}
+
+// AN IMPORTER IN ONE OF THIS PLUGIN'S NAMESPACES CARRIES IT in front of its path at run time — with
+// a `/` in front of that again, where the bundler hands the path alone.
+function pathOf(importer: string): string {
+    return importer.replace(/^\/?abide-[a-z]+:/, '')
+}
+
+// THE PATH BUN NAMES A FILE BY HAS ITS LINKS RESOLVED, and so has the root a compilation is served
+// under (`serveCompilation`).
+function compiledAt(served: Served, path: string): CompiledFile {
+    const compiled = served.file(path)
+    if (compiled === undefined)
+        throw new Error(
+            `abide: ${path} is imported, and no compile of this app reached it.`,
+        )
+    return compiled
+}
+
+const SCANNER = new Bun.Transpiler({ loader: 'ts' })
+
+// 34.16 — BOUND, NOT RAW. The compiled module is a function of accessors answering its markup (33.4);
+// what an app's own module calls is a function of plain props answering a `Component` (35.4), which
+// `render` invokes with nothing. Every name the module exports rides beside it: a `<script module>`'s,
+// and the handlers a `<script server>` declares (34.23).
+//
+// NAMED RATHER THAN `export *`: the server blocks load side by side at boot, and a star export
+// through a module still loading found none of its names.
+function boundModule(path: string, server: string): string {
+    const specifier = JSON.stringify(path)
+    const names: string[] = []
+    for (const name of SCANNER.scan(server).exports)
+        if (name !== 'default') names.push(name)
+    return `import component from ${specifier}
+${names.length === 0 ? '' : `export { ${names.join(', ')} } from ${specifier}\n`}export default (props = {}) => {
+    const accessors = {}
+    for (const key in props) {
+        const value = props[key]
+        accessors[key] = () => value
+    }
+    return () => component(accessors)
+}
+`
+}

package/src/server/answerFailure.ts

@@ -6,10 +6,11 @@
 import { type Failed, problemOf } from '#shared/Failed.ts'
 import { RENDER_LOG } from '#shared/log.ts'
 import { coversPrefix, partsOf } from '#shared/matchRoute.ts'
+import { coversRoute, parseRoutePattern } from '#shared/routePattern.ts'
 import type { AppSources } from './answerRequest.ts'
 import { DOCUMENT_HEADERS } from './DOCUMENT_HEADERS.ts'
-import { boundPage, render } from './render.ts'
-import { beginRender } from './requestScope.ts'
+import { boundPage, renderDocument } from './render.ts'
+import { beginRender, currentRequestScope } from './requestScope.ts'
 
 /** What a page's failure is painted from: the error pages, and the document they go into. */
 export type ErrorPages = Pick<AppSources, 'errors' | 'errorDocument'>
@@ -47,13 +48,22 @@ export function answered(failure: Failed<string, unknown>): Response {
 /**
  * The error pages for `pathname`, nearest first.
  *
- * 35.2 — every one whose directory is a prefix of the address, each segment meaning what it means
- * in a route.
+ * 35.2 — AS A LAYOUT IS: over the route the request matched, every one whose route covers it, as
+ * a layout's and an `onError`'s does (35.1, 37.5). An address no route matched has only its path,
+ * and every one whose directory is a prefix of it answers, each segment meaning what it means in a
+ * route.
  */
 function errorsFor(errors: RankedError[], pathname: string): RankedError[] {
+    const route = currentRequestScope()?.route
+    const found: RankedError[] = []
+    if (route !== undefined) {
+        const segments = parseRoutePattern(route)
+        for (const error of errors)
+            if (coversRoute(error.segments, segments)) found.push(error)
+        return found
+    }
     // 15.16's address has no parts to be nearest to, so the root's page paints it.
     const parts = partsOf(pathname) ?? []
-    const found: RankedError[] = []
     for (const error of errors)
         if (coversPrefix(error.segments, parts)) found.push(error)
     return found
@@ -77,7 +87,7 @@ export async function answerFailure(
         try {
             const bound = boundPage(error, { failure: () => failure })
             beginRender(undefined)
-            const document = await render(bound, app.errorDocument)
+            const document = await renderDocument(bound, app.errorDocument)
             return new Response(document, { status, headers })
         } catch (thrown) {
             RENDER_LOG.warning(