npm - @abide/abide - Versions diffs - 0.100.0 → 0.102.0 - Mend

@abide/abide 0.100.0 → 0.102.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (160) hide show

package/CHANGELOG.md +31 -0
package/bin/abide.ts +227 -163
package/docs/REGISTRY.md +726 -0
package/docs/RULEBOOK.md +2753 -0
package/docs/abide.md +12878 -0
package/package.json +10 -3
package/scaffold/AGENTS.md +31 -0
package/scaffold/CLAUDE.md +1 -0
package/scaffold/src/layout.abide +18 -0
package/src/compiler/Lowering.ts +78 -9
package/src/compiler/ShadowMap.ts +2 -2
package/src/compiler/TypeSession.ts +262 -67
package/src/compiler/argsSchemaOf.ts +1 -1
package/src/compiler/checkApp.ts +43 -15
package/src/compiler/checkedShadow.ts +39 -5
package/src/compiler/classifyRead.ts +6 -4
package/src/compiler/classifyTemplate.ts +1 -1
package/src/compiler/compileApp.ts +433 -193
package/src/compiler/compiledEntry.ts +43 -39
package/src/compiler/componentGraph.ts +58 -71
package/src/compiler/declaredExports.ts +24 -7
package/src/compiler/emitClient.ts +141 -71
package/src/compiler/emitComponent.ts +37 -8
package/src/compiler/emitSource.ts +106 -13
package/src/compiler/handlersUnder.ts +106 -56
package/src/compiler/index.ts +7 -0
package/src/compiler/mountsOf.ts +138 -0
package/src/compiler/nearest.ts +14 -0
package/src/compiler/parseAbide.ts +157 -20
package/src/compiler/projectShadow.ts +213 -7
package/src/compiler/reactiveTypes.ts +20 -7
package/src/compiler/readSources.ts +15 -2
package/src/compiler/readsIn.ts +61 -7
package/src/compiler/renderMarkup.ts +3 -3
package/src/compiler/scaffold.ts +30 -11
package/src/compiler/serveLanguage.ts +125 -34
package/src/compiler/sourceMapOf.ts +193 -0
package/src/compiler/splitImports.ts +205 -83
package/src/compiler/syncTypes.ts +32 -0
package/src/compiler/tokenize.ts +14 -0
package/src/compiler/writeDefaultProject.ts +1 -1
package/src/compiler/writeTypes.ts +82 -0
package/src/server/CLIENT_BUILD.ts +11 -13
package/src/server/DEFAULT_PORT.ts +1 -1
package/src/server/LAUNCHER_FILES.ts +9 -0
package/src/server/MODULE_QUERIES.ts +18 -0
package/src/server/TABLES.ts +7 -0
package/src/server/VIRTUAL_DIRECTORY.ts +4 -5
package/src/server/abideModules.ts +391 -0
package/src/server/answerFailure.ts +16 -6
package/src/server/answerRequest.ts +235 -106
package/src/server/answerRpc.ts +124 -39
package/src/server/answerSocket.ts +141 -48
package/src/server/answerValue.ts +22 -9
package/src/server/appDirectories.ts +1 -1
package/src/server/appPlugins.ts +1 -1
package/src/server/appTree.ts +179 -0
package/src/server/argsFor.ts +2 -2
package/src/server/assistant.ts +2 -2
package/src/server/bridgeRelay.ts +6 -8
package/src/server/claudeCode.ts +0 -6
package/src/server/clientBuildOptions.ts +8 -3
package/src/server/coerceArgs.ts +1 -1
package/src/server/commands.ts +37 -37
package/src/server/componentModules.d.ts +3 -1
package/src/server/compressAnswer.ts +48 -14
package/src/server/config.ts +25 -29
package/src/server/configFields.ts +31 -25
package/src/server/createApp.ts +59 -73
package/src/server/devWorker.ts +144 -183
package/src/server/executableName.ts +4 -0
package/src/server/fenceServer.ts +37 -35
package/src/server/generatedSurfaces.ts +99 -66
package/src/server/hooks.ts +124 -52
package/src/server/iconAccent.ts +191 -0
package/src/server/index.ts +11 -7
package/src/server/installSourceMaps.ts +88 -0
package/src/server/launcherOptions.ts +34 -31
package/src/server/launcherPage.ts +107 -64
package/src/server/manifestOf.ts +16 -13
package/src/server/namesUnder.ts +2 -2
package/src/server/nativeMenu.ts +5 -5
package/src/server/negotiateEncoding.ts +1 -1
package/src/server/principal.ts +10 -5
package/src/server/realOrAsGiven.ts +10 -0
package/src/server/refuseAddressCollision.ts +21 -14
package/src/server/remote.ts +49 -52
package/src/server/render.ts +65 -94
package/src/server/renderComponent.ts +5 -0
package/src/server/reportHealth.ts +2 -2
package/src/server/requestScope.ts +12 -1
package/src/server/runBuild.ts +24 -0
package/src/server/runCompiled.ts +5 -5
package/src/server/runDesktop.ts +52 -27
package/src/server/serveBuild.ts +43 -52
package/src/server/serveDev.ts +81 -39
package/src/server/shell.ts +7 -22
package/src/server/sourceMappings.ts +139 -0
package/src/server/surfaceOf.ts +18 -3
package/src/server/testBuild.ts +1 -19
package/src/server/withAbideSources.ts +117 -0
package/src/shared/ADDRESSES.ts +7 -18
package/src/shared/APP_META.ts +7 -0
package/src/shared/CopyOptions.ts +1 -1
package/src/shared/DEBUG_META.ts +1 -1
package/src/shared/GLOBAL_GETS.ts +9 -3
package/src/shared/RESERVED_DIRECTORIES.ts +15 -0
package/src/shared/RPC_SERVER.ts +2 -2
package/src/shared/cookies.ts +2 -2
package/src/shared/csp.ts +1 -1
package/src/shared/escapeText.ts +1 -1
package/src/shared/filledPath.ts +85 -0
package/src/shared/framing.ts +79 -6
package/src/shared/headKeyOf.ts +2 -0
package/src/shared/index.ts +1 -1
package/src/shared/log.ts +27 -13
package/src/shared/matchRoute.ts +23 -4
package/src/shared/menuItem.ts +3 -3
package/src/shared/reactive/Cursor.ts +3 -9
package/src/shared/reactive/Keyed.ts +4 -3
package/src/shared/reactive/NotLanded.ts +1 -1
package/src/shared/reactive/Reactive.ts +81 -60
package/src/shared/reactive/argsContract.ts +4 -4
package/src/shared/reactive/canonicalKey.ts +4 -4
package/src/shared/reactive/chunksOfStream.ts +6 -0
package/src/shared/reactive/index.ts +1 -1
package/src/shared/reactive/recordWrites.ts +103 -5
package/src/shared/reactive/structural.ts +1 -1
package/src/shared/reactive/tracking.ts +155 -21
package/src/shared/reactive/watch.ts +10 -6
package/src/shared/refuse.ts +1 -1
package/src/shared/routePattern.ts +82 -46
package/src/shared/rpc.ts +47 -13
package/src/shared/rpcRequest.ts +27 -3
package/src/shared/url.ts +4 -44
package/src/shared/writePath.ts +1 -1
package/src/ui/LAYER_NAMES.ts +1 -1
package/src/ui/List.ts +3 -3
package/src/ui/MOUNTING_LEVEL.ts +18 -0
package/src/ui/Mismatch.ts +1 -1
package/src/ui/RawRun.ts +1 -1
package/src/ui/Router.ts +38 -31
package/src/ui/Scope.ts +1 -1
package/src/ui/TryRegion.ts +2 -2
package/src/ui/applyHead.ts +33 -0
package/src/ui/index.ts +1 -1
package/src/ui/menuBridge.ts +1 -1
package/src/ui/moveNode.ts +1 -1
package/src/ui/reconcile.ts +2 -2
package/src/ui/reportMenu.ts +2 -2
package/src/ui/routing.ts +2 -2
package/src/ui/setAttribute.ts +1 -1
package/src/ui/setText.ts +1 -1
package/src/ui/socketWire.ts +9 -7
package/src/ui/wire.ts +1 -1
package/scaffold/src/server/app.ts +0 -6
package/scaffold/src/shared/.gitkeep +0 -0
package/scaffold/src/ui/app.html +0 -8
package/src/server/componentImports.ts +0 -56
/package/scaffold/src/{ui/pages/page.abide → page.abide} +0 -0

package/src/compiler/parseAbide.ts CHANGED Viewed

@@ -8,6 +8,7 @@ import {
     type Attribute,
     type Branch,
     bodiesOf,
+    type ElementNode,
     type ForBlock,
     type InlineComponent,
     type Setup,
@@ -18,6 +19,7 @@ import {
     nesting,
     skipQuoted,
     slotEnd,
+    startsToken,
     type Token,
     tokenize,
 } from './tokenize.ts'
@@ -37,6 +39,11 @@ export type AbideFile = {
      * `scripts` because the two run a different number of times, which is the whole of the clause.
      */
     modules: string[]
+    /**
+     * `<script server>` bodies in source order — 34.20, module scope on a server alone. Apart from
+     * `modules` because the browser's module never carries them.
+     */
+    servers: string[]
     /**
      * `<style>` bodies in source order, outside any block body — each scoped to the component (34.4). A
      * body's own is on its block (34.11).
@@ -47,6 +54,12 @@ export type AbideFile = {
      * template here so no walk over the body steps around it. In tree order, which is 39.5.
      */
     head: TemplateNode[]
+    /**
+     * 35.15 — the document's `<html>` and `<body>`, where the file is written inside them: each with
+     * its attributes and none of its children, which are the head and the template. `undefined`
+     * where the template is not.
+     */
+    document: { html: ElementNode; body: ElementNode } | undefined
     template: TemplateNode[]
     /** 32.43 — the inline components the template's own body declares, in source order. */
     components: InlineComponent[]
@@ -68,11 +81,19 @@ export type AbideFile = {
     origins: Origins
 }
+/** Every script body a file holds — module, server and per-instance — for a walk over its imports. */
+export function scriptBodies(file: AbideFile): string[] {
+    return [...file.modules, ...file.servers, ...file.scripts]
+}
 type Origins = {
     modules: number[]
+    servers: number[]
     scripts: number[]
     holders: Map<object, number>
     keys: Map<object, number>
+    /** 38.39 — per `{#for}` block, where its item and its index start (`-1` where it has none). */
+    bindings: Map<object, { item: number; index: number }>
 }
 /**
@@ -111,13 +132,16 @@ function unwindTo(
 export function parseAbide(source: string): AbideFile {
     const scripts: string[] = []
     const modules: string[] = []
+    const servers: string[] = []
     const styles: string[] = []
     let generics: string | undefined
     const origins: Origins = {
         modules: [],
+        servers: [],
         scripts: [],
         holders: new Map(),
         keys: new Map(),
+        bindings: new Map(),
     }
     const root: TemplateNode[] = []
     // The open elements, innermost last. `root` is the floor and is never popped.
@@ -152,11 +176,16 @@ export function parseAbide(source: string): AbideFile {
             // the div — while the browser re-parsing that markup closes at `</DIV>`, so every
             // position the client walks to after it is a different node and the page hydrates
             // against the wrong tree.
+            const closing = source.slice(at + 2, close).trim()
+            // 34.34 — a `<script>` is raw text whose body takes its close tag with it, so one met
+            // here is what is left of a block that ended early: a `</script>` in a comment or a
+            // string in it, and the source after it would be rendered as the page.
+            if (sameTag(closing, 'script'))
+                throw new Error(
+                    'abide: a </script> that closes no <script> — a block ends at the first `</script>` in it, even one in a comment or a string. Write it `<\\/script>` there. RULEBOOK 34.34.',
+                )
             const innermost = open[open.length - 1]
-            if (
-                typeof innermost === 'string' &&
-                sameTag(innermost, source.slice(at + 2, close).trim())
-            ) {
+            if (typeof innermost === 'string' && sameTag(innermost, closing)) {
                 stack.pop()
                 open.pop()
             }
@@ -213,7 +242,7 @@ export function parseAbide(source: string): AbideFile {
                 lowerTag === 'style'
                     ? styles
                     : lowerTag === 'script'
-                      ? scriptBlock(tag.attributes, scripts, modules)
+                      ? scriptBlock(tag.attributes, scripts, modules, servers)
                       : undefined
             const declared =
                 block === undefined || block === styles
@@ -224,7 +253,7 @@ export function parseAbide(source: string): AbideFile {
                 // setup have no call to be generic over.
                 if (block !== scripts || blocks.length > 0)
                     throw new Error(
-                        'abide: generics="…" belongs on the component\'s own <script>, and this one is a <script module> or a block body\'s. RULEBOOK 34.13.',
+                        'abide: generics="…" belongs on the component\'s own <script>, and this one is a <script module>, a <script server> or a block body\'s. RULEBOOK 34.13.',
                     )
                 if (generics !== undefined)
                     throw new Error(
@@ -233,7 +262,12 @@ export function parseAbide(source: string): AbideFile {
                 generics = declared
             }
             if (lowerTag === 'script' || lowerTag === 'style') {
-                const raw = rawBody(source, lowerTag, tag)
+                const raw = rawBody(
+                    source,
+                    lowerTag,
+                    tag,
+                    block !== undefined && block !== styles,
+                )
                 // 14.8 — A `<script>` INSIDE A BLOCK IS THAT BODY'S, set up once each time the body is
                 // built, and not the component's: lifted, it ran once for the page and a row's own
                 // names (`{#for item …}`) were not in scope.
@@ -272,6 +306,7 @@ export function parseAbide(source: string): AbideFile {
                 if (block !== undefined) {
                     if (block === scripts) origins.scripts.push(tag.end)
                     else if (block === modules) origins.modules.push(tag.end)
+                    else if (block === servers) origins.servers.push(tag.end)
                     block.push(raw.body)
                     at = raw.end
                     continue
@@ -508,11 +543,16 @@ export function parseAbide(source: string): AbideFile {
     }
     const components = fileComponents(root, declared)
-    refuseImported(components, [...modules, ...scripts])
+    refuseImported(components, [...modules, ...servers, ...scripts])
     collapseWhitespace(root)
     const head: TemplateNode[] = []
     const template: TemplateNode[] = []
+    let document: AbideFile['document']
     for (const node of root) {
+        if (node.kind === 'element' && node.lowerTag === 'html') {
+            document = documentOf(node, head, template)
+            continue
+        }
         if (node.kind === 'element' && node.lowerTag === 'head') {
             assertNoNestedHead(node.children, '<head>')
             for (const child of node.children) head.push(child)
@@ -521,11 +561,23 @@ export function parseAbide(source: string): AbideFile {
         assertNoNestedHead([node], '')
         template.push(node)
     }
+    // 35.16 — the document is written once, around everything else.
+    if (document !== undefined)
+        for (const node of root)
+            if (
+                !(node.kind === 'element' && node.lowerTag === 'html') &&
+                !(node.kind === 'text' && node.text.trim() === '')
+            )
+                throw new Error(
+                    `abide: ${node.kind === 'element' ? `<${node.tag}>` : 'markup'} stands beside <html>, and a file written inside <html> has nothing outside it. RULEBOOK 35.16.`,
+                )
     return {
         scripts,
         modules,
+        servers,
         styles,
         head,
+        document,
         template,
         components,
         generics,
@@ -578,7 +630,7 @@ function inlineComponent(header: {
     }
     if (close !== tokens.length - 1)
         throw new Error(
-            `abide: {#component ${header.text}} is not a name and one parenthesised props pattern. Write {#component ${name.text}(props)}. RULEBOOK 32.39.`,
+            `abide: {#component ${header.text}} is not a name and one parenthesized props pattern. Write {#component ${name.text}(props)}. RULEBOOK 32.39.`,
         )
     const inside = (from: number, to: number): { text: string; at: number } =>
         trimmed(header.text, from, to)
@@ -695,6 +747,43 @@ function refuseImported(components: InlineComponent[], blocks: string[]): void {
                     )
 }
+/**
+ * 35.15 — the `<html>` a file is written inside: its `<head>`'s children added to `head`, its
+ * `<body>`'s to `template`, and the two elements handed back with their attributes alone.
+ */
+function documentOf(
+    html: ElementNode,
+    head: TemplateNode[],
+    template: TemplateNode[],
+): { html: ElementNode; body: ElementNode } {
+    let body: ElementNode | undefined
+    for (const child of html.children) {
+        if (child.kind === 'text' && child.text.trim() === '') continue
+        if (child.kind === 'element' && child.lowerTag === 'head') {
+            assertNoNestedHead(child.children, '<head>')
+            for (const node of child.children) head.push(node)
+            continue
+        }
+        if (child.kind === 'element' && child.lowerTag === 'body' && !body) {
+            body = child
+            assertNoNestedHead(child.children, '<body>')
+            for (const node of child.children) template.push(node)
+            continue
+        }
+        throw new Error(
+            `abide: <html> holds a <head> and a <body> and nothing else, and this one holds ${child.kind === 'element' ? `<${child.tag}>` : 'more'}. RULEBOOK 35.16.`,
+        )
+    }
+    if (body === undefined)
+        throw new Error(
+            'abide: <html> holds no <body>, so the page has nowhere to go. RULEBOOK 35.16.',
+        )
+    // The elements themselves, emptied, so where each attribute was written is still known.
+    html.children = []
+    body.children = []
+    return { html, body }
+}
 /**
  * Throws where a `<head>` stands anywhere but the top level of the file.
  *
@@ -712,6 +801,14 @@ function assertNoNestedHead(nodes: TemplateNode[], within: string): void {
             throw new Error(
                 `abide: a <head> must be top level in a .abide file, and this one is inside ${within}. RULEBOOK 39.2.`,
             )
+        // 35.16 — the document's own elements are written once, at the top, around the rest.
+        if (
+            node.kind === 'element' &&
+            (node.lowerTag === 'html' || node.lowerTag === 'body')
+        )
+            throw new Error(
+                `abide: <${node.tag}> ${within === '' ? 'stands among the markup' : `is inside ${within}`}, and the document's <html> and <body> are written once, at the top of the root layout.abide. RULEBOOK 35.16.`,
+            )
         const label =
             node.kind === 'element'
                 ? `<${node.tag}>`
@@ -783,29 +880,49 @@ function sameTag(left: string, right: string): boolean {
 /**
  * The list a `<script>`'s body belongs in, or `undefined` where it is markup.
  *
- * 34.1 is the bare tag and 34.2 is the bare `module` attribute; anything else on the tag — `src`, `type`, `defer`, `nonce` —
+ * 34.1 is the bare tag, 34.2 the bare `module` attribute and 34.20 the bare `server` one; anything
+ * else on the tag — `src`, `type`, `defer`, `nonce` —
  * is a `<script>` the author wrote for the DOCUMENT, and lifting it into component setup moves it
- * out of the markup and throws its attributes away.
+ * out of the markup and throws its attributes away — save beside `server`, which 34.33 refuses.
  *
- * 34.12, 34.13 — BUT `lang="ts"` AND `generics="…"` ARE THE COMPONENT'S. Every block is TypeScript,
- * so `lang="ts"` says nothing, and an editor's convention read as markup took the author's whole
- * setup out of the component without a word.
+ * 34.13 — BUT `generics="…"` IS THE COMPONENT'S. 34.12 — `lang` is refused on any `<script>`: every
+ * block is TypeScript, so it says nothing, and read as markup it took the author's whole setup out of
+ * the component without a word.
  */
 function scriptBlock(
     attributes: Attribute[],
     scripts: string[],
     modules: string[],
+    servers: string[],
 ): string[] | undefined {
     let module = false
+    let server = false
+    let markup = false
     for (const attribute of attributes) {
         // `<script module>` carries the marker and no value. `module="x"` names something else.
         if (attribute.lowerName === 'module' && attribute.value === '')
             module = true
-        else if (attribute.lowerName === 'lang' && attribute.value === 'ts')
-            continue
-        else if (attribute.lowerName !== 'generics') return undefined
+        else if (attribute.lowerName === 'server') {
+            server = true
+            if (attribute.value !== '') markup = true
+        } else if (attribute.lowerName === 'lang')
+            throw new Error(
+                'abide: every <script> in a .abide file is TypeScript, so `lang` says nothing — remove it. RULEBOOK 34.12.',
+            )
+        else if (attribute.lowerName !== 'generics') markup = true
     }
-    return module ? modules : scripts
+    // 34.33 — a `server` attribute on a tag that would be markup ships the server's source to the
+    // document and the browser's module, so it is refused rather than demoted.
+    if (server && markup)
+        throw new Error(
+            'abide: a <script> carrying `server` is a server block, written `<script server>` with nothing beside it. RULEBOOK 34.33.',
+        )
+    if (markup) return undefined
+    if (module && server)
+        throw new Error(
+            'abide: a <script> is `module` or `server`, not both — a server block is module scope already. RULEBOOK 34.20.',
+        )
+    return server ? servers : module ? modules : scripts
 }
 /**
@@ -826,13 +943,22 @@ function rawBody(
     source: string,
     lowerTag: string,
     tag: { selfClosing: boolean; end: number },
+    code: boolean,
 ): { body: string; end: number } {
     if (tag.selfClosing) return { body: '', end: tag.end }
-    // The body ends at the first literal close tag, so a `</script>` inside a string in a script
-    // block ends it early — the case is real and is not handled yet.
+    // The body ends at the first literal close tag, as a browser's does, so a `</script>` inside
+    // a string or a comment in a script block ends it early — and the real close tag after it
+    // is refused where the template meets it (34.34).
     const close = closeTagAt(source, lowerTag, tag.end)
     if (close === null)
         return { body: source.slice(tag.end), end: source.length }
+    // 34.35 — a component block's early end is refused AT the early end, because what is left
+    // over can open a `<script>` of its own that takes the real close tag, and then 34.34 meets
+    // nothing to refuse while the block's source between them renders as the page.
+    if (code && !startsToken(source, tag.end, close.start))
+        throw new Error(
+            'abide: a </script> inside a string, a comment or a regex ends the <script> block there, as a browser would. Write it `<\\/script>`. RULEBOOK 34.35.',
+        )
     return { body: source.slice(tag.end, close.start), end: close.end }
 }
@@ -1005,9 +1131,20 @@ function forBlock(
     }
     origins.holders.set(block, subject.at)
     if (key.text !== '') origins.keys.set(block, key.at)
+    origins.bindings.set(block, {
+        item: header.at + leadingSpace(source),
+        index:
+            comma === undefined
+                ? -1
+                : header.at + comma.end + leadingSpace(source.slice(comma.end)),
+    })
     return block
 }
+function leadingSpace(text: string): number {
+    return text.length - text.trimStart().length
+}
 function readTag(
     source: string,
     open: number,

package/src/compiler/projectShadow.ts CHANGED Viewed

@@ -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,
@@ -37,6 +45,8 @@ export type Span = { start: number; end: number }
 export type Projection = {
     text: string
     modules: Span
+    /** 34.20 — 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.26 — 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.26 — 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.25 — 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.26 — 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.26 — 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 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)
+    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
@@ -410,11 +569,14 @@ function project(file: AbideFile): Projection {
     // 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>')
+    refuseTopLevelAwait(file.servers.join('\n'), '<script server>')
     refuseTopLevelAwait(scriptsText, '<script>')
     refuseInstanceExport(scriptsText)
+    refuseServerDefault(file.servers.join('\n'))
     return {
         text,
         modules,
+        servers,
         scripts,
         positions: new PositionTable(positions),
         slots,
@@ -573,6 +735,50 @@ function refuseInstanceExport(source: string): void {
     }
 }
+/**
+ * 34.22 — a `<script server>` exporting `default`, refused: the module's default is its component,
+ * and a handler is addressed by its name (16.2).
+ */
+/**
+ * 34.26 — 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.26.`,
+        )
+}
+function refuseServerDefault(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
+        // `export { x as default }` names it too.
+        else if (
+            text === 'default' &&
+            ((depth === 0 && previous === EXPORT) ||
+                (depth === 1 && previous === 'as'))
+        )
+            throw new Error(
+                "abide: a <script server> cannot export `default` — the module's default is its component. Export the handler under a name; the name is its address's last segment. RULEBOOK 34.22.",
+            )
+        previous = text
+    }
+}
 /**
  * 34.13 — each type parameter a component declares, as a type its body cannot see inside.
  *