@abide/abide 0.103.0 → 0.105.0

package/src/compiler/compileApp.ts

@@ -1,50 +1,31 @@
-import { existsSync, readFileSync, realpathSync } from 'node:fs' // bun exposes no sync existence check, read or realpath of its own
-import { dirname, posix, relative as relativeTo } from 'node:path' // bun exposes no path helpers of its own
+import { realpathSync } from 'node:fs' // bun exposes no sync realpath of its own
+import { dirname, posix } from 'node:path' // bun exposes no path helpers of its own
 import {
     type Compilation,
     type CompiledFile,
     resolvedFile,
 } from '#server/abideModules.ts'
 import type { Mount } from '#server/answerRpc.ts'
-import { abideUnder, appFiles } from '#server/appTree.ts'
 import { CLIENT_ENTRY } from '#server/CLIENT_BUILD.ts'
 import { COMPONENT_QUERY } from '#server/MODULE_QUERIES.ts'
 import { ROUTES_TABLE, SERVER_TABLE } from '#server/TABLES.ts'
 import { VIRTUAL_DIRECTORY } from '#server/VIRTUAL_DIRECTORY.ts'
 import { CLIENT_ADDRESS } from '#shared/ADDRESSES.ts'
-import { LAUNCHER_PAGE } from '#shared/LAUNCHER_FILES.ts'
+import { ROUTING_SPECIFIER, WIRE_SPECIFIER } from '#shared/SPECIFIERS.ts'
 import {
-    coversRoute,
-    parseRoutePattern,
-    placeOf,
-    routeOf,
-    type Segment,
-} from '#shared/routePattern.ts'
-import {
-    ROUTING_SPECIFIER,
-    SHARED_SPECIFIER,
-    WIRE_SPECIFIER,
-} from '#shared/SPECIFIERS.ts'
-import { abideImportsOf, appGraph } from './componentGraph.ts'
+    type AppLayout,
+    type AppRoute,
+    appLayout,
+    type PlacedSource,
+    shapeOf,
+} from './appLayout.ts'
 import { emitSource } from './emitSource.ts'
-import { formatDiagnosis } from './formatDiagnosis.ts'
-import {
-    type HandlerFile,
-    handlersUnder,
-    type Refuse,
-    THROW,
-} from './handlersUnder.ts'
-import { hooksCalled } from './hooksCalled.ts'
-import { mountsOf } from './mountsOf.ts'
+import { handlersUnder } from './handlersUnder.ts'
+import { isAbideSpecifier } from './hookCalls.ts'
 import { nearest } from './nearest.ts'
-import type { AbideFile } from './parseAbide.ts'
-import {
-    type ParsedSource,
-    parseSources,
-    type ReadSource,
-    readSources,
-    refusal,
-} from './readSources.ts'
+import { projectShadow } from './projectShadow.ts'
+import { Refusals } from './Refusals.ts'
+import { type ReadSource, readSources } from './readSources.ts'
 import { respecified } from './splitImports.ts'
 import { type Diagnosis, TypeSession } from './TypeSession.ts'
 import { writeDefaultProject } from './writeDefaultProject.ts'
@@ -55,20 +36,6 @@ import { writeDefaultProject } from './writeDefaultProject.ts'
 // commands serving different markup from the same sources is exactly what one compile in two sinks
 // makes impossible.
 
-type AppRoute = {
-    /** The address, in the bracket spelling `routePattern` parses. */
-    pattern: string
-    /** The `.abide` this route paints, relative to the app root. */
-    source: string
-    /**
-     * 35.1 — the `layout.abide` files this page renders inside, outermost first.
-     *
-     * A fact about the file tree, like the address itself, so a layout cannot be forgotten and
-     * cannot be declared twice.
-     */
-    layouts: string[]
-}
-
 /** An app's compiled output: every file and table (`Compilation`), its routes, and its warnings. */
 export type CompiledApp = Compilation & {
     routes: AppRoute[]
@@ -100,10 +67,10 @@ export type AppChecker = {
      */
     saw: (path: string | undefined) => void
     /**
-     * The app's own `.abide`, read (`sourcesUnder`) — kept until `saw` hears anything move, so a
-     * check asked again and again while an editor types re-reads nothing on disk.
+     * The app, laid out (`appLayout`) — kept until `saw` hears anything move, so a check asked again
+     * and again while an editor types re-reads nothing on disk.
      */
-    sources: () => ReturnType<typeof sourcesUnder>
+    layout: () => Promise<AppLayout>
     /**
      * Whether the project it was opened on is still the app's; if so, flushes what `saw` held.
      *
@@ -136,21 +103,21 @@ export async function openChecker(appRoot: string): Promise<AppChecker> {
     session.root = root
     const moved = new Set<string>()
     let movedSomewhere = false
-    let sources: ReturnType<typeof sourcesUnder> | undefined
+    let layout: Promise<AppLayout> | undefined
     return {
         session,
         root,
         saw: (path) => {
-            sources = undefined
+            layout = undefined
             if (path === undefined) movedSomewhere = true
             else moved.add(path)
         },
-        sources: () => {
-            sources ??= sourcesUnder(root).catch((thrown: unknown) => {
-                sources = undefined
+        layout: () => {
+            layout ??= appLayout(root).catch((thrown: unknown) => {
+                layout = undefined
                 throw thrown
             })
-            return sources
+            return layout
         },
         current: () => {
             if (projectFiles(root) !== opened) return false
@@ -183,7 +150,7 @@ function projectFiles(root: string): string {
  * `kept` is one the caller holds across runs and closes itself; one opened here is closed whatever
  * `run` did.
  */
-export async function withChecker<Result>(
+async function withChecker<Result>(
     root: string,
     kept: AppChecker | undefined,
     run: (session: TypeSession) => Promise<Result>,
@@ -196,135 +163,6 @@ export async function withChecker<Result>(
     }
 }
 
-/**
- * Every `.abide` of the app's own, read, in path order — and the root as bun resolves it.
- *
- * `Bun.resolveSync` answers a symlink-free path (`/tmp` is `/private/tmp` on macOS), so a root
- * spelled through a link would have every import resolve to a file this walk never listed, and
- * every component read as uninvoked. THE READS OVERLAP: nothing a source is read for depends on
- * another, and this runs again on every `abide dev` save.
- */
-export async function sourcesUnder(
-    appRoot: string,
-): Promise<{ root: string; sources: { path: string; text: string }[] }> {
-    const root = realpathSync(appRoot)
-    return { root, sources: await sourcesAt(root, abideUnder(root)) }
-}
-
-/** The `.abide` at each of `relatives`, below `root`, read. */
-async function sourcesAt(
-    root: string,
-    relatives: readonly string[],
-): Promise<{ path: string; text: string }[]> {
-    const paths: string[] = []
-    for (const path of relatives) paths.push(`${root}/${path}`)
-    const texts = await Promise.all(paths.map((path) => Bun.file(path).text()))
-    const sources: { path: string; text: string }[] = []
-    for (let at = 0; at < paths.length; at += 1)
-        sources.push({ path: paths[at] as string, text: texts[at] as string })
-    return sources
-}
-
-/**
- * `parsed` and every `.abide` outside them that one of them imports — a dependency's, or a linked
- * package's — parsed, and every one those import in turn; and every `.abide` under a directory one
- * of them mounts, at the position the mount gives it (23.19). With them, the app's own handler files
- * — `own`, below `root`, as its walk found them (`appFiles`) — and every one a mounted directory
- * holds, each at the position it answers by.
- *
- * 34.23 — COMPILED WITH THE APP, by the app's checker, so a component a package ships as source is
- * one of the app's in every way but its address: it is never routed (`placeOf`) unless mounted.
- */
-export async function withDependencies(
-    root: string,
-    parsed: readonly ParsedSource[],
-    own: readonly string[],
-    resolve: (specifier: string, from: string) => string | undefined,
-    refused?: Diagnosis[],
-): Promise<{
-    sources: ParsedSource[]
-    handlers: HandlerFile[]
-    mounted: Compilation['mounted']
-}> {
-    const all = [...parsed]
-    const handlers: HandlerFile[] = []
-    for (const relative of own)
-        handlers.push({
-            path: `${root}/${relative}`,
-            relative,
-            position: relative,
-        })
-    // The mounted handler files placed so far; the app's own is never mounted (23.20).
-    const handled = new Set<string>()
-    const mounted: Compilation['mounted'] = {}
-    const byPath = new Map<string, ParsedSource>()
-    for (const source of all) byPath.set(source.path, source)
-    // 23.20 — a directory mounts once, and by whom.
-    const mountedBy = new Map<string, string>()
-    const refuse = (path: string, message: string): void => {
-        if (refused === undefined) throw new Error(message)
-        refused.push(refusal(path, new Error(message)))
-    }
-    const add = async (found: {
-        path: string
-        position?: string
-    }): Promise<void> => {
-        const text = await Bun.file(found.path).text()
-        for (const one of parseSources([{ ...found, text }], refused)) {
-            byPath.set(one.path, one)
-            all.push(one)
-        }
-    }
-    for (let at = 0; at < all.length; at += 1) {
-        const source = all[at] as ParsedSource
-        const position = source.position ?? relativeTo(root, source.path)
-        const mounts = mountsOf(root, source.path, position, source.file)
-        if (typeof mounts === 'string') {
-            refuse(source.path, mounts)
-            continue
-        }
-        for (const mount of mounts) {
-            const other = mountedBy.get(mount.directory)
-            if (other !== undefined) {
-                refuse(
-                    source.path,
-                    `abide: ${other} and ${position} both mount ${mount.specifier}, and a directory answers at one place. RULEBOOK 23.20.`,
-                )
-                continue
-            }
-            mountedBy.set(mount.directory, position)
-            mounted[relativeTo(root, mount.directory)] = mount.at
-            for (const placed of mount.handlers) {
-                // Two mounts can overlap, one directory inside the other; a file is placed once.
-                if (handled.has(placed.path)) continue
-                handled.add(placed.path)
-                handlers.push({
-                    path: placed.path,
-                    relative: relativeTo(root, placed.path),
-                    position: placed.position,
-                })
-            }
-            for (const { path, position: placed } of mount.files) {
-                // A file a component import reached first takes its mount's position all the same.
-                const known = byPath.get(path)
-                if (known !== undefined) {
-                    known.position = placed
-                    continue
-                }
-                await add({ path, position: placed })
-            }
-        }
-        for (const target of abideImportsOf(
-            source.path,
-            source.file,
-            resolve,
-        ).values()) {
-            if (!byPath.has(target)) await add({ path: target })
-        }
-    }
-    return { sources: all, handlers, mounted }
-}
-
 /**
  * The `Compilation` alone out of `app`, which is what is written to disk and served: the rest of a
  * compiled app is the commands' to read.
@@ -339,7 +177,8 @@ export function compilationOf(app: CompiledApp): Compilation {
 }
 
 /**
- * Compiles every `.abide` source and handler of the app at `appRoot` (`Compilation`).
+ * Compiles every `.abide` source and handler of the app at `appRoot` (`Compilation`), stopping at
+ * the first thing it refuses.
  *
  * `kept` is a checker the caller holds across compiles and closes itself.
  */
@@ -347,185 +186,162 @@ export async function compileApp(
     appRoot: string,
     kept?: AppChecker,
 ): Promise<CompiledApp> {
+    return (await compiled(appRoot, kept, false)).app
+}
+
+/**
+ * The app at `appRoot` compiled — THE ONE PIPELINE `abide build` and `abide check` both run, the
+ * layout, the reads, the lints and the emit, differing only in what a refusal does (`Refusals`) and
+ * in what is checked beside: a build stops at the first refusal, and a check (`checking`) reports
+ * every one at its file with what the checker says of each file (38.3), and goes on checking
+ * whatever a refusal does not stop (38.33).
+ */
+export async function compiled(
+    appRoot: string,
+    kept: AppChecker | undefined,
+    checking: boolean,
+): Promise<{ app: CompiledApp; findings: Diagnosis[] }> {
     const root = realpathSync(appRoot)
-    // ONE WALK for the sources, the handler files and the public files, refusing a tree 23.16-23.18
-    // forbids before anything is read.
-    const { abide, handlers, published } = appFiles(root)
-    const sources = await sourcesAt(root, abide)
-    // 16.2 — an app of handler files alone is still an app.
-    if (sources.length === 0 && handlers.length === 0)
-        return {
-            files: {},
-            tables: {},
-            handlers: {},
-            mounted: {},
-            routes: [],
-            mounts: [],
-            sources: 0,
-            warnings: [],
-            published,
-        }
+    const refusals = new Refusals(root, checking)
+    // ONE LAYOUT for the sources, the handler files and the public files, and what the tree refuses
+    // is met before the checker is asked anything.
+    const layout = await (kept?.layout() ?? appLayout(root))
+    refusals.adopt(layout.refused)
+    const app: CompiledApp = {
+        files: {},
+        tables: {},
+        handlers: {},
+        mounted: layout.mounted,
+        routes: [],
+        mounts: [],
+        sources: layout.own,
+        warnings: [],
+        published: layout.published,
+    }
+    // 16.2 — an app of handler files alone is still an app; one of neither has nothing to build, and
+    // a check still has its `.ts` to check.
+    if (
+        !checking &&
+        layout.sources.length === 0 &&
+        layout.handlers.length === 0
+    )
+        return { app, findings: [] }
 
-    // One session for the whole build: opening it spawns the checker, and the cost is paid once
+    // One session for the whole compile: opening it spawns the checker, and the cost is paid once
     // rather than per file.
     return withChecker(root, kept, async (session) => {
-        // A BUILD STOPS AT THE FIRST REFUSAL, so neither step is handed a list to report it in.
-        const own = parseSources(sources)
-        const resolve = resolverIn()
-        const {
-            sources: parsed,
-            handlers: handlerFiles,
-            mounted,
-        } = await withDependencies(root, own, handlers, resolve)
-        const { read, warnings } = await readSources(session, parsed)
-        const { ambient, unkeyed } = await session.lints(root, parsed)
-        // 11.37 — a build error, every read named, rather than a first one and a second run.
-        if (ambient.length > 0) {
-            const lines: string[] = []
-            for (const read of ambient)
-                lines.push(formatDiagnosis(read, process.cwd()))
-            throw new Error(lines.join('\n'))
-        }
-        const emitted = await emitApp(
-            root,
+        // 38.33 — A FILE WHOSE PROJECTION IS REFUSED (34.3, 34.17) is refused at its file, found here
+        // because every later step projects it and would refuse it for the whole app.
+        const projected: PlacedSource[] = []
+        for (const source of layout.sources)
+            try {
+                projectShadow(source.file)
+                projected.push(source)
+            } catch (thrown) {
+                refusals.at(source.path, thrown)
+            }
+        const { read, warnings } = await readSources(
             session,
-            read,
-            resolve,
-            handlerFiles,
+            projected,
+            refusals,
         )
+        let found: Diagnosis[] = []
+        let emittable = read
+        if (checking) {
+            // THE APP'S OWN FILES ARE REPORTED ON: a dependency's is compiled with them (34.23), and
+            // what is wrong inside a package is the package's to report.
+            const reported: typeof read = []
+            for (const source of read)
+                if (!source.dependency) reported.push(source)
+            const diagnosed = await session.diagnose(reported, layout)
+            found = diagnosed.diagnoses
+            // A FILE WHOSE LOWERING REFUSED is `found` already, at its line, and is not emitted.
+            emittable = []
+            for (const source of read)
+                if (!diagnosed.refused.has(source.path)) emittable.push(source)
+        }
+        const { ambient, unkeyed } = await session.lints(root, projected)
+        // 11.37 — a build error, every read named.
+        refusals.adopt(ambient)
+        // What the emit throws with no one file to name is refused at the root; a refusal of a file
+        // is refused at it.
+        let emitWarnings: Diagnosis[] = []
+        try {
+            const whole = await emitApp(layout, session, emittable, refusals)
+            Object.assign(app, whole)
+            emitWarnings = whole.warnings
+        } catch (thrown) {
+            refusals.at(root, thrown)
+        }
+        // 11.30 — warned on, and the build goes on.
+        app.warnings = [...warnings, ...unkeyed, ...emitWarnings]
         return {
-            ...emitted,
-            mounted,
-            published,
-            sources: sources.length,
-            // 11.30 — warned on, and the build goes on.
-            warnings: [...warnings, ...unkeyed, ...emitted.warnings],
+            app,
+            findings: [
+                ...refusals.found,
+                ...unkeyed,
+                ...warnings,
+                ...emitWarnings,
+                ...found,
+            ],
         }
     })
 }
 
-/**
- * The emit half of `compileApp`, over sources already parsed and read.
- *
- * `abide check` has done both by then, file by file, and asks this for only what the whole app can
- * refuse: two handlers at one address, or a template the emit cannot lower.
- */
-export async function emitApp(
-    root: string,
+/** The emit half of `compiled`, over sources already laid out and read. */
+async function emitApp(
+    layout: Pick<
+        AppLayout,
+        'root' | 'handlers' | 'routes' | 'errors' | 'published'
+    >,
     session: TypeSession,
-    sources: readonly ReadSource[],
-    /** The resolver the sources' dependencies were found with, whose answers it keeps. */
-    resolve: (specifier: string, from: string) => string | undefined,
-    /** The handler files, the app's own and each mounted one (`withDependencies`). */
-    handlerFiles: readonly HandlerFile[],
-    /** Told of each refusal at its file; the build's throws the first. */
-    refuse: Refuse = THROW,
+    sources: readonly ReadSource<PlacedSource>[],
+    refusals: Refusals,
 ): Promise<
     Pick<
         CompiledApp,
         'files' | 'tables' | 'handlers' | 'routes' | 'mounts' | 'warnings'
     >
 > {
+    const { root, routes, errors } = layout
     const files: Record<string, CompiledFile> = {}
     const tables: Record<string, string> = {}
-    const routes: AppRoute[] = []
-    // 32.17 AND 34.14 — WHICH FILES ARE INVOKED AS COMPONENTS, and where each import lands. A
-    // caller's client module imports its child's, so a child with nothing to hydrate still
-    // needs one to exist (`emitClient`'s no-op), and an invoked file carries its own markup
-    // (`emitClient`). Built before the emit loop because a page may invoke a component the
-    // walk reaches later.
-    const graph = appGraph(root, sources, resolve)
-    const parsed = graph.nodes
-
-    // 35.1, 35.12 — every `layout.abide` by the route it covers, one to a route; 35.13 — and one
-    // with no template wraps nothing, being the route's hooks alone.
-    const layouts: AppLayout[] = []
-    const layoutAt = new Map<string, string>()
-    const errorAt = new Map<string, string>()
-    for (const entry of parsed) {
-        if (entry.kind !== 'layout' && entry.kind !== 'error') continue
-        const route = routeOf(entry.position)
-        const held = entry.kind === 'layout' ? layoutAt : errorAt
-        const other = held.get(shapeOf(route))
-        if (other !== undefined) {
-            refuse(
-                entry.relative,
-                new Error(
-                    `abide: ${other} and ${entry.relative} are both the ${entry.kind}.abide at ${route}. RULEBOOK 35.12.`,
-                ),
-            )
-            continue
-        }
-        held.set(shapeOf(route), entry.relative)
-        if (entry.kind === 'layout' && entry.file.template.length > 0)
-            layouts.push({
-                source: entry.relative,
-                segments: parseRoutePattern(route),
-            })
-    }
-    // 35.2 — every `error.abide`, with the route it answers for and the layouts around it.
-    const errors: AppRoute[] = []
-    for (const entry of parsed) {
-        if (entry.kind !== 'page' && entry.kind !== 'error') continue
-        // 23.3, 35.14 — a page or an `error.abide` with nothing to paint is its route's hooks
-        // alone.
-        if (!paints(entry.file)) continue
-        ;(entry.kind === 'page' ? routes : errors).push({
-            pattern: entry.route as string,
-            source: entry.relative,
-            layouts: layoutsAround(entry.route as string, layouts),
-        })
-    }
-
     // 16.2 AND 16.28 — THE HANDLERS, read before a module is emitted: the server mounts each one,
     // and the browser holds its wrapper in its place — a handler file's as that file, a private
     // handler's in the server block's place in its own file's module. Written whether or not there
     // is a page: a handler is answered over http to a caller that has none.
     const { mounts, warnings } = await handlersUnder(
         session,
-        parsed,
-        handlerFiles,
-        refuse,
+        sources,
+        layout.handlers,
+        refusals,
     )
-    refuseSharedRoutes(routes, mounts, refuse)
-    refuseStrayLauncher(parsed, handlerFiles, refuse)
+    refuseSharedRoutes(routes, mounts, refusals)
+    refuseAddressCollision(routes, mounts, layout.published, refusals)
     const standIns = standInsOf(mounts)
     // 37.1 — every module a server block or a handler file runs in, for the boot to import before
     // `onStart`.
     const servers: string[] = []
-    for (const file of handlerFiles) servers.push(file.relative)
+    for (const file of layout.handlers) servers.push(file.relative)
     let transitions = false
-    for (const entry of parsed) {
-        // 35.16 — of the files with an address, the root layout alone is outermost in every render.
-        if (
-            entry.file.document !== undefined &&
-            entry.kind !== 'component' &&
-            !(entry.kind === 'layout' && routeOf(entry.position) === '/')
-        ) {
-            refuse(
-                entry.relative,
-                new Error(
-                    `abide: ${entry.relative} writes <html>, and of the pages, layouts and error pages only the root layout.abide writes the document. RULEBOOK 35.16.`,
-                ),
+    for (const entry of sources) {
+        let emitted: ReturnType<typeof emitSource>
+        try {
+            emitted = emitSource(
+                entry,
+                standIns.get(entry.relative),
+                entry.text,
             )
+        } catch (thrown) {
+            refusals.at(entry.path, thrown)
             continue
         }
-        const emitted = emitSource(
-            entry.relative,
-            entry.file,
-            entry.answer,
-            graph.invoked.has(entry.path),
-            standIns.get(entry.relative),
-            entry.text,
-            entry.position,
-        )
         if (entry.file.servers.length > 0) servers.push(entry.relative)
         transitions ||= emitted.transitions
         // 34.26 — a dependency's module runs on the app's runtime, whatever the package carries.
-        const onAppRuntime =
-            placeOf(entry.relative) === 'dependency'
-                ? (text: string) => onAbideOf(root, entry.path, text)
-                : (text: string) => text
+        const onAppRuntime = entry.dependency
+            ? (text: string) => onAbideOf(root, entry.path, text)
+            : (text: string) => text
         files[entry.relative] = {
             server: onAppRuntime(emitted.server),
             client: onAppRuntime(emitted.client),
@@ -541,11 +357,10 @@ export async function emitApp(
     // forgotten. The loaders are dynamic imports, which is what keeps a destination's
     // markup and bindings off the entry page's bundle until somebody navigates there.
     //
-    // TWO TABLES OFF ONE WALK, each importing a file's `?component` face — the same addresses
+    // TWO TABLES OFF ONE LAYOUT, each importing a file's `?component` face — the same addresses
     // either way, which is what keeps the pair from being two walks that can disagree. The
-    // server's is written with no
-    // page too — an app of handlers alone still answers — and the client's, with the entry
-    // that boots it, only where there is a page to boot.
+    // server's is written with no page too — an app of handlers alone still answers — and the
+    // client's, with the entry that boots it, only where there is a page to boot.
     tables[SERVER_TABLE] = serverTable(routes, errors, servers, mounts)
     // 16.74 — what the browser holds of each handler file, and the route its hooks are filed at:
     // read by the module's load, which runs before the server table is imported.
@@ -584,11 +399,7 @@ export async function emitApp(
 function onAbideOf(root: string, path: string, text: string): string {
     const from = dirname(realpathSync(path))
     return respecified(text, (specifier) => {
-        if (
-            specifier !== SHARED_SPECIFIER &&
-            !specifier.startsWith(`${SHARED_SPECIFIER}/`)
-        )
-            return undefined
+        if (!isAbideSpecifier(specifier)) return undefined
         let target: string
         try {
             target = resolvedFile(specifier, root)
@@ -619,41 +430,6 @@ function tableImport(source: string): string {
     )
 }
 
-// A layout and the route it covers, parsed.
-type AppLayout = { source: string; segments: Segment[] }
-
-/**
- * The layouts a page renders inside, outermost first.
- *
- * 35.1 — every `layout.abide` whose route lies ON THE WAY DOWN to the page's wraps it and no other
- * does: `src/layout.abide` wraps the page `src/media/index.abide` serves at `/media`, and so does
- * `src/[section]/layout.abide`. So the test is a prefix of the route, kind by kind, and the nesting
- * order is the route's depth.
- */
-function layoutsAround(route: string, layouts: AppLayout[]): string[] {
-    const page = parseRoutePattern(route)
-    const chain: AppLayout[] = []
-    for (const layout of layouts)
-        if (coversRoute(layout.segments, page)) chain.push(layout)
-    // A shorter route is an outer one: they are prefixes of each other by construction.
-    chain.sort((one, two) => one.segments.length - two.segments.length)
-    const sources: string[] = []
-    for (const layout of chain) sources.push(layout.source)
-    return sources
-}
-
-/**
- * A route with its parameters' names erased: what two routes answering one address share.
- *
- * 19.1 — `/media/[id]` and `/media/[slug]` are one route.
- */
-function shapeOf(route: string): string {
-    let shape = ''
-    for (const segment of parseRoutePattern(route))
-        shape += `/${segment.kind === 'static' ? segment.name : `[${segment.kind}]`}`
-    return shape === '' ? '/' : shape
-}
-
 /**
  * Refuses, naming both, where two files answer one method at one route — at the second.
  *
@@ -662,7 +438,7 @@ function shapeOf(route: string): string {
 function refuseSharedRoutes(
     routes: AppRoute[],
     mounts: Mount[],
-    refuse: Refuse,
+    refusals: Refusals,
 ): void {
     const owners = new Map<string, string>()
     const claim = (method: string, route: string, source: string): void => {
@@ -670,7 +446,7 @@ function refuseSharedRoutes(
         const owner = owners.get(key)
         if (owner === undefined) owners.set(key, source)
         else
-            refuse(
+            refusals.at(
                 source,
                 new Error(
                     `abide: ${owner} and ${source} both answer ${method} at ${route}. RULEBOOK 19.1.`,
@@ -682,110 +458,44 @@ function refuseSharedRoutes(
 }
 
 /**
- * Refuses, naming the file, where anything but the root's `launcher.abide` calls `onLauncher`.
+ * Refuses, naming both, where a public file claims a route's address or another public file's — at
+ * the public file.
  *
- * 38.107 — the launch loads that file alone, so a call anywhere else is never read.
+ * 36.13 — the walks that find routes and public files cannot see each other's collisions from
+ * inside either one; this is where they meet, and naming BOTH is the clause. Two `public`
+ * directories can claim one address too, since each mounts at the path above it (36.11). IN THE
+ * COMPILE, so the build, dev and check all ask it (38.33), and `abide start` trusts the build:
+ * `answerRequest` answers a public file AHEAD of any route on the ground that a collision cannot
+ * exist at run time, and 30.8 says dev resolves an address the way the built app does.
  */
-function refuseStrayLauncher(
-    sources: readonly { relative: string; position: string; file: AbideFile }[],
-    handlerFiles: readonly HandlerFile[],
-    refuse: Refuse,
+function refuseAddressCollision(
+    routes: AppRoute[],
+    mounts: Mount[],
+    published: Map<string, string>,
+    refusals: Refusals,
 ): void {
-    const stray = (relative: string): void =>
-        refuse(
-            relative,
-            new Error(
-                `abide: ${relative} calls onLauncher, which is read from src/${LAUNCHER_PAGE} alone. Move the call there. RULEBOOK 38.107.`,
-            ),
-        )
-    for (const source of sources)
-        if (
-            source.position !== LAUNCHER_PAGE &&
-            source.file.servers.some(callsLauncher)
-        )
-            stray(source.relative)
-    for (const file of handlerFiles)
-        if (callsLauncher(readFileSync(file.path, 'utf8'))) stray(file.relative)
-}
-
-function callsLauncher(source: string): boolean {
-    return (
-        source.includes('onLauncher') &&
-        hooksCalled(source).includes('onLauncher')
-    )
-}
-
-/**
- * Resolves a specifier from a directory as bun does, or `undefined` where it does not resolve.
- *
- * A COMPONENT IMPORT RESOLVES THE WAY THE APP'S OWN IMPORTS DO — its import map, from the file
- * that wrote it. One that does not resolve is left as written, and the bundle names it. THE
- * ANSWER IS A REAL PATH, as every root handed to the compiler is.
- */
-export function resolverIn(): (
-    specifier: string,
-    from: string,
-) => string | undefined {
-    // ONE ANSWER PER SPECIFIER AND DIRECTORY for as long as the resolver lives: a compile resolves
-    // every import once for its dependencies and again for its graph, and hands both one resolver.
-    const answered = new Map<string, string | undefined>()
-    return (specifier, from) => {
-        const key = `${from}\0${specifier}`
-        if (answered.has(key)) return answered.get(key)
-        const found = resolveFrom(specifier, from)
-        answered.set(key, found)
-        return found
-    }
-}
-
-function resolveFrom(specifier: string, from: string): string | undefined {
-    try {
-        return resolvedFile(specifier, from)
-    } catch {
-        // 38.65 — BUN KEEPS A DIRECTORY'S LISTING FOR THE LIFE OF THE PROCESS, and looks a `#` specifier up
-        // in it with no second look — where a relative one that misses reads the directory again.
-        // `abide dev` compiles in one process for its whole session, so a component created since
-        // its directory was listed never resolved, and was read as uninvoked. The `imports` map is
-        // read here instead, and the file it names looked for on disk.
-        return specifier.startsWith('#')
-            ? throughImports(specifier, from)
-            : undefined
-    }
-}
-
-/** A `#` specifier resolved through the nearest `package.json`'s `imports`, to a file that exists. */
-function throughImports(specifier: string, from: string): string | undefined {
-    const manifest = nearest(from, 'package.json')
-    if (manifest === undefined) return undefined
-    const imports = (
-        JSON.parse(readFileSync(manifest, 'utf8')) as {
-            imports?: Record<string, unknown>
-        }
-    ).imports
-    if (imports === undefined) return undefined
-    const base = dirname(manifest)
-    for (const [key, targets] of Object.entries(imports)) {
-        const star = key.indexOf('*')
-        let matched: string | undefined
-        if (star === -1) matched = key === specifier ? '' : undefined
-        else if (
-            specifier.startsWith(key.slice(0, star)) &&
-            specifier.endsWith(key.slice(star + 1)) &&
-            specifier.length >= key.length - 1
-        )
-            matched = specifier.slice(
-                star,
-                specifier.length - (key.length - star - 1),
+    const patterns = new Set<string>()
+    for (const route of routes) patterns.add(route.pattern)
+    for (const mount of mounts) patterns.add(mount.address)
+    const claimed = new Map<string, string>()
+    for (const [source, address] of published) {
+        const other = claimed.get(address)
+        if (patterns.has(address))
+            refusals.at(
+                source,
+                new Error(
+                    `abide: ${source} and the route ${address} claim the same address. RULEBOOK 36.13.`,
+                ),
             )
-        if (matched === undefined) continue
-        // A conditions object names no path of its own, and is passed over.
-        for (const target of [targets].flat()) {
-            if (typeof target !== 'string') continue
-            const path = posix.join(base, target.replace('*', matched))
-            if (existsSync(path)) return path
-        }
+        else if (other !== undefined)
+            refusals.at(
+                source,
+                new Error(
+                    `abide: ${other} and ${source} are both answered at ${address}. RULEBOOK 36.13.`,
+                ),
+            )
+        else claimed.set(address, source)
     }
-    return undefined
 }
 
 /** The rows of either route table, one per route, `column` appending the fields only one carries. */
@@ -942,11 +652,6 @@ import { wire as __wire } from '${WIRE_SPECIFIER}'
 ${lines.join('')}`
 }
 
-/** Whether a page or an error page has anything to paint: a template, or a head. 23.3, 35.14. */
-export function paints(file: AbideFile): boolean {
-    return file.template.length > 0 || file.head.length > 0
-}
-
 // THE ENTRY. An app does not write it: which module boots the client is the build's knowledge,
 // exactly as the route table is, and a hand-written entry is one more file to keep in step with a
 // layout that moves.