@abide/abide 0.117.2 → 0.119.0

package/src/compiler/formatDiagnosis.ts

@@ -1,4 +1,5 @@
 import { relative } from 'node:path' // bun exposes no path helpers of its own
+
 import type { Diagnosis } from './TypeSession.ts'
 
 /**

package/src/compiler/handlersUnder.ts

@@ -11,12 +11,13 @@
 
 import type { Mount } from '#server/answerRpc.ts'
 import { frameworkRouteRefusal } from '#server/appTree.ts'
+import { PRIVATE_EXPORT } from '#server/PRIVATE_EXPORT.ts'
 import { surfaceName } from '#server/surfaceOf.ts'
 import { PRIVATE_HANDLERS_ADDRESS } from '#shared/ADDRESSES.ts'
 import { parseRoutePattern } from '#shared/routePattern.ts'
+
 import type { PlacedHandler, PlacedSource } from './appLayout.ts'
 import { declaredExports } from './declaredExports.ts'
-import { PRIVATE_EXPORT } from '#server/PRIVATE_EXPORT.ts'
 import type { Refusals } from './Refusals.ts'
 import type { Diagnosis, TypeSession } from './TypeSession.ts'
 
@@ -45,7 +46,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 +85,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 +101,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 +121,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 +153,7 @@ export async function handlersUnder(
                 name,
                 export: each.name,
                 scope,
+                matchers: {},
                 private: true,
                 ui: each.ui,
                 cli: false,

package/src/compiler/hookCalls.ts

@@ -1,4 +1,5 @@
 import { SHARED_SPECIFIER } from '#shared/SPECIFIERS.ts'
+
 import { importStatements } from './splitImports.ts'
 import { type Token, tokenize } from './tokenize.ts'
 

package/src/compiler/lineOf.ts

@@ -20,6 +20,23 @@ export function lineOf(
     return { line, column: end - lineStart + 1 }
 }
 
+/**
+ * The protocol's `{ line, character }`, from 0, as an offset into `text`. A character is a UTF-16
+ * code unit in the protocol and in a JavaScript string alike.
+ */
+export function offsetOf(
+    text: string,
+    position: { line: number; character: number },
+): number {
+    let at = 0
+    for (let line = 0; line < position.line; line += 1) {
+        const end = text.indexOf('\n', at)
+        if (end === -1) return text.length
+        at = end + 1
+    }
+    return at + position.character
+}
+
 /** abide's own finding at `offset` into `text`, or at line 0 where the text was not handed in. */
 export function diagnosisAt(
     path: string,

package/src/compiler/matchersOf.ts

@@ -0,0 +1,157 @@
+// 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

@@ -10,8 +10,10 @@
 
 import { realpathSync, statSync } from 'node:fs' // bun exposes no sync stat or realpath of its own
 import { dirname, relative, resolve } from 'node:path' // bun exposes no path helpers of its own
+
 import { appFiles } from '#server/appTree.ts'
 import { placeOf } from '#server/placement.ts'
+
 import { nearest } from './nearest.ts'
 import { type AbideFile, scriptBodies } from './parseAbide.ts'
 import { Refusals } from './Refusals.ts'
@@ -31,6 +33,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 +89,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,125 @@
+// 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/parseAbide.ts

@@ -1,16 +1,18 @@
 import { SyntaxKind } from 'typescript/unstable/ast'
+
 import { URL_ATTRIBUTES } from '#shared/URL_ATTRIBUTES.ts'
+
 import { isComponentTag, isSlot, propKeyOf } from './classifyTemplate.ts'
 import { decodeCharacterReferences } from './decodeCharacterReferences.ts'
 import { isNamedAlone } from './isNamedAlone.ts'
 import { lineOf } from './lineOf.ts'
 import { PositionedRefusal } from './PositionedRefusal.ts'
-import { TEMPLATE_BLOCKS } from './TEMPLATE_BLOCKS.ts'
 import { importedNames } from './splitImports.ts'
+import { TEMPLATE_BLOCKS } from './TEMPLATE_BLOCKS.ts'
 import {
     type Attribute,
-    type Branch,
     bodiesOf,
+    type Branch,
     type ElementNode,
     type ForBlock,
     type InlineComponent,
@@ -106,6 +108,8 @@ type Origins = {
     names: Map<object, number>
     /** 38.116 — per element closed by a tag of its own, where that close tag's name starts. */
     closes: Map<object, number>
+    /** Where each block body's `<script>` setup starts — 32.48, 14.8. */
+    setups: number[]
 }
 
 /**
@@ -216,6 +220,7 @@ export function parseAbide(source: string): AbideFile {
         bindings: new Map(),
         names: new Map(),
         closes: new Map(),
+        setups: [],
     }
     const root: TemplateNode[] = []
     // The open elements, innermost last. `root` is the floor and is never popped.
@@ -365,8 +370,7 @@ export function parseAbide(source: string): AbideFile {
                 if (block === styles && blocks.length > 0) {
                     const owner = bodyOf(
                         blocks[blocks.length - 1] as
-                            | TemplateNode
-                            | InlineComponent,
+                            TemplateNode | InlineComponent,
                     )
                     owner.style =
                         owner.style === null
@@ -377,8 +381,7 @@ export function parseAbide(source: string): AbideFile {
                 }
                 if (block === scripts && blocks.length > 0) {
                     const holder = blocks[blocks.length - 1] as
-                        | TemplateNode
-                        | InlineComponent
+                        TemplateNode | InlineComponent
                     const owner = bodyOf(holder)
                     if (owner.setup !== null)
                         throw new Error(
@@ -388,6 +391,7 @@ export function parseAbide(source: string): AbideFile {
                         )
                     owner.setup = { text: raw.body }
                     origins.holders.set(owner.setup, tag.end)
+                    origins.setups.push(tag.end)
                     at = raw.end
                     continue
                 }
@@ -1072,7 +1076,7 @@ function rawBody(
  * already `trim()`s for this, which is one question with two answers until now — so the end is
  * handed back rather than recomputed from the tag's length.
  */
-function closeTagAt(
+export function closeTagAt(
     source: string,
     tag: string,
     from: number,
@@ -1113,6 +1117,9 @@ function pushText(
     return next
 }
 
+/** The ` if` after `{:else` — a whole word, so `{:elseif}` and `{:else ifValid}` are not one. */
+export const ELSE_IF = /^\s+if(?=[\s(])/
+
 /**
  * Where the condition on a `{:else …}` arm starts in `inner`, or its end for the bare `{:else}`
  * that always takes.
@@ -1124,7 +1131,7 @@ function pushText(
 function elseSubjectAt(inner: string): number {
     const rest = inner.slice(':else'.length)
     if (rest.trim() === '') return inner.length
-    const keyword = /^\s+if(?=[\s(])/.exec(rest)
+    const keyword = ELSE_IF.exec(rest)
     if (keyword === null || rest.slice(keyword[0].length).trim() === '')
         throw new Error(
             `abide: {${inner}} is not a control block. Write {:else} or {:else if <condition>}.`,
@@ -1147,28 +1154,18 @@ function trimmed(
 }
 
 /**
- * Parses a `{#for}` header into its item, index, subject and key.
- *
- * `item, index of list by key` — `index` and `by` are optional, and everything after `of` up to
- * a top-level `by` is the subject. Split on the KEYWORDS rather than on commas, because the
- * subject may hold both.
+ * The `of`, the `,` and the `by` that divide a `{#for}` header — each the first at depth zero.
  *
- * THE SEPARATOR IS THE ONE AT DEPTH ZERO AND OUTSIDE A STRING — all three of them, and each was
- * wrong its own way. `{#for { id, name } of rows}` split on the pattern's own comma and the item
- * became `{ id`, which the emitters write straight into a parameter list. `{#for x of
- * names.filter(n => n !== "run by me")}` split on the ` by ` inside the string literal and the
- * subject ended mid-quote. One scanner for all three rather than one fix for the comma.
+ * THE HEADER IS TOKENS, read by the scanner a slot is: an `of`, a `,` or a `by` inside a string,
+ * a call or an object pattern is the expression's own, and only one at depth zero divides the
+ * header. `by` is a word rather than a keyword, so a member named `by` is not one.
  */
-function forBlock(
-    file: string,
-    header: { text: string; at: number },
-    origins: Origins,
-): ForBlock {
-    const source = header.text
-    // THE HEADER IS TOKENS, read by the scanner a slot is: an `of`, a `,` or a `by` inside a string,
-    // a call or an object pattern is the expression's own, and only one at depth zero divides the
-    // header. `by` is a word rather than a keyword, so a member named `by` is not one.
-    const tokens = tokenize(source)
+export function forSeparators(header: string): {
+    of: Token | undefined
+    comma: Token | undefined
+    by: Token | undefined
+} {
+    const tokens = tokenize(header)
     let depth = 0
     let of: Token | undefined
     let comma: Token | undefined
@@ -1191,6 +1188,29 @@ function forBlock(
         )
             by = token
     }
+    return { of, comma, by }
+}
+
+/**
+ * Parses a `{#for}` header into its item, index, subject and key.
+ *
+ * `item, index of list by key` — `index` and `by` are optional, and everything after `of` up to
+ * a top-level `by` is the subject. Split on the KEYWORDS rather than on commas, because the
+ * subject may hold both.
+ *
+ * THE SEPARATOR IS THE ONE AT DEPTH ZERO AND OUTSIDE A STRING — all three of them, and each was
+ * wrong its own way. `{#for { id, name } of rows}` split on the pattern's own comma and the item
+ * became `{ id`, which the emitters write straight into a parameter list. `{#for x of
+ * names.filter(n => n !== "run by me")}` split on the ` by ` inside the string literal and the
+ * subject ended mid-quote. One scanner for all three rather than one fix for the comma.
+ */
+function forBlock(
+    file: string,
+    header: { text: string; at: number },
+    origins: Origins,
+): ForBlock {
+    const source = header.text
+    const { of, comma, by } = forSeparators(source)
     // A `{#for}` with nothing to iterate rendered as a block over the subject '' — zero rows,
     // forever, with nothing saying why (32.22 is an ABSENT subject, not a missing one).
     if (of === undefined)

package/src/compiler/projectShadow.ts

@@ -1,14 +1,16 @@
 import { SyntaxKind } from 'typescript/unstable/ast'
+
 import { PRIVATE_EXPORT } from '#server/PRIVATE_EXPORT.ts'
 import { isEventName } from '#shared/isEventName.ts'
+
 import { isComponentTag, propKeyOf } from './classifyTemplate.ts'
 import { isNamedAlone } from './isNamedAlone.ts'
+import type { AbideFile } from './parseAbide.ts'
 import {
     type Position,
     type PositionKind,
     PositionTable,
 } from './PositionTable.ts'
-import type { AbideFile } from './parseAbide.ts'
 import {
     attributedImports,
     IMPORT_ATTRIBUTES,
@@ -501,12 +503,17 @@ function project(file: AbideFile): Projection {
                 body(node.children, node.components)
                 continue
             }
-            // 32.16 — the catch arm binds the failure, and the checker has to see the name.
+            // 32.16 — the catch arm binds the failure, and the checker has to see the name. Read once
+            // with `void`, as a `catch` binding is never reported unused. An arm that names none binds
+            // nothing.
             if (node.block === 'try') {
                 const [tried, caught] = node.branches as [Branch, Branch]
                 text += '{\n'
                 inBody(tried)
-                text += `}\n{ const ${node.error === '' ? '__failure' : node.error}: any = undefined\n`
+                text +=
+                    node.error === ''
+                        ? '}\n{\n'
+                        : `}\n{ const ${node.error}: any = undefined; void ${node.error}\n`
                 inBody(caught)
                 text += '}\n'
                 continue
@@ -763,7 +770,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/reactiveOptions.ts

@@ -11,6 +11,7 @@ import {
     isObjectLiteralExpression,
     isPropertyAssignment,
 } from 'typescript/unstable/ast/is'
+
 import type { Method } from '#shared/rpc.ts'
 
 /**

package/src/compiler/reactiveTypes.ts

@@ -4,18 +4,19 @@ import {
     isVariableDeclaration,
 } from 'typescript/unstable/ast/is'
 import {
-    type Symbol as CheckedSymbol,
     type Checker,
     ObjectFlags,
     type ObjectType,
     type Project,
     SignatureKind,
+    type Symbol as CheckedSymbol,
     type Type,
     TypeFlags,
     type TypeParameter,
     type TypeReference,
     type UnionOrIntersectionType,
 } from 'typescript/unstable/async'
+
 import { aliasedSymbol } from './aliasedSymbol.ts'
 
 // WHAT THE CHECKER SAYS A NAME HOLDS, asked by both of the session's jobs over one snapshot: the

package/src/compiler/readsIn.ts

@@ -26,13 +26,14 @@ import {
     isVariableStatement,
 } from 'typescript/unstable/ast/is'
 import {
-    type Symbol as CheckedSymbol,
     type Checker,
     SignatureKind,
+    type Symbol as CheckedSymbol,
     SymbolFlags,
     type Type,
     TypeFlags,
 } from 'typescript/unstable/async'
+
 import { aliasedSymbol } from './aliasedSymbol.ts'
 import { CheckerAnswer } from './CheckerAnswer.ts'
 import {
@@ -45,13 +46,13 @@ import {
     TRANSPARENT,
 } from './classifyRead.ts'
 import type { Finding } from './Finding.ts'
+import type { AbideFile } from './parseAbide.ts'
 import {
     holdsReactive,
     type Position,
     type PositionKind,
     type PositionTable,
 } from './PositionTable.ts'
-import type { AbideFile } from './parseAbide.ts'
 import { INLINE_PROPS, type Span } from './projectShadow.ts'
 import { REACTIVE_MEMBERS } from './REACTIVE_MEMBERS.ts'
 import { optionNamed, reactiveOptions } from './reactiveOptions.ts'