@abide/abide 0.105.1 → 0.106.0

package/src/compiler/renderMarkup.ts

@@ -302,6 +302,8 @@ function renderPosition(
 
     const parts: string[] = []
     let open = `<${node.tag}`
+    // 32.61 — a `<textarea>`'s or `<select>`'s bound value, which is written inside the tag.
+    let within: string | undefined
     // WHAT IS NOT MARKUP IS NOT WRITTEN: a listener, `bind:element`, a refused URL, a bind whose
     // value is not an attribute, and every merge member after the one the group is written at.
     for (const one of classifyAttributes(node, lowering)) {
@@ -310,7 +312,10 @@ function renderPosition(
             continue
         }
         if (one.kind === 'bound') {
-            if (one.reflects === undefined) continue
+            if (one.reflects === undefined) {
+                if (one.bind === 'value') within = boundRead(one, lowering)
+                continue
+            }
             parts.push(JSON.stringify(open), boundMarkup(one, lowering))
             open = ''
             continue
@@ -349,7 +354,25 @@ function renderPosition(
     // `<br>`, and a close tag written for one is markup no browser accepts.
     if (node.children.length === 0 && VOID_ELEMENTS.has(node.lowerTag))
         return parts.join(' + ')
+    // 32.61 — THE VALUE IN PLACE OF THE AUTHOR'S TEXT, led by the newline the parser drops after
+    // `<textarea>` so a value opening on one keeps it.
+    if (
+        within !== undefined &&
+        node.lowerTag === 'textarea' &&
+        node.children.length === 0
+    )
+        return [
+            ...parts,
+            `'\\n' + ${lowering.use('escapeAttribute')}(${within})`,
+            JSON.stringify(`</${node.tag}>`),
+        ].join(' + ')
     const children = renderLevel(at.children, lowering, lane)
+    if (within !== undefined && node.lowerTag === 'select')
+        return [
+            ...parts,
+            `${lowering.use('selectedMarkup')}(${concat(children)}, ${within})`,
+            JSON.stringify(`</${node.tag}>`),
+        ].join(' + ')
     return [...parts, ...children, JSON.stringify(`</${node.tag}>`)].join(' + ')
 }
 
@@ -586,10 +609,7 @@ function boundMarkup(
     written: ClassifiedAttribute & { kind: 'bound' },
     lowering: Lowering,
 ): string {
-    const read = slotValueOf(
-        lowering,
-        `${lowering.use('boundValue')}(${lowering.reference(written.attribute)})`,
-    )
+    const read = boundRead(written, lowering)
     if (written.bind === 'value')
         return `' value="' + ${lowering.use('escapeAttribute')}(${read}) + '"'`
     const on =
@@ -599,6 +619,17 @@ function boundMarkup(
     return `(${on} ? ' ${written.reflects}' : '')`
 }
 
+/** A bind's value at render, under 41.4's guard: `undefined` while it is in flight. */
+function boundRead(
+    written: ClassifiedAttribute & { kind: 'bound' },
+    lowering: Lowering,
+): string {
+    return slotValueOf(
+        lowering,
+        `${lowering.use('boundValue')}(${lowering.reference(written.attribute)})`,
+    )
+}
+
 /**
  * A static attribute's markup: the bare name, or the name and its value's bytes (`staticBytes`).
  *

package/src/compiler/scaffold.ts

@@ -1,6 +1,6 @@
 // 38.1 — `abide scaffold <name>`: THE LAYOUT EVERY ABIDE APP HAS, written into `<name>`. There is
-// nothing to choose, because what is scaffolded is a root layout and a page — the files the commands
-// read — and the test preload.
+// nothing to choose, because what is scaffolded is a root layout, a page, a handler file the page
+// calls, a test of that handler, and a test that mounts the page and counts the work a click does.
 // A file that is already there is left as it is and reported skipped, so a scaffold run over a
 // half-made project finishes it rather than overwriting it.
 
@@ -22,15 +22,22 @@ const ABIDE_DEPENDENCY = PACKAGE_ROOT.includes('/node_modules/')
     ? `^${abidePackage.version}`
     : `file:${PACKAGE_ROOT}`
 
+// THE HARNESS BESIDE IT, by the same rule: from a registry its latest, whose peer range on abide is
+// what keeps the two in step; from a checkout the checkout's own harness.
+const HARNESS_DEPENDENCY = PACKAGE_ROOT.includes('/node_modules/')
+    ? 'latest'
+    : `file:${PACKAGE_ROOT.slice(0, PACKAGE_ROOT.lastIndexOf('/'))}/harness`
+
 // The `#src` alias, written as the package's `imports` and again as the checker's `paths`.
 const SOURCE_ALIAS = { '#src/*': ['./src/*', './src/*.ts'] }
 
 /**
- * 38.109 — the starter's `bunfig.toml`: a test imports the app's `.abide` files as modules, with
+ * 38.109, 38.119 — the starter's `bunfig.toml`: the harness's abide preload, which is a DOM a test
+ * can mount into and measure, then abide's own — the app's `.abide` files imported as modules, with
  * nothing booted first.
  */
 export const TEST_PRELOAD =
-    '# 38.109 — a test imports the app\'s `.abide` files as modules, with nothing booted first.\n[test]\npreload = ["@abide/abide/test"]\n'
+    '# 38.109, 38.119 — a DOM to mount into and measure, then the app\'s `.abide` files as modules.\n[test]\npreload = ["@abide/harness/abide/preload"]\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.
@@ -51,6 +58,8 @@ function filesFor(name: string): Record<string, string> {
                     start: 'abide start',
                     // 38.108 — every address, and the file answering it.
                     routes: 'abide routes',
+                    // 38.112 — the starter's own test, under the 38.109 preload.
+                    test: 'bun test',
                 },
                 // ONE ALIAS FOR THE SOURCE, and two targets for it, because an extensionless
                 // specifier is how an import is written and only bun probes for the extension:
@@ -62,8 +71,12 @@ function filesFor(name: string): Record<string, string> {
                 imports: SOURCE_ALIAS,
                 dependencies: { '@abide/abide': ABIDE_DEPENDENCY },
                 // `Bun`, `bun:sqlite` and the rest of the runtime a server module reaches for are
-                // typed by these, and `abide check` reports every one untyped without them.
-                devDependencies: { '@types/bun': 'latest' },
+                // typed by these, and `abide check` reports every one untyped without them. The
+                // harness is what the starter's tests measure the work a click does with (38.119).
+                devDependencies: {
+                    '@abide/harness': HARNESS_DEPENDENCY,
+                    '@types/bun': 'latest',
+                },
             },
             null,
             4,

package/src/compiler/serveLanguage.ts

@@ -1,8 +1,11 @@
 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 } from './checkApp.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 { isNamedAlone } from './isNamedAlone.ts'
 import { nearest } from './nearest.ts'
 import type { Diagnosis, Inspection, Place } from './TypeSession.ts'
 
@@ -12,9 +15,9 @@ import type { Diagnosis, Inspection, Place } from './TypeSession.ts'
 //
 // WHAT IT SPEAKS is the part of the protocol a diagnostic needs: the handshake, a document opened,
 // changed and closed, and `publishDiagnostics` back. The document is synced whole (`Full`), so what
-// is checked is exactly the editor's text, saved or not. A hover and a jump to a definition are
-// asked of the program that check registered (`TypeSession.inspect`), so they answer about the
-// same text.
+// is checked is exactly the editor's text, saved or not. A hover, a jump to a definition, a
+// completion, the references to a name and a rename of it are asked of the program that check
+// registered (`TypeSession`), so they answer about the same text.
 //
 // THE APP IS THE DOCUMENT'S. An editor starts this at the root of whatever it has open, which in a
 // monorepo is not an app at all, so each document is checked against the root of the NEAREST
@@ -111,7 +114,7 @@ export async function serveLanguage(
                 },
                 severity: SEVERITY[diagnosis.category],
                 source: 'abide',
-                ...(diagnosis.code === 0 ? {} : { code: diagnosis.code }),
+                ...codeOf(diagnosis),
                 message: diagnosis.message,
             })
         }
@@ -121,6 +124,10 @@ export async function serveLanguage(
         })
     }
 
+    // The text the editor holds for a file, where it holds one.
+    const held = (path: string): string | undefined =>
+        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
@@ -155,6 +162,18 @@ export async function serveLanguage(
         return checker
     }
 
+    // An app with no page open is checked again only when one opens, and its checker is a process
+    // holding the whole program — closed rather than kept, or every app the editor ever visited
+    // keeps one for the session. Queued behind the checks, so none is in flight when it closes.
+    const closeIfUnopened = async (app: string): Promise<void> => {
+        for (const uri of documents.keys()) if (placed(uri)?.app === app) return
+        watchers.get(app)?.close()
+        watchers.delete(app)
+        const checker = checkers.get(app)
+        checkers.delete(app)
+        await checker?.close().catch(() => {})
+    }
+
     const run = async (uri: string): Promise<void> => {
         const document = documents.get(uri)
         if (document === undefined) return
@@ -169,8 +188,7 @@ export async function serveLanguage(
                 await checkerOf(app),
                 path,
                 document.text,
-                (held) =>
-                    documents.get(Bun.pathToFileURL(spelled(held)).href)?.text,
+                held,
             )
         } catch (thrown) {
             // The checker's own failure, not the page's: the next check opens another.
@@ -210,14 +228,22 @@ export async function serveLanguage(
     // A question about a document is about the text the editor shows, so a check still settling
     // runs now rather than after the answer; and it is answered in the queue, after that check.
     const inspect = (params: unknown): Promise<Inspection | undefined> =>
-        ask(params, (session, path, text, offset) =>
-            session.inspect(path, text, offset),
+        ask(params, (checker, path, text, offset) =>
+            checker.session.inspect(path, text, offset),
         )
 
+    // 38.116 — asked after every page of the app is lowered, which is what a page this one never
+    // imports needs to be among the references.
+    const references = (params: unknown) =>
+        ask(params, async (checker, path, text, offset) => {
+            await lowerApp(checker, held)
+            return checker.session.references(path, text, offset)
+        })
+
     const ask = <Answer>(
         params: unknown,
         question: (
-            session: AppChecker['session'],
+            checker: AppChecker,
             path: string,
             text: string,
             offset: number,
@@ -238,7 +264,7 @@ export async function serveLanguage(
             const at = placed(uri)
             if (document === undefined || at === undefined) return undefined
             return question(
-                (await checkerOf(at.app)).session,
+                await checkerOf(at.app),
                 at.path,
                 document.text,
                 offsetOf(document.text, position),
@@ -262,7 +288,11 @@ export async function serveLanguage(
                             textDocumentSync: 1,
                             hoverProvider: true,
                             definitionProvider: true,
-                            completionProvider: { triggerCharacters: ['.'] },
+                            referencesProvider: true,
+                            renameProvider: { prepareProvider: true },
+                            completionProvider: {
+                                triggerCharacters: ['.', '<', '#', ':', '/'],
+                            },
                         },
                         serverInfo: { name: 'abide' },
                     },
@@ -327,8 +357,8 @@ export async function serveLanguage(
                 const trigger = (
                     params?.context as { triggerCharacter?: string } | undefined
                 )?.triggerCharacter
-                const found = await ask(params, (session, path, text, offset) =>
-                    session.complete(path, text, offset, trigger),
+                const found = await ask(params, (checker, path, text, offset) =>
+                    checker.session.complete(path, text, offset, trigger),
                 )
                 const items: object[] = []
                 for (const entry of found?.entries ?? [])
@@ -358,12 +388,84 @@ export async function serveLanguage(
                 send({ id: message.id, result: locations })
                 return true
             }
+            case 'textDocument/references': {
+                const found = await references(params)
+                const declarations = (
+                    params?.context as
+                        | { includeDeclaration?: boolean }
+                        | undefined
+                )?.includeDeclaration
+                const locations: object[] = []
+                for (const place of found?.occurrences ?? [])
+                    if (declarations !== false || !place.declaration)
+                        locations.push(locationOf(spelled(place.path), place))
+                send({ id: message.id, result: locations })
+                return true
+            }
+            case 'textDocument/prepareRename': {
+                const found = await references(params)
+                send(
+                    found === undefined
+                        ? { id: message.id, result: null }
+                        : !found.renamable
+                          ? refusedRename(message.id, found.written)
+                          : {
+                                id: message.id,
+                                result: {
+                                    range: rangeOf(found.name),
+                                    placeholder: found.written,
+                                },
+                            },
+                )
+                return true
+            }
+            // A rename is every reference given the new name — and a shorthand the half it renames,
+            // with the other written out beside it.
+            case 'textDocument/rename': {
+                const renamed = params?.newName as string
+                if (!isNamedAlone(renamed)) {
+                    send({
+                        id: message.id,
+                        error: {
+                            code: -32602,
+                            message: `\`${renamed}\` is not a name.`,
+                        },
+                    })
+                    return true
+                }
+                const found = await references(params)
+                if (found !== undefined && !found.renamable) {
+                    send(refusedRename(message.id, found.written))
+                    return true
+                }
+                const changes: Record<string, object[]> = {}
+                for (const place of found?.occurrences ?? []) {
+                    const uri = Bun.pathToFileURL(spelled(place.path)).href
+                    const newText =
+                        place.shorthand === 'local'
+                            ? `${found?.written}: ${renamed}`
+                            : place.shorthand === 'property'
+                              ? `${renamed}: ${found?.written}`
+                              : renamed
+                    const edits = changes[uri] ?? []
+                    edits.push({ range: rangeOf(place), newText })
+                    changes[uri] = edits
+                }
+                send({
+                    id: message.id,
+                    result: found === undefined ? null : { changes },
+                })
+                return true
+            }
             case 'textDocument/didClose': {
                 const closed = params?.textDocument as { uri: string }
                 if (!documents.delete(closed.uri)) return true
                 clearTimeout(timers.get(closed.uri))
                 timers.delete(closed.uri)
                 publish(closed.uri, [], '')
+                const at = placed(closed.uri)
+                if (at !== undefined)
+                    queue = queue.then(() => closeIfUnopened(at.app))
                 return true
             }
         }
@@ -459,14 +561,47 @@ function offsetOf(
 
 /** 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) }
+}
+
+/** A `Place`'s span, lines and columns from 1, as the protocol's `Range`, from 0. */
+function rangeOf(place: Place): object {
+    return {
+        start: {
+            line: place.start.line - 1,
+            character: place.start.column - 1,
+        },
+        end: { line: place.end.line - 1, character: place.end.column - 1 },
+    }
+}
+
+/** 38.116 — a rename refused, for a name declared where no author writes. */
+function refusedRename(id: Message['id'], name: string): object {
     return {
-        uri: Bun.pathToFileURL(path).href,
-        range: {
-            start: {
-                line: place.start.line - 1,
-                character: place.start.column - 1,
-            },
-            end: { line: place.end.line - 1, character: place.end.column - 1 },
+        id,
+        error: {
+            code: -32803,
+            message: `\`${name}\` is declared in a library, and a library is not renamed.`,
         },
     }
 }
+
+/**
+ * The protocol's `code` for a finding: the checker's own number, or the clause an abide finding
+ * cites, with the rulebook's page for it.
+ *
+ * 38.118.
+ */
+function codeOf(diagnosis: Diagnosis): {
+    code?: number | string
+    codeDescription?: { href: string }
+} {
+    if (diagnosis.code !== 0) return { code: diagnosis.code }
+    const [clause] = citedClauses(diagnosis.message)
+    return clause === undefined
+        ? {}
+        : {
+              code: clause,
+              codeDescription: { href: `${DOCS_SITE}/rulebook#${clause}` },
+          }
+}

package/src/compiler/templateContext.ts

@@ -0,0 +1,150 @@
+import { importedNames } from './splitImports.ts'
+import { TEMPLATE_BLOCKS } from './TEMPLATE_BLOCKS.ts'
+
+/**
+ * What the markup at a cursor is waiting for: a block keyword after `{#`, `{:` or `{/`, a component
+ * tag after `<`, or an attribute inside a component's tag — `typed` being what is written of it so
+ * far. `undefined` in a script, a style, an expression, or text, which is the checker's to answer.
+ */
+export type TemplateContext =
+    | { kind: 'block'; typed: string; offered: string[] }
+    | { kind: 'tag'; typed: string; offered: string[] }
+    | { kind: 'attribute'; tag: string; typed: string; written: string[] }
+
+/**
+ * 38.117 — the template completion a cursor at `offset` in a `.abide`'s `text` stands in.
+ *
+ * READ OFF THE TEXT, NOT A PARSE: a tag or a block being typed is exactly the text the parser
+ * refuses, so the markup is scanned from the last script or style before the cursor.
+ */
+export function templateContext(
+    text: string,
+    offset: number,
+): TemplateContext | undefined {
+    const markup = markupStart(text, offset)
+    if (markup === -1) return undefined
+    let depth = 0
+    let braceAt = -1
+    let tagAt = -1
+    for (let at = markup; at < offset; at += 1) {
+        const char = text[at]
+        if (depth > 0) {
+            if (char === '{') depth += 1
+            else if (char === '}') depth -= 1
+            else if (char === '"' || char === "'" || char === '`')
+                at = quoteEnd(text, at, offset)
+            continue
+        }
+        if (char === '{') {
+            depth = 1
+            braceAt = at
+        } else if (tagAt !== -1) {
+            if (char === '>') tagAt = -1
+            else if (char === '"' || char === "'")
+                at = quoteEnd(text, at, offset)
+        } else if (char === '<' && /[A-Za-z/]/.test(text[at + 1] ?? '')) {
+            tagAt = at
+        } else if (char === '<' && at + 1 === offset) tagAt = at
+    }
+    if (depth > 0) {
+        const block = /^\{([#:/])([a-z ]*)$/.exec(text.slice(braceAt, offset))
+        if (block === null) return undefined
+        return {
+            kind: 'block',
+            typed: block[2] as string,
+            offered: blocksAfter(block[1] as string, text, braceAt),
+        }
+    }
+    if (tagAt === -1) return undefined
+    const tag = text.slice(tagAt, offset)
+    const name = /^<([A-Za-z][\w$.]*)?$/.exec(tag)
+    if (name !== null)
+        return {
+            kind: 'tag',
+            typed: name[1] ?? '',
+            offered: componentsIn(text),
+        }
+    const component = /^<([A-Z][\w$]*)\s/.exec(tag)
+    const typing = /\s([\w$-]*)$/.exec(tag)
+    if (component === null || typing === null) return undefined
+    const written: string[] = []
+    // The values written so far, taken out, leave the names.
+    const names = tag
+        .slice(component[0].length, tag.length - (typing[1] as string).length)
+        .replace(/"[^"]*"|'[^']*'|\{[^{}]*\}/g, ' ')
+    for (const found of names.matchAll(/[A-Za-z_$][\w$:-]*/g))
+        written.push(found[0])
+    return {
+        kind: 'attribute',
+        tag: component[1] as string,
+        typed: typing[1] as string,
+        written,
+    }
+}
+
+/** Where the markup holding `offset` starts, or -1 where `offset` is inside a script or a style. */
+function markupStart(text: string, offset: number): number {
+    let start = 0
+    const lower = text.toLowerCase()
+    const opened = /<(script|style)\b[^>]*>/gi
+    for (;;) {
+        const open = opened.exec(text)
+        if (open === null || open.index >= offset) return start
+        const body = open.index + open[0].length
+        const close = lower.indexOf(
+            `</${(open[1] as string).toLowerCase()}`,
+            body,
+        )
+        if (offset >= body && (close === -1 || offset <= close)) return -1
+        if (close === -1) return -1
+        start = text.indexOf('>', close) + 1
+        opened.lastIndex = start
+    }
+}
+
+/** The offset of the quote closing the one at `at`, or the last one before `limit`. */
+function quoteEnd(text: string, at: number, limit: number): number {
+    const quote = text[at]
+    for (let next = at + 1; next < limit; next += 1) {
+        if (text[next] === '\\') next += 1
+        else if (text[next] === quote) return next
+    }
+    return limit
+}
+
+/**
+ * The keywords that may follow `sigil`: every block after `{#`, and after `{:` and `{/` the arms and
+ * the close of the innermost block still open before `at` — every one where none is.
+ */
+function blocksAfter(sigil: string, text: string, at: number): string[] {
+    const blocks = Object.keys(TEMPLATE_BLOCKS)
+    if (sigil === '#') return blocks
+    const open: string[] = []
+    const marks = new RegExp(`\\{([#/])(${blocks.join('|')})(?![\\w$])`, 'g')
+    for (const mark of text.slice(0, at).matchAll(marks)) {
+        if (mark[1] === '#') open.push(mark[2] as string)
+        else if (open[open.length - 1] === mark[2]) open.pop()
+    }
+    const innermost = open[open.length - 1]
+    if (sigil === '/') return innermost === undefined ? blocks : [innermost]
+    if (innermost !== undefined) return [...(TEMPLATE_BLOCKS[innermost] ?? [])]
+    const arms: string[] = []
+    for (const block of blocks) arms.push(...(TEMPLATE_BLOCKS[block] ?? []))
+    return arms
+}
+
+/**
+ * The components a tag in `text` may name: each TitleCase name its scripts import, and each
+ * `{#component}` it declares (32.41).
+ */
+function componentsIn(text: string): string[] {
+    const names = new Set<string>()
+    for (const script of text.matchAll(
+        /<script\b[^>]*>([\s\S]*?)(?:<\/script|$)/gi,
+    ))
+        for (const { name } of importedNames(script[1] as string))
+            if (/^[A-Z]/.test(name)) names.add(name)
+    for (const found of text.matchAll(/\{#component\s+([A-Z][\w$]*)/g))
+        names.add(found[1] as string)
+    return [...names]
+}

package/src/compiler/tokenize.ts

@@ -186,6 +186,12 @@ function scan(
     while (true) {
         let kind = scanner.scan()
         if (kind === SyntaxKind.EndOfFile) return
+        // A `#` NAMING NOTHING scans as an empty private name and the scanner does not move past
+        // it, so `{#` typed at the end of a file never finished parsing. It is stepped over.
+        if (scanner.getTokenEnd() === scanner.getTokenStart()) {
+            scanner.resetTokenState(scanner.getTokenEnd() + 1)
+            continue
+        }
         if (
             expectsOperand &&
             (kind === SyntaxKind.SlashToken ||

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.1.0'
+export const BRIDGE_VERSION = '0.2.0'

package/src/server/Inbox.ts

@@ -20,6 +20,14 @@ export class Inbox<Item> implements AsyncIterable<Item> {
         this.#wake?.()
     }
 
+    /** Closes this inbox and hands what nothing has read yet to a new one, for a new reader. */
+    handOff(): Inbox<Item> {
+        const next = new Inbox<Item>()
+        next.#items = this.#items.splice(0)
+        this.close()
+        return next
+    }
+
     async *[Symbol.asyncIterator](): AsyncGenerator<Item> {
         for (;;) {
             if (this.#items.length > 0) {

package/src/server/MCP_PROTOCOL_VERSION.ts

@@ -1,3 +1,3 @@
 // The MCP protocol version abide's servers answer `initialize` with: `/__abide/mcp`, and the one a
-// paired bridge's Claude Code reaches through the relay (45.17).
+// paired bridge's Claude Code reaches through the relay (44.17).
 export const MCP_PROTOCOL_VERSION = '2025-06-18'

package/src/server/MOUNTABLE.ts

@@ -0,0 +1,6 @@
+/**
+ * The key a bound component carries what `mount` needs under: its props as accessors, and a loader
+ * for its browser module. A registered symbol, because the module that sets it is generated text
+ * (`boundModule`) and spells it by its description.
+ */
+export const MOUNTABLE = Symbol.for('abide.mountable')

package/src/server/abideModules.ts

@@ -43,6 +43,7 @@ import {
     STYLE_QUERY,
     TEXT_QUERY,
 } from './MODULE_QUERIES.ts'
+import { MOUNTABLE } from './MOUNTABLE.ts'
 import { realOrAsGiven } from './realOrAsGiven.ts'
 import { SERVER_TABLE } from './TABLES.ts'
 import { VIRTUAL_DIRECTORY } from './VIRTUAL_DIRECTORY.ts'
@@ -449,6 +450,7 @@ function compiledAt(served: Held, path: string): CompiledFile {
 // 34.16 — BOUND, NOT RAW. The compiled module is a function of accessors answering its markup (33.4);
 // what an app's own module calls is a function of plain props answering a `Component` (35.4), which
 // `render` invokes with nothing. The component is the module's one export (34.17).
+// 38.119 — and it carries what `mount` hydrates it with: the same accessors, and its browser module.
 function boundModule(path: string): string {
     return `import component from ${JSON.stringify(path)}
 export default (props = {}) => {
@@ -457,7 +459,12 @@ export default (props = {}) => {
         const value = props[key]
         accessors[key] = () => value
     }
-    return () => component(accessors)
+    const bound = () => component(accessors)
+    bound[Symbol.for(${JSON.stringify(MOUNTABLE.description)})] = {
+        accessors,
+        client: () => import(${JSON.stringify(`${path}${CLIENT_QUERY}`)}),
+    }
+    return bound
 }
 `
 }

package/src/server/answerRequest.ts

@@ -18,6 +18,7 @@ import {
 import { APP_META } from '#shared/APP_META.ts'
 import { DEBUG_META } from '#shared/DEBUG_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'
@@ -514,7 +515,8 @@ export async function appSources(parts: SourceParts): Promise<AppSources> {
     const sources: AppSources = {
         routes: rankRoutes([...rows.values()]),
         errors,
-        errorDocument: documentOf([]),
+        // 35.18 — marked, so the browser hydrates no page over what an error page painted.
+        errorDocument: intoHead(documentOf([]), `<meta name="${ERROR_META}">`),
         framework: client.framework,
         published,
         explained: parts.explained,