@abide/abide 0.101.0 → 0.103.0

package/src/compiler/projectShadow.ts

@@ -8,6 +8,14 @@ import {
     PositionTable,
 } from './PositionTable.ts'
 import type { AbideFile } from './parseAbide.ts'
+import {
+    attributedImports,
+    IMPORT_ATTRIBUTES,
+    type ImportBinding,
+    importStatements,
+    newlinesIn,
+    SOURCE_SUFFIX,
+} from './splitImports.ts'
 import type {
     Body,
     Branch,
@@ -16,7 +24,7 @@ import type {
     Setup,
     TemplateNode,
 } from './TemplateNode.ts'
-import { tokenize } from './tokenize.ts'
+import { nesting, tokenize } from './tokenize.ts'
 
 export type Span = { start: number; end: number }
 
@@ -37,6 +45,8 @@ export type Span = { start: number; end: number }
 export type Projection = {
     text: string
     modules: Span
+    /** 34.19 — the `<script server>` bodies, module scope like `modules` and the server's alone. */
+    servers: Span
     scripts: Span
     /** Every template position, ascending, each with its kind — what the checker's tree is asked. */
     positions: PositionTable
@@ -83,6 +93,45 @@ export function projectShadow(file: AbideFile): Projection {
     return projection
 }
 
+type ImportStatement = ReturnType<typeof importStatements>[number]
+
+/** 34.22 — a binding as two blocks importing the same thing agree on it. */
+function bindingKey(
+    statement: ImportStatement,
+    binding: ImportBinding,
+): string {
+    return `${statement.specifier}|${statement.attributes}|${binding.imported}|${binding.local}`
+}
+
+/**
+ * 34.22 — what is left of an import once the bindings `drops` answers for are taken out:
+ * `undefined` where none is, `''` where every one is, and the statement over the rest otherwise,
+ * spelled from its tokens.
+ */
+function keptImport(
+    statement: ImportStatement,
+    drops: (statement: ImportStatement, binding: ImportBinding) => boolean,
+): string | undefined {
+    const parts: string[] = []
+    const named: string[] = []
+    for (const binding of statement.bindings) {
+        if (drops(statement, binding)) continue
+        // The default's own slot and a namespace stand outside the braces; `{ default as x }` in.
+        if (
+            (binding.imported === 'default' &&
+                binding.written === binding.local) ||
+            binding.imported === '*'
+        )
+            parts.push(binding.written)
+        else named.push(binding.written)
+    }
+    const kept = parts.length + named.length
+    if (kept === statement.bindings.length) return undefined
+    if (kept === 0) return ''
+    if (named.length > 0) parts.push(`{ ${named.join(', ')} }`)
+    return `import ${statement.typeOnly ? 'type ' : ''}${parts.join(', ')} from '${statement.specifier}'${statement.attributes === '' ? '' : ` ${statement.attributes}`}`
+}
+
 function project(file: AbideFile): Projection {
     const origins: Origin[] = []
     // 34.13 — scaffolding ahead of every block, so each one and the template are in their scope.
@@ -102,17 +151,115 @@ function project(file: AbideFile): Projection {
     }
 
     // Blocks of one kind, joined as the file wrote them, each run placed where it stood.
-    const blocks = (bodies: string[], starts: number[]): Span => {
+    const blocks = (
+        bodies: string[],
+        starts: number[],
+        drops: (statement: ImportStatement, binding: ImportBinding) => boolean,
+    ): Span => {
         const start = text.length
         for (let at = 0; at < bodies.length; at += 1) {
             if (at > 0) text += '\n'
-            copied(bodies[at] as string, starts[at])
+            script(bodies[at] as string, starts[at], drops)
         }
         return { start, end: text.length }
     }
-    const modules = blocks(file.modules, file.origins.modules)
+    // 34.21 — a block copied as written, save that a `.abide` imported as text names the module
+    // holding its text, and loses the attribute bun would otherwise read that module as text by.
+    //
+    // 34.22 — and a binding a `<script server>` and the file's `<script module>` or `<script>` both
+    // import is written once: the server's module holds the other blocks' imports too, and written
+    // twice it was a duplicate binding. `drops` says which copy goes. A blank line per line it
+    // spanned keeps the block line for line with the file.
+    const script = (
+        body: string,
+        origin: number | undefined,
+        drops: (statement: ImportStatement, binding: ImportBinding) => boolean,
+    ): void => {
+        const edits: { start: number; end: number; written: string }[] = []
+        for (const one of attributedImports(body, 'text'))
+            edits.push({
+                start: one.literalStart,
+                end: one.end,
+                written: `'${one.specifier}${SOURCE_SUFFIX}'`,
+            })
+        // 23.19 — a mount is the build's to read, and no module of the checker's or bun's.
+        for (const one of attributedImports(body, 'routes'))
+            edits.push({
+                start: one.start,
+                end: one.end,
+                written: `;${'\n'.repeat(newlinesIn(body, one.start, one.end))}`,
+            })
+        for (const one of importStatements(body)) {
+            const kept = keptImport(one, drops)
+            if (kept === undefined) continue
+            edits.push({
+                start: one.start,
+                end: one.end,
+                written: `${kept === '' ? ';' : kept}${'\n'.repeat(newlinesIn(body, one.start, one.end))}`,
+            })
+        }
+        edits.sort((one, two) => one.start - two.start)
+        let from = 0
+        for (const edit of edits) {
+            if (edit.start < from) continue
+            copied(
+                body.slice(from, edit.start),
+                origin === undefined ? undefined : origin + from,
+            )
+            place(origin === undefined ? undefined : origin + edit.start, 0)
+            text += edit.written
+            from = edit.end
+        }
+        copied(
+            body.slice(from),
+            origin === undefined ? undefined : origin + from,
+        )
+    }
+    // 34.22 — per binding the blocks both sides run import, whether one of them imports a value;
+    // and the bindings the server block imports as values.
+    const shared = new Map<string, boolean>()
+    for (const body of [...file.modules, ...file.scripts])
+        for (const one of importStatements(body))
+            for (const binding of one.bindings) {
+                const key = bindingKey(one, binding)
+                shared.set(key, shared.get(key) === true || !binding.typeOnly)
+            }
+    const serverValues = new Set<string>()
+    for (const body of file.servers)
+        for (const one of importStatements(body))
+            for (const binding of one.bindings)
+                if (!binding.typeOnly)
+                    serverValues.add(bindingKey(one, binding))
+    // A TYPE-ONLY IMPORT NEVER STANDS FOR A VALUE ONE: erased, it binds nothing at run time, so where
+    // the server block imports the value, it is the other block's type-only copy that goes.
+    const typeOnlyOfServerValue = (
+        statement: ImportStatement,
+        binding: ImportBinding,
+    ): boolean =>
+        binding.typeOnly && serverValues.has(bindingKey(statement, binding))
+    const modules = blocks(
+        file.modules,
+        file.origins.modules,
+        typeOnlyOfServerValue,
+    )
     text += '\n;\n'
-    const scripts = blocks(file.scripts, file.origins.scripts)
+    const servers = blocks(
+        file.servers,
+        file.origins.servers,
+        (statement, binding) => {
+            const value = shared.get(bindingKey(statement, binding))
+            if (value === undefined || (value === false && !binding.typeOnly))
+                return false
+            if (value && !binding.typeOnly) refuseTwoFaces(statement, binding)
+            return true
+        },
+    )
+    text += '\n;\n'
+    const scripts = blocks(
+        file.scripts,
+        file.origins.scripts,
+        typeOnlyOfServerValue,
+    )
     const scriptsText = text.slice(scripts.start, scripts.end)
     text += '\n'
     const positions: Position[] = []
@@ -161,7 +308,7 @@ function project(file: AbideFile): Projection {
     // 32.17 — A COMPONENT TAG IS A CALL, AND IT IS PROJECTED AS ONE: the name it invokes, handed the
     // record the build hands it (`invocationProps`), so the checker holds each value to the prop the
     // child declares (33.4), reports a name nobody imported, and answers a hover or a jump on the
-    // tag with the import's (38.40). Spreads first and explicit keys after, which is the order 33.12
+    // tag with the import's (38.39). Spreads first and explicit keys after, which is the order 33.12
     // resolves them in.
     const invocation = (node: ElementNode): void => {
         // 32.36 — CALLED OPTIONALLY, so a value that may be absent is checked as one that may
@@ -386,8 +533,17 @@ function project(file: AbideFile): Projection {
                 ),
             )
             text += ')\n'
-            text += `for (const ${node.item} of ${ROWS_OF}(${subject})) {\n`
-            if (node.index !== '') text += `const ${node.index} = 0\n`
+            // 38.39 — the item and the index copied from where they stand, so a hover on either is
+            // the binding's. The index is a `number`: `= 0` alone types it the literal `0`.
+            const bound = file.origins.bindings.get(node)
+            text += 'for (const '
+            copied(node.item, bound?.item)
+            text += ` of ${ROWS_OF}(${subject})) {\n`
+            if (node.index !== '') {
+                text += 'const '
+                copied(node.index, bound?.index)
+                text += ': number = 0\n'
+            }
             // `inBody` but for the key, which stands after the row's setup and before its nodes.
             setup(node.setup)
             declare(node.components)
@@ -402,6 +558,9 @@ function project(file: AbideFile): Projection {
     }
     declare(file.components)
     walk(file.head)
+    // 35.17 — the document's attributes are read as any element's are.
+    if (file.document !== undefined)
+        walk([file.document.html, file.document.body])
     walk(file.template)
     if (subjects > 0) text += ROWS_OF_DECLARATION
     if (inlineProps) text += INLINE_PROPS_IMPORT
@@ -409,12 +568,23 @@ function project(file: AbideFile): Projection {
     // 34.3 — BOTH BLOCKS. A `<script>` is a function body on both sides, where an `await` at its top
     // does not parse; a `<script module>` is module scope, where it would, and holds the import of
     // every file that reaches it until it settles — the render waiting on it in all but name.
-    refuseTopLevelAwait(file.modules.join('\n'), '<script module>')
+    const modulesText = file.modules.join('\n')
+    const serversText = file.servers.join('\n')
+    refuseTopLevelAwait(modulesText, '<script module>')
+    refuseTopLevelAwait(serversText, '<script server>')
     refuseTopLevelAwait(scriptsText, '<script>')
-    refuseInstanceExport(scriptsText)
+    // A kind at a time: a token at the end of one kind's text would decide how the next one's first
+    // reads.
+    refuseExport(modulesText)
+    refuseExport(serversText)
+    refuseExport(scriptsText)
+    // 16.70 — what the server block binds, re-exported under a name no author writes, so the
+    // checker reads each one's declaring call as it reads a handler file's default.
+    text += privateExports(serversText)
     return {
         text,
         modules,
+        servers,
         scripts,
         positions: new PositionTable(positions),
         slots,
@@ -537,6 +707,7 @@ declare function ${ROWS_OF}<T>(subject: Iterable<T> | AsyncIterable<T> | null |
  */
 function refuseTopLevelAwait(source: string, block: string): void {
     if (!source.includes(AWAIT)) return
+    // Brackets alone, not `nesting`: a template's substitution is still the top level here.
     let depth = 0
     for (const token of tokenize(source)) {
         const text = token.text
@@ -550,29 +721,89 @@ function refuseTopLevelAwait(source: string, block: string): void {
 }
 
 /**
- * Throws where a `<script>` exports.
+ * Throws where a script block exports.
  *
- * 34.18 — AN EXPORT IS THE MODULE'S, and a `<script>` runs once per instance: there is no one
- * instance an importer could be reading from. Refused rather than emitted, as 34.3's `await` is —
- * the block is a function body on both sides, and the bundler's own error names neither the page
- * nor the fix.
+ * 34.17 — A `.abide`'S ONE EXPORT IS ITS COMPONENT. A handler another file calls is a handler file
+ * (16.2), a value two files share is a module under a lib directory, and what the framework reads
+ * off a file is a hook it calls (37.1). Refused rather than emitted, as 34.3's `await` is: the
+ * bundler's own error names neither the file nor the fix.
  */
-function refuseInstanceExport(source: string): void {
+function refuseExport(source: string): void {
     if (!source.includes(EXPORT)) return
     let depth = 0
     let previous = ''
     for (const token of tokenize(source)) {
         const text = token.text
-        if (text === '{' || text === '(' || text === '[') depth += 1
-        else if (text === '}' || text === ')' || text === ']') depth -= 1
+        const moved = nesting(token.kind)
+        if (moved !== 0) depth += moved
         else if (depth === 0 && text === EXPORT && previous !== '.')
             throw new Error(
-                "abide: a <script> cannot export — it runs once per instance, and an export is the module's. Move the declaration to <script module>. RULEBOOK 34.18.",
+                '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.',
             )
         previous = text
     }
 }
 
+/** The prefix a server block's bindings are re-exported under, for the build alone (16.70). */
+export const PRIVATE_EXPORT = '__handler_'
+
+/**
+ * 16.70 — the `export { … }` re-exporting each name the server blocks bind under `PRIVATE_EXPORT`,
+ * or `''` where they bind none. One spelling for the checker's view and the emitted module, which
+ * the build's handler table reads a private handler out of by the same name.
+ */
+export function privateExports(servers: string): string {
+    const listed: string[] = []
+    for (const name of serverBindings(servers))
+        listed.push(`${name} as ${PRIVATE_EXPORT}${name}`)
+    return listed.length === 0 ? '' : `export { ${listed.join(', ')} }\n`
+}
+
+/**
+ * The names a `<script server>` binds with `const`, `let` or `var` at its top level, a
+ * destructuring's aside: a handler is a call bound to one name.
+ */
+function serverBindings(source: string): string[] {
+    const names: string[] = []
+    if (source === '') return names
+    let depth = 0
+    let declaring = false
+    for (const token of tokenize(source)) {
+        const text = token.text
+        const moved = nesting(token.kind)
+        if (moved !== 0) {
+            depth += moved
+            declaring = false
+        } else if (depth !== 0) continue
+        else if (text === 'const' || text === 'let' || text === 'var')
+            declaring = true
+        else if (declaring && token.kind === SyntaxKind.Identifier) {
+            names.push(text)
+            declaring = false
+        } else declaring = false
+    }
+    return names
+}
+
+/**
+ * 34.22 — throws where the binding both blocks import is a `.abide`'s default or namespace: the
+ * server block's is the function binding its props (34.16) and the other block's is the module it
+ * compiles to (32.17), and one name in one module scope cannot hold both.
+ */
+function refuseTwoFaces(
+    statement: ImportStatement,
+    binding: ImportBinding,
+): void {
+    if (
+        statement.specifier.endsWith('.abide') &&
+        !IMPORT_ATTRIBUTES.text.test(statement.attributes) &&
+        (binding.imported === 'default' || binding.imported === '*')
+    )
+        throw new Error(
+            `abide: <script server> imports ${binding.local} from '${statement.specifier}' as another script block of its file does — a server block's .abide is the function binding its props (34.16), the other block's is its module (32.17), and one name cannot be both. Import it under another name in the <script server>. RULEBOOK 34.22.`,
+        )
+}
+
 /**
  * 34.13 — each type parameter a component declares, as a type its body cannot see inside.
  *

package/src/compiler/reactiveTypes.ts

@@ -76,8 +76,8 @@ async function everyPresentMember(
     return present
 }
 
-// Where abide declares `Reactive`, `props`, `route` and `Selection`, found in the project the way
-// `METHODS_SOURCE` is.
+// Where abide declares `Reactive`, `props`, `route`, `Selection` and `onConfig`, found in the project
+// the way `METHODS_SOURCE` is.
 const REACTIVE_SOURCE = Bun.fileURLToPath(
     new URL('../shared/reactive/Reactive.ts', import.meta.url),
 )
@@ -90,16 +90,20 @@ const ROUTE_SOURCE = Bun.fileURLToPath(
 const SELECTION_SOURCE = Bun.fileURLToPath(
     new URL('../shared/reactive/index.ts', import.meta.url),
 )
+const HOOKS_SOURCE = Bun.fileURLToPath(
+    new URL('../server/hooks.ts', import.meta.url),
+)
 
 /**
- * Abide's own `Reactive`, `Selection`, `props` and `route` declarations, as this project's checker
- * names them.
+ * Abide's own `Reactive`, `Selection`, `props`, `route` and `onConfig` declarations, as this
+ * project's checker names them.
  *
  * 31.3 — A `Reactive` IS TOLD BY ITS DECLARATION, never by how it prints. Every instantiation of
  * abide's `Reactive` carries the symbol of the one type literal it is declared as, whatever alias
  * or re-export the app reached it through — so `type Counter = Reactive<number>` is one, and an
  * app's own type that happens to be spelled `Reactive` is not. `undefined` where the project never
- * reaches abide, and then nothing in it is one. `props` is abide's file as the checker names it.
+ * reaches abide, and then nothing in it is one. `props` and `onConfig` are abide's files as the
+ * checker names them.
  */
 export type Abide = {
     /** 23.9 — abide's `route`, as the file the checker names it. */
@@ -110,14 +114,17 @@ export type Abide = {
      */
     selection: CheckedSymbol | undefined
     props: string | undefined
+    /** 27.13 — abide's `onConfig`, as the file the checker names it. */
+    onConfig: string | undefined
 }
 
 export async function abideIn(project: Project): Promise<Abide> {
-    const [declares, props, selects, route] = await Promise.all([
+    const [declares, props, selects, route, hooks] = await Promise.all([
         project.program.getSourceFile(REACTIVE_SOURCE),
         project.program.getSourceFile(PROPS_SOURCE),
         project.program.getSourceFile(SELECTION_SOURCE),
         project.program.getSourceFile(ROUTE_SOURCE),
+        project.program.getSourceFile(HOOKS_SOURCE),
     ])
     let selection: CheckedSymbol | undefined
     for (const statement of selects?.statements ?? [])
@@ -142,7 +149,13 @@ export async function abideIn(project: Project): Promise<Abide> {
             reactive = await literal?.getSymbol()
             break
         }
-    return { route: route?.path, reactive, selection, props: props?.path }
+    return {
+        route: route?.path,
+        reactive,
+        selection,
+        props: props?.path,
+        onConfig: hooks?.path,
+    }
 }
 
 /**

package/src/compiler/readSources.ts

@@ -13,6 +13,8 @@ export type ParsedSource = {
     text: string
     file: AbideFile
     quiet: boolean
+    /** 23.19 — where a mounted package's file stands in the app; `undefined` for one at its own path. */
+    position: string | undefined
 }
 
 /** One `.abide` as the emitters and the checked lowering take it: parsed, and answered. */
@@ -25,7 +27,12 @@ export type ReadSource = ParsedSource & { answer: CheckerAnswer }
  * parsed around it — a quiet one's is nobody's. Without it the refusal is thrown, as a build stops.
  */
 export function parseSources(
-    sources: readonly { path: string; text: string; quiet?: boolean }[],
+    sources: readonly {
+        path: string
+        text: string
+        quiet?: boolean
+        position?: string
+    }[],
     refused?: Diagnosis[],
 ): ParsedSource[] {
     const parsed: ParsedSource[] = []
@@ -39,7 +46,13 @@ export function parseSources(
             if (!quiet) refused.push(refusal(source.path, thrown))
             continue
         }
-        parsed.push({ path: source.path, text: source.text, file, quiet })
+        parsed.push({
+            path: source.path,
+            text: source.text,
+            file,
+            quiet,
+            position: source.position,
+        })
     }
     return parsed
 }

package/src/compiler/readsIn.ts

@@ -8,6 +8,7 @@ import {
     isCallExpression,
     isClassDeclaration,
     isEnumDeclaration,
+    isExpressionStatement,
     isFunctionDeclaration,
     isFunctionExpression,
     isIdentifier,
@@ -66,8 +67,9 @@ import { trackingWarnings } from './trackingWarnings.ts'
 export type ShadowSpans = {
     /** Where the shadow's scripts end and its template begins. */
     scriptsEnd: number
-    /** The `<script module>` bodies, and the `<script>` bodies, in the shadow. */
+    /** The `<script module>`, `<script server>` and `<script>` bodies, in the shadow. */
     modules: Span
+    servers: Span
     scripts: Span
     positions: PositionTable
 }
@@ -123,7 +125,8 @@ export async function readsIn(
     sourceFile: SourceFile,
     shadowPath: string,
     spans: ShadowSpans,
-    abidePath: string,
+    // The file below the app's root, which its route is read off (23.14).
+    routedPath: string,
     file: AbideFile,
 ): Promise<{ answer: CheckerAnswer; warnings: Finding[] }> {
     // A destructuring pattern binds names this does not see, and that is 31.12's case.
@@ -185,7 +188,14 @@ export async function readsIn(
     // Awaited after the round trips below, so a 33.14 refusal would reject with nothing
     // listening and be reported unhandled; `await props` still throws it.
     props.catch(() => {})
-    const params = routeReads(checker, abide, sourceFile, abidePath, reads)
+    const params = routeReads(checker, abide, sourceFile, routedPath, reads)
+    const configs = configReads(
+        checker,
+        abide,
+        sourceFile,
+        spans.servers,
+        reads,
+    )
     // No name is no round trip to ask about none.
     const symbols =
         names.length === 0 ? [] : await checker.getSymbolAtLocation(names)
@@ -249,6 +259,7 @@ export async function readsIn(
     await Promise.all(holding)
     await props
     await params
+    await configs
     const statics = new Set<number>()
     const expressions = spans.positions.nodesIn(
         sourceFile,
@@ -271,7 +282,7 @@ export async function readsIn(
     await proveSlots(checker, expressions, reads, statics)
     reads.sort(byPosition)
     const warnings = await warningsFor(checker, located, spans.positions)
-    // 34.19.
+    // 34.18.
     for (const warning of await sharedModuleWrites(
         checker,
         shadowPath,
@@ -683,7 +694,7 @@ const ROUTE_MEMBERS = new Set(['url', 'params', 'name', 'navigating'])
  * a name, and this read is spelled as a member.
  *
  * 23.9 — AND `route.params` IN A PAGE OR A LAYOUT IS WHAT THAT FILE'S OWN ROUTE PROMISES. The file
- * is the route: `ui/pages/media/[id]/page.abide` only ever renders where `id` matched, so its
+ * is the route: `media/[id].abide` only ever renders where `id` matched, so its
  * `route.params` has an `id`, and a layout's has its own segments and whatever a page below adds.
  * Only the checker reads that — the running module reads the one `route` every page shares.
  */
@@ -691,11 +702,11 @@ async function routeReads(
     checker: Checker,
     abide: Abide,
     sourceFile: Node,
-    abidePath: string,
+    routedPath: string,
     reads: Read[],
 ): Promise<void> {
     if (abide.route === undefined) return
-    const routed = fileKind(abidePath)
+    const routed = fileKind(routedPath)
     const kind = routed === 'page' || routed === 'layout' ? routed : undefined
     const accesses: Node[] = []
     const owners: Node[] = []
@@ -714,7 +725,7 @@ async function routeReads(
     sourceFile.forEachChild(visit)
     if (owners.length === 0) return
     const symbols = await checker.getSymbolAtLocation(owners)
-    const pattern = routeOf(abidePath)
+    const pattern = routeOf(routedPath)
     for (let at = 0; at < accesses.length; at += 1) {
         const symbol = symbols[at]
         if (symbol === undefined) continue
@@ -777,6 +788,49 @@ function refuseDeclared(
             )
 }
 
+/**
+ * 27.13 — each `onConfig(…)` standing as a statement at the top of a `<script server>`, as a read of
+ * its callee, pushed onto `reads`.
+ *
+ * The callee says which are abide's, as `props`'s does. A call anywhere else — inside a function,
+ * or handing its unfiling back to a name — is filed all the same, and declares nothing.
+ */
+async function configReads(
+    checker: Checker,
+    abide: Abide,
+    sourceFile: Node & { statements: readonly Node[] },
+    servers: Span,
+    reads: Read[],
+): Promise<void> {
+    if (abide.onConfig === undefined) return
+    const callees: Node[] = []
+    for (const statement of sourceFile.statements) {
+        const start = statement.getStart()
+        if (start < servers.start) continue
+        if (start >= servers.end) break
+        if (
+            isExpressionStatement(statement) &&
+            isCallExpression(statement.expression) &&
+            isIdentifier(statement.expression.expression)
+        )
+            callees.push(statement.expression.expression)
+    }
+    if (callees.length === 0) return
+    const named = await checker.getSymbolAtLocation(callees)
+    for (let at = 0; at < callees.length; at += 1) {
+        const symbol = named[at]
+        if (symbol === undefined) continue
+        const callee = await aliasedSymbol(checker, symbol)
+        if (
+            callee.name !== 'onConfig' ||
+            callee.valueDeclaration?.path !== abide.onConfig
+        )
+            continue
+        const node = callees[at] as Node
+        reads.push(newRead(node.getStart(), node.end, 'config'))
+    }
+}
+
 /**
  * The reads a `props<Props>()` destructuring contributes, pushed onto `reads`.
  *

package/src/compiler/renderMarkup.ts

@@ -108,7 +108,7 @@ export const HEADS = '__heads'
  * EVERY MARKUP POSITION THAT EVALUATES AN AUTHOR EXPRESSION, rather than the two that were found
  * first. A GUARD HERE IS HALF A MECHANISM — it trades a throw for a HOLE, and something on the
  * client has to fill that hole once the value lands: a text slot has `runHere` and `textHere`, a
- * `{#for}` has `List.hydrate`'s count check, an attribute has its own binding re-running on the
+ * `{#for}` has `List.hydrate`'s count check, an attribute has its own binding rerunning on the
  * value that landed (32.3), and the `{#if}` chain has `isEmptyRegion` — which is why that one is
  * guarded at the REGION rather than per subject, and says so at its own arm. The ESCAPER STAYS
  * OUTSIDE: absence is `undefined` here and what it means is already decided where it lands (see
@@ -296,7 +296,7 @@ function renderPosition(
             `abide: a ${at.kind} position holds a ${node.kind} node.`,
         )
 
-    // 32.17 — A CAPITALISED TAG IS AN INVOCATION, and the capital is the whole of the
+    // 32.17 — A CAPITALIZED TAG IS AN INVOCATION, and the capital is the whole of the
     // distinction. It is emitted as a CALL, so the child's own module renders it.
     if (isComponentTag(node.tag)) return invocationMarkup(node, at, lowering)
 
@@ -536,7 +536,7 @@ function serverComponent(
     // standing side by side are two instances, each creating what no ancestor holds (10.6).
     const { opened, closed } = shareScope(lowering, '')
     return `function ${component.name}(${PROPS} = {}) {
-${opened}${head}${setup}${definitions(sink, lowering)}return { head: '', body: ${renderMarkup(sink, lowering, SERVER_LANE)} }${closed}
+${opened}${head}${setup}${definitions(sink, lowering)}return { head: '', body: ${renderMarkup(sink, lowering, SERVER_LANE)}, document: undefined }${closed}
 }`
 }