@abide/abide 0.102.0 → 0.103.0

package/src/compiler/emitComponent.ts

@@ -1,7 +1,9 @@
+import { SERVER_SPECIFIER } from '#shared/SPECIFIERS.ts'
 import { type CheckerAnswer, UNCHECKED } from './CheckerAnswer.ts'
 import { Cursor, placeTemplate } from './Cursor.ts'
 import { type LoweredChunk, Lowering, PROPS } from './Lowering.ts'
 import type { AbideFile } from './parseAbide.ts'
+import { privateExports } from './projectShadow.ts'
 import {
     concat,
     definitions,
@@ -11,7 +13,6 @@ import {
     renderMarkup,
     SERVER_LANE,
 } from './renderMarkup.ts'
-import { SERVER_SPECIFIER } from './SPECIFIERS.ts'
 import { insideShare, SETTLED_AT, shareScope } from './shareScope.ts'
 import { splitImports, withoutProps } from './splitImports.ts'
 import type { TemplateNode } from './TemplateNode.ts'
@@ -43,8 +44,8 @@ export function emitComponent(
     file: AbideFile,
     answer: CheckerAnswer = UNCHECKED,
     settles = false,
-    /** The route a `<script server>` files its hooks at (37.1), where the file is under one. */
-    route?: string,
+    /** The route a `<script server>` files its hooks at (37.1). */
+    route = '/',
     /** 38.97 — where given, every chunk the module is written around (`sourceMapOf`). */
     chunks?: LoweredChunk[],
 ): string {
@@ -75,21 +76,20 @@ export function emitComponent(
     // 31.1 and 31.4 hold INSIDE a `.abide` file, not just in its template, so the script block is
     // lowered with the same rewrite the slots get.
     //
-    // 34.2 — A `<script module>` IS MODULE SCOPE, here as in the browser, so what it exports is the
-    // module's (34.17). What must stay per request is a `reactive`, which is by 11.32 wherever it
-    // is declared.
+    // 34.2 — A `<script module>` IS MODULE SCOPE, here as in the browser. What must stay per request
+    // is a `reactive`, which is by 11.32 wherever it is declared.
     const moduleSetup = splitImports(lowering.modules())
-    // 34.20 — A `<script server>` IS MODULE SCOPE ON THIS SIDE ALONE, run between two calls that
+    // 34.19 — A `<script server>` IS MODULE SCOPE ON THIS SIDE ALONE, run between two calls that
     // file every hook it makes at the file's route (37.1). Its body cannot await at its top level
     // (34.3), so nothing else runs inside the window.
     const serverSetup = splitImports(lowering.servers(), 'source')
     const serverBody =
         serverSetup.body === ''
             ? ''
-            : `${lowering.use('fileRoute')}(${JSON.stringify(route ?? '/')})
+            : `${lowering.use('fileRoute')}(${JSON.stringify(route)})
 ${serverSetup.body}
 ${lowering.use('fileRoute')}(undefined)
-`
+${privateExports(file.servers.join('\n'))}`
     const setup = splitImports(lowering.scripts())
     const componentBody = setup.body
 

package/src/compiler/emitSource.ts

@@ -1,5 +1,5 @@
 import { STYLE_QUERY } from '#server/MODULE_QUERIES.ts'
-import { fileKind, placeOf, routeOf } from '#shared/routePattern.ts'
+import { fileKind, scopeOf } from '#shared/routePattern.ts'
 import type { CheckerAnswer } from './CheckerAnswer.ts'
 import { emitClient } from './emitClient.ts'
 import { emitComponent } from './emitComponent.ts'
@@ -27,8 +27,8 @@ export function emitSource(
     answer: CheckerAnswer,
     invoked: boolean,
     /**
-     * 34.23 — what the browser's module exports in place of the server block: the wrapper of each
-     * handler it declares, under the handler's name (`standInsOf`).
+     * 16.28 — what the browser's module binds in place of the server block: the wrapper of each
+     * private handler it declares, under the handler's name (`standInsOf`).
      */
     standIns = '',
     /** 38.97 — the `.abide`'s text, where the build wants each module's source map. */
@@ -46,7 +46,6 @@ export function emitSource(
     transitions: boolean
 } {
     const kind = fileKind(position)
-    const routed = placeOf(position) === 'address'
     // 34.4 — A COMPONENT WITH STYLES: its elements carry its token, and the styles, scoped,
     // are a stylesheet its client module imports — which the bundle collects into the
     // stylesheet the document links (38.23).
@@ -108,7 +107,7 @@ export function emitSource(
         file,
         answer,
         kind !== 'component',
-        routed ? routeOf(position) : undefined,
+        scopeOf(position),
         serverChunks,
     )
     const name = relative.slice(relative.lastIndexOf('/') + 1)
@@ -174,10 +173,7 @@ type Mapped = {
 // only where all three texts match, so two apps in one process sharing a path cannot cross.
 const MAPPED = new Map<string, Mapped>()
 
-/**
- * The browser's module with each handler's wrapper after it, or the wrappers alone where it had
- * nothing else to carry: a file a page imports for its handlers is imported all the same.
- */
+/** The browser's module with each private handler's wrapper after it. */
 function withStandIns(client: string, standIns: string): string {
     if (standIns === '') return client
     return client === '' ? standIns : `${client}\n${standIns}`

package/src/compiler/handlersUnder.ts

@@ -1,35 +1,50 @@
-// 16.2 AND 19.15 — EVERY HANDLER AN APP DECLARES, AND WHERE IT IS ANSWERED. A handler is an export
-// of a `<script server>` in a `.abide` of the app's own, and its address is that file's
-// route — its directory's (23.14) — and then the export's name. A directory's handlers may sit in as
-// many of its files as an author likes; two of them exporting one name is 19.1's refusal.
+// 16.2 AND 16.70 — EVERY HANDLER AN APP DECLARES, AND WHERE IT IS ANSWERED. A handler file's default
+// export answers at that file's route (23.14), and is the app's public surface; a handler a
+// `<script server>` declares is its file's alone, answered below `/__abide/handlers/` at the file's
+// path and its binding's name, and listed nowhere (16.71).
 //
-// READ, NOT RUN. The build finds handlers by what their blocks SAY rather than by importing them,
-// so a build never runs server code: a server block may open a database at import, and nothing
+// READ, NOT RUN. The build finds handlers by what their files SAY rather than by importing them,
+// so a build never runs server code: a handler file may open a database at import, and nothing
 // about building a browser bundle is a reason to. The checker the build already holds lists what
-// the file's projection exports and which call declares each (19.15) — which is also what makes an
-// export that is not a handler a refusal here rather than an address that silently never answers.
+// each module exports and which call declares each (16.73) — which is also what makes an export
+// that is not a handler a refusal here rather than an address that silently never answers.
 
 import type { Mount } from '#server/answerRpc.ts'
 import { refuseFrameworkRoute } from '#server/appTree.ts'
 import { surfaceName } from '#server/surfaceOf.ts'
-import { parseRoutePattern, placeOf, routeOf } from '#shared/routePattern.ts'
+import { PRIVATE_HANDLERS_ADDRESS } from '#shared/ADDRESSES.ts'
+import {
+    parseRoutePattern,
+    placeOf,
+    routeOf,
+    scopeOf,
+} from '#shared/routePattern.ts'
 import { declaredExports } from './declaredExports.ts'
 import type { AbideFile } from './parseAbide.ts'
+import { PRIVATE_EXPORT } from './projectShadow.ts'
 import type { Diagnosis, TypeSession } from './TypeSession.ts'
 
-/** A `.abide` the build read, by its path and its path below the app's root. */
-type Source = {
+/** A handler file, by its path and its path below the app's root. */
+export type HandlerFile = {
     path: string
     relative: string
     /** 23.19 — the path it answers by: its own, or the one its mount gives it. */
     position: string
-    file: AbideFile
 }
 
-const TRANSPILER = new Bun.Transpiler({ loader: 'ts' })
+/** A `.abide` the build read. */
+type Source = HandlerFile & { file: AbideFile }
 
-// 19.22 — as the transpiler prints it, one statement to a line; `export * as name` names its export.
-const STAR_EXPORT = /^export \* from /m
+/**
+ * Told of each thing the emit refuses, at the file below the root it names. The build's throws;
+ * `abide check` collects every one at its file (38.33).
+ */
+export type Refuse = (relative: string, thrown: unknown) => void
+
+/** The build's answer to a refusal: the first one stops it. */
+export const THROW: Refuse = (_relative, thrown) => {
+    throw thrown
+}
 
 /**
  * The app's handler mounts, with the warnings the build raised reading them.
@@ -40,64 +55,45 @@ const STAR_EXPORT = /^export \* from /m
 export async function handlersUnder(
     session: TypeSession,
     sources: readonly Source[],
+    files: readonly HandlerFile[],
+    refuse: Refuse = THROW,
 ): Promise<{ mounts: Mount[]; warnings: Diagnosis[] }> {
-    // 34.31 — a dependency's server block has no address of its own: what it declares is mounted
-    // where a file of the app's re-exports it, and as that file's.
     const serving: Source[] = []
-    for (const source of sources) {
-        if (source.file.servers.length === 0) continue
-        if (
-            STAR_EXPORT.test(
-                TRANSPILER.transformSync(source.file.servers.join('\n')),
-            )
-        )
-            throw new Error(
-                `abide: ${source.relative} re-exports with \`export *\` from its <script server>, whose names the build cannot read without running it. Name each handler it re-exports. RULEBOOK 19.22.`,
-            )
-        if (placeOf(source.position) !== 'dependency') serving.push(source)
-    }
-    const project = await session.project()
+    for (const source of sources)
+        if (source.file.servers.length > 0) serving.push(source)
+    const paths: string[] = []
+    for (const file of files) paths.push(file.path)
+    const project = await session.projectWith(paths)
+    for (const source of serving) paths.push(session.projectionOf(source.path))
     const declared =
-        project === undefined || serving.length === 0
+        project === undefined || paths.length === 0
             ? []
-            : await declaredExports(
-                  project,
-                  session.tsconfig,
-                  serving.map((source) => session.projectionOf(source.path)),
-              )
+            : await declaredExports(project, session.tsconfig, paths)
     const mounts: Mount[] = []
     const warnings: Diagnosis[] = []
     const names = new Map<string, string>()
-    for (let at = 0; at < serving.length; at += 1) {
-        const { relative, position, file } = serving[at] as Source
-        const route = routeOf(position)
-        // 19.15 — what THE SERVER BLOCK exports, out of everything the file's module does: its
-        // component and its `<script module>`'s names are the module's own.
-        const exported = new Set(
-            TRANSPILER.scan(file.servers.join('\n')).exports,
-        )
-        for (const {
-            name,
-            method,
-            ui,
-            cli,
-            mcp,
-            description,
-            copy,
-            defaults,
-            args,
-            unread,
-        } of declared[at] ?? []) {
-            if (!exported.has(name)) continue
-            if (method === undefined)
+    for (let at = 0; at < files.length; at += 1) {
+        const { relative, position } = files[at] as HandlerFile
+        try {
+            const address = routeOf(position)
+            const exported = declared[at] ?? []
+            const handler = exported.find((each) => each.name === 'default')
+            // 16.73 — the default and nothing else, declared by one of the five methods.
+            for (const each of exported)
+                if (each.name !== 'default' || each.method === undefined)
+                    throw new Error(
+                        each.name === 'default'
+                            ? `abide: ${relative}'s default export is not declared as a handler. A handler file's default is declared by abide's \`GET(…)\` (or POST, PUT, PATCH, DELETE); anything else belongs under a lib directory. RULEBOOK 16.73.`
+                            : `abide: ${relative} exports \`${each.name}\`, and a handler file exports its handler as its default and nothing else. Move \`${each.name}\` into a module under a lib or a server directory. RULEBOOK 16.73.`,
+                    )
+            if (handler?.method === undefined)
                 throw new Error(
-                    `abide: ${relative} exports \`${name}\` from its <script server>, which is not declared as a handler. A server block exports handlers alone, each declared by abide's \`GET(…)\` (or POST, PUT, PATCH, DELETE); anything else belongs in a module of its own. RULEBOOK 19.15.`,
+                    `abide: ${relative} is a handler file — a .ts directly in an address directory — and exports no handler as its default. Export one (\`export default GET(…)\`), or move the file into a lib directory. RULEBOOK 16.73, 23.22.`,
                 )
-            const address = `${route === '/' ? '' : route}/${name}`
             refuseFrameworkRoute(address, relative)
-            refuseUndeclaredParameters(address, args, relative, name)
+            refuseUndeclaredParameters(address, handler.args, relative)
             // 20.13 — one name per handler on every generated surface.
-            const surface = surfaceName(method, address)
+            const surface = surfaceName(handler.method, address)
             const named = names.get(surface)
             if (named !== undefined)
                 throw new Error(
@@ -106,23 +102,69 @@ export async function handlersUnder(
             names.set(surface, relative)
             mounts.push({
                 address,
-                method,
+                method: handler.method,
+                source: relative,
+                name: address.slice(address.lastIndexOf('/') + 1),
+                export: 'default',
+                scope: scopeOf(position),
+                private: false,
+                ui: handler.ui,
+                cli: handler.cli,
+                mcp: handler.mcp,
+                description: handler.description,
+                copy: handler.copy,
+                defaults: handler.defaults,
+                args: handler.args,
+            })
+            warnings.push(...handler.unread)
+        } catch (thrown) {
+            refuse(relative, thrown)
+        }
+    }
+    for (let at = 0; at < serving.length; at += 1) {
+        const { relative, position } = serving[at] as Source
+        // 34.24 — a dependency's file answers where a mount places it, and its handlers below the
+        // path it has there.
+        const below = placeOf(position) === 'dependency' ? relative : position
+        for (const each of declared[files.length + at] ?? []) {
+            if (each.method === undefined) continue
+            if (!each.name.startsWith(PRIVATE_EXPORT)) continue
+            const name = each.name.slice(PRIVATE_EXPORT.length)
+            mounts.push({
+                address: privateAddress(below, name),
+                method: each.method,
                 source: relative,
                 name,
-                ui,
-                cli,
-                mcp,
-                description,
-                copy,
-                defaults,
-                args,
+                export: each.name,
+                scope: scopeOf(position),
+                private: true,
+                ui: each.ui,
+                cli: false,
+                mcp: false,
+                description: each.description,
+                copy: each.copy,
+                defaults: each.defaults,
+                args: each.args,
             })
-            warnings.push(...unread)
+            warnings.push(...each.unread)
         }
     }
     return { mounts, warnings }
 }
 
+/**
+ * The address of the private handler `name` the `.abide` at `path` declares: below
+ * `PRIVATE_HANDLERS_ADDRESS`, the file's path without its extension, each segment's brackets and
+ * dots dropped so nothing in it reads as a parameter, then its name (16.70).
+ */
+export function privateAddress(path: string, name: string): string {
+    const segments: string[] = []
+    for (const segment of path.replace(/\.abide$/, '').split('/'))
+        if (segment !== '' && segment !== '..')
+            segments.push(segment.replace(/[[\].]/g, ''))
+    return `${PRIVATE_HANDLERS_ADDRESS}/${segments.join('/')}/${name}`
+}
+
 /**
  * Throws where a handler's `Args` does not declare a parameter its route carries.
  *
@@ -133,7 +175,6 @@ function refuseUndeclaredParameters(
     address: string,
     args: unknown,
     source: string,
-    exported: string,
 ): void {
     const schema = args as
         | {
@@ -153,7 +194,7 @@ function refuseUndeclaredParameters(
         )
             continue
         throw new Error(
-            `abide: ${source}'s \`${exported}\` answers at ${address}, and its args do not declare \`${segment.name}\`. RULEBOOK 16.67.`,
+            `abide: ${source} answers at ${address}, and its handler's args do not declare \`${segment.name}\`. RULEBOOK 16.67.`,
         )
     }
 }

package/src/compiler/hooksCalled.ts

@@ -0,0 +1,35 @@
+import { tokenize } from './tokenize.ts'
+
+/** Every hook abide exports, by name. */
+export const HOOK_NAMES: ReadonlySet<string> = new Set([
+    'middleware',
+    'onStart',
+    'onStop',
+    'onError',
+    'onConfig',
+    'onHealth',
+    'onPrincipal',
+    'onLauncher',
+    'onMenu',
+])
+
+/**
+ * Each of abide's hook names called in `source`, in the order written: the name, then `(`, and not
+ * a declaration — a member call included, since `server.onStart(…)` is abide's hook all the same.
+ * Read, not run — what `abide routes` lists and the build's refusals of a hook called where it is
+ * never read (38.107) go by.
+ */
+export function hooksCalled(source: string): string[] {
+    const called: string[] = []
+    let previous = ''
+    let named: string | undefined
+    for (const token of tokenize(source)) {
+        if (named !== undefined && token.text === '(') called.push(named)
+        named =
+            HOOK_NAMES.has(token.text) && previous !== 'function'
+                ? token.text
+                : undefined
+        previous = token.text
+    }
+    return called
+}

package/src/compiler/mountsOf.ts

@@ -1,16 +1,16 @@
-// 23.19 — A PACKAGE'S DIRECTORY, MOUNTED WHERE THE APP SAYS. `import 'kit/admin' with { type: 'routes' }`
-// in a file of the app's places every `.abide` under the package's `admin` directory at the importing
-// file's directory, so its pages, layouts, error pages and handlers answer below it — and the app,
-// not the package, decides where: the mount is a line in a file the app writes, at the position the
-// app gave it.
+// 23.19 — A PACKAGE'S DIRECTORY, MOUNTED WHERE THE APP SAYS.
+// `import 'kit/admin' with { type: 'routes' }` in a file of the app's places every `.abide` and
+// handler file under the package's `admin` directory at the importing file's directory, so its
+// pages, layouts, error pages and handlers answer below it — and the app, not the package, decides
+// where: the mount is a line in a file the app writes, at the position the app gave it.
 //
 // A FILE KEEPS ITS PATH AND GAINS A POSITION. It is compiled, served and keyed by where it lies, as
-// any dependency's is (34.27); its POSITION — the path it would have below the root — is what
+// any dependency's is (34.23); its POSITION — the path it would have below the root — is what
 // `placeOf`, `fileKind` and `routeOf` read, so a mounted page is a page by the same test as the app's.
 
 import { readFileSync, realpathSync, statSync } from 'node:fs' // bun exposes no sync read, stat or realpath of its own
 import { dirname, relative, resolve } from 'node:path' // bun exposes no path helpers of its own
-import { abideUnder } from '#server/appTree.ts'
+import { appFiles } from '#server/appTree.ts'
 import { placeOf } from '#shared/routePattern.ts'
 import { nearest } from './nearest.ts'
 import { type AbideFile, parseAbide, scriptBodies } from './parseAbide.ts'
@@ -19,11 +19,17 @@ import { attributedImports, IMPORT_ATTRIBUTES } from './splitImports.ts'
 /** A `.abide` on disk, and the position it takes in the app. */
 type Placed = { path: string; position: string }
 
-/** One directory a file mounts, and each `.abide` under it at the position it takes in the app. */
-export type Mounted = {
+/**
+ * One directory a file mounts, and each `.abide` and each handler file under it at the position it
+ * takes in the app.
+ */
+type DirectoryMount = {
     specifier: string
     directory: string
+    /** The position its files take below the root: the mounting file's directory, `/`-ended. */
+    at: string
     files: Placed[]
+    handlers: Placed[]
 }
 
 /**
@@ -38,8 +44,8 @@ export function mountsOf(
     path: string,
     position: string,
     file: AbideFile,
-): Mounted[] | string {
-    const mounts: Mounted[] = []
+): DirectoryMount[] | string {
+    const mounts: DirectoryMount[] = []
     const at = position.includes('/')
         ? `${position.slice(0, position.lastIndexOf('/'))}/`
         : ''
@@ -50,13 +56,19 @@ export function mountsOf(
                 return `abide: ${position} mounts ${specifier}, and no directory answers to it. RULEBOOK 23.19.`
             if (ownDirectory(root, directory))
                 return `abide: ${position} mounts ${specifier}, which is the app's own directory already. RULEBOOK 23.20.`
-            const files: Placed[] = []
-            for (const below of abideUnder(directory))
-                files.push({
-                    path: `${directory}/${below}`,
-                    position: `${at}${below}`,
-                })
-            mounts.push({ specifier, directory, files })
+            // The package's tree is the package's to refuse; a mount places what it finds.
+            const found = appFiles(directory, () => {})
+            const placed = (below: string): Placed => ({
+                path: `${directory}/${below}`,
+                position: `${at}${below}`,
+            })
+            mounts.push({
+                specifier,
+                directory,
+                at,
+                files: found.abide.map(placed),
+                handlers: found.handlers.map(placed),
+            })
         }
     return mounts
 }

package/src/compiler/parseAbide.ts

@@ -40,7 +40,7 @@ export type AbideFile = {
      */
     modules: string[]
     /**
-     * `<script server>` bodies in source order — 34.20, module scope on a server alone. Apart from
+     * `<script server>` bodies in source order — 34.19, module scope on a server alone. Apart from
      * `modules` because the browser's module never carries them.
      */
     servers: string[]
@@ -177,12 +177,12 @@ export function parseAbide(source: string): AbideFile {
             // 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
+            // 34.29 — 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.',
+                    '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.29.',
                 )
             const innermost = open[open.length - 1]
             if (typeof innermost === 'string' && sameTag(innermost, closing)) {
@@ -880,10 +880,10 @@ 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, 34.2 the bare `module` attribute and 34.20 the bare `server` one; anything
+ * 34.1 is the bare tag, 34.2 the bare `module` attribute and 34.19 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 — save beside `server`, which 34.33 refuses.
+ * out of the markup and throws its attributes away — save beside `server`, which 34.28 refuses.
  *
  * 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
@@ -911,16 +911,16 @@ function scriptBlock(
             )
         else if (attribute.lowerName !== 'generics') markup = true
     }
-    // 34.33 — a `server` attribute on a tag that would be markup ships the server's source to the
+    // 34.28 — 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.',
+            'abide: a <script> carrying `server` is a server block, written `<script server>` with nothing beside it. RULEBOOK 34.28.',
         )
     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.',
+            'abide: a <script> is `module` or `server`, not both — a server block is module scope already. RULEBOOK 34.19.',
         )
     return server ? servers : module ? modules : scripts
 }
@@ -948,16 +948,16 @@ function rawBody(
     if (tag.selfClosing) return { body: '', end: tag.end }
     // 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).
+    // is refused where the template meets it (34.29).
     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
+    // 34.30 — 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.29 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.',
+            '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.30.',
         )
     return { body: source.slice(tag.end, close.start), end: close.end }
 }