@abide/abide 0.103.0 → 0.105.0

package/src/compiler/componentGraph.ts

@@ -1,12 +1,6 @@
-import { dirname, relative as relativeTo } from 'node:path' // bun exposes no path helpers of its own
-import {
-    type FileKind,
-    fileKind,
-    placeOf,
-    routeOf,
-} from '#shared/routePattern.ts'
+import { dirname } from 'node:path' // bun exposes no path helpers of its own
 import { type AbideFile, scriptBodies } from './parseAbide.ts'
-import { abideImports, attributedImports } from './splitImports.ts'
+import { abideImports } from './splitImports.ts'
 
 type Resolve = (specifier: string, from: string) => string | undefined
 
@@ -60,66 +54,3 @@ export function abideImportsOf(
         }
     return resolved
 }
-
-/** One source in the app graph: where it is below the root, what it is, and its address. */
-export type AppNode<Source> = Source & {
-    relative: string
-    /** 23.19 — the path it answers by: its own below the root, or the one its mount gives it. */
-    position: string
-    kind: FileKind
-    /** 23.3 — the address of a page or an error page, and `undefined` for anything else. */
-    route: string | undefined
-}
-
-/**
- * The app as one graph, built once per build or check: every source with its kind and address,
- * and which files are invoked as components.
- */
-export function appGraph<
-    Source extends {
-        path: string
-        file: AbideFile
-        position?: string | undefined
-    },
->(
-    root: string,
-    sources: readonly Source[],
-    resolve: Resolve,
-): { nodes: AppNode<Source>[]; invoked: Set<string> } {
-    const nodes: AppNode<Source>[] = []
-    for (const source of sources) {
-        // Below the root for the app's own files, and above it — `../node_modules/…` — for a
-        // dependency's (34.24).
-        const relative = relativeTo(root, source.path)
-        const position = source.position ?? relative
-        // 34.20 — a server block of the app's own under a `server` or `public` directory, refused
-        // here before anything reads its handlers: neither directory holds a component that runs.
-        const place = placeOf(position)
-        if (
-            source.file.servers.length > 0 &&
-            (place === 'server' || place === 'public')
-        )
-            throw new Error(
-                `abide: ${relative} has a <script server>, and it is under a ${place} directory, where nothing has an address. Move the file out of it, or the code into a module under a server directory. RULEBOOK 34.20.`,
-            )
-        // 34.21 — a file imported as text is found at build, not when its module first loads.
-        for (const script of scriptBodies(source.file))
-            for (const { specifier } of attributedImports(script, 'text'))
-                if (resolve(specifier, dirname(source.path)) === undefined)
-                    throw new Error(
-                        `abide: ${relative} imports ${specifier} as text, and there is no such file. RULEBOOK 34.21.`,
-                    )
-        const kind = fileKind(position)
-        nodes.push({
-            ...source,
-            relative,
-            position,
-            kind,
-            route:
-                kind === 'page' || kind === 'error'
-                    ? routeOf(position)
-                    : undefined,
-        })
-    }
-    return { nodes, invoked: componentGraph(sources, resolve).invoked }
-}

package/src/compiler/declaredExports.ts

@@ -44,6 +44,7 @@ import {
     isReactiveMember,
     valueTypeOf,
 } from './reactiveTypes.ts'
+import type { Refusals } from './Refusals.ts'
 import type { Diagnosis } from './TypeSession.ts'
 
 /**
@@ -57,12 +58,16 @@ import type { Diagnosis } from './TypeSession.ts'
  * export here: it is erased, and has no address to answer at.
  *
  * `projectName` is the tsconfig the project was opened on, which a module outside it is refused by.
+ * 38.33 — WHAT IS REFUSED OF A MODULE IS REFUSED AT ITS FILE, `named[at]` for `paths[at]`, every
+ * export read either way: a module with a refusal is `undefined`, so nothing refuses it twice.
  */
 export async function declaredExports(
     project: Project,
     projectName: string,
     paths: readonly string[],
-): Promise<DeclaredExport[][]> {
+    named: readonly string[],
+    refusals: Refusals,
+): Promise<(DeclaredExport[] | undefined)[]> {
     const checker = project.checker
     // ABIDE'S FILE AS THE CHECKER NAMES IT, not as this module does: it canonicalizes a path to
     // the disk's case rules, so on a case-insensitive disk `/Users/…/Code` comes back
@@ -71,79 +76,93 @@ export async function declaredExports(
         ?.path
     const abide = await abideIn(project)
     return allSettled(
-        paths.map(async (path) => {
+        paths.map(async (path, at) => {
+            const file = named[at] as string
             const sourceFile = await project.program.getSourceFile(path)
-            if (sourceFile === undefined)
-                throw new Error(
-                    `abide: ${path} is not inside the project ${projectName}, so what it exports cannot be read (16.73). Give the app a tsconfig whose include reaches it.`,
+            if (sourceFile === undefined) {
+                refusals.at(
+                    file,
+                    new Error(
+                        `abide: ${path} is not inside the project ${projectName}, so what it exports cannot be read (16.73). Give the app a tsconfig whose include reaches it.`,
+                    ),
                 )
+                return undefined
+            }
             const module = await checker.getSymbolAtLocation(sourceFile)
             if (module === undefined) return []
             const exports = await checker.getExportsOfModule(module)
+            let refused = false
             const found = await allSettled(
                 exports.map(async (exported) => {
-                    const target = await aliasedSymbol(checker, exported)
-                    if ((target.flags & SymbolFlags.Value) === 0)
-                        return undefined
-                    const declared = await declaringMethod(
-                        checker,
-                        target,
-                        methodsPath,
-                    )
-                    const unread: Diagnosis[] = []
-                    for (const value of declared?.unread ?? []) {
-                        const file = value.getSourceFile()
-                        unread.push(
-                            diagnosisAt(
-                                file.fileName === sourceFile.fileName
-                                    ? path
-                                    : file.fileName,
-                                file.text,
-                                value.getStart(),
-                                'warning',
-                                `abide: \`${value.parent.getText()}\` is not a value the build can read, so \`${exported.name}\`'s browser copy is built without it. Write it as a literal, or as a \`const\` whose type is one. RULEBOOK 18.15.`,
-                            ),
-                        )
-                    }
-                    // 19.9 — a handler's args, as its annotation types them.
-                    const handlerType =
-                        declared === undefined
-                            ? undefined
-                            : await checker.getTypeOfSymbol(target)
-                    if (handlerType !== undefined && abide.reactive) {
-                        const at = await nestedReactiveIn(
+                    try {
+                        const target = await aliasedSymbol(checker, exported)
+                        if ((target.flags & SymbolFlags.Value) === 0)
+                            return undefined
+                        const declared = await declaringMethod(
                             checker,
-                            abide.reactive,
-                            await valueOfRpc(checker, handlerType),
-                            '',
-                            { seen: new Set(), depth: 0 },
+                            target,
+                            methodsPath,
                         )
-                        if (at !== undefined)
-                            throw new Error(
-                                `abide: ${path} — \`${exported.name}\` returns a \`Reactive\` at \`${at}\`, which the wire would carry as the function it is rather than the value it holds. Read it there, or return the \`Reactive\` itself to have it adopted (11.12). RULEBOOK 16.39.`,
+                        const unread: Diagnosis[] = []
+                        for (const value of declared?.unread ?? []) {
+                            const file = value.getSourceFile()
+                            unread.push(
+                                diagnosisAt(
+                                    file.fileName === sourceFile.fileName
+                                        ? path
+                                        : file.fileName,
+                                    file.text,
+                                    value.getStart(),
+                                    'warning',
+                                    `abide: \`${value.parent.getText()}\` is not a value the build can read, so \`${exported.name}\`'s browser copy is built without it. Write it as a literal, or as a \`const\` whose type is one. RULEBOOK 18.15.`,
+                                ),
                             )
-                    }
-                    return {
-                        name: exported.name,
-                        method: declared?.method,
-                        ui: declared?.ui ?? true,
-                        cli: declared?.cli ?? true,
-                        mcp: declared?.mcp ?? true,
-                        description: declared?.description,
-                        copy: declared?.copy,
-                        defaults: declared?.defaults,
-                        args:
-                            handlerType === undefined
+                        }
+                        // 19.9 — a handler's args, as its annotation types them.
+                        const handlerType =
+                            declared === undefined
                                 ? undefined
-                                : await argsSchemaOf(
-                                      checker,
-                                      handlerType,
-                                      declared?.defaulted ?? [],
-                                  ),
-                        unread,
+                                : await checker.getTypeOfSymbol(target)
+                        if (handlerType !== undefined && abide.reactive) {
+                            const at = await nestedReactiveIn(
+                                checker,
+                                abide.reactive,
+                                await valueOfRpc(checker, handlerType),
+                                '',
+                                { seen: new Set(), depth: 0 },
+                            )
+                            if (at !== undefined)
+                                throw new Error(
+                                    `abide: ${path} — \`${exported.name}\` returns a \`Reactive\` at \`${at}\`, which the wire would carry as the function it is rather than the value it holds. Read it there, or return the \`Reactive\` itself to have it adopted (11.12). RULEBOOK 16.39.`,
+                                )
+                        }
+                        return {
+                            name: exported.name,
+                            method: declared?.method,
+                            ui: declared?.ui ?? true,
+                            cli: declared?.cli ?? true,
+                            mcp: declared?.mcp ?? true,
+                            description: declared?.description,
+                            copy: declared?.copy,
+                            defaults: declared?.defaults,
+                            args:
+                                handlerType === undefined
+                                    ? undefined
+                                    : await argsSchemaOf(
+                                          checker,
+                                          handlerType,
+                                          declared?.defaulted ?? [],
+                                      ),
+                            unread,
+                        }
+                    } catch (thrown) {
+                        refused = true
+                        refusals.at(file, thrown)
+                        return undefined
                     }
                 }),
             )
+            if (refused) return undefined
             const handlers: DeclaredExport[] = []
             for (const entry of found)
                 if (entry !== undefined) handlers.push(entry)

package/src/compiler/emitClient.ts

@@ -7,6 +7,7 @@ import {
 } from '#shared/ANCHORS.ts'
 import { anchorMarkup } from '#shared/anchorMarkup.ts'
 import { CHILDREN } from '#shared/CHILDREN.ts'
+import { RUNTIME_SPECIFIER, SHARED_SPECIFIER } from '#shared/SPECIFIERS.ts'
 import { type CheckerAnswer, UNCHECKED } from './CheckerAnswer.ts'
 import {
     Cursor,
@@ -39,7 +40,6 @@ import {
     type ValueRender,
 } from './renderMarkup.ts'
 import { SHARED_NAMES } from './SHARED_NAMES.ts'
-import { RUNTIME_SPECIFIER, SHARED_SPECIFIER } from '#shared/SPECIFIERS.ts'
 import {
     insideShare,
     resumedShare,
@@ -213,19 +213,18 @@ export function emitClient(
     // to read when this level leaves or a level under it does. One thunk, which the apply below
     // reads too, so the markup expression is emitted once.
     const registered = heads
-        ? `if (${ROUTED}) ${ROUTED}.head = () => ${headMarkup}\n`
+        ? `if (${ROUTED}) ${ROUTED}.setHead(() => ${headMarkup})\n`
         : ''
     const applied = heads
-        ? `if (${ROUTED}) ${lowering.use('applyHead')}(${ROUTED}.head()); `
+        ? `if (${ROUTED}) ${lowering.use('applyHead')}(${ROUTED}.headMarkup()); `
         : ''
     // Applied with the fill either way, so the watch's first run only subscribes: what it would
     // write is already there, from the server or from the line above.
-    if (liveHeads)
-        lines.push(
-            `if (${ROUTED}) ${lowering.use('liveHead')}(${SCOPE}, ${ROUTED}.head)`,
-        )
+    if (liveHeads) lines.push(`if (${ROUTED}) ${ROUTED}.followHead(${SCOPE})`)
     // 39.1, 39.6 — A COMPONENT'S HEAD IS ITS PAGE'S, on a navigation as on the server: added to the
-    // level the router is mounting (`contributeHead`), which a row grown later is not.
+    // level it stands in (`contributeHead`), a row grown later included. Asked of the
+    // region before the fill makes it look painted; owned by the component's scope as its first
+    // unit, so the head leaves with the region — and, 39.13, follows its value until then.
     const ownHead = routed ? undefined : headSink(file)
     const ownMarkup =
         ownHead === undefined
@@ -234,7 +233,8 @@ export function emitClient(
     const contributed =
         ownMarkup === "''"
             ? ''
-            : `${lowering.use('contributeHead')}(${REGION_ROOT}, () => ${ownMarkup})\n`
+            : `const __headed = ${lowering.use('contributeHead')}(${REGION_ROOT}, () => ${ownMarkup})\n`
+    if (contributed !== '') lines.unshift(`${SCOPE}.own(__headed)`)
     const builds = carriesOwnMarkup && page.positions.length > 0
     let fills = contributed
     if (applied !== '' || builds) {
@@ -406,7 +406,7 @@ function deferredMarkup(
 function __markup(${REGION_ROOT}) {
 ${insideShare(lowering, SETTLED_AT, markup)}
 }
-if (${ROUTED}) { ${ROUTED}.markup = __markup; ${ROUTED}.share = ${SETTLED_AT}; return${declared ? ` ${SCOPE}` : ''} }
+if (${ROUTED}) { ${ROUTED}.leaveMarkup(__markup, ${SETTLED_AT}); return${declared ? ` ${SCOPE}` : ''} }
 return __markup(${REGION_ROOT})`
 }
 
@@ -738,9 +738,7 @@ if (__r${slot} !== undefined) ${SCOPE}.stops.push(__r${slot})`,
         }
     }
     if (writes.length > 0)
-        attributes.push(
-            `const __a${slot} = ${element}\n${writes.join('\n')}`,
-        )
+        attributes.push(`const __a${slot} = ${element}\n${writes.join('\n')}`)
     for (const unit of binds) attributes.push(unit)
     for (const unit of spreads) attributes.push(unit)
     return { handlers, attributes, elements }

package/src/compiler/emitComponent.ts

@@ -22,6 +22,8 @@ const BODY = '__body'
 // A page's or a layout's deferred build (41.19).
 const BUILT = '__built'
 const BUILD = '__build'
+// The calls renders had made as a component's setup began (41.28).
+const CALLS_BEFORE = '__callsBefore'
 
 /**
  * The server module for a parsed `.abide` file: one ESM module exporting its component.
@@ -37,8 +39,8 @@ const BUILD = '__build'
  *
  * `settles` IS A PAGE OR A LAYOUT, which `render` builds a level at a time (41.19): its setup runs
  * at the call and its markup is built on the first read of `head` or `body`, so the calls the
- * setup started are given the turn to answer that a component built inside its caller's markup is
- * not. Every other component builds where it is called, and pays nothing for the difference.
+ * setup started are given the turn to answer. Every other component answers the same way only where
+ * its setup made a call (41.28), and builds where it is called otherwise.
  */
 export function emitComponent(
     file: AbideFile,
@@ -121,8 +123,8 @@ ${privateExports(file.servers.join('\n'))}`
     // child the markup invokes must not be set up twice. The build resumes the share scope the
     // setup ran in (10.5), since by the time it is read the caller's has long been left — and that
     // scope is `scope` on the answer, so `composePage` sets the level below up inside it too.
-    const level = settles
-        ? `    const ${SETTLED_AT} = ${lowering.use('currentShare')}()
+    const deferred =
+        (): string => `    const ${SETTLED_AT} = ${lowering.use('currentShare')}()
     let ${BUILT}
     const ${BUILD} = () => {
         if (${BUILT} !== undefined) return ${BUILT}
@@ -135,10 +137,23 @@ ${privateExports(file.servers.join('\n'))}`
         get body() { return ${BUILD}().body },
         get document() { return ${BUILD}().document },
     }`
-        : build
+    // 41.28 — EVERY OTHER COMPONENT BUILDS WHERE IT IS CALLED unless its setup
+    // made a call, and then answers as a page does, for `renderComponent` to build after the turn.
+    // THE BUILD IS WRITTEN TWICE rather than always run through `__build`: the closure measured ~4%
+    // a row on `bench:component`'s card under JSC, the second copy nothing but server module bytes.
+    // One with no setup cannot call, and is written once.
+    const waits = !settles && componentBody.trim() !== ''
+    const level = settles
+        ? deferred()
+        : waits
+          ? `    if (${lowering.use('callsInRender')}() !== ${CALLS_BEFORE}) {
+${deferred()}
+    }
+${build}`
+          : build
     return `${moduleImports(lowering, () => SERVER_SPECIFIER, [moduleSetup, serverSetup, setup])}
 ${moduleSetup.body === '' ? '' : `${moduleSetup.body}\n`}${serverBody}export default function Component(${lowering.takesProps() ? `${PROPS} = {}` : ''}) {
-${opened}${componentBody}
+${waits ? `    const ${CALLS_BEFORE} = ${lowering.use('callsInRender')}()\n` : ''}${opened}${componentBody}
 ${level}${closed}
 }
 `

package/src/compiler/emitSource.ts

@@ -1,5 +1,5 @@
 import { STYLE_QUERY } from '#server/MODULE_QUERIES.ts'
-import { fileKind, scopeOf } from '#shared/routePattern.ts'
+import type { Placement } from '#server/placement.ts'
 import type { CheckerAnswer } from './CheckerAnswer.ts'
 import { emitClient } from './emitClient.ts'
 import { emitComponent } from './emitComponent.ts'
@@ -18,34 +18,34 @@ import { sourceMapOf } from './sourceMapOf.ts'
  * One `.abide`'s modules, in the mode the build compiles it in: its server module, its client
  * module (`''` where it has none) and its scoped stylesheet.
  *
- * Everything that mode depends on is the path below the app root and whether another file invokes
- * it (`componentGraph`), so a test handing over the same two facts compiles what the build would.
+ * Everything that mode depends on is where the file is placed (`placement`) and whether another
+ * file invokes it (`componentGraph`), so a test handing over the same facts compiles what the build
+ * would.
  */
 export function emitSource(
-    relative: string,
-    file: AbideFile,
-    answer: CheckerAnswer,
-    invoked: boolean,
+    source: Pick<Placement, 'relative' | 'kind' | 'scope'> & {
+        file: AbideFile
+        answer: CheckerAnswer
+        invoked: boolean
+    },
     /**
      * 16.28 — what the browser's module binds in place of the server block: the wrapper of each
      * private handler it declares, under the handler's name (`standInsOf`).
      */
     standIns = '',
     /** 38.97 — the `.abide`'s text, where the build wants each module's source map. */
-    source?: string,
-    /** 23.19 — the path it answers by, where a mount gives it one other than `relative`. */
-    position = relative,
+    text?: string,
 ): {
     server: string
     client: string
-    /** 38.97 — each module's `mappings` into the `.abide`, where `source` was given. */
+    /** 38.97 — each module's `mappings` into the `.abide`, where `text` was given. */
     serverMappings: string | undefined
     clientMappings: string | undefined
     sheet: string | undefined
     /** 39.8 — whether a `<style>` names a view transition, read here rather than at run time. */
     transitions: boolean
 } {
-    const kind = fileKind(position)
+    const { relative, kind, file, answer, invoked } = source
     // 34.4 — A COMPONENT WITH STYLES: its elements carry its token, and the styles, scoped,
     // are a stylesheet its client module imports — which the bundle collects into the
     // stylesheet the document links (38.23).
@@ -87,9 +87,9 @@ export function emitSource(
     // has no `.client.ts`, so a file shipping no runtime is a fact about the build rather than a
     // claim about the bundler.
     const serverChunks: LoweredChunk[] | undefined =
-        source === undefined ? undefined : []
+        text === undefined ? undefined : []
     const clientChunks: LoweredChunk[] | undefined =
-        source === undefined ? undefined : []
+        text === undefined ? undefined : []
     const client = emitClient(
         file,
         answer,
@@ -107,7 +107,7 @@ export function emitSource(
         file,
         answer,
         kind !== 'component',
-        scopeOf(position),
+        source.scope,
         serverChunks,
     )
     const name = relative.slice(relative.lastIndexOf('/') + 1)
@@ -118,24 +118,24 @@ export function emitSource(
         standIns,
     )
     let mapped: Mapped | undefined
-    if (source !== undefined) {
+    if (text !== undefined) {
         mapped = MAPPED.get(relative)
         if (
             mapped === undefined ||
-            mapped.source !== source ||
+            mapped.source !== text ||
             mapped.server !== server ||
             mapped.client !== browser
         ) {
             const projected = projectShadow(file).origins
             mapped = {
-                source,
+                source: text,
                 server,
                 client: browser,
                 serverMappings: sourceMapOf(
                     server,
                     serverChunks ?? [],
                     projected,
-                    source,
+                    text,
                 ),
                 clientMappings:
                     browser === ''
@@ -144,7 +144,7 @@ export function emitSource(
                               browser,
                               clientChunks ?? [],
                               projected,
-                              source,
+                              text,
                           ),
             }
             MAPPED.set(relative, mapped)

package/src/compiler/handlersUnder.ts

@@ -10,18 +10,14 @@
 // that is not a handler a refusal here rather than an address that silently never answers.
 
 import type { Mount } from '#server/answerRpc.ts'
-import { refuseFrameworkRoute } from '#server/appTree.ts'
+import { frameworkRouteRefusal } from '#server/appTree.ts'
 import { surfaceName } from '#server/surfaceOf.ts'
 import { PRIVATE_HANDLERS_ADDRESS } from '#shared/ADDRESSES.ts'
-import {
-    parseRoutePattern,
-    placeOf,
-    routeOf,
-    scopeOf,
-} from '#shared/routePattern.ts'
+import { parseRoutePattern } from '#shared/routePattern.ts'
+import type { PlacedHandler, PlacedSource } from './appLayout.ts'
 import { declaredExports } from './declaredExports.ts'
-import type { AbideFile } from './parseAbide.ts'
 import { PRIVATE_EXPORT } from './projectShadow.ts'
+import type { Refusals } from './Refusals.ts'
 import type { Diagnosis, TypeSession } from './TypeSession.ts'
 
 /** A handler file, by its path and its path below the app's root. */
@@ -32,19 +28,11 @@ export type HandlerFile = {
     position: string
 }
 
-/** A `.abide` the build read. */
-type Source = HandlerFile & { file: AbideFile }
-
-/**
- * Told of each thing the emit refuses, at the file below the root it names. The build's throws;
- * `abide check` collects every one at its file (38.33).
- */
-export type Refuse = (relative: string, thrown: unknown) => void
-
-/** The build's answer to a refusal: the first one stops it. */
-export const THROW: Refuse = (_relative, thrown) => {
-    throw thrown
-}
+/** A `.abide` the build read, placed. */
+type Source = Pick<
+    PlacedSource,
+    'path' | 'relative' | 'position' | 'place' | 'scope' | 'file'
+>
 
 /**
  * The app's handler mounts, with the warnings the build raised reading them.
@@ -55,28 +43,49 @@ export const THROW: Refuse = (_relative, thrown) => {
 export async function handlersUnder(
     session: TypeSession,
     sources: readonly Source[],
-    files: readonly HandlerFile[],
-    refuse: Refuse = THROW,
+    files: readonly Pick<
+        PlacedHandler,
+        'path' | 'relative' | 'route' | 'scope'
+    >[],
+    refusals: Refusals,
 ): Promise<{ mounts: Mount[]; warnings: Diagnosis[] }> {
     const serving: Source[] = []
     for (const source of sources)
         if (source.file.servers.length > 0) serving.push(source)
     const paths: string[] = []
-    for (const file of files) paths.push(file.path)
+    const named: string[] = []
+    for (const file of files) {
+        paths.push(file.path)
+        named.push(file.relative)
+    }
     const project = await session.projectWith(paths)
-    for (const source of serving) paths.push(session.projectionOf(source.path))
+    for (const source of serving) {
+        paths.push(session.projectionOf(source.path))
+        named.push(source.path)
+    }
+    // A module whose read was refused is `undefined`, refused at its file already.
     const declared =
         project === undefined || paths.length === 0
-            ? []
-            : await declaredExports(project, session.tsconfig, paths)
+            ? paths.map(() => [])
+            : await declaredExports(
+                  project,
+                  session.tsconfig,
+                  paths,
+                  named,
+                  refusals,
+              )
     const mounts: Mount[] = []
     const warnings: Diagnosis[] = []
     const names = new Map<string, string>()
     for (let at = 0; at < files.length; at += 1) {
-        const { relative, position } = files[at] as HandlerFile
+        const {
+            relative,
+            route: address,
+            scope,
+        } = files[at] as (typeof files)[number]
+        const exported = declared[at]
+        if (exported === undefined) continue
         try {
-            const address = routeOf(position)
-            const exported = declared[at] ?? []
             const handler = exported.find((each) => each.name === 'default')
             // 16.73 — the default and nothing else, declared by one of the five methods.
             for (const each of exported)
@@ -90,7 +99,8 @@ export async function handlersUnder(
                 throw new Error(
                     `abide: ${relative} is a handler file — a .ts directly in an address directory — and exports no handler as its default. Export one (\`export default GET(…)\`), or move the file into a lib directory. RULEBOOK 16.73, 23.22.`,
                 )
-            refuseFrameworkRoute(address, relative)
+            const framework = frameworkRouteRefusal(address, relative)
+            if (framework !== undefined) throw framework
             refuseUndeclaredParameters(address, handler.args, relative)
             // 20.13 — one name per handler on every generated surface.
             const surface = surfaceName(handler.method, address)
@@ -106,7 +116,7 @@ export async function handlersUnder(
                 source: relative,
                 name: address.slice(address.lastIndexOf('/') + 1),
                 export: 'default',
-                scope: scopeOf(position),
+                scope,
                 private: false,
                 ui: handler.ui,
                 cli: handler.cli,
@@ -118,14 +128,14 @@ export async function handlersUnder(
             })
             warnings.push(...handler.unread)
         } catch (thrown) {
-            refuse(relative, thrown)
+            refusals.at(relative, thrown)
         }
     }
     for (let at = 0; at < serving.length; at += 1) {
-        const { relative, position } = serving[at] as Source
+        const { relative, position, place, scope } = serving[at] as Source
         // 34.24 — a dependency's file answers where a mount places it, and its handlers below the
         // path it has there.
-        const below = placeOf(position) === 'dependency' ? relative : position
+        const below = place === 'dependency' ? relative : position
         for (const each of declared[files.length + at] ?? []) {
             if (each.method === undefined) continue
             if (!each.name.startsWith(PRIVATE_EXPORT)) continue
@@ -136,7 +146,7 @@ export async function handlersUnder(
                 source: relative,
                 name,
                 export: each.name,
-                scope: scopeOf(position),
+                scope,
                 private: true,
                 ui: each.ui,
                 cli: false,