@abide/abide 0.117.1 → 0.118.0

package/src/compiler/matchersOf.ts

@@ -0,0 +1,147 @@
+// 23.26, 23.27 — WHICH MATCHER EACH SEGMENT NAMES, resolved once at build and carried into the route
+// tables as text, so nothing at run time looks a name up. A segment's `=NAME` is the param file
+// `NAME.param.ts` in the directory holding that segment or the nearest one above it, below the root
+// the file is filed under: the app's root for the app's own, and a mounted directory for the files
+// under it (23.19), so a host's matcher never decides a mounted package's segment.
+//
+// ONE MATCHER PER POSITION across every file filed there (23.27): a layout, a page and a handler
+// directory at `/holdings/[symbol=TICKER]` share the segment, and a page that took `BRK.B` under a
+// layout whose segment refused it would be wrapped by a layout no address of its own reaches.
+
+import { parseRoutePattern } from '#shared/routePattern.ts'
+import { matcherOf } from './paramFile.ts'
+import type { Refusals } from './Refusals.ts'
+
+/** A directory a file mounts (23.19), where it mounts, and the param files under it, by path. */
+export type MountedTree = { directory: string; at: string; params: string[] }
+
+/** A file with a route: its path, the name refusals give it, and the position it answers by. */
+type Routed = { path: string; relative: string; position: string; route: string }
+
+/**
+ * Each routed file's matchers, by its path: every name its route's segments give, to the anchored
+ * source of the param file it resolves to — empty where its route names none.
+ *
+ * `params` is every param file of the app's own, by path. Refusals land at the file the fault is in:
+ * a param file that declares no matcher at itself, a name that resolves to none at the segment's file.
+ */
+export async function matchersOf(
+    root: string,
+    routed: readonly Routed[],
+    params: readonly string[],
+    trees: readonly MountedTree[],
+    refusals: Refusals,
+): Promise<Map<string, Record<string, string>>> {
+    // Every param file's matcher, read once whichever routes name it; `undefined` where 23.24 or
+    // 23.25 refused the file, so a segment naming it refuses nothing more.
+    const sources = new Map<string, string | undefined>()
+    const all = [...params]
+    for (const tree of trees) all.push(...tree.params)
+    for (const path of all) {
+        if (sources.has(path)) continue
+        const matcher = matcherOf(labelOf(root, path), await Bun.file(path).text())
+        if (matcher instanceof Error) {
+            refusals.at(path, matcher)
+            sources.set(path, undefined)
+        } else sources.set(path, matcher)
+    }
+    const byPath = new Map<string, Record<string, string>>()
+    // 23.27 — what each parameter position resolved to, and the first file that said so.
+    const atPosition = new Map<string, { found: string; file: string }>()
+    for (const file of routed) {
+        const matchers: Record<string, string> = {}
+        const tree = treeOf(file.path, trees)
+        const positionParts = file.position.split('/')
+        let shape = ''
+        let at = 0
+        for (const segment of parseRoutePattern(file.route)) {
+            shape += `/${segment.kind === 'static' ? segment.name : `[${segment.kind}]`}`
+            const index = at
+            at += 1
+            if (segment.kind === 'static') continue
+            const found =
+                segment.matcher === undefined
+                    ? ''
+                    : nearestParam(
+                          root,
+                          tree,
+                          positionParts.slice(0, index),
+                          segment.matcher,
+                          sources,
+                      )
+            if (found === undefined) {
+                refusals.at(
+                    file.path,
+                    new Error(
+                        `abide: ${file.relative} names the matcher ${segment.matcher}, and no ${segment.matcher}.param.ts is in the directory holding that segment or any directory above it. RULEBOOK 23.26.`,
+                    ),
+                )
+                continue
+            }
+            const other = atPosition.get(shape)
+            if (other === undefined) atPosition.set(shape, { found, file: file.relative })
+            else if (other.found !== found)
+                refusals.at(
+                    file.path,
+                    new Error(
+                        `abide: ${other.file} and ${file.relative} decide the parameter at ${shape} by ${describe(root, other.found)} and by ${describe(root, found)}, and one position takes one matcher. RULEBOOK 23.27.`,
+                    ),
+                )
+            const source = found === '' ? undefined : sources.get(found)
+            if (segment.matcher !== undefined && source !== undefined)
+                matchers[segment.matcher] = source
+        }
+        byPath.set(file.path, matchers)
+    }
+    return byPath
+}
+
+/**
+ * The param file `NAME.param.ts` a segment at `holding` names, nearest first, or `undefined`.
+ *
+ * `holding` is the position of the directory holding the segment, and the walk stops at the root
+ * the segment is filed under: inside a mounted directory, that directory; a segment of the position
+ * the mount itself takes is the mounting app's.
+ */
+function nearestParam(
+    root: string,
+    tree: MountedTree | undefined,
+    holding: string[],
+    name: string,
+    sources: Map<string, string | undefined>,
+): string | undefined {
+    const atParts = tree === undefined ? 0 : tree.at.split('/').length - 1
+    const inside = tree !== undefined && holding.length >= atParts
+    const base = inside ? tree.directory : root
+    const below = inside ? holding.slice(atParts) : holding
+    for (let depth = below.length; depth >= 0; depth -= 1) {
+        const directory = [base, ...below.slice(0, depth)].join('/')
+        const candidate = `${directory}/${name}.param.ts`
+        if (sources.has(candidate)) return candidate
+    }
+    return undefined
+}
+
+/** The mounted directory `path` lies in, the deepest where two nest, or `undefined` for the app's own. */
+function treeOf(
+    path: string,
+    trees: readonly MountedTree[],
+): MountedTree | undefined {
+    let deepest: MountedTree | undefined
+    for (const tree of trees)
+        if (
+            path.startsWith(`${tree.directory}/`) &&
+            (deepest === undefined ||
+                tree.directory.length > deepest.directory.length)
+        )
+            deepest = tree
+    return deepest
+}
+
+function labelOf(root: string, path: string): string {
+    return path.startsWith(`${root}/`) ? path.slice(root.length + 1) : path
+}
+
+function describe(root: string, found: string): string {
+    return found === '' ? 'no matcher' : labelOf(root, found)
+}

package/src/compiler/mountsOf.ts

@@ -31,6 +31,8 @@ type DirectoryMount = {
     at: string
     files: Placed[]
     handlers: Placed[]
+    /** 23.26 — the param files under it, by path: what its own segments' matchers resolve in. */
+    params: string[]
 }
 
 /**
@@ -85,6 +87,7 @@ export function mountsOf(
                 at,
                 files: found.abide.map(placed),
                 handlers: found.handlers.map(placed),
+                params: found.params.map((below) => `${directory}/${below}`),
             })
         }
     return mounts

package/src/compiler/paramFile.ts

@@ -0,0 +1,124 @@
+// 23.24, 23.25 — A PARAM FILE, READ AND NEVER RUN. `<NAME>.param.ts` says what a segment naming
+// `NAME` accepts, and the build carries that into both route tables as a regex literal, so the
+// file is read off its tokens: one `export const NAME = /…/`, nothing else. A file that does
+// anything more could only be honoured by running it, and nothing about building a route table is
+// a reason to run app code.
+//
+// 30.36 — THE DOT-SEGMENT FLOOR IS WRITTEN INTO THE SOURCE rather than tested beside it, so the walk
+// holds one test per part whatever the segment names: a matcher can lift the period default (30.34)
+// and still never admit `.` or `..`, which the URL parser collapses into another route.
+
+import { SyntaxKind } from 'typescript/unstable/ast'
+import { tokenize } from './tokenize.ts'
+
+/** The name a param file declares: its file name before `.param.ts`. */
+export function paramNameOf(path: string): string {
+    return path.slice(path.lastIndexOf('/') + 1, -'.param.ts'.length)
+}
+
+/**
+ * The anchored source of the matcher the param file at `relative` declares, or why it declares none.
+ *
+ * Anchored as `^(?!\.\.?$)(?:…)$`: the whole part, percent-decoded, and never a dot-segment.
+ */
+export function matcherOf(relative: string, text: string): string | Error {
+    const name = paramNameOf(relative)
+    const tokens = tokenize(text)
+    const kinds: SyntaxKind[] = []
+    for (const token of tokens)
+        if (token.kind !== SyntaxKind.EndOfFile) kinds.push(token.kind)
+    const declared =
+        kinds.length >= 5 &&
+        kinds.length <= 6 &&
+        kinds[0] === SyntaxKind.ExportKeyword &&
+        kinds[1] === SyntaxKind.ConstKeyword &&
+        kinds[2] === SyntaxKind.Identifier &&
+        kinds[3] === SyntaxKind.EqualsToken &&
+        kinds[4] === SyntaxKind.RegularExpressionLiteral &&
+        (kinds.length === 5 || kinds[5] === SyntaxKind.SemicolonToken)
+    if (!declared)
+        return new Error(
+            `abide: ${relative} must hold one \`export const ${name} = /…/\` and nothing else, an import included. RULEBOOK 23.24.`,
+        )
+    const exported = (tokens[2] as { text: string }).text
+    if (exported !== name)
+        return new Error(
+            `abide: ${relative} exports ${exported}, and a param file exports the name it is filed under, ${name}. RULEBOOK 23.24.`,
+        )
+    const literal = (tokens[4] as { text: string }).text
+    const close = literal.lastIndexOf('/')
+    if (close !== literal.length - 1)
+        return new Error(
+            `abide: ${relative} carries the flag ${literal.slice(close + 1)}, and a matcher carries none: a route, OpenAPI and a JSON Schema's \`pattern\` would each read it differently. RULEBOOK 23.24.`,
+        )
+    const body = literal.slice(1, close)
+    const runaway = runawayIn(body)
+    if (runaway !== undefined)
+        return new Error(
+            `abide: ${relative} carries ${runaway}, which can take time exponential in a part's length on an address made to. RULEBOOK 23.25.`,
+        )
+    return `^(?!\\.\\.?$)(?:${body})$`
+}
+
+/**
+ * 23.25 — what in a regex's source can backtrack without bound, or `undefined`.
+ *
+ * A repetition with no upper bound (`*`, `+`, `{n,}`) of a group that itself holds one, and a
+ * backreference. Read character by character rather than parsed: a class and an escape are skipped
+ * as single atoms, which is all the shape the two questions need.
+ */
+export function runawayIn(body: string): string | undefined {
+    // One entry per open group: whether it holds an unbounded repetition.
+    const holds: boolean[] = [false]
+    // Whether the atom just read is a group holding one.
+    let groupHolding = false
+    for (let at = 0; at < body.length; at += 1) {
+        const char = body[at] as string
+        if (char === '\\') {
+            const next = body[at + 1] ?? ''
+            if ((next >= '1' && next <= '9') || next === 'k')
+                return 'a backreference'
+            at += 1
+            groupHolding = false
+            continue
+        }
+        if (char === '[') {
+            at += 1
+            while (at < body.length && body[at] !== ']')
+                at += body[at] === '\\' ? 2 : 1
+            groupHolding = false
+            continue
+        }
+        if (char === '(') {
+            holds.push(false)
+            groupHolding = false
+            continue
+        }
+        if (char === ')') {
+            const inner = holds.pop() ?? false
+            if (inner) holds[holds.length - 1] = true
+            groupHolding = inner
+            continue
+        }
+        const unbounded =
+            char === '*' ||
+            char === '+' ||
+            (char === '{' && /^\{\d+,\}/.test(body.slice(at)))
+        if (unbounded) {
+            if (groupHolding) return 'a repetition of a group that repeats'
+            holds[holds.length - 1] = true
+            groupHolding = false
+            continue
+        }
+        // A bounded `{n}` or `{n,m}` repeats a group a fixed number of times, and keeps what it
+        // repeats as the atom a following quantifier would apply to.
+        if (char === '{') {
+            const end = body.indexOf('}', at)
+            if (end !== -1) at = end
+            continue
+        }
+        if (char === '?') continue
+        groupHolding = false
+    }
+    return undefined
+}

package/src/compiler/projectShadow.ts

@@ -763,7 +763,7 @@ function refuseExport(source: string): void {
         if (moved !== 0) depth += moved
         else if (depth === 0 && text === EXPORT && previous !== '.')
             throw new Error(
-                'abide: a .abide cannot export — its component is its one export. A handler another file calls is a handler file (a .ts beside the page, `export default GET(…)`); a value files share is a module under a lib directory. RULEBOOK 34.17.',
+                'abide: a .abide cannot export — its component is its one export. A handler another file calls is a handler file (a <name>.handler.ts beside the page, `export default GET(…)`); a value files share is a module under a lib directory. RULEBOOK 34.17.',
             )
         previous = text
     }

package/src/compiler/readsIn.ts

@@ -28,6 +28,7 @@ import {
 import {
     type Symbol as CheckedSymbol,
     type Checker,
+    SignatureKind,
     SymbolFlags,
     type Type,
     TypeFlags,
@@ -129,7 +130,9 @@ export async function readsIn(
     shadowPath: string,
     spans: ShadowSpans,
     file: AbideFile,
-): Promise<{ answer: CheckerAnswer; warnings: Finding[] }> {
+    /** Where each name the lowered program proved a `Reactive` starts (`bindingsOfReads`). */
+    held: ReadonlySet<number>,
+): Promise<{ answer: CheckerAnswer; warnings: Finding[]; suspects: number[] }> {
     // A destructuring pattern binds names this does not see, and that is 31.12's case.
     const names: Node[] = []
     const spelled = new Set<string>()
@@ -210,6 +213,12 @@ export async function readsIn(
         ),
     )
     await dropValueHolders(checker, names, reactive)
+    for (let at = 0; at < names.length; at += 1)
+        if (
+            reactive[at] === undefined &&
+            held.has((names[at] as Node).getStart())
+        )
+            reactive[at] = symbols[at]
     // 32.32 — A VALUE WHOSE `reactive(…)` DECLARES `by` keys a `{#for}` over it,
     // wherever the value is declared.
     const byValue = await Promise.all(
@@ -296,7 +305,86 @@ export async function readsIn(
         spans.scripts,
     ))
         warnings.push(warning)
-    return { answer: new CheckerAnswer(reads, statics), warnings }
+    const answer = new CheckerAnswer(reads, statics)
+    return {
+        answer,
+        warnings,
+        suspects: await bindingsOfReads(
+            checker,
+            abide,
+            names,
+            reactive,
+            answer,
+        ),
+    }
+}
+
+/**
+ * Where each binding starts whose type the projection cannot vouch for, for the lowered program to
+ * answer (`TypeSession.classify`).
+ *
+ * 31.1 — A BINDING TYPED FROM A READ IS TYPED FROM THE `Reactive` IN THE PROJECTION, and the read is
+ * of its value. `reactive(route.url.pathname)` asks a `Reactive<URL>` for a `pathname` it does not
+ * declare; the argument is the error type, which `reactive`'s overloads resolve to a `Keyed`, and
+ * the binding then lowered as no `Reactive` at all — `bookId = 'y'` rebinding the name and nothing
+ * waking. Lowered, the argument is `route.url().pathname` and the binding a `Reactive<string>`.
+ *
+ * ONLY A CALL THAT CAN HAND BACK A `Reactive` IS ASKED: an un-annotated binding, not one already,
+ * initialized by a call holding a read, to a callee one of whose signatures returns a `Reactive`.
+ * Anything else is a value however its reads are typed, and asking would cost every page that
+ * computes from one a second snapshot.
+ */
+async function bindingsOfReads(
+    checker: Checker,
+    abide: Abide,
+    names: readonly Node[],
+    reactive: readonly (CheckedSymbol | undefined)[],
+    answer: CheckerAnswer,
+): Promise<number[]> {
+    const suspects: number[] = []
+    const asked: Promise<void>[] = []
+    for (let at = 0; at < names.length; at += 1) {
+        const name = names[at] as Node
+        const declaration = name.parent
+        if (
+            reactive[at] !== undefined ||
+            !isVariableDeclaration(declaration) ||
+            declaration.type !== undefined ||
+            declaration.initializer === undefined
+        )
+            continue
+        let call: Node = declaration.initializer
+        while (TRANSPARENT.has(call.kind))
+            call = (call as unknown as { expression: Node }).expression
+        if (
+            !isCallExpression(call) ||
+            !answer.holdsRead({ start: call.getStart(), end: call.end })
+        )
+            continue
+        const callee = call.expression
+        asked.push(
+            (async () => {
+                const type = await checker.getTypeAtLocation(callee)
+                if (type === undefined) return
+                for (const signature of await checker.getSignaturesOfType(
+                    type,
+                    SignatureKind.Call,
+                )) {
+                    const returned =
+                        await checker.getReturnTypeOfSignature(signature)
+                    if (
+                        returned !== undefined &&
+                        (await isReactiveType(checker, abide, returned, false))
+                    ) {
+                        suspects.push(name.getStart())
+                        return
+                    }
+                }
+            })(),
+        )
+    }
+    await Promise.all(asked)
+    return suspects
 }
 
 /**

package/src/compiler/serveLanguage.ts

@@ -129,8 +129,8 @@ export async function serveLanguage(
         documents.get(Bun.pathToFileURL(spelled(path)).href)?.text
 
     // An app's checker, opened on first use and kept for the session — and TOLD WHAT MOVED ON DISK,
-    // or it answers every check from the text it read when it opened: an export added to a `.ts`
-    // beside the page is "no exported member" until the editor restarts this. A project whose
+    // or it answers every check from the text it read when it opened: an export added to a `lib`
+    // module the page imports is "no exported member" until the editor restarts this. A project whose
     // tsconfig or package.json moved is opened again.
     const checkerOf = async (app: string): Promise<AppChecker> => {
         let checker = checkers.get(app)

package/src/server/answerRequest.ts

@@ -100,6 +100,8 @@ type ServerRoute = {
     // 38.28 — the modules a browser loads at this address, the page's then its layouts', as keys
     // into the manifest `manifestOf` reads.
     clientModules: string[]
+    // 23.26 — each matcher its pattern names, to the anchored source the build resolved it to.
+    matchers: Record<string, string>
 }
 
 // 35.2 — an error page, and the directory it answers for.
@@ -122,6 +124,7 @@ type Ranked = RankedError & {
  */
 type RouteRow = {
     pattern: string
+    matchers: Record<string, string>
     segments: Segment[]
     page: Ranked | undefined
     handlers: Map<Method, Mounted>
@@ -178,6 +181,16 @@ export type AppSources = {
 // 41.29 — the seed sink of a render no page hydrates: every call is left to run when it is made.
 const SEEDS_NOTHING: PageRender['seed'] = () => false
 
+// 35.19 — what fetch calls a navigation request's destinations, and a script's `fetch`.
+const PAGE_DESTINATIONS = new Set([
+    'document',
+    'embed',
+    'frame',
+    'iframe',
+    'object',
+    'empty',
+])
+
 /** The `Response` to one request: a handler, a surface of abide's own, a file, or a page. */
 export async function answerRequest(
     app: AppSources,
@@ -331,6 +344,17 @@ async function answerMatched(
             headers: { 'cache-control': 'no-store' },
         })
 
+    // 35.19 — A REQUEST THAT CANNOT DISPLAY A PAGE, such as the `/favicon.ico` a browser asks every
+    // site for where a `[param]` page matches it: refused before setup, so no handler runs for it
+    // and no caller is minted. Bare, because an error page would set up too and nothing shows it;
+    // `no-store`, because the address answers a navigation with the page.
+    const destination = request.headers.get('sec-fetch-dest')
+    if (destination !== null && !PAGE_DESTINATIONS.has(destination))
+        return new Response(null, {
+            status: 404,
+            headers: { 'cache-control': 'no-store' },
+        })
+
     // 33.4 — a prop is an ACCESSOR, which is the contract `renderComponent` renders a child under
     // and the one the client router mounts a page under; the params are the record `firstMatch`
     // hands the client for this same address.
@@ -534,16 +558,22 @@ export async function appSources(parts: SourceParts): Promise<AppSources> {
             pattern: route.pattern,
             load: route.load,
             layouts: route.layouts,
+            matchers: route.matchers,
             document: documentOf(route.clientModules),
         })
     // 19.1 — the build refused two files at one route and method, so a route is one row however
-    // many methods answer at it.
+    // many methods answer at it — and 23.27 one matcher per position, so whichever file opens the
+    // row brings what every file at it would.
     const rows = new Map<string, Omit<RouteRow, 'segments'>>()
-    const rowAt = (pattern: string): Omit<RouteRow, 'segments'> => {
+    const rowAt = (
+        pattern: string,
+        matchers: Record<string, string>,
+    ): Omit<RouteRow, 'segments'> => {
         let row = rows.get(pattern)
         if (row === undefined) {
             row = {
                 pattern,
+                matchers,
                 page: undefined,
                 handlers: new Map(),
                 answers: new Map(),
@@ -552,12 +582,19 @@ export async function appSources(parts: SourceParts): Promise<AppSources> {
         }
         return row
     }
-    for (const page of rankRoutes(pages)) rowAt(page.pattern).page = page
+    for (const page of rankRoutes(pages))
+        rowAt(page.pattern, page.matchers).page = page
     for (const handler of mounted.handlers.values())
-        rowAt(handler.address).handlers.set(handler.method, handler)
+        rowAt(handler.address, handler.matchers).handlers.set(
+            handler.method,
+            handler,
+        )
     const errors: RankedError[] = []
     for (const error of parts.table.errors)
-        errors.push({ ...error, segments: parseRoutePattern(error.pattern) })
+        errors.push({
+            ...error,
+            segments: parseRoutePattern(error.pattern, error.matchers),
+        })
     errors.sort((a, b) => b.segments.length - a.segments.length)
     const sources: AppSources = {
         routes: rankRoutes([...rows.values()]),

package/src/server/answerRpc.ts

@@ -72,6 +72,8 @@ export type Mount = {
     export: string
     /** The route its hooks are filed at, which its rungs are read over (37.1, 16.72). */
     scope: string
+    /** 23.26 — each matcher its address names, to the anchored source its row is ranked with. */
+    matchers: Record<string, string>
     /** Whether it is a private handler, listed nowhere (16.71). */
     private: boolean
     /** Whether a browser is handed a wrapper for it. 20.4. */
@@ -154,6 +156,7 @@ export function mountedOwn(
             name,
             export: name,
             scope: '/',
+            matchers: {},
             private: false,
             ui: false,
             cli: false,

package/src/server/appTree.ts

@@ -1,6 +1,6 @@
 // 23.14 — WHERE AN APP'S ADDRESSES ARE, read off the tree in one walk. A file directly in a directory
 // below the root is an address — a page, a layout, an error page or a handler file — and nothing
-// else is there but its tests (23.22); a fence is never one (23.15): `public` holds files answered as
+// else is there but its tests and the param files its segments name (23.22, 23.24); a fence is never one (23.15): `public` holds files answered as
 // authored at the path of the directories above it, and `lib` holds the rest, a server file among it
 // (23.23). So listing a directory lists its routes.
 //
@@ -22,6 +22,8 @@ import {
 import {
     DIRECTORY_FILES,
     isDeclarationFile,
+    isHandlerFile,
+    isParamFile,
     isServerFile,
     isBenchFile,
     isTestFile,
@@ -36,6 +38,8 @@ type AppFiles = {
     abide: string[]
     /** Every handler file, in path order. */
     handlers: string[]
+    /** 23.24 — every param file directly in an address directory, in path order. */
+    params: string[]
     /** Every module under a `lib` directory, in path order — read for 37.13. */
     modules: string[]
     /** Every file under a `public` directory, to the address it is answered at below the mount. */
@@ -52,6 +56,7 @@ export function appFiles(root: string, refusals: Refusals): AppFiles {
     const files: AppFiles = {
         abide: [],
         handlers: [],
+        params: [],
         modules: [],
         published: new Map(),
     }
@@ -61,6 +66,7 @@ export function appFiles(root: string, refusals: Refusals): AppFiles {
     walk(root, '', undefined, files, refusals, packaged)
     files.abide.sort()
     files.handlers.sort()
+    files.params.sort()
     files.modules.sort()
     return files
 }
@@ -126,13 +132,17 @@ function walk(
                 isDeclarationFile(path)
             )
                 continue
-            if (!abide && !isModule(path)) {
+            if (isParamFile(path)) {
+                files.params.push(path)
+                continue
+            }
+            if (!abide && !isHandlerFile(path)) {
                 if (packaged && relative === '' && !path.endsWith('.ts'))
                     continue
                 refusals.at(
                     path,
                     new Error(
-                        `abide: ${path} is directly in an address directory, which holds pages, layouts, error pages, handler files, test files, bench files and declaration files alone. Move it into a lib directory, beside it or in any directory above it. RULEBOOK 23.22.`,
+                        `abide: ${path} is directly in an address directory, which holds pages, layouts, error pages, handler files, param files, test files, bench files and declaration files alone. ${path.endsWith('.ts') ? 'Name a handler file <name>.handler.ts, or move anything else' : 'Move it'} into a lib directory, beside it or in any directory above it. RULEBOOK 23.22.`,
                     ),
                 )
                 continue
@@ -211,8 +221,7 @@ export function holdsApp(root: string): boolean {
     return !appSourcesUnder(root, '').next().done
 }
 
-// Every `.abide` under `directory`, and every handler file — a module whose place is an address, and
-// no server file (23.23).
+// Every `.abide` under `directory`, and every handler file whose place is an address.
 function* appSourcesUnder(
     directory: string,
     relative: string,
@@ -230,9 +239,7 @@ function* appSourcesUnder(
             yield* appSourcesUnder(`${directory}/${entry.name}`, `${path}/`)
         else if (
             path.endsWith('.abide') ||
-            (isModule(path) &&
-                !isServerFile(path) &&
-                placeOf(path) === 'address')
+            (isHandlerFile(path) && placeOf(path) === 'address')
         )
             yield path
     }