@abide/abide 0.117.2 → 0.119.0

package/src/compiler/renderMarkup.ts

@@ -1,10 +1,10 @@
-import { REGION_CLOSE, REGION_OPEN, ROW_OPEN } from '#shared/ANCHORS.ts'
 import { anchorMarkup, regionMarkup } from '#shared/anchorMarkup.ts'
+import { REGION_CLOSE, REGION_OPEN, ROW_OPEN } from '#shared/ANCHORS.ts'
 import { armAnchor } from '#shared/armAnchor.ts'
 import { CHILDREN } from '#shared/CHILDREN.ts'
 import { escapeQuote } from '#shared/escapeText.ts'
 import { headKeyOf } from '#shared/headKeyOf.ts'
-import { Cursor, type PlacedNode, placeTemplate } from './Cursor.ts'
+
 import {
     attributeOf,
     type ClassifiedAttribute,
@@ -15,6 +15,7 @@ import {
     isSlot,
     type MergeGroup,
 } from './classifyTemplate.ts'
+import { Cursor, type PlacedNode, placeTemplate } from './Cursor.ts'
 import { invocationProps, passedName } from './invocationProps.ts'
 import { type Lowering, PROPS } from './Lowering.ts'
 import type { AbideFile } from './parseAbide.ts'

package/src/compiler/resolverIn.ts

@@ -1,6 +1,8 @@
 import { existsSync, readFileSync } from 'node:fs' // bun exposes no sync existence check or read of its own
 import { dirname, posix } from 'node:path' // bun exposes no path helpers of its own
+
 import { resolvedFile } from '#server/abideModules.ts'
+
 import { nearest } from './nearest.ts'
 
 /**

package/src/compiler/sameTemplate.ts

@@ -0,0 +1,150 @@
+import { SyntaxKind } from 'typescript/unstable/ast'
+
+import type { AbideFile } from './parseAbide.ts'
+import type { Body, InlineComponent, TemplateNode } from './TemplateNode.ts'
+import { tokenize } from './tokenize.ts'
+
+// 38.127 — WHAT `abide format` MAY CHANGE, and nothing else: the whitespace a browser collapses, a
+// run's indentation where 33.17 and 33.18 read only its kind, and the code `bun fmt` printed, read as
+// its tokens — a script block's in any order, since `sortImports` moves its imports. Everything else — a tag, an attribute's text, a block's shape, a line inside a template
+// literal — is compared as the parser read it.
+
+/** Whether `before` and `after` are one template, under what `abide format` may change. 38.127. */
+export function sameTemplate(before: AbideFile, after: AbideFile): boolean {
+    return shapeOf(before) === shapeOf(after)
+}
+
+function shapeOf(file: AbideFile): string {
+    const parts: string[] = []
+    for (const code of file.modules) parts.push(blockShape(code))
+    for (const code of file.servers) parts.push(blockShape(code))
+    for (const code of file.scripts) parts.push(blockShape(code))
+    for (const style of file.styles) parts.push(styleShape(style))
+    parts.push(file.generics ?? '')
+    nodesShape(file.head, parts)
+    if (file.document !== undefined) {
+        nodesShape([file.document.html], parts)
+        nodesShape([file.document.body], parts)
+    }
+    nodesShape(file.template, parts)
+    for (const component of file.components) componentShape(component, parts)
+    return parts.join('\u0000')
+}
+
+function nodesShape(nodes: TemplateNode[], parts: string[]): void {
+    for (const node of nodes) {
+        if (node.kind === 'text') {
+            parts.push(`text ${textShape(node.text)}`)
+            continue
+        }
+        if (node.kind === 'expression') {
+            parts.push(`slot ${codeShape(node.source)}`)
+            continue
+        }
+        if (node.kind === 'element') {
+            parts.push(`<${node.tag}`)
+            for (const attribute of node.attributes)
+                parts.push(
+                    attribute.expression
+                        ? `${attribute.name}={${codeShape(attribute.value)}}`
+                        : `${attribute.name}=${attribute.value}`,
+                )
+            nodesShape(node.children, parts)
+            for (const component of node.components)
+                componentShape(component, parts)
+            for (const component of node.passed)
+                componentShape(component, parts)
+            parts.push(`</${node.tag}>`)
+            continue
+        }
+        if (node.block === 'for') {
+            parts.push(
+                `{#for ${codeShape(node.item)},${codeShape(node.index)} of ${codeShape(node.subject)} by ${codeShape(node.key)}`,
+            )
+            bodyShape(node, parts)
+        } else {
+            parts.push(
+                node.block === 'try'
+                    ? `{#try ${node.error}`
+                    : `{#${node.block}`,
+            )
+            for (const branch of node.branches) {
+                parts.push(`{:${codeShape(branch.subject)}`)
+                bodyShape(branch, parts)
+            }
+        }
+        parts.push('{/}')
+    }
+}
+
+function bodyShape(body: Body, parts: string[]): void {
+    parts.push(
+        body.setup === null ? '' : blockShape(body.setup.text),
+        body.style === null ? '' : styleShape(body.style),
+    )
+    nodesShape(body.children, parts)
+    for (const component of body.components) componentShape(component, parts)
+}
+
+function componentShape(component: InlineComponent, parts: string[]): void {
+    parts.push(
+        `{#component ${component.name}(${component.pattern}: ${component.type})`,
+    )
+    bodyShape(component, parts)
+    parts.push('{/component}')
+}
+
+/**
+ * A text node as the browser renders it: within text, every whitespace run holding a newline is one
+ * space however it is indented. A node that is whitespace alone keeps its KIND — a newline alone, or
+ * one carrying indentation — since 33.17 and 33.18 drop the two apart.
+ */
+function textShape(text: string): string {
+    if (text.trim() === '') return /[ \t]/.test(text) ? '\n ' : '\n'
+    return text.replace(/\s*\n\s*/g, '\n')
+}
+
+/** Code as its tokens, in order. */
+function codeShape(code: string): string {
+    return tokensOf(code).join(' ')
+}
+
+/** A script block's code as its tokens in any order: `bun fmt`'s `sortImports` moves its imports. */
+function blockShape(code: string): string {
+    return tokensOf(code).sort().join(' ')
+}
+
+/**
+ * Code's tokens, with what a printer adds or drops at will taken out: the separators `;` and `,`,
+ * the parentheses, and how a string or a number is spelled. A template literal's text is a token,
+ * so a line moved inside one is a different token.
+ */
+function tokensOf(code: string): string[] {
+    const tokens: string[] = []
+    for (const token of tokenize(code))
+        switch (token.kind) {
+            case SyntaxKind.SemicolonToken:
+            case SyntaxKind.CommaToken:
+            case SyntaxKind.OpenParenToken:
+            case SyntaxKind.CloseParenToken:
+                continue
+            case SyntaxKind.StringLiteral:
+                tokens.push(
+                    JSON.stringify(
+                        token.text.slice(1, -1).replace(/\\(['"])/g, '$1'),
+                    ),
+                )
+                continue
+            case SyntaxKind.NumericLiteral:
+                tokens.push(String(Number(token.text.replaceAll('_', ''))))
+                continue
+            default:
+                tokens.push(token.text)
+        }
+    return tokens
+}
+
+/** A style with its whitespace and its `;`s taken out, which CSS reads none of outside a string. */
+function styleShape(style: string): string {
+    return style.replace(/[\s;]+/g, '')
+}

package/src/compiler/scaffold.ts

@@ -5,6 +5,7 @@
 // half-made project finishes it rather than overwriting it.
 
 import { withoutTrailingSlash } from '#server/withoutTrailingSlash.ts'
+
 import abidePackage from '../../package.json' with { type: 'json' }
 import { COMPILER_OPTIONS } from './writeDefaultProject.ts'
 
@@ -39,7 +40,7 @@ const SOURCE_ALIAS = { '#src/*': ['./src/*', './src/*.ts'] }
  * lands first on the PATH inside `bun run`, shadowing the bun that runs everything else.
  */
 export const BUNFIG =
-    '# 38.122 — a peer is not installed: an installed `bun` would shadow this one inside `bun run`.\n[install]\npeer = false\n\n# 38.109, 38.119 — a DOM to mount into and measure, then the app\'s `.abide` files as modules.\n[test]\nroot = "src"\npreload = ["@abide/harness/abide/preload"]\n'
+    '# 38.122 — a peer is not installed: an installed `bun` would shadow this one inside `bun run`.\n[install]\npeer = false\n\n# 38.109, 38.119 — a DOM to mount into and measure, then the app\'s `.abide` files as modules.\n[test]\nroot = "src"\npreload = ["@abide/harness/abide/preload"]\n\n# What `bun fmt` and `abide format` print.\n[fmt]\ntabWidth = 4\nsemi = false\nsingleQuote = true\nsortImports = true\n'
 
 // WRITTEN, NOT COPIED, beside the manifests: a packer drops a `bunfig.toml` or a `.gitignore` from
 // the tarball (`bun pm pack` both, `npm pack` the second), so neither survives as a starter file.
@@ -55,6 +56,8 @@ function filesFor(name: string): Record<string, string> {
                 scripts: {
                     // 38.103 — the checker over `.abide`, which `tsc` does not read.
                     check: 'abide check',
+                    // 38.125 — every `.abide`, then every other file `bun fmt` reads.
+                    format: 'abide format && bun fmt',
                     dev: 'abide dev',
                     build: 'abide build',
                     start: 'abide start',
@@ -101,16 +104,6 @@ function filesFor(name: string): Record<string, string> {
             null,
             4,
         )}\n`,
-        'biome.json': `${JSON.stringify(
-            {
-                formatter: { indentStyle: 'space', indentWidth: 4 },
-                javascript: {
-                    formatter: { quoteStyle: 'single', semicolons: 'asNeeded' },
-                },
-            },
-            null,
-            4,
-        )}\n`,
     }
 }
 

package/src/compiler/serveLanguage.ts

@@ -1,11 +1,16 @@
 import { existsSync, type FSWatcher, watch } from 'node:fs' // bun exposes no file watcher or sync existence check of its own
 import { dirname } from 'node:path' // bun exposes no path helpers of its own
+
 import { realOrAsGiven } from '#server/realOrAsGiven.ts'
+
 import { checkSource, lowerApp } from './checkApp.ts'
 import { citedClauses } from './citedClauses.ts'
 import { type AppChecker, openChecker } from './compileApp.ts'
 import { DOCS_SITE } from './DOCS_SITE.ts'
+import { formatAbide } from './formatAbide.ts'
+import { formatDiagnosis } from './formatDiagnosis.ts'
 import { isNamedAlone } from './isNamedAlone.ts'
+import { lineOf, offsetOf } from './lineOf.ts'
 import { nearest } from './nearest.ts'
 import type { Diagnosis, Inspection, Place } from './TypeSession.ts'
 
@@ -129,8 +134,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)
@@ -290,6 +295,7 @@ export async function serveLanguage(
                             definitionProvider: true,
                             referencesProvider: true,
                             renameProvider: { prepareProvider: true },
+                            documentFormattingProvider: true,
                             completionProvider: {
                                 triggerCharacters: ['.', '<', '#', ':', '/'],
                             },
@@ -392,8 +398,7 @@ export async function serveLanguage(
                 const found = await references(params)
                 const declarations = (
                     params?.context as
-                        | { includeDeclaration?: boolean }
-                        | undefined
+                        { includeDeclaration?: boolean } | undefined
                 )?.includeDeclaration
                 const locations: object[] = []
                 for (const place of found?.occurrences ?? [])
@@ -457,6 +462,45 @@ export async function serveLanguage(
                 })
                 return true
             }
+            case 'textDocument/formatting': {
+                // 38.130 — the text the editor holds, formatted as `abide format` formats a file:
+                // one edit replacing the whole of it, none where nothing moves.
+                const uri = (params?.textDocument as { uri: string }).uri
+                const document = documents.get(uri)
+                if (document === undefined) {
+                    send({ id: message.id, result: null })
+                    return true
+                }
+                const path = Bun.fileURLToPath(uri)
+                const text = document.text
+                const formatted = await formatAbide(path, text)
+                // Shown rather than published: a publish would replace what the check reported.
+                for (const finding of formatted.findings)
+                    send({
+                        method: 'window/showMessage',
+                        params: {
+                            type: 2,
+                            message: formatDiagnosis(finding, dirname(path)),
+                        },
+                    })
+                send({
+                    id: message.id,
+                    result:
+                        formatted.text === text
+                            ? []
+                            : [
+                                  {
+                                      range: rangeOf({
+                                          path,
+                                          start: { line: 1, column: 1 },
+                                          end: lineOf(text, text.length),
+                                      }),
+                                      newText: formatted.text,
+                                  },
+                              ],
+                })
+                return true
+            }
             case 'textDocument/didClose': {
                 const closed = params?.textDocument as { uri: string }
                 if (!documents.delete(closed.uri)) return true
@@ -542,23 +586,6 @@ function wordLength(line: string, character: number): number {
     return word === undefined ? 1 : word.length
 }
 
-/**
- * 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.
- */
-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
-}
-
 /** A `Place` at `path`, lines and columns from 1, as the protocol's `Location`, from 0. */
 function locationOf(path: string, place: Place): object {
     return { uri: Bun.pathToFileURL(path).href, range: rangeOf(place) }

package/src/compiler/sharedModuleWrites.ts

@@ -4,9 +4,10 @@ import {
     isVariableDeclarationList,
 } from 'typescript/unstable/ast/is'
 import type {
-    Symbol as CheckedSymbol,
     Checker,
+    Symbol as CheckedSymbol,
 } from 'typescript/unstable/async'
+
 import { classifyRead, FUNCTIONS } from './classifyRead.ts'
 import type { Finding } from './Finding.ts'
 import type { Span } from './projectShadow.ts'

package/src/compiler/sourceMapOf.ts

@@ -11,6 +11,7 @@
 // What no chunk covers is the framework's own scaffolding, and maps to nothing.
 
 import { encodeMappings, type Segment } from '#server/sourceMappings.ts'
+
 import type { LoweredChunk } from './Lowering.ts'
 import type { Origin } from './projectShadow.ts'
 import { mapBack } from './ShadowMap.ts'

package/src/compiler/splitImports.ts

@@ -1,5 +1,7 @@
 import { SyntaxKind } from 'typescript/unstable/ast'
+
 import { COMPONENT_QUERY, TEXT_QUERY } from '#server/MODULE_QUERIES.ts'
+
 import { isContextualKeyword, type Token, tokenize } from './tokenize.ts'
 
 /**

package/src/compiler/templateWarnings.ts

@@ -2,12 +2,12 @@ import type { CheckerAnswer } from './CheckerAnswer.ts'
 import type { Read } from './classifyRead.ts'
 import { isComponentTag } from './classifyTemplate.ts'
 import { isNamedAlone } from './isNamedAlone.ts'
-import { Lowering } from './Lowering.ts'
 import { diagnosisAt } from './lineOf.ts'
+import { Lowering } from './Lowering.ts'
 import type { AbideFile } from './parseAbide.ts'
 import {
-    type Body,
     bodiesOf,
+    type Body,
     type ForBlock,
     type TemplateNode,
     visitBodies,

package/src/compiler/trackingWarnings.ts

@@ -14,6 +14,7 @@ import {
     isPropertyAccessExpression,
     isWhileStatement,
 } from 'typescript/unstable/ast/is'
+
 import { FUNCTIONS, TRANSPARENT } from './classifyRead.ts'
 import type { Finding } from './Finding.ts'
 import type { PositionKind, PositionTable } from './PositionTable.ts'

package/src/compiler/writeDefaultProject.ts

@@ -11,6 +11,7 @@
 import { mkdtemp, rm } from 'node:fs/promises' // bun exposes no temporary-directory creation or recursive removal of its own
 import { tmpdir } from 'node:os' // bun exposes no temporary-directory path of its own
 import { dirname, resolve } from 'node:path' // bun exposes no path helpers of its own
+
 import { nearest } from './nearest.ts'
 
 /** What every abide app in the docs and the scaffold is written against. */
@@ -33,7 +34,10 @@ export async function writeDefaultProject(
     await Bun.write(
         tsconfig,
         JSON.stringify({
-            compilerOptions: { ...COMPILER_OPTIONS, paths: await aliasPaths(root) },
+            compilerOptions: {
+                ...COMPILER_OPTIONS,
+                paths: await aliasPaths(root),
+            },
             include: [`${root}/**/*`],
         }),
     )

package/src/server/BRIDGE_VERSION.ts

@@ -1,3 +1,3 @@
 // The `abide-bridge` release a pairing command names, so a visitor's `bunx` runs the relay this
 // server speaks. `packages/abide/tests/claudeCode.test.ts` holds it to the bridge package's own.
-export const BRIDGE_VERSION = '0.3.4'
+export const BRIDGE_VERSION = '0.3.5'

package/src/server/abideModules.ts

@@ -18,7 +18,9 @@
 // to this one rather than registering a plugin nobody asks.
 
 import { basename, dirname, resolve } from 'node:path' // bun exposes no path helpers of its own
+
 import { SERVER_SPECIFIER } from '#shared/SPECIFIERS.ts'
+
 import type { ServerTable } from './answerRequest.ts'
 import type { MountRow } from './answerRpc.ts'
 import {

package/src/server/answerFailure.ts

@@ -7,6 +7,7 @@ import { type Failed, problemOf } from '#shared/Failed.ts'
 import { RENDER_LOG } from '#shared/log.ts'
 import { coversPrefix, partsOf } from '#shared/matchRoute.ts'
 import { coversRoute, parseRoutePattern } from '#shared/routePattern.ts'
+
 import type { AppSources } from './answerRequest.ts'
 import { DOCUMENT_HEADERS } from './DOCUMENT_HEADERS.ts'
 import { boundPage, renderDocument } from './render.ts'

package/src/server/answerRequest.ts

@@ -19,23 +19,23 @@ import {
 } from '#shared/ADDRESSES.ts'
 import { APP_META } from '#shared/APP_META.ts'
 import { DEBUG_META } from '#shared/DEBUG_META.ts'
-import { ICON_ADDRESSES } from '#shared/LAUNCHER_FILES.ts'
-import { OFFLINE_META } from '#shared/OFFLINE_META.ts'
 import { decodedOrKept } from '#shared/decodedOrKept.ts'
 import { ERROR_META } from '#shared/ERROR_META.ts'
 import { escapeAttribute } from '#shared/escapeText.ts'
 import { type Failed, isFailed } from '#shared/Failed.ts'
 import { HandlerRoute } from '#shared/HandlerRoute.ts'
+import { health } from '#shared/health.ts'
 import { KEEP_HEADER } from '#shared/KEEP_HEADER.ts'
 import { KEEP_OPENED } from '#shared/KEEP_OPENED.ts'
-import { health } from '#shared/health.ts'
+import { ICON_ADDRESSES } from '#shared/LAUNCHER_FILES.ts'
 import { appName } from '#shared/log.ts'
-import { compose } from '#shared/Middleware.ts'
-import { MOUNT_META } from '#shared/MOUNT_META.ts'
 import { matchOf, type Params, partsOf } from '#shared/matchRoute.ts'
+import { compose } from '#shared/Middleware.ts'
 import { MOUNT, mounted } from '#shared/mount.ts'
+import { MOUNT_META } from '#shared/MOUNT_META.ts'
 import { NAVIGATION_HEADER } from '#shared/NAVIGATION_HEADER.ts'
-import { refuse, notFound as refusedNotFound } from '#shared/refuse.ts'
+import { OFFLINE_META } from '#shared/OFFLINE_META.ts'
+import { notFound as refusedNotFound, refuse } from '#shared/refuse.ts'
 import { arrive } from '#shared/route.ts'
 import {
     parseRoutePattern,
@@ -44,29 +44,30 @@ import {
 } from '#shared/routePattern.ts'
 import type { Method, Rpc } from '#shared/rpc.ts'
 import { rpcRequest } from '#shared/rpcRequest.ts'
+
 import { answered, answerFailure } from './answerFailure.ts'
 import {
     answerRpc,
     type Mounted,
-    type MountRow,
     mountedOwn,
     mountHandlers,
+    type MountRow,
 } from './answerRpc.ts'
 import { answerBlobTagged, answerValue, contentEtag } from './answerValue.ts'
-import { answerBridge } from './bridgeRelay.ts'
-import { CLIENT_ENTRY } from './CLIENT_BUILD.ts'
-import { appManifest } from './appManifest.ts'
 import { answerWorker } from './answerWorker.ts'
+import { appManifest } from './appManifest.ts'
+import { answerBridge } from './bridgeRelay.ts'
 import { callerOrMint } from './callerOf.ts'
-import { settingOn } from './config.ts'
+import { CLIENT_ENTRY } from './CLIENT_BUILD.ts'
 import { compressAnswer } from './compressAnswer.ts'
-import { DOCUMENT_HEADERS } from './DOCUMENT_HEADERS.ts'
-import { OFFLINE_STALE } from './OFFLINE_STALE.ts'
+import { settingOn } from './config.ts'
 import { noteCallInRender } from './deferredBuilds.ts'
+import { DOCUMENT_HEADERS } from './DOCUMENT_HEADERS.ts'
 import { answerMcp, openApi } from './generatedSurfaces.ts'
 import { type AppRung, failureOf, rungsOver } from './hooks.ts'
 import { chunksOf, type Manifest } from './manifestOf.ts'
 import { muxAdmission } from './muxUpgrade.ts'
+import { OFFLINE_STALE } from './OFFLINE_STALE.ts'
 import { plainAnswer } from './plainAnswer.ts'
 import { prefers } from './prefers.ts'
 import { PRINCIPAL_MOUNT } from './principal.ts'
@@ -78,8 +79,8 @@ import {
     renderDocument,
 } from './render.ts'
 import {
-    type AnsweringApp,
     adoptRequest,
+    type AnsweringApp,
     beginRender,
     currentRequestScope,
     type PageRender,
@@ -100,6 +101,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 +125,7 @@ type Ranked = RankedError & {
  */
 type RouteRow = {
     pattern: string
+    matchers: Record<string, string>
     segments: Segment[]
     page: Ranked | undefined
     handlers: Map<Method, Mounted>
@@ -178,6 +182,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 +345,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 +559,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 +583,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

@@ -11,15 +11,16 @@ import { GLOBAL_GETS } from '#shared/GLOBAL_GETS.ts'
 import { isRecord } from '#shared/isRecord.ts'
 import type { JsonValue } from '#shared/JsonValue.ts'
 import { mounted as underMount } from '#shared/mount.ts'
-import { RPC_SERVER } from '#shared/RPC_SERVER.ts'
 import type { Gated } from '#shared/reactive/argsContract.ts'
 import { deadlineOf, heldGenerationOf } from '#shared/reactive/index.ts'
 import type { Defaults } from '#shared/reactive/parameterDefaults.ts'
 import { notFound, refuse } from '#shared/refuse.ts'
 import type { HeldToAnnotation, Method, Rpc } from '#shared/rpc.ts'
+import { RPC_SERVER } from '#shared/RPC_SERVER.ts'
 import { argsInURL } from '#shared/rpcRequest.ts'
 import { VERSION_HEADER } from '#shared/VERSION_HEADER.ts'
 import { versionInEtag } from '#shared/versionInEtag.ts'
+
 import {
     answered,
     answerFailure,
@@ -29,7 +30,6 @@ import {
 import { followAsEvents } from './answerSocket.ts'
 import { answerValue, namesEtag, sseHeaders } from './answerValue.ts'
 import { argsFor } from './argsFor.ts'
-import { OFFLINE_STALE } from './OFFLINE_STALE.ts'
 import { callerOf } from './callerOf.ts'
 import {
     argsDocumentOf,
@@ -45,6 +45,7 @@ import {
     crossingRefusal,
 } from './crossingOrigin.ts'
 import { type AppRung, failureOf, rungsOver } from './hooks.ts'
+import { OFFLINE_STALE } from './OFFLINE_STALE.ts'
 import { prefers } from './prefers.ts'
 import {
     currentRequestScope,
@@ -72,6 +73,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 +157,7 @@ export function mountedOwn(
             name,
             export: name,
             scope: '/',
+            matchers: {},
             private: false,
             ui: false,
             cli: false,