@abide/abide 0.117.2 → 0.118.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abide/abide",
-    "version": "0.117.2",
+    "version": "0.118.0",
     "type": "module",
     "description": "Isomorphic type-safe framework for reactive async interfaces for humans and machines",
     "license": "MIT",

package/scaffold/AGENTS.md

@@ -36,7 +36,7 @@ before writing code, rather than guessing from Svelte, Vue or React. It installs
 - A file's path below `src/` is its address. `src/invoices/index.abide` answers `/invoices`,
   `src/invoices/[id].abide` answers `/invoices/123`, and `layout.abide` wraps the pages below it;
   the outermost one writes `<html>`. Run `bun run routes` to see every address and the file behind it.
-- A `.ts` beside the pages is a handler: `src/invoices/getInvoice.ts` holds
+- A `<name>.handler.ts` beside the pages is a handler: `src/invoices/getInvoice.handler.ts` holds
   `export default GET(…)` and answers `/invoices/getInvoice`. It is the app's public API, for pages,
   scripts, the CLI and MCP alike.
 - A `.abide` cannot export. A `<script server>` in one holds that file's private handlers

package/scaffold/src/getGreeting.test.ts

@@ -1,5 +1,5 @@
 import { expect, test } from 'bun:test'
-import getGreeting from './getGreeting.ts'
+import getGreeting from './getGreeting.handler.ts'
 
 test('the handler answers with the name it is given', async () => {
     expect(await getGreeting({ name: 'Ada' })).toBe('Hello, Ada')

package/scaffold/src/index.abide

@@ -1,6 +1,6 @@
 <script>
 import { reactive } from '@abide/abide'
-import getGreeting from '#src/getGreeting.ts'
+import getGreeting from '#src/getGreeting.handler.ts'
 
 let count = reactive(0)
 const greeting = reactive(() => getGreeting({ name: 'world' }))

package/src/compiler/TypeSession.ts

@@ -21,9 +21,10 @@ import {
     type Type,
 } from 'typescript/unstable/async'
 import { placeOf } from '#server/placement.ts'
+import { parseRoutePattern } from '#shared/routePattern.ts'
 import { aliasedSymbol } from './aliasedSymbol.ts'
 import { AMBIENT_SOURCES, ambientReadsIn } from './ambientReadsIn.ts'
-import type { AppLayout, PlacedSource } from './appLayout.ts'
+import type { AppLayout, AppRoute, PlacedSource } from './appLayout.ts'
 import { argsDefaultsIn } from './argsDefaultsIn.ts'
 import { type CheckerAnswer, UNCHECKED } from './CheckerAnswer.ts'
 import {
@@ -974,7 +975,7 @@ export class TypeSession {
             Partial<Pick<PlacedSource, 'kind' | 'route'>> & {
                 quiet?: boolean
             })[],
-        app: Pick<AppLayout, 'root' | 'addresses' | 'handlers'>,
+        app: Pick<AppLayout, 'root' | 'addresses' | 'handlers' | 'routes'>,
         scripts = true,
     ): Promise<{ diagnoses: Diagnosis[]; refused: Set<string> }> {
         using _held = this.hold()
@@ -1033,7 +1034,7 @@ export class TypeSession {
         // module augments one.
         this.register(
             `${this.canonical(within)}/${ROUTES_DECLARATION}`,
-            routesDeclaration(app.addresses),
+            routesDeclaration(app.addresses, app.routes),
             created,
             changed,
         )
@@ -1570,13 +1571,45 @@ function isFile(path: string): boolean {
 const ROUTES_DECLARATION = 'abide-routes.d.ts'
 const URL_SOURCE = Bun.fileURLToPath(new URL('../shared/url', import.meta.url))
 
-/** 30.26 — each of `addresses` as a key of abide's `Routes`. */
-function routesDeclaration(addresses: readonly string[]): string {
+/**
+ * 30.26 — each of `addresses` as a key of abide's `Routes`, and 23.9, 30.3 — a page route's params
+ * narrowed where its matcher is an alternation of literals, which is the one matcher a type can say.
+ */
+function routesDeclaration(
+    addresses: readonly string[],
+    routes: readonly AppRoute[],
+): string {
+    const narrowed = new Map<string, string>()
+    for (const route of routes) {
+        let members = ''
+        for (const segment of parseRoutePattern(route.pattern)) {
+            if (segment.kind !== 'required' && segment.kind !== 'optional')
+                continue
+            const literals = literalsOf(
+                segment.matcher === undefined
+                    ? undefined
+                    : route.matchers[segment.matcher],
+            )
+            if (literals === undefined) continue
+            members += ` ${JSON.stringify(segment.name)}${segment.kind === 'optional' ? '?' : ''}: ${literals};`
+        }
+        if (members !== '') narrowed.set(route.pattern, `{${members} }`)
+    }
     let keys = ''
     for (const route of addresses)
-        keys += `        ${JSON.stringify(route)}: true\n`
+        keys += `        ${JSON.stringify(route)}: ${narrowed.get(route) ?? 'true'}\n`
     return `export {}\ndeclare module ${JSON.stringify(URL_SOURCE)} {\n    interface Routes {\n${keys}    }\n}\n`
 }
+
+/** The union of the literals an anchored matcher source alternates between, or `undefined`. */
+function literalsOf(source: string | undefined): string | undefined {
+    const body = source?.match(/^\^\(\?!\\\.\\\.\?\$\)\(\?:(.*)\)\$$/)?.[1]
+    if (body === undefined || !/^[\w~-]+(?:\|[\w~-]+)*$/.test(body)) return undefined
+    return body
+        .split('|')
+        .map((literal) => JSON.stringify(literal))
+        .join(' | ')
+}
 const AMBIENT_DECLARATIONS = `declare module '*.css' {}
 declare module '*.md' {
     const text: string

package/src/compiler/appLayout.ts

@@ -16,6 +16,7 @@ import {
 import { abideImportsOf, componentGraph } from './componentGraph.ts'
 import type { HandlerFile } from './handlersUnder.ts'
 import { hookCalls, hooksIn } from './hookCalls.ts'
+import { type MountedTree, matchersOf } from './matchersOf.ts'
 import { mountsOf } from './mountsOf.ts'
 import { type AbideFile, scriptBodies } from './parseAbide.ts'
 import { Refusals } from './Refusals.ts'
@@ -49,6 +50,8 @@ export type PlacedHandler = HandlerFile & {
     scope: string
     text: string
     hooks: string[]
+    /** 23.26 — each matcher its route names, to the anchored source the route tables carry. */
+    matchers: Record<string, string>
 }
 
 /** A page or an error page and the layouts it renders inside. */
@@ -64,6 +67,8 @@ export type AppRoute = {
      * cannot be declared twice.
      */
     layouts: string[]
+    /** 23.26 — each matcher its pattern names, to the anchored source the route tables carry. */
+    matchers: Record<string, string>
 }
 
 /** The app at a root, laid out (`appLayout`). */
@@ -105,7 +110,10 @@ export async function appLayout(root: string): Promise<AppLayout> {
     // COLLECTED, whoever asks: a layout is kept across checks (`AppChecker`), and a build adopts
     // what it found (`Refusals.adopt`).
     const refusals = new Refusals(root, true)
-    const { abide, handlers, modules, published } = appFiles(root, refusals)
+    const { abide, handlers, params, modules, published } = appFiles(
+        root,
+        refusals,
+    )
     await refuseModuleHooks(root, modules, refusals)
     const resolve = resolverIn()
     const unparsed = new Refusals(root, true)
@@ -149,10 +157,43 @@ export async function appLayout(root: string): Promise<AppLayout> {
             scope: placement(file.relative, file.position).scope,
             text,
             hooks: hooksIn([text]),
+            matchers: {},
         })
     }
     refuseStrayLauncher(sources, placedHandlers, refusals)
     const { routes, errors } = routesOf(sources, refusals)
+    // 23.26 — every routed file's matchers, a layout's among them for 23.27's sake though no table
+    // carries a layout's own.
+    const routed: {
+        path: string
+        relative: string
+        position: string
+        route: string
+    }[] = []
+    const relativeToPath = new Map<string, string>()
+    for (const source of sources) {
+        if (source.route === undefined) continue
+        relativeToPath.set(source.relative, source.path)
+        routed.push({
+            path: source.path,
+            relative: source.relative,
+            position: source.position,
+            route: source.route,
+        })
+    }
+    for (const handler of placedHandlers) routed.push(handler)
+    const matchers = await matchersOf(
+        root,
+        routed,
+        params.map((path) => `${root}/${path}`),
+        found.trees,
+        refusals,
+    )
+    for (const handler of placedHandlers)
+        handler.matchers = matchers.get(handler.path) ?? {}
+    for (const route of [...routes, ...errors])
+        route.matchers =
+            matchers.get(relativeToPath.get(route.source) ?? '') ?? {}
     const addresses = new Set<string>()
     for (const route of routes) addresses.add(route.pattern)
     for (const address of published.values()) addresses.add(address)
@@ -215,6 +256,8 @@ export async function withDependencies(
     handlers: HandlerFile[]
     /** 23.19 — each mounted `.abide`'s position, by its path; one at its own path is not here. */
     positions: Map<string, string>
+    /** 23.26 — each mounted directory, where it mounts, and the param files under it. */
+    trees: MountedTree[]
 }> {
     const all = [...parsed]
     const handlers: HandlerFile[] = []
@@ -231,6 +274,7 @@ export async function withDependencies(
     const positions = new Map<string, string>()
     // 23.20 — a directory mounts once, and by whom.
     const mountedBy = new Map<string, string>()
+    const trees: MountedTree[] = []
     const add = async (path: string): Promise<void> => {
         let text: string
         try {
@@ -268,6 +312,11 @@ export async function withDependencies(
                 continue
             }
             mountedBy.set(mount.directory, position)
+            trees.push({
+                directory: mount.directory,
+                at: mount.at,
+                params: mount.params,
+            })
             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
@@ -292,7 +341,7 @@ export async function withDependencies(
             if (!byPath.has(target)) await add(target)
         }
     }
-    return { sources: all, handlers, positions }
+    return { sources: all, handlers, positions, trees }
 }
 
 /** Whether a page or an error page has anything to paint: a template, or a head. 23.3, 35.14. */
@@ -450,6 +499,7 @@ function routesOf(
             pattern,
             source: source.relative,
             layouts: around,
+            matchers: {},
         })
     }
     return { routes, errors }

package/src/compiler/appMap.ts

@@ -14,6 +14,8 @@ type MappedRoute = {
     address: string
     file: string
     kind: 'page' | 'handler' | 'private'
+    /** 23.26 — each matcher its address names, to the anchored pattern it takes a part by. */
+    matchers: Record<string, string>
 }
 
 /** One hook call, the route it is filed at, and the file making it. */
@@ -39,6 +41,7 @@ export async function appMap(
             address: route.pattern,
             file: route.source,
             kind: 'page',
+            matchers: route.matchers,
         })
     for (const mount of app.mounts)
         routes.push({
@@ -46,6 +49,7 @@ export async function appMap(
             address: mount.address,
             file: mount.source,
             kind: mount.private ? 'private' : 'handler',
+            matchers: mount.matchers,
         })
     routes.sort((one, two) =>
         one.address === two.address
@@ -79,6 +83,17 @@ export function mapText(map: Awaited<ReturnType<typeof appMap>>): string {
         lines.push(
             `${route.method.padEnd(methods)}  ${route.address.padEnd(addresses)}  ${route.file}${route.kind === 'private' ? '  (private)' : ''}`,
         )
+    // 23.26 — each matcher once, whichever routes name it: what a part must match to be taken.
+    const matchers = new Map<string, string>()
+    for (const route of map.routes)
+        for (const name in route.matchers)
+            matchers.set(name, route.matchers[name] as string)
+    if (matchers.size > 0) {
+        lines.push('', 'matchers')
+        const names = width([...matchers.keys()])
+        for (const [name, pattern] of matchers)
+            lines.push(`  ${name.padEnd(names)}  /${pattern}/`)
+    }
     if (map.hooks.length > 0) {
         lines.push('', 'hooks')
         const hooks = width(map.hooks.map((hook) => hook.hook))

package/src/compiler/compileApp.ts

@@ -514,7 +514,7 @@ function tableOf(
             (layout) => `() => import(${tableImport(layout)})`,
         )
         rows.push(
-            `    { pattern: ${JSON.stringify(route.pattern)}, load: () => import(${tableImport(route.source)}), layouts: [${wrapping.join(', ')}]${column(route)} },`,
+            `    { pattern: ${JSON.stringify(route.pattern)}, load: () => import(${tableImport(route.source)}), layouts: [${wrapping.join(', ')}], matchers: ${JSON.stringify(route.matchers)}${column(route)} },`,
         )
     }
     return rows.join('\n')

package/src/compiler/compiledEntry.ts

@@ -120,7 +120,7 @@ import * as table from ${JSON.stringify(tablePath(app.root, SERVER_TABLE))}
     return `// Written by \`abide compile\`. The whole app, as what one executable holds.
 ${imports}
 // 38.56 — a file declaring handlers as a script names it through the app's one alias:
-// \`#src/invoices/getInvoice.ts\`, to the module it is.
+// \`#src/invoices/getInvoice.handler.ts\`, to the module it is.
 const declared = {}
 for (const row of table.handlers) declared[\`#src/\${row.source}\`] = row.load
 

package/src/compiler/handlersUnder.ts

@@ -45,7 +45,7 @@ export async function handlersUnder(
     sources: readonly Source[],
     files: readonly Pick<
         PlacedHandler,
-        'path' | 'relative' | 'route' | 'scope'
+        'path' | 'relative' | 'route' | 'scope' | 'matchers'
     >[],
     refusals: Refusals,
 ): Promise<{ mounts: Mount[]; warnings: Diagnosis[] }> {
@@ -84,6 +84,7 @@ export async function handlersUnder(
             relative,
             route: address,
             scope,
+            matchers,
         } = files[at] as (typeof files)[number]
         const exported = declared[at]
         if (exported === undefined) continue
@@ -99,7 +100,7 @@ export async function handlersUnder(
                     )
             if (handler?.method === undefined)
                 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.`,
+                    `abide: ${relative} is a handler file — a <name>.handler.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.`,
                 )
             const framework = frameworkRouteRefusal(address, relative)
             if (framework !== undefined) throw framework
@@ -119,6 +120,7 @@ export async function handlersUnder(
                 name: address.slice(address.lastIndexOf('/') + 1),
                 export: 'default',
                 scope,
+                matchers,
                 private: false,
                 ui: handler.ui,
                 cli: handler.cli,
@@ -150,6 +152,7 @@ export async function handlersUnder(
                 name,
                 export: each.name,
                 scope,
+                matchers: {},
                 private: true,
                 ui: each.ui,
                 cli: false,

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/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)