@abide/abide 0.103.0 → 0.104.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @abide/abide
 
+## 0.104.0
+
+### Minor Changes
+
+- c95d974: Breaking: for await over a reactive is one run ([`0013bd0`](https://github.com/briancray/abide/commit/0013bd0a279bc73cbd5d5db3f4424bd2a2418fac))
+- c95d974: Breaking: mcp publishes every handler as a tool ([`a983075`](https://github.com/briancray/abide/commit/a98307582cc388f38c3d2377e176f74fe41b63da))
+- c95d974: Breaking: a hook called outside a .abide or a handler file is a build error (37.13) ([`c03e97c`](https://github.com/briancray/abide/commit/c03e97c05d27db709ecb02ad06a53574b1c98ee5))
+- c95d974: a server directory nests under lib or tests (23.16) ([`f928540`](https://github.com/briancray/abide/commit/f928540ecbe57af94c780a2b73c7109ef87faa52))
+
+### Patch Changes
+
+- c95d974: every spelling of a handler file import is the face the server mounts (16.2) ([`1e2e721`](https://github.com/briancray/abide/commit/1e2e72171950f7b3d0144fbe12b4e6d35c226fbd))
+
 ## 0.103.0
 
 ### Minor Changes

package/docs/REGISTRY.md

@@ -93,7 +93,7 @@ type Gated<Gate, Accepted> = [Schema<Accepted>] extends [Gate] ? never : Failed<
 | `identity` | `(next: Stored, previous: Stored) => unknown` | What makes it the same value. | 5.1, 5.2, 5.3, 5.4, 5.5, 9.3, 11.17, 18.4 |
 | `structural` | `(next: unknown, previous: unknown) => boolean` | The by-value comparator an app declares on `identity`. | 5.4, 5.5, 18.4 |
 | `by` | `(keyof Element & string) \| ((element: Element) => unknown)`, over the `Element` a `Stored` array holds | What tells one element of the value from another. | 5.22, 18.4, 18.15, 32.32 |
-| `ttl` | `number` | The life of a production, or of a keyed entry. | 6.1, 6.2, 6.3, 6.4, 6.5, 6.6, 6.7, 6.8, 6.9, 6.11, 11.6, 11.35, 11.45, 11.48, 11.49, 11.69 |
+| `ttl` | `number` | The life of a production, or of a keyed entry. | 6.1, 6.2, 6.3, 6.4, 6.5, 6.6, 6.7, 6.8, 6.9, 6.10, 11.6, 11.35, 11.45, 11.48, 11.49, 11.69 |
 | `args` | `Schema<Args>` | The gate on a keyed value's args. | 9.4, 11.28, 11.30, 11.40, 11.41, 11.56, 11.60, 11.68 |
 | `global` | `boolean` | Opts out of the default scope into one cache shared by every caller in the process. | 11.34, 11.35, 11.36, 11.37, 11.38, 11.39, 11.53, 11.67 |
 | `tags` | `string[] \| ((args: Args) => string[])` | What a `Selection` matches on. | 11.43, 11.44, 18.4, 18.15 |
@@ -111,8 +111,8 @@ type Gated<Gate, Accepted> = [Schema<Accepted>] extends [Gate] ? never : Failed<
 | `s.then` | `<Result>(onSettled?: (value: Stored) => Result \| PromiseLike<Result>, onFailed?: (error: unknown) => Result \| PromiseLike<Result>) => Promise<Result>` | The settling, as a promise. | 1.4, 2.7, 2.8 |
 | `s.catch` | `<Result>(onFailed: (error: unknown) => Result \| PromiseLike<Result>) => Promise<Stored \| Result>` | The settling's refusal path. | 1.4, 1.5 |
 | `s.finally` | `(onSettled: () => void) => Promise<Stored>` | The settling's end, whichever way it went. | 1.4, 1.5 |
-| `for await (… of s)` | `AsyncIterable<Produced>` | The live cursor face of a read. | 2.5, 2.6, 5.10, 6.10, 9.12 |
-| `s[Symbol.asyncIterator]` | `() => AsyncIterator<Produced>` | The production in flight, and then what follows it. | 2.5, 6.10 |
+| `for await (… of s)` | `AsyncIterable<Produced>` | What one run produced: the settled value once, or a stream's chunks. | 2.5, 2.6, 5.10, 9.12, 9.15, 9.16 |
+| `s[Symbol.asyncIterator]` | `() => AsyncIterator<Produced>` | The run being served, from its start to its end. | 2.5, 2.6 |
 
 ### Writes
 
@@ -671,13 +671,13 @@ type Gated<Gate, Accepted> = [Schema<Accepted>] extends [Gate] ? never : Failed<
 
 | Name | Signature | Meaning | Rules |
 | --- | --- | --- | --- |
-| `middleware` | `(...rungs: Middleware<{ request: Request }, Response>[]) => () => void` | The per-request lane at the calling file's route. | 18.26, 37.2, 37.3 |
-| `onStart` | `(fn: (start: () => Promise<void>) => void \| Promise<void>) => () => void` | Wraps the boot. | 37.4, 37.6 |
-| `onStop` | `(fn: (stop: () => Promise<void>) => void \| Promise<void>) => () => void` | Mirrors it for teardown. | 37.4, 37.6 |
-| `onError` | `(fn: (error: unknown) => unknown) => () => void` | Runs on an unexpected error at the calling file's route. | 37.5, 37.8 |
-| `onConfig` | `(fn: ConfigDefaults \| null, options?: ConfigOptions) => () => void` | The app's config defaults. | 27.6, 37.7 |
-| `onHealth` | `(report: () => unknown \| Promise<unknown>) => () => void` | The app's health reporter. | 25.2, 37.7 |
-| `onPrincipal` | `(resolve: (claims: unknown) => unknown \| Promise<unknown>) => () => void` | Turns claims into the app's half of a principal. | 26.4, 37.7 |
+| `middleware` | `(...rungs: Middleware<{ request: Request }, Response>[]) => () => void` | The per-request lane at the calling file's route. | 18.26, 37.2, 37.3, 37.13 |
+| `onStart` | `(fn: (start: () => Promise<void>) => void \| Promise<void>) => () => void` | Wraps the boot. | 37.4, 37.6, 37.13 |
+| `onStop` | `(fn: (stop: () => Promise<void>) => void \| Promise<void>) => () => void` | Mirrors it for teardown. | 37.4, 37.6, 37.13 |
+| `onError` | `(fn: (error: unknown) => unknown) => () => void` | Runs on an unexpected error at the calling file's route. | 37.5, 37.8, 37.13 |
+| `onConfig` | `(fn: ConfigDefaults \| null, options?: ConfigOptions) => () => void` | The app's config defaults. | 27.6, 37.7, 37.13 |
+| `onHealth` | `(report: () => unknown \| Promise<unknown>) => () => void` | The app's health reporter. | 25.2, 37.7, 37.13 |
+| `onPrincipal` | `(resolve: (claims: unknown) => unknown \| Promise<unknown>) => () => void` | Turns claims into the app's half of a principal. | 26.4, 37.7, 37.13 |
 | `onLauncher` | `(options: () => LauncherOptions) => () => void` | The window the desktop app opens and the forms its launcher offers. | 38.80, 38.81, 38.83, 38.86, 38.102, 38.107 |
 
 ## The desktop app

package/docs/RULEBOOK.md

@@ -106,11 +106,11 @@ second.
 
 2.4 A failed revalidation MUST NOT cause a read to throw.
 
-2.5 `s[Symbol.asyncIterator]` MUST yield the production in flight from its start, and MUST then
-continue live.
+2.5 On a value that is not a streaming producer, `s[Symbol.asyncIterator]` MUST settle as `s.then`
+does, yielding once what it resolves with.
 
-2.6 On a value that is not a streaming producer, `s[Symbol.asyncIterator]` MUST hand back the
-standing value once per turn, however many productions or patches landed since the last.
+2.6 On a streaming producer, `s[Symbol.asyncIterator]` MUST yield the chunks of the run being served
+from its first, and MUST end when that run closes.
 
 2.7 `s.then` MUST resolve with the value where `s.busy` becomes false and 2.2 would not throw.
 
@@ -270,9 +270,7 @@ the production it serves.
 
 6.9 An expiry MUST NOT report `s.busy` true.
 
-6.10 A cursor MUST NOT be handed an `undefined` production.
-
-6.11 A streaming producer's `ttl` MUST run from its run's close, and MUST NOT reach the run in
+6.10 A streaming producer's `ttl` MUST run from its run's close, and MUST NOT reach the run in
 flight.
 
 # 7. Triggers
@@ -396,6 +394,11 @@ made by one (11.61) MUST end with it.
 9.14 A subscriber's copy of a wired `Reactive` MUST report `s.busy` true until the first production
 arrives.
 
+9.15 A cursor over a streaming producer MUST throw, once it has yielded every chunk, the failure its
+run ended on.
+
+9.16 A cursor over a streaming producer MUST end where a new run replaces the one it was reading.
+
 # 10. Sharing
 
 10.1 `reactive.share` MUST get or create in one call.
@@ -1164,8 +1167,8 @@ lists a handler for it. What a closed one answers is 36.7.
 
 20.8 Every `/__abide/**` address MUST run inside the app's own middleware.
 
-20.9 `/__abide/mcp` MUST publish a handler that reads as a tool and a resource according to which
-arm `GET` took, and MUST NOT require a flag to tell them apart.
+20.9 `/__abide/mcp` MUST publish every handler it lists as a tool, a `GET` taking no args included,
+and MUST NOT publish one as a resource.
 
 20.10 A handler whose own `Middleware` rung would refuse a caller MUST still be listed, and MUST
 still be refused on the call.
@@ -1294,7 +1297,8 @@ segment a page below it adds.
 
 23.15 A file under a fence MUST NOT have a route.
 
-23.16 A fence under a fence MUST be a build error naming both.
+23.16 A fence under a fence MUST be a build error naming both, save a `server` directory under a
+`lib` or a `tests` directory.
 
 23.17 A route whose first segment is `__abide` MUST be a build error.
 
@@ -1432,8 +1436,7 @@ module ran is not the one served after it.
 27.12 `Config` MUST admit a field an app declares on it, of any type.
 
 27.13 `abide check` and `abide lsp` MUST type `Config` with what the defaults of every `onConfig`
-called as a statement at the top of a `<script server>`, a handler file or a module under a `server`
-directory return, and a union return with the keys
+called as a statement at the top of a `<script server>` or a handler file return, and a union return with the keys
 every member of it has.
 
 # 28. Logging
@@ -2079,6 +2082,9 @@ through `App.stop`, and the process MUST then exit with 0.
 
 37.12 A second `SIGTERM` or `SIGINT` while the app is stopping MUST end the process at once.
 
+37.13 A lifecycle hook called in a module of the app's own that is neither a `.abide` nor a handler
+file MUST be a build error naming the module and the hook.
+
 # 38. Commands
 
 38.1 `abide scaffold` MUST write a starter project, and MUST skip a step already done.

package/docs/abide.md

@@ -1597,11 +1597,11 @@ Read on: [Throttle & debounce](/values/slow-down-a-value-that-changes-too-fast.m
 
 ## Following a channel sees turns, not every message
 
-`for await (const turns of onboarding)` walks the channel's cursor. On a value with no streaming producer the cursor hands back the standing value once per turn, however many writes landed since the last, and a patch in place is one of them (2.6). A burst of three messages in one turn is one step, holding all three.
+`onboarding.watch((turns) => …)` follows the channel. The effect runs once at the end of a turn, however many writes landed in it, and a patch in place is one of them (12.10). A burst of three messages in one turn is one run, holding all three.
 
-So there is no exactly-once tail of a channel. Code that has to act on every message acts where it writes it — in `say`, beside the push. The cursor never hands back an `undefined` value (6.10).
+So there is no exactly-once tail of a channel. Code that has to act on every message acts where it writes it — in `say`, beside the push.
 
-A stream is the other case: its cursor yields from the start of the run in flight and then live, one step per chunk (2.5), and a capped window still delivers every chunk (5.10).
+`for await` is not a follow. Over a value it yields the settled value once and ends, as `await` does (2.5). Over a stream it yields each chunk of the run and ends at the close (2.6), and a capped window still delivers every chunk (5.10).
 
 Read on: [Watching values](/values/do-something-when-a-value-changes.md) · [Streaming data](/data/send-data-as-it-arrives.md)
 
@@ -2506,7 +2506,7 @@ Two costs, and both are yours rather than abide's.
 
 And a global value is bounded by its own `ttl` and the app's `invalidate` and by nothing else. There is no byte ceiling and no eviction count: measuring an arbitrary value costs an O(size) walk, and an LRU would evict an entry a reader is mid-flight on. `global: true` with `ttl: Infinity` is an unbounded cache — unbounded because the app asked for it, the bound being a number the app knows and abide does not.
 
-A global value over a stream fans one producer out to many readers, and it needs no retention to do it. A reader arriving mid-stream gets the run in flight from its start and then goes live (2.5), and a reader leaving does not cancel the producer for the ones that remain (11.39).
+A global value over a stream fans one producer out to many readers, and it needs no retention to do it. A reader arriving mid-stream gets the run in flight from its first chunk to its close (2.6), and a reader leaving does not cancel the producer for the ones that remain (11.39).
 
 Read on: [Recent values](/values/keep-the-last-few-values.md) · [Auth & principal](/app/know-who-is-calling.md) · [Authorization](/data/decide-who-may-call-what.md) · [Response types](/data/answer-with-something-other-than-json.md)
 
@@ -3652,7 +3652,7 @@ Read on: [Patching a list](/values/patch-a-list-from-a-live-feed.md) · [Lists](
 
 Every `Reactive` holds its standing value and nothing before it. Where you want the ones before it, hold them: make the value the array, and append where you write.
 
-A reader cannot build the window for you. `for await` over a value hands back the standing value once per turn, and a burst of writes in one turn is one step (2.6), so a window a reader assembles misses whatever landed in the same turn. The writer sees every value, which is why the window is built where the write is.
+A reader cannot build the window for you. A `watch` runs once per turn, and a burst of writes in one turn is one run (12.10), so a window a reader assembles misses whatever landed in the same turn. The writer sees every value, which is why the window is built where the write is.
 
 A channel is this same shape with many writers — a `reactive` over an array that everyone connected reads, trimmed the same way.
 
@@ -5176,7 +5176,7 @@ Read on: [Loading states](/values/show-a-value-that-isnt-there-yet.md) · [Lists
 
 ## A reader arriving mid-run replays the run
 
-There is no retention option on the transport and none is owed. What a late reader needs is the answer being built, and a cursor over the stream hands it the run in flight from its start before it goes live (2.5). So a reader arriving halfway through still paints every row.
+There is no retention option on the transport and none is owed. What a late reader needs is the answer being built, and a `for await` over the stream hands it the run in flight from its first chunk to its close (2.6). So a reader arriving halfway through still paints every row.
 
 ## A stream is not a channel
 
@@ -5386,7 +5386,7 @@ The call hands back the same `Reactive` the handler had, `Produced` included (16
 
 Writing to that copy is not how to send. A `set` on it stands only until the next production replaces it (9.4), so a turn goes through `say`.
 
-`room.invalidate({ id })` and `room.refresh({ id })` inside a handler reach every browser's copy of that room (7.10, 7.18). A `for await` over the room hands back the standing array once per turn, a burst collapsing to the latest (2.6), so code that has to act on every message acts in `say`.
+`room.invalidate({ id })` and `room.refresh({ id })` inside a handler reach every browser's copy of that room (7.10, 7.18). A `watch` on the room runs once per turn, a burst collapsing to the latest (12.10), so code that has to act on every message acts in `say`.
 
 ## Each instance holds its own room
 
@@ -9229,27 +9229,10 @@ Read on: [Config](/app/configure-the-app.md) · [Authorization](/data/decide-who
 
 ## A root rung answers what no route does
 
-`middleware` filed at the root route runs before routing, so a rung there can answer an address no page or handler claims, and hand everything else on with `next()`. These docs serve every page as markdown that way:
-
-```ts src/lib/downloads.ts — excerpt
-middleware(async (next, { request }) => {
-    const { pathname, origin } = new URL(request.url)
-    if (!pathname.endsWith('.md') && !pathname.endsWith('/llms.txt'))
-        return next()
-    if (pathname === '/llms.txt')
-        return new Response('# abide\n\nEvery page, as markdown: abide.md\n')
-    if (pathname === '/abide.md') {
-        bundled ??= bundle(origin)
-        return new Response(await bundled, { headers: MARKDOWN })
-    }
-    for (const group of SITE)
-        for (const page of group.pages)
-            if (pathname === markdownAddressOf(page.route))
-                return new Response(await pageMarkdown(page.route, origin), {
-                    headers: MARKDOWN,
-                })
-    return next()
-})
+`middleware` filed at the root route runs before routing, so a rung there can answer an address no page or handler claims, and hand everything else on with `next()`. These docs serve every page as markdown that way — the rung is a module's export, and the root layout files it with `middleware(serveDownloads)`, since a hook is only called in a page, a layout or a handler file (37.13):
+
+```ts src/lib/serveDownloads.ts — excerpt
+export const serveDownloads: Middleware<
 ```
 
 It uses the same response helpers everything else does, there being no second set.
@@ -10006,13 +9989,15 @@ let refused = reactive('—')
 <script server>
 // The docs app's own hooks; each example files its own in its own file.
 import { csp, middleware, onConfig } from '@abide/abide/server'
-import '#src/lib/downloads.ts'
+import { serveDownloads } from '#src/lib/serveDownloads.ts'
 
 // The sign-in examples need a secret: one per process, or the deployment's.
 const PRINCIPAL_SECRET = crypto.randomUUID()
 
 onConfig(() => ({ ABIDE_PRINCIPAL_SECRET: PRINCIPAL_SECRET }))
 
+middleware(serveDownloads)
+
 // Every docs page's policy; 'self' so the docs can frame invoice previews.
 middleware(csp({ 'frame-ancestors': ["'self'"] }))
 </script>
@@ -10307,11 +10292,11 @@ Read on: [Withholding a surface](/machines/keep-a-handler-off-a-surface.md)
 
 An MCP server is a list of tools with typed arguments and descriptions. A declared handler is a typed argument shape with a description. `/__abide/mcp` is the second read as the first, over streamable http.
 
-## The method decides tool or resource
+## Every handler is a tool
 
-A handler is published as a **tool** or as a **resource** according to which arm `GET` took, and no flag tells them apart. A read is a resource, a mutation is a tool — which is the distinction MCP already draws, arrived at from the declaration rather than from an annotation somebody has to keep true.
+Every handler the route table publishes is a **tool** — a read that takes no arguments as much as a mutation. None is published as an MCP resource, because a client that only calls tools, Claude Code under `abide-bridge` among them, would never reach a handler listed as one.
 
-That is the whole of the mapping, and it is worth being able to state in one line: the model sees your app's verbs because your app already declared which of its handlers change something.
+That is the whole of the mapping: the model sees every handler your app publishes, and whether one changes something is the handler's own method, not a second listing.
 
 ## The description is the handler's
 
@@ -11810,8 +11795,8 @@ Every `Reactive` takes these, whichever overload made it.
 | `s.then` | `<Result>(onSettled?: (value: Stored) => Result \| PromiseLike<Result>, onFailed?: (error: unknown) => Result \| PromiseLike<Result>) => Promise<Result>` | The settling, as a promise. Resolves when `busy()` goes false, and rejects with what a read would throw. |
 | `s.catch` | `<Result>(onFailed: (error: unknown) => Result \| PromiseLike<Result>) => Promise<Stored \| Result>` | The settling's refusal path, derived from `then`. Fires for a producer that failed with nothing landed, and for nothing else. |
 | `s.finally` | `(onSettled: () => void) => Promise<Stored>` | The settling's end, whichever way it went. What ends is the settling, not the value — a subscriber's copy of a channel settles at its first production and goes on. |
-| `for await (… of s)` | `AsyncIterable<Produced>` | The live cursor face of a read. On a stream, one turn per chunk. On any other value, the standing value once per turn — a burst collapses to the latest, and an in-place `patch` is a turn of its own. |
-| `s[Symbol.asyncIterator]` | `() => AsyncIterator<Produced>` | The production in flight from its start, and then what follows it. A chunk is a piece of one value, so a stream's cursor sees every chunk; any other value's cursor sees where the value stands. |
+| `for await (… of s)` | `AsyncIterable<Produced>` | What one run produced. On a stream, one turn per chunk, ending at the close and throwing what failed the run. On any other value, the settled value once, as `await` gives it. To follow changes, `watch`. |
+| `s[Symbol.asyncIterator]` | `() => AsyncIterator<Produced>` | The run being served, from its start to its end. A chunk is a piece of one value, so a stream's cursor sees every chunk; any other value's cursor sees the value it settles on. |
 
 ## Writes
 
@@ -12843,7 +12828,7 @@ src/
 
 A route is its file's path without the extension, and an `index.abide`, a `layout.abide` and an `error.abide` take their directory's (23.14). Every other `.abide` directly in a directory is a page (23.21), so a component lives under a `lib`. A `.ts` there is a handler file.
 
-`lib`, `tests`, `server` and `public` are the fences, and nothing under one has a route (23.15). One inside another is a build error, and so is an `index.abide`, a `layout.abide` or an `error.abide` under one (23.16, 23.18). A directory's top level holds pages, layouts, error pages, handler files, directories and fences alone — any other file there is a build error naming the `lib` to move it into (23.22). So listing a directory lists its routes, and `abide routes` lists the app's.
+`lib`, `tests`, `server` and `public` are the fences, and nothing under one has a route (23.15). One inside another is a build error, save a `server` inside a `lib` or a `tests`, which keeps code only the server loads beside the components that call it — and so is an `index.abide`, a `layout.abide` or an `error.abide` under one (23.16, 23.18). A directory's top level holds pages, layouts, error pages, handler files, directories and fences alone — any other file there is a build error naming the `lib` to move it into (23.22). So listing a directory lists its routes, and `abide routes` lists the app's.
 
 ### Resolution order
 
@@ -12967,7 +12952,7 @@ A page and a handler file are **addresses rather than names**, and so are `index
 | `onPrincipal` | `(resolve: (claims: unknown) => unknown \| Promise<unknown>) => () => void` | Turns claims into the app's half of a principal. |
 | `onLauncher` | `(options: () => LauncherOptions) => () => void` | The window the desktop app opens and the forms its launcher offers. |
 
-Each is a hook you **call** rather than an export the framework looks for, a `.abide` exporting nothing. It is filed at the route of the `.abide` or the handler file that called it, and at the root where a module called it (37.1). A `.abide` under a `lib` or a `tests` directory files its hooks at the route of the directory holding that one. `onLauncher` is called in `src/launcher.abide` alone.
+Each is a hook you **call** rather than an export the framework looks for, a `.abide` exporting nothing. It is filed at the route of the `.abide` or the handler file that called it (37.1), and any other module calling one is a build error (37.13) — export the function and call the hook where it serves. A `.abide` under a `lib` or a `tests` directory files its hooks at the route of the directory holding that one. `onLauncher` is called in `src/launcher.abide` alone.
 
 `middleware` runs over that route and the ones below it — before routing at the root, after it anywhere else — and `onError` hears an error there, nearest route first. The rest are the process's wherever they are written, and every one of a kind composes: `onConfig` and `onPrincipal` merge what each answers, the deeper route's over the root's. `abide routes` lists every call with the route it is filed at.
 
@@ -12985,7 +12970,7 @@ Every one hands back the way off again, so a module that is torn down can remove
 
 ### `Config` is typed from the `onConfig` calls
 
-`abide check` and `abide lsp` type `Config` from the defaults every `onConfig` returns, read where it is called as a statement at the top of a `<script server>`, of a handler file or of a module under a `server` directory (27.13). A default that returns a union types the keys every member of it has. So a config read is typed without a declaration of its own, wherever in the app the default is written.
+`abide check` and `abide lsp` type `Config` from the defaults every `onConfig` returns, read where it is called as a statement at the top of a `<script server>` or of a handler file (27.13). A default that returns a union types the keys every member of it has. So a config read is typed without a declaration of its own, wherever in the app the default is written.
 
 ### `NODE_ENV` is verbatim
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abide/abide",
-    "version": "0.103.0",
+    "version": "0.104.0",
     "type": "module",
     "description": "Isomorphic type-safe framework for reactive async interfaces for humans and machines",
     "license": "MIT",

package/src/compiler/TypeSession.ts

@@ -863,7 +863,7 @@ export class TypeSession {
                 configModules: configModulesUnder(within, files),
             }
         }
-        // 27.13 — what a handler file or a server module defaults, beside it.
+        // 27.13 — what a handler file defaults, beside it.
         for (const [path, text] of await this.walked.configModules) {
             const shadow = moduleConfigShadow(text)
             const at = `${this.canonical(path)}${CONFIG_SUFFIX}`
@@ -1329,17 +1329,15 @@ function flatten(diagnostic: {
 const CONFIG_SUFFIX = '.config-shadow.ts'
 
 /**
- * Every handler file and every module under a `server` directory below `within` that names
- * `onConfig`, with its text — the modules a server runs that 27.13 types `Config` off.
+ * Every handler file below `within` that names `onConfig`, with its text — the modules a server
+ * runs that 27.13 types `Config` off, since 37.13 refuses a hook anywhere else that is no `.abide`.
  */
 async function configModulesUnder(
     within: string,
-    { handlers, modules }: ReturnType<typeof appFiles>,
+    { handlers }: ReturnType<typeof appFiles>,
 ): Promise<[string, string][]> {
     const paths: string[] = []
     for (const name of handlers) paths.push(`${within}/${name}`)
-    for (const name of modules)
-        if (placeOf(name) === 'server') paths.push(`${within}/${name}`)
     const texts = await Promise.all(paths.map((path) => Bun.file(path).text()))
     const found: [string, string][] = []
     for (let at = 0; at < paths.length; at += 1)

package/src/compiler/appMap.ts

@@ -53,7 +53,7 @@ export async function appMap(
               : 1,
     )
     const hooks: MappedHook[] = []
-    const { abide, handlers, modules } = appFiles(root, () => {})
+    const { abide, handlers } = appFiles(root, () => {})
     for (const file of abide) {
         const parsed = parseAbide(readFileSync(`${root}/${file}`, 'utf8'))
         // Block by block: one block's last token would decide how the next one's first reads.
@@ -64,11 +64,6 @@ export async function appMap(
     for (const file of handlers)
         for (const hook of hooksCalled(readFileSync(`${root}/${file}`, 'utf8')))
             hooks.push({ hook, route: scopeOf(file), file })
-    // 37.1 — A MODULE THAT IS NEITHER files at the root: it runs as it is imported, before the
-    // importing file's route is set.
-    for (const file of modules)
-        for (const hook of hooksCalled(readFileSync(`${root}/${file}`, 'utf8')))
-            hooks.push({ hook, route: '/', file })
     return { routes, hooks }
 }
 

package/src/compiler/checkApp.ts

@@ -4,6 +4,7 @@ import { placeOf } from '#shared/routePattern.ts'
 import {
     type AppChecker,
     emitApp,
+    refuseModuleHooks,
     resolverIn,
     sourcesUnder,
     withChecker,
@@ -40,10 +41,13 @@ export async function checkApp(
     return withChecker(root, kept, async (session) => {
         const refused: Diagnosis[] = []
         const own = parseSources(sources, refused)
-        // 23.16-23.18 — what the build's walk would refuse of the tree, at each file it names.
-        const { handlers } = appFiles(root, (path, message) => {
-            refused.push(refusal(`${root}/${path}`, message))
-        })
+        // 23.16-23.18 and 37.13 — what the build's walk would refuse of the tree, at each file it names.
+        // 38.33 — each at its file, and every one rather than the first.
+        const atFile = (relative: string, thrown: unknown): void => {
+            refused.push(refusal(`${root}/${relative}`, thrown))
+        }
+        const { handlers, modules } = appFiles(root, atFile)
+        refuseModuleHooks(root, modules, atFile)
         const resolve = resolverIn()
         const { sources: everyParsed, handlers: handlerFiles } =
             await withDependencies(root, own, handlers, resolve, refused)
@@ -83,11 +87,7 @@ export async function checkApp(
                             emittable,
                             resolve,
                             handlerFiles,
-                            // 38.33 — each at its file, and every one rather than the first.
-                            (relative, thrown) =>
-                                refused.push(
-                                    refusal(`${root}/${relative}`, thrown),
-                                ),
+                            atFile,
                         )
                     ).warnings,
                 )

package/src/compiler/checkedShadow.ts

@@ -169,7 +169,7 @@ ${aliases}declare module '${SERVER_SPECIFIER}' {
 const TOP_LEVEL_CONFIG = /^onConfig\s*\(/gm
 
 /**
- * 27.13 FOR A MODULE THAT IS NO `.abide` — a handler file, or one under a `server` directory: its
+ * 27.13 FOR A HANDLER FILE, the one module that is no `.abide` and may call a hook (37.13): its
  * text with each `onConfig(…)` at its top level bound as the lowering binds a server block's, and
  * `Config` extended by each, or `undefined` where it files none.
  *

package/src/compiler/compileApp.ts

@@ -45,7 +45,7 @@ import {
     readSources,
     refusal,
 } from './readSources.ts'
-import { respecified } from './splitImports.ts'
+import { importStatements, respecified } from './splitImports.ts'
 import { type Diagnosis, TypeSession } from './TypeSession.ts'
 import { writeDefaultProject } from './writeDefaultProject.ts'
 
@@ -350,7 +350,8 @@ export async function compileApp(
     const root = realpathSync(appRoot)
     // ONE WALK for the sources, the handler files and the public files, refusing a tree 23.16-23.18
     // forbids before anything is read.
-    const { abide, handlers, published } = appFiles(root)
+    const { abide, handlers, modules, published } = appFiles(root)
+    refuseModuleHooks(root, modules)
     const sources = await sourcesAt(root, abide)
     // 16.2 — an app of handler files alone is still an app.
     if (sources.length === 0 && handlers.length === 0)
@@ -584,11 +585,7 @@ export async function emitApp(
 function onAbideOf(root: string, path: string, text: string): string {
     const from = dirname(realpathSync(path))
     return respecified(text, (specifier) => {
-        if (
-            specifier !== SHARED_SPECIFIER &&
-            !specifier.startsWith(`${SHARED_SPECIFIER}/`)
-        )
-            return undefined
+        if (!isAbideSpecifier(specifier)) return undefined
         let target: string
         try {
             target = resolvedFile(specifier, root)
@@ -708,6 +705,46 @@ function refuseStrayLauncher(
         if (callsLauncher(readFileSync(file.path, 'utf8'))) stray(file.relative)
 }
 
+/**
+ * 37.13 — a hook called in a module that is neither a `.abide` nor a handler file runs as the module
+ * is imported, before any file's route is set, and not at all where nothing imports it. A hook is a
+ * name the module imports from abide, or a member of a namespace it does, so `emitter.onError(…)` in
+ * a module that imports abide for `reactive` is no hook.
+ */
+export function refuseModuleHooks(
+    root: string,
+    modules: readonly string[],
+    refuse: Refuse = THROW,
+): void {
+    for (const module of modules) {
+        const source = readFileSync(`${root}/${module}`, 'utf8')
+        if (!source.includes(SHARED_SPECIFIER)) continue
+        const imported = new Set<string>()
+        for (const statement of importStatements(source))
+            if (isAbideSpecifier(statement.specifier))
+                for (const binding of statement.bindings)
+                    if (!binding.typeOnly) imported.add(binding.imported)
+        const hook = hooksCalled(source).find(
+            (name) => imported.has(name) || imported.has('*'),
+        )
+        if (hook !== undefined)
+            refuse(
+                module,
+                new Error(
+                    `abide: ${module} calls ${hook}, and it is neither a .abide nor a handler file, so the call has no route. Export what it is handed and call ${hook} in the page, layout or handler file it serves. RULEBOOK 37.13.`,
+                ),
+            )
+    }
+}
+
+/** `@abide/abide` or one of its subpaths. */
+function isAbideSpecifier(specifier: string): boolean {
+    return (
+        specifier === SHARED_SPECIFIER ||
+        specifier.startsWith(`${SHARED_SPECIFIER}/`)
+    )
+}
+
 function callsLauncher(source: string): boolean {
     return (
         source.includes('onLauncher') &&

package/src/compiler/projectShadow.ts

@@ -683,7 +683,7 @@ const ROWS_OF = '__rowsOf'
  *
  * The item is read off the subject as `listOf` iterates it: what a `Reactive` read by
  * name hands back (31.1 lowers `rows` to `rows()`), or the subject itself. THE CALL IS THE FIRST
- * OVERLOAD because a `Reactive` is ALSO an `AsyncIterable` of its productions (2.5), and inferred
+ * OVERLOAD because a `Reactive` is ALSO an `AsyncIterable` of what it produced (2.5, 2.6), and inferred
  * over one union the item came out as the row OR the whole list. Declared AFTER everything, so no
  * offset above it moves, and ambient, so there is nothing to emit. Where inference fails the item
  * is `unknown`, and a member of that is unprovable — the safe side.