@abide/abide 0.102.0 → 0.104.0

package/docs/abide.md

@@ -135,7 +135,7 @@ In abide it is the handler, and a page that reads it. You declare what a value *
 
 **Read an invoice** — A row from your database on the page, with nothing between them. One file: the handler you would have written anyway, and the markup that reads it.
 
-```abide Invoice.abide
+```abide lib/Invoice.abide
 <script server>
 import { GET, notFound } from '@abide/abide/server'
 
@@ -143,7 +143,7 @@ const INVOICES = new Map([
     ['42', { number: 'INV-0042', total: '$1,240.00', dueOn: '2026-09-14' }],
 ])
 
-export const getInvoice = GET(
+const getInvoice = GET(
     async ({ id }: { id: string }) => {
         await Bun.sleep(450) // a slow database, so the wait is on screen
         const invoice = INVOICES.get(id)
@@ -179,7 +179,7 @@ Read on: [Templates](/templates.md) · [Values by name](/templates/read-and-writ
 
 ## Data from the server
 
-A handler a `<script server>` exports is callable. The method you declare it with is the whole difference between a read and a write.
+A handler you declare is callable. The method you declare it with is the whole difference between a read and a write.
 
 Read on: [Data from the server](/data.md) · [Reading data](/data/read-data-without-writing-an-api.md) · [Mutations](/data/change-something-on-the-server.md) · [Live updates](/data/keep-a-room-of-callers-in-sync.md)
 
@@ -243,7 +243,7 @@ abide has one answer.
 
 **`Reactive` — four producers, one way to ask** — A contact and its notes. Watch which rows say “…” on arrival, then type a note and add it.
 
-```abide Contact.abide
+```abide lib/Contact.abide
 <script server>
 import { GET } from '@abide/abide/server'
 
@@ -251,7 +251,7 @@ const CONTACTS = new Map([
     ['1', { id: '1', name: 'Ada Lovelace', email: 'ada@example.com' }],
 ])
 
-export const getContact = GET(
+const getContact = GET(
     async ({ id }: { id: string }) => {
         await Bun.sleep(900) // a slow database, so the wait is on screen
         const row = CONTACTS.get(id)
@@ -336,10 +336,8 @@ Address, method, argument and result schemas, description — all of it already
 
 That is why failures are strict. A refusal is a **named value carrying data**, not a status code and a sentence:
 
-```abide src/groups/page.abide — excerpt
-<script server>
-export const join = POST(() => notMember({ group: 'staff' }))
-</script>
+```ts src/groups/join.ts — excerpt
+export default POST(() => notMember({ group: 'staff' }))
 ```
 
 The caller narrows it by name and gets `.data` typed — your own template and a model on the far side of an HTTP request, identically.
@@ -365,13 +363,13 @@ The caller narrows it by name and gets `.data` typed — your own template and a
 
 *Put something on screen, change it, and see where the code that changed it lives.*
 
-A page is a file. Put a `page.abide` in a directory under `src` and the path it sits at is the address it answers on — there is no route table to register it in, and no build step to tell about it.
+A page is a file, and its path below `src` is the address it answers on: `src/index.abide` is `/`, and `src/about.abide` is `/about`. There is no route table to register it in, and no build step to tell about it.
 
-```abide src/page.abide
+```abide src/index.abide
 <script server>
 import { GET } from '@abide/abide/server'
 
-export const getGreeting = GET(() => `Hello from Bun ${Bun.version}`)
+const getGreeting = GET(() => `Hello from Bun ${Bun.version}`)
 </script>
 
 <script>
@@ -385,30 +383,34 @@ let count = reactive(0)
 <button onclick={() => count += 1}>Clicked {count} times</button>
 ```
 
-*1 file, 15 lines* — and the app serves `/`, with `getGreeting` answering at `/getGreeting` beside it.
+*1 file, 15 lines* — and the app serves `/`, with `getGreeting` a handler only this page calls.
 
 One file holds a function that runs on the server, the values, the markup that shows them, and the click that changes one. There is no API between the two halves, no store to declare, no component to register, and no re-render to ask for.
 
-## Where the file goes decides the address
+## A file's path is the address it answers
 
-The directory is the path, and a `page.abide` makes that directory a page.
+A file's path below `src` is its address. Nothing else names a route.
 
 | File | Answers on |
 | --- | --- |
-| `src/page.abide` | `/` |
-| `src/about/page.abide` | `/about` |
-| `src/invoices/page.abide` | `/invoices` |
-| `src/invoices/[id]/page.abide` | `/invoices/42`, with `42` readable as `route.params.id` |
+| `src/index.abide` | `/` |
+| `src/about.abide` | `/about` |
+| `src/invoices/index.abide` | `/invoices` |
+| `src/invoices/[id].abide` | `/invoices/42`, with `42` readable as `route.params.id` |
+| `src/invoices/getInvoice.ts` | `GET /invoices/getInvoice`, the handler its default export declares |
+| `src/invoices/lib/Row.abide` | no address: a component the pages import |
 
-Every directory under `src` is a segment of an address, so `src/billing/page.abide` is `/billing`. Group an app by subject, and the addresses follow.
+An `index.abide` answers its directory's own address, and any other `.abide` adds its name. A `.ts` beside the pages is a handler file, and its name is its last segment.
 
-A handler answers below its file's directory, under the name it was exported as: `getGreeting` in `src/page.abide` is `/getGreeting`, and the same export in `src/invoices/page.abide` would be `/invoices/getGreeting`.
+Code that is not an address goes in one of four directories that never are: `lib` for components and modules, `tests`, `server` and `public`. Anything else beside the pages fails the build, so listing a directory lists its routes. Group an app by subject, and the addresses follow.
 
 Read on: [Routes](/pages/add-a-page.md) · [Sub-path mounting](/pages/serve-the-app-under-a-sub-path.md)
 
 ## `<script server>` runs on the server, `<script>` sets up the page
 
-`<script server>` runs on the server alone, once. What it exports is a handler — `GET` declares one — and the rest of the file calls it by the name it was declared with. The browser is never sent the block: the build generates a call under the same name in its place, so `Bun.version` is read where Bun is.
+`<script server>` runs on the server alone, once. What it declares with `GET` is a handler, and the rest of the file calls it by the name it was declared with. The browser is never sent the block: the build generates a call under the same name in its place, so `Bun.version` is read where Bun is.
+
+No block of a `.abide` exports anything. The component is the file's one export, and a handler its `<script server>` declares is called by that file alone.
 
 The `<script>` block is the page's setup: ordinary imports, ordinary TypeScript, run once for this instance of the page. Everything after it is the markup, and the file shares one scope — the template resolves names against its two scripts and nothing else.
 
@@ -426,7 +428,7 @@ Inside a `.abide` file, a reactive value is read and written under its own name.
 
 Naming `count` in an expression **reads** it; the explicit `count()` and `count.set(v)` keep compiling everywhere the sugar does, because the sugar is over those forms rather than instead of them. A `.ts` file — which has no template around it — writes them out:
 
-```ts src/ui/counters.ts
+```ts src/lib/counters.ts
 import { reactive } from '@abide/abide'
 
 export const count = reactive(0)
@@ -441,12 +443,12 @@ Read on: [Local state](/values/show-a-value-that-changes.md) · [Values by name]
 
 The same page reaches your database through a handler its own `<script server>` declares, and reads it like any other value.
 
-```abide src/invoices/[id]/page.abide — excerpt
+```abide src/invoices/[id].abide — excerpt
 <script server>
 import { GET } from '@abide/abide/server'
 import { database } from '#src/server/database'
 
-export const getInvoice = GET(
+const getInvoice = GET(
     ({ id }: { id: string }) => database.invoice.find(id),
     { description: 'One invoice, by id.' },
 )
@@ -466,7 +468,7 @@ No `fetch`, no client module, and no second copy of the invoice type. The browse
 
 Reading `invoice` starts the load, and the document goes out before the row lands: the two values are holes that fill when it does. That is the default, and it is why neither line above has a loading branch in it.
 
-A handler several pages share goes in a file of its own: any `.abide` can hold a `<script server>`, it answers at its directory's address, and a page imports it like any other module.
+That handler is this page's alone, and no other file can import it. One a second file calls goes in a handler file: `src/invoices/getInvoice.ts`, holding `export default GET(…)`, answers at `/invoices/getInvoice`, and a page imports it like any other module. It is the app's public surface, so the command line and MCP list it too.
 
 Read on: [Reading data](/data/read-data-without-writing-an-api.md) · [Loading states](/values/show-a-value-that-isnt-there-yet.md)
 
@@ -508,7 +510,7 @@ A request lands, and bytes start leaving before anything it needs has arrived. T
 |  | Stage | What runs |
 | --- | --- | --- |
 | 1 | the request arrives | each `middleware` rung the root layout files |
-| 2 | the route resolves | the `page.abide` at that path, inside its layouts |
+| 2 | the route resolves | the page file at that path, inside its layouts |
 | 3 | the render starts | every load the page reads, all of them at once |
 | 4 | the first bytes leave | the head, then the markup as far as it goes |
 | 5 | the document closes | as soon as the walk is done |
@@ -547,7 +549,7 @@ Read on: [Auth & principal](/app/know-who-is-calling.md) · [Authorization](/dat
 
 ## 2. The route resolves
 
-The path picks a `page.abide`, and the layouts in the directories above it wrap it. All of that renders into one document, and the root `src/layout.abide` writes it: written inside `<html>`, its `<head>` is the document's head and its `<body>` holds the chrome and the slot every page goes in. The attributes on the two are the document's own, and live as on any element.
+The path picks the page file at it, and the layouts in the directories above it wrap it. All of that renders into one document, and the root `src/layout.abide` writes it: written inside `<html>`, its `<head>` is the document's head and its `<body>` holds the chrome and the slot every page goes in. The attributes on the two are the document's own, and live as on any element.
 
 ```abide src/layout.abide — excerpt
 <html lang="en">
@@ -577,9 +579,9 @@ The total time is the slowest one, not the sum — and the first byte does not w
 
 The head goes first, then the markup. A read of a value still in flight renders nothing and opens a **sink**, and the hole fills when the value lands. The markup after it keeps going out.
 
-```abide src/invoices/[id]/page.abide — excerpt
+```abide src/invoices/[id].abide — excerpt
 <script server>
-export const getInvoice = GET(({ id }: { id: string }) =>
+const getInvoice = GET(({ id }: { id: string }) =>
     database.invoice.find(id),
 )
 </script>
@@ -652,7 +654,7 @@ Read on: [Links & navigation](/pages/link-to-another-page.md) · [View transitio
 <head>
 <meta charset="utf-8">
 <script type="application/json" data-abide-seed>
-[["GET","/invoices/42/getInvoice",{}]]
+[["GET","/__abide/handlers/invoices/id/getInvoice",{"id":"42"}]]
 </script>
 <script>/* issues each call, stashes each Promise under its key */</script>
 <link rel="stylesheet" href="/_abide/app.7f3c9a1e.css">
@@ -685,20 +687,26 @@ Those filler scripts are **byte-identical** — every one of them, in every docu
 
 ## The directory a file is in decides where it runs
 
-`src/` is the app, and every file in it runs on both sides unless its directory says otherwise. Group it by subject — `src/billing/page.abide`, `src/billing/server`, `src/billing/ui` — and the build enforces the split wherever the directories sit.
+`src/` is the app, and every file in it runs on both sides unless its directory says otherwise. Group it by subject — `src/billing/index.abide`, `src/billing/server`, `src/billing/lib` — and the build enforces the split wherever the directories sit.
 
 | Directory | What is in it | Reached by |
 | --- | --- | --- |
-| `src/**/` | addresses: pages, layouts, and the handlers a `<script server>` exports | anything; the browser gets a handler's client |
+| `src/**/` | addresses: pages, layouts, error pages and handler files | anything; the browser gets a handler's client |
+| `**/lib/**` | components and modules, which are no address | anything |
 | `**/server/**` | code the browser never loads | the server alone; a page importing it is a compile error |
+| `**/tests/**` | the app's tests | `bun test`; never served |
+| `**/public/**` | files answered as they are | a request for one, at its path below the directory |
+
+A directory holds addresses and those four alone. Any other file directly in it fails the build, naming the file and the `lib` to move it into, so what a directory lists is what it answers.
 
 `#src/…` is the one import alias, mapping onto `src/`. Two files are addresses rather than names, and both are optional:
 
 | File | What it is |
 | --- | --- |
 | `src/layout.abide` | the root layout: the document and the chrome every page shares, and the app's own `<script server>` |
+| `src/launcher.abide` | the desktop app's launcher |
 
-Read on: [Config](/app/configure-the-app.md) · [Lifecycle](/app/run-code-at-start-and-stop.md)
+Read on: [Routes](/pages/add-a-page.md) · [Config](/app/configure-the-app.md) · [Lifecycle](/app/run-code-at-start-and-stop.md)
 
 ## Next
 
@@ -827,7 +835,7 @@ The options are `schema`, `transform`, `store`, `identity`, `by`, `ttl`, `thrott
 
 **`reactive(v)` — a value the page owns** — A contact's handle. Type into the field and watch the heading.
 
-```abide OwnedHandle.abide
+```abide lib/OwnedHandle.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -853,7 +861,7 @@ Read on: [Values by name](/templates/read-and-write-a-value-by-name.md)
 
 **`reactive(load)` — the settled value, never the promise** — A contact fetched when the page is built. Reload the page to watch it land again.
 
-```abide Record.abide
+```abide lib/Record.abide
 <script server>
 import { refuse } from '@abide/abide'
 import { GET } from '@abide/abide/server'
@@ -862,7 +870,7 @@ const CONTACTS: Record<string, { name: string; role: string }> = {
     '42': { name: 'Ada Lovelace', role: 'Engineer' },
 }
 
-export const getContact = GET(
+const getContact = GET(
     async (args: { id: string }) => {
         // A slow service, so the wait is on screen.
         await Bun.sleep(900)
@@ -900,7 +908,7 @@ Read on: [Loading states](/values/show-a-value-that-isnt-there-yet.md) · [Reloa
 
 **`reactive(v, { transform })` — what is stored is not what you typed** — A contact's handle, normalized on the way in. Type a name with capitals and a space.
 
-```abide TransformHandle.abide
+```abide lib/TransformHandle.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -958,7 +966,7 @@ Both take `schema`, `transform`, `store`, `global`, `tags`, `throttle` and `debo
 
 **`reactive(() => …)` — an auto-tracked derivation** — A deal, and the total that follows its seats. Step the seats.
 
-```abide Deal.abide
+```abide lib/Deal.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -1007,7 +1015,7 @@ There is one `set` in the design and it is `Reactive`'s, so writing to a derived
 
 **`reactive(() => call(args))` — a load the value adopts** — A profile panel behind two tabs. Open the other person, then come back to the first.
 
-```abide Profile.abide
+```abide lib/Profile.abide
 <script server>
 import { GET } from '@abide/abide/server'
 
@@ -1020,7 +1028,7 @@ const PEOPLE: Record<string, { name: string; role: string }> = {
 const OPENED: Record<string, number> = {}
 
 /** Runs once per request that reaches it, so `opened` counts loads. */
-export const getProfile = GET(
+const getProfile = GET(
     async (args: { id: string }) => {
         // A slow service, so the wait is on screen.
         await Bun.sleep(450)
@@ -1082,12 +1090,12 @@ Read on: [Reading data](/data/read-data-without-writing-an-api.md) · [Caching](
 
 **A write to a derived value stands until the next recompute** — An edit box seeded from a person the server sent. Type into it, then reload.
 
-```abide Draft.abide
+```abide lib/Draft.abide
 <script server>
 import { GET } from '@abide/abide/server'
 
 /** The same person on every call, so a refill changes no field. */
-export const getPerson = GET(
+const getPerson = GET(
     async (args: { id: string }) => {
         // A slow service, so the wait is on screen.
         await Bun.sleep(450)
@@ -1135,7 +1143,7 @@ A write of a settled value is not a load — `ready()` stays true and `busy()` n
 
 **`reactive((args) => …)` — a factory, one entry per key** — The contact search, filtering as you type. Type toward Ada, then backspace over what you typed.
 
-```abide Search.abide
+```abide lib/Search.abide
 <script server>
 import { reactive } from '@abide/abide'
 import { GET } from '@abide/abide/server'
@@ -1150,7 +1158,7 @@ const matching = reactive(async (args: { query: string }) => {
     return PEOPLE.filter((one) => one.toLowerCase().includes(word))
 })
 
-export const searchContacts = GET(matching, {
+const searchContacts = GET(matching, {
     description: 'Contacts whose name contains a query.',
 })
 </script>
@@ -1187,7 +1195,7 @@ Read on: [Caching](/values/load-once-per-set-of-arguments.md) · [Throttle & deb
 
 **A read after an `await` registers nothing** — Two counts under one contact filter, differing in one line. Change the filter.
 
-```abide Counts.abide
+```abide lib/Counts.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -1239,12 +1247,12 @@ Read on: [Reloading](/values/decide-when-a-value-reloads.md)
 
 **`reactive(() => gate ? … : …)` — a branch on a gate that has not landed** — A contact an auditor may read and not edit. Watch the top Save button, and reload the page to see it again.
 
-```abide Contact.abide
+```abide lib/Contact.abide
 <script server>
 import { GET } from '@abide/abide/server'
 
 /** What this caller may do with the record, which only the server knows. */
-export const getViewer = GET(
+const getViewer = GET(
     async () => {
         // A slow service, so the wait is on screen.
         await Bun.sleep(1600)
@@ -1277,7 +1285,7 @@ The hole is where the wait shows. `mode === 'locked'` throws the same way, and a
 
 Only you know which answer is safe before there is one, so say it with the probe:
 
-```abide Contact.abide — excerpt
+```abide lib/Contact.abide — excerpt
 <button disabled={!mode.ready() || mode === 'locked'}>Save</button></li>
 ```
 
@@ -1327,7 +1335,7 @@ Every other option is the one any reactive value takes. `args` refuses a key (11
 
 **`reactive<Turn[]>([])` — a channel anything can reach** — A conversation's composer, and the line above it that reports who spoke last. Press Send and watch a component the composer never names.
 
-```ts onboarding.ts
+```ts lib/onboarding.ts
 import { reactive } from '@abide/abide'
 
 export type Turn = { id: number; speaker: string; text: string }
@@ -1336,7 +1344,7 @@ export type Turn = { id: number; speaker: string; text: string }
 export const onboarding = reactive<Turn[]>([], { by: 'id' })
 ```
 
-```abide Chat.abide
+```abide lib/Chat.abide
 <script>
 import { reactive } from '@abide/abide'
 import { onboarding } from './onboarding.ts'
@@ -1359,7 +1367,7 @@ const draft = reactive('How do I rotate an API key?')
 </div>
 ```
 
-```abide LastSpoken.abide
+```abide lib/LastSpoken.abide
 <script>
 import { reactive } from '@abide/abide'
 // The same import reaches the same channel. No prop, no provider.
@@ -1395,7 +1403,7 @@ Read on: [Live updates](/data/keep-a-room-of-callers-in-sync.md) · [Loading sta
 
 **`reactive((args) => [])` — a channel per key** — Two conversations behind one declaration. Send something in onboarding, switch to billing, send there, and come back.
 
-```abide Conversation.abide
+```abide lib/Conversation.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -1449,7 +1457,7 @@ Read on: [Caching](/values/load-once-per-set-of-arguments.md) · [Schemas](/data
 
 **`patch` with a trim — a channel that keeps three turns** — A transcript pane over a conversation already three turns old. Send a fourth and watch the top of it.
 
-```abide TrimmedChat.abide
+```abide lib/TrimmedChat.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -1512,7 +1520,7 @@ Read on: [Recent values](/values/keep-the-last-few-values.md) · [Lists](/templa
 
 **`{ transform }` on a channel — a message refused by name** — The composer holding a message longer than the conversation takes. Press Send, then cut it down and press again.
 
-```abide LimitedChat.abide
+```abide lib/LimitedChat.abide
 <script>
 import { reactive, refuse } from '@abide/abide'
 import { z } from 'zod'
@@ -1589,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)
 
@@ -1659,7 +1667,7 @@ A list arrives once and then changes for the rest of the session. Refetching it
 
 **`s.patch(mutate)` — change in place, and wake the readers** — A regional dashboard whose order counts arrive one region at a time.
 
-```abide Regions.abide
+```abide lib/Regions.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -1716,7 +1724,7 @@ Read on: [Local state](/values/show-a-value-that-changes.md) · [Watching values
 
 **`applyOrderCount(byId, …)` — the same fold, reached without `patch`** — The same dashboard, and a helper handed the held table directly.
 
-```abide UnpatchedRegions.abide
+```abide lib/UnpatchedRegions.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -1787,7 +1795,7 @@ Read on: [Channels](/values/let-anything-publish-and-anything-read.md) · [Watch
 
 **`reactive(() => rows, { transform })` — an array in, an index held** — The regions table arriving from the server as a list, on a dashboard whose updates name ids.
 
-```abide LoadedRegions.abide
+```abide lib/LoadedRegions.abide
 <script server>
 import { GET } from '@abide/abide/server'
 
@@ -1800,7 +1808,7 @@ const BOOKED: Region[] = [
     { id: 'west', name: 'West', orders: 91 },
 ]
 
-export const getRegions = GET(
+const getRegions = GET(
     async (): Promise<Region[]> => {
         // A slow service, so the wait is on screen.
         await Bun.sleep(450)
@@ -1915,7 +1923,7 @@ Two booleans, four states, and the states an interface actually shows are the co
 
 **A read starts the load and leaves a hole** — An invoice with no loading branch anywhere in it. Reload the page and watch the three fields fill.
 
-```abide Invoice.abide
+```abide lib/Invoice.abide
 <script server>
 import { GET } from '@abide/abide/server'
 
@@ -1929,7 +1937,7 @@ const INVOICES: Record<string, Invoice> = {
     },
 }
 
-export const getInvoice = GET(
+const getInvoice = GET(
     async ({ id }: { id: string }) => {
         // A slow database, so the wait is on screen.
         await Bun.sleep(900)
@@ -1977,7 +1985,7 @@ Read on: [Streaming HTML](/pages/send-the-page-before-the-data-lands.md) · [Exp
 
 **`NotLanded` — a read before the value arrives** — A contact's email, with a Copy button. Open another contact and press Copy before the address lands.
 
-```abide CopyEmail.abide
+```abide lib/CopyEmail.abide
 <script server>
 import { GET } from '@abide/abide/server'
 
@@ -1987,7 +1995,7 @@ const EMAILS: Record<string, string> = {
     katherine: 'katherine@example.com',
 }
 
-export const getContact = GET(
+const getContact = GET(
     async ({ id }: { id: string }) => {
         // A slow directory, so there is time to press Copy before it lands.
         await Bun.sleep(1500)
@@ -2042,14 +2050,14 @@ Outside the render flow there is no hole to leave, so the throw reaches your cod
 
 **The first load and every one after are `ready()` apart** — An invoice with a Refresh beside it. Wait for the figures, then press Refresh and watch what does not disappear.
 
-```abide RefreshInvoice.abide
+```abide lib/RefreshInvoice.abide
 <script server>
 import { GET } from '@abide/abide/server'
 
 // Counts the loads: the total never moves, so this is what shows a refresh.
 let sent = 0
 
-export const getInvoiceTotal = GET(
+const getInvoiceTotal = GET(
     async (_args: { id: string }) => {
         // A slow database, so the wait is on screen.
         await Bun.sleep(900)
@@ -2098,7 +2106,7 @@ Read on: [Reloading](/values/decide-when-a-value-reloads.md)
 
 **A derived value is busy while what it reads is** — A count of unpaid invoices, derived from a list still loading. Reload the page and watch the figure before the list lands.
 
-```abide Unpaid.abide
+```abide lib/Unpaid.abide
 <script server>
 import { GET } from '@abide/abide/server'
 
@@ -2108,7 +2116,7 @@ const INVOICES = [
     { id: '4023', total: '$76.50', paid: false },
 ]
 
-export const listInvoices = GET(
+const listInvoices = GET(
     async () => {
         // A slow database, so the wait is on screen.
         await Bun.sleep(900)
@@ -2150,7 +2158,7 @@ Read on: [Derived values](/values/derive-a-value-from-other-values.md)
 
 **`s.error()` hands the failure back rather than throwing** — An invoice whose billing service is down. The page renders the message instead of letting it reach the error page.
 
-```abide UnreachableInvoice.abide
+```abide lib/UnreachableInvoice.abide
 <script server>
 import { refuse } from '@abide/abide'
 import { GET } from '@abide/abide/server'
@@ -2170,7 +2178,7 @@ const INVOICES: Record<string, { total: string }> = {
     '4020': { total: '$980.00' },
 }
 
-export const getBilledInvoice = GET(
+const getBilledInvoice = GET(
     async ({ id }: { id: string }) => {
         // A slow billing service, so the wait is on screen.
         await Bun.sleep(600)
@@ -2278,8 +2286,7 @@ Calling it hands back a `Reactive` for that key, so a probe on the result asks a
 
 **`reactive((args) => …)` — identity per set of arguments** — Two tiles on one dashboard, each on its own range. Put them both on 30d, then send one back to 7d.
 
-```abide Tiles.abide
-<script server>
+```ts getMetrics.ts
 import { reactive } from '@abide/abide'
 import { GET } from '@abide/abide/server'
 
@@ -2300,13 +2307,13 @@ const metricsFor = reactive(async ({ range }: { range: string }) => {
     return { orders: found.orders, average: found.average, computed }
 })
 
-export const getMetrics = GET(metricsFor, {
+export default GET(metricsFor, {
     description: 'Metrics for a range.',
 })
-</script>
+```
 
+```abide lib/Tiles.abide
 <script>
-import { reactive } from '@abide/abide'
 import Average from './Average.abide'
 import Total from './Total.abide'
 </script>
@@ -2315,10 +2322,10 @@ import Total from './Total.abide'
 <Average/>
 ```
 
-```abide Total.abide
+```abide lib/Total.abide
 <script>
 import { reactive } from '@abide/abide'
-import { getMetrics } from './Tiles.abide'
+import getMetrics from '../getMetrics.ts'
 
 const RANGES = ['7d', '30d']
 
@@ -2344,10 +2351,10 @@ const metrics = reactive(() => getMetrics({ range }))
 </ul>
 ```
 
-```abide Average.abide
+```abide lib/Average.abide
 <script>
 import { reactive } from '@abide/abide'
-import { getMetrics } from './Tiles.abide'
+import getMetrics from '../getMetrics.ts'
 
 const RANGES = ['7d', '30d']
 
@@ -2386,7 +2393,7 @@ Read on: [Derived values](/values/derive-a-value-from-other-values.md) · [Reloa
 
 **One entry per canonical args key** — One panel, and three ways to spell the query behind it. Change the spelling, then change the region.
 
-```abide Query.abide
+```abide lib/Query.abide
 <script server>
 import { reactive } from '@abide/abide'
 import { GET } from '@abide/abide/server'
@@ -2406,7 +2413,7 @@ const queryMetricsFor = reactive(async (query: Query) => {
     return { orders: ORDERS[query.region] ?? 0, computed }
 })
 
-export const getQueryMetrics = GET(queryMetricsFor, {
+const getQueryMetrics = GET(queryMetricsFor, {
     description: 'Metrics for a range and a region.',
 })
 </script>
@@ -2499,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)
 
@@ -2507,7 +2514,7 @@ Read on: [Recent values](/values/keep-the-last-few-values.md) · [Auth & princip
 
 **`tags` — a selection that reaches across keyed values** — Two regions, each with revenue and recent orders behind keyed values that never mention one another. Press one region's button and watch the other stand still.
 
-```abide Regions.abide
+```abide lib/Regions.abide
 <script>
 import Region from './Region.abide'
 </script>
@@ -2516,7 +2523,7 @@ import Region from './Region.abide'
 <Region region="south"/>
 ```
 
-```abide Region.abide
+```abide lib/Region.abide
 <script server>
 import { GET } from '@abide/abide/server'
 
@@ -2530,7 +2537,7 @@ const COUNT: Record<string, number> = { north: 128, south: 94 }
 const computed: Record<string, number> = { north: 0, south: 0 }
 const loaded: Record<string, number> = { north: 0, south: 0 }
 
-export const getTotals = GET(
+const getTotals = GET(
     async ({ region }: { region: string }) => {
         // A slow database, so the wait is on screen.
         await Bun.sleep(450)
@@ -2543,7 +2550,7 @@ export const getTotals = GET(
     { description: 'Order totals for a region.' },
 )
 
-export const getOrders = GET(
+const getOrders = GET(
     async ({ region }: { region: string }) => {
         await Bun.sleep(450)
         loaded[region] = (loaded[region] ?? 0) + 1
@@ -2637,7 +2644,7 @@ There are three answers, and they are three because they fail differently.
 
 **`invalidate()` marks stale; `refresh()` reloads now** — A shelf count with both triggers under it. Press Mark stale and watch nothing happen, then press Reload now.
 
-```abide Level.abide
+```abide lib/Level.abide
 <script server>
 import { reactive } from '@abide/abide'
 import { GET } from '@abide/abide/server'
@@ -2654,7 +2661,7 @@ const levelOfShelf = reactive(async (_shelf: Shelf) => {
     return { onHand: 12, counted }
 })
 
-export const getLevel = GET(levelOfShelf, {
+const getLevel = GET(levelOfShelf, {
     description: 'Stock on a shelf, by warehouse and sku.',
 })
 </script>
@@ -2747,7 +2754,7 @@ There is no bare form wider than the scope. A probe reports and a trigger acts,
 
 **`k.refresh(Partial<Args>)` — a slice of the args space** — Two warehouses holding the same shelf. Book one out of east and watch which of the two loads again.
 
-```abide Shelves.abide
+```abide lib/Shelves.abide
 <script server>
 import { reactive } from '@abide/abide'
 import { GET, POST } from '@abide/abide/server'
@@ -2766,11 +2773,11 @@ const stockForShelf = reactive(async ({ warehouse, sku }: Shelf) => {
     return { onHand: ON_HAND[shelf] ?? 0, loads: loads[shelf] }
 })
 
-export const getStock = GET(stockForShelf, {
+const getStock = GET(stockForShelf, {
     description: 'Stock on a shelf, by warehouse and sku.',
 })
 
-export const bookOut = POST(
+const bookOut = POST(
     ({ warehouse, sku }: Shelf) => {
         const shelf = `${warehouse}/${sku}`
         ON_HAND[shelf] = (ON_HAND[shelf] ?? 0) - 1
@@ -2835,7 +2842,7 @@ Read on: [Offline](/app/know-when-the-browser-goes-offline.md) · [Watching valu
 
 **`{ ttl }` — expires with nobody asking** — A shelf count that keeps for three seconds. Press Read it again straight away, then wait and press it once more.
 
-```abide Shelf.abide
+```abide lib/Shelf.abide
 <script server>
 import { reactive } from '@abide/abide'
 import { GET } from '@abide/abide/server'
@@ -2856,7 +2863,7 @@ const stockForShelf = reactive(
     { ttl: 3_000 },
 )
 
-export const getCachedStock = GET(stockForShelf, {
+const getCachedStock = GET(stockForShelf, {
     description: 'Stock on a shelf, by warehouse and sku.',
 })
 </script>
@@ -2953,7 +2960,7 @@ Declaring both is a build error naming the value, there being no reading under w
 
 **`{ debounce }` — one load once the typing stops** — A figure filtered by a region you type. Clear the box and type north, and watch the figure rather than the field.
 
-```abide Orders.abide
+```abide lib/Orders.abide
 <script server>
 import { GET } from '@abide/abide/server'
 
@@ -2965,7 +2972,7 @@ const BY_REGION: Record<string, number> = {
     north: 128,
 }
 
-export const countOrders = GET(
+const countOrders = GET(
     async (args: { region: string }) => {
         // A slow service, so the wait is on screen.
         await Bun.sleep(450)
@@ -3013,7 +3020,7 @@ Read on: [Loading states](/values/show-a-value-that-isnt-there-yet.md) · [Reloa
 
 **`{ throttle }` — the first arrival, then a ceiling** — A feed arriving twenty times a second beside the tile that shows it. Watch the two figures drift apart.
 
-```abide Live.abide
+```abide lib/Live.abide
 <script>
 import { reactive, watch } from '@abide/abide'
 
@@ -3070,13 +3077,13 @@ Read on: [Caching](/values/load-once-per-set-of-arguments.md) · [Form binding](
 
 **`identity: structural` — an equal reload wakes nobody** — Two regional totals and the chart drawn from them. Record a sale and the chart redraws; refresh with nothing new and it does not.
 
-```abide Chart.abide
+```abide lib/Chart.abide
 <script server>
 import { GET, POST } from '@abide/abide/server'
 
 const totals = { north: 1240, south: 980 }
 
-export const getSales = GET(
+const getSales = GET(
     async () => {
         await Bun.sleep(150)
         // A fresh record on every load, the way a query result is.
@@ -3085,7 +3092,7 @@ export const getSales = GET(
     { description: 'Sales by region.' },
 )
 
-export const recordSale = POST(
+const recordSale = POST(
     () => {
         totals.north += 120
     },
@@ -3174,7 +3181,7 @@ What comes back is whatever the thunk built, which is an ordinary `Reactive` wit
 
 **`reactive.share(key, build)` — get-or-create in this scope** — A now-playing bar over a library of tracks. Press a title and watch the bar, which the library never speaks to.
 
-```abide Library.abide
+```abide lib/Library.abide
 <script>
 import { reactive } from '@abide/abide'
 import NowPlaying from './NowPlaying.abide'
@@ -3195,7 +3202,7 @@ reactive.share('nowPlaying', () => reactive('nothing'))
 </div>
 ```
 
-```abide NowPlaying.abide
+```abide lib/NowPlaying.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -3208,7 +3215,7 @@ const playing = reactive.share('nowPlaying', () => reactive('nothing'))
 </ul>
 ```
 
-```abide TrackRow.abide
+```abide lib/TrackRow.abide
 <script>
 import { props, reactive } from '@abide/abide'
 
@@ -3234,7 +3241,7 @@ Read on: [Components](/templates/reuse-a-piece-of-markup.md) · [Form binding](/
 
 **`reactive.share` hands back the one that won** — One key asked for twice, once properly and once with the value built outside the call. Step the volume and watch the third tile.
 
-```abide Volume.abide
+```abide lib/Volume.abide
 <script>
 import { type Reactive, reactive } from '@abide/abide'
 
@@ -3265,7 +3272,7 @@ Building the value outside the call and passing it in fails silently, which is w
 
 `Shared` is your app's own registry, widened by declaration merging — and an **opt-in tightening**, not a precondition. A key it declares is checked against it; a key it does not is inferred from the thunk, so `reactive.share` works before you have written one.
 
-```ts src/shared.ts — excerpt
+```ts src/lib/shared.ts — excerpt
 declare module '@abide/abide' {
     interface Shared {
         nowPlaying: Reactive<string>
@@ -3283,7 +3290,7 @@ Read on: [Channels](/values/let-anything-publish-and-anything-read.md) · [Live
 
 **A shared value lives where it was created, and below** — Two shelves rendered from one component, each with a control below it asking for the same key. Queue on one shelf and watch the other.
 
-```abide Shelves.abide
+```abide lib/Shelves.abide
 <script>
 import Shelf from './Shelf.abide'
 </script>
@@ -3292,7 +3299,7 @@ import Shelf from './Shelf.abide'
 <Shelf name="ambient"/>
 ```
 
-```abide Shelf.abide
+```abide lib/Shelf.abide
 <script>
 import { props, reactive } from '@abide/abide'
 import QueueControl from './QueueControl.abide'
@@ -3311,7 +3318,7 @@ let queued = reactive.share('queued', () => reactive('nothing'))
 <QueueControl name={name}/>
 ```
 
-```abide QueueControl.abide
+```abide lib/QueueControl.abide
 <script>
 import { props, reactive } from '@abide/abide'
 
@@ -3370,7 +3377,7 @@ The effect is an `Effect`, and what it may return is a `Disposer`. Both calls ha
 
 **`watch(effect)` — run something outside the page on change** — A contact's handle, and the browser tab that names what you are editing. Type into the field, then press Reset.
 
-```abide TabTitle.abide
+```abide lib/TabTitle.abide
 <script>
 import { reactive, watch } from '@abide/abide'
 
@@ -3412,7 +3419,7 @@ Read on: [Derived values](/values/derive-a-value-from-other-values.md) · [Scrip
 
 **`() => Disposer` — each rerun tears down the one before it** — Notes on a contact, saved a beat after you stop typing. Type a few characters quickly and watch the saved line.
 
-```abide Autosave.abide
+```abide lib/Autosave.abide
 <script>
 import { reactive, watch } from '@abide/abide'
 
@@ -3457,7 +3464,7 @@ Read on: [Throttle & debounce](/values/slow-down-a-value-that-changes-too-fast.m
 
 **`watch(sources, effect)` — reads both, wakes on one** — An audit line that should follow a reassignment and not every keystroke. Type into the notes, then change the owner.
 
-```abide Assignment.abide
+```abide lib/Assignment.abide
 <script>
 import { reactive, watch } from '@abide/abide'
 
@@ -3536,7 +3543,7 @@ Read on: [Derived values](/values/derive-a-value-from-other-values.md)
 
 **`flushSync()` — measure the page the write left** — A contact's notes in a box that scrolls. Add a note — the handler measures the list straight after the write, and lands on the note it just added.
 
-```abide Notes.abide
+```abide lib/Notes.abide
 <script>
 import { flushSync, reactive } from '@abide/abide'
 
@@ -3604,7 +3611,7 @@ The window is an array the value holds. You append to it and trim it in one `pat
 
 **`patch` with a trim — a window onto the recent past** — A pane over an answer arriving one token at a time. Press Next token a few times and watch the top of the list.
 
-```abide TokenWindow.abide
+```abide lib/TokenWindow.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -3645,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.
 
@@ -3655,7 +3662,7 @@ Read on: [Channels](/values/let-anything-publish-and-anything-read.md)
 
 **An undo stack is history the app keeps** — A composer draft with an Undo beside it. Type a few edits, then press Undo more than once.
 
-```ts undoStack.ts
+```ts lib/undoStack.ts
 /** An undo is itself a write, so the position lives over a snapshot. */
 export function undoStack<T>(limit: number) {
     const held: T[] = []
@@ -3682,7 +3689,7 @@ export function undoStack<T>(limit: number) {
 }
 ```
 
-```abide Draft.abide
+```abide lib/Draft.abide
 <script>
 import { reactive, watch } from '@abide/abide'
 import { undoStack } from './undoStack.ts'
@@ -3758,14 +3765,14 @@ A `Reactive` lives and dies with its scope unless it is told otherwise. A `store
 
 **`{ store }` — where the value lives when the process does not** — A volume the player keeps between visits. Step it up, then reload the page.
 
-```abide Volume.abide
+```abide lib/Volume.abide
 <script server>
 import { GET, POST } from '@abide/abide/server'
 
 // A setting never written answers `null`, the miss.
 const SETTINGS: Record<string, string> = {}
 
-export const readSetting = GET(
+const readSetting = GET(
     async ({ name }: { name: string }) => {
         // A slow database, so the wait is on screen.
         await Bun.sleep(450)
@@ -3774,7 +3781,7 @@ export const readSetting = GET(
     { description: 'A setting, by name.' },
 )
 
-export const writeSetting = POST(
+const writeSetting = POST(
     (args: { name: string; value: string }) => {
         SETTINGS[args.name] = args.value
     },
@@ -3786,7 +3793,7 @@ export const writeSetting = POST(
 import type { Store } from '@abide/abide'
 
 /** Both halves or neither: `Store` has no spelling for one alone. */
-export function settingsStore<T>(name: string): Store<T> {
+function settingsStore<T>(name: string): Store<T> {
     return {
         // Stored as JSON; a setting never written answers `null`, the miss.
         get: async () => {
@@ -3865,7 +3872,7 @@ A deploy that restarts every instance no longer stampedes the thing behind it.
 
 **One store per args key, derived from the key** — Two profiles whose settings live at two addresses. Both are read at once, and neither reads back the other's.
 
-```abide Profiles.abide
+```abide lib/Profiles.abide
 <script server>
 import { reactive, type Store } from '@abide/abide'
 import { GET } from '@abide/abide/server'
@@ -3899,7 +3906,7 @@ const settingsCache = reactive(
     { store: ({ profile }) => redisStore<Settings>(`settings:${profile}`) },
 )
 
-export const getSettings = GET(settingsCache, {
+const getSettings = GET(settingsCache, {
     description: 'The settings of a profile.',
 })
 </script>
@@ -3967,9 +3974,9 @@ Read on: [Channels](/values/let-anything-publish-and-anything-read.md) · [Recen
 
 # Data from the server
 
-*A handler a server block exports is callable, and the method you declare it with is the difference.*
+*A handler is callable, and the method you declare it with is the difference.*
 
-A handler a `<script server>` exports is callable. The method you declare it with is the whole difference between a read and a write.
+A handler you declare is callable. The method you declare it with is the whole difference between a read and a write.
 
 | You declare | Means |
 | --- | --- |
@@ -3977,13 +3984,8 @@ A handler a `<script server>` exports is callable. The method you declare it wit
 | `POST` / `PUT` / `PATCH` / `DELETE` | a mutation, retaining nothing by default |
 | a `GET` over a `global` value, patched by a `POST` | live state every caller follows |
 
-```abide src/invoices/api.abide — excerpt
-<script server>
-export const listInvoices = GET(() => database.invoice.all())
-export const payInvoice = POST(
-    ({ id }: { id: string }) => database.invoice.pay(id),
-)
-</script>
+```ts src/invoices/listInvoices.ts — excerpt
+export default GET(() => database.invoice.all())
 ```
 
 ## Reading data
@@ -4068,14 +4070,13 @@ Read on: [Handler URLs](/data/find-the-url-a-handler-answers-on.md)
 
 You have a database and a page that needs a row. Most stacks make that four artifacts: a handler, a route registration, a client function, and a shared type nothing enforces. Three exist only because the halves are in different processes.
 
-Here you write the handler.
+A `.ts` beside your pages is a handler, and its path is its address. A handler only one file calls can stay in that file instead. Either way, the page calls it by name.
 
-## A handler is an export of a `<script server>`
+## A handler is a file's default export
 
 **`GET(fn)` — a handler a page imports** — An invoice read straight out of the database by a component. Reload the page and watch it land.
 
-```abide Invoice.abide
-<script server>
+```ts getInvoice.ts
 import { GET } from '@abide/abide/server'
 
 type InvoiceRow = { number: string; dueOn: string; total: string }
@@ -4084,8 +4085,8 @@ const INVOICES: Record<string, InvoiceRow> = {
     '4021': { number: 'INV-4021', dueOn: '2026-09-14', total: '$1,240.00' },
 }
 
-/** Address from the directory and the export; schemas from the annotation. */
-export const getInvoice = GET(
+/** Address from the file's path; schemas from the annotation. */
+export default GET(
     async ({ id }: { id: string }) => {
         await Bun.sleep(700) // a slow database, so the wait is on screen
         const row = INVOICES[id]
@@ -4094,10 +4095,12 @@ export const getInvoice = GET(
     },
     { description: 'An invoice, by id.' },
 )
-</script>
+```
 
+```abide lib/Invoice.abide
 <script>
 import { reactive } from '@abide/abide'
+import getInvoice from '../getInvoice.ts'
 
 const invoice = reactive(() => getInvoice({ id: '4021' }))
 </script>
@@ -4109,28 +4112,28 @@ const invoice = reactive(() => getInvoice({ id: '4021' }))
 </ul>
 ```
 
-*1 file, 0 API in it* — against a route, a fetch, a client wrapper and a type kept in step by hand.
+*2 files, 0 API in them* — against a route, a fetch, a client wrapper and a type kept in step by hand.
 
-A `<script server>` block runs on the server alone. Write one in any `.abide`, wrap a function in `GET` and export it. `GET` derives the argument and result schemas from the annotations you already wrote.
+A handler file runs on the server alone. Put a `.ts` in a directory under `src`, wrap a function in `GET` and make it the default export. `GET` derives the argument and result schemas from the annotations you already wrote.
 
-The address is the directory the file sits in, then the export's name:
+The address is the file's path, and the file's name is its last segment:
 
-| File | Export | Answers at |
-| --- | --- | --- |
-| `src/data/read-data-without-writing-an-api/Invoice.abide` | `getInvoice` | `/server/read-data-without-writing-an-api/getInvoice` |
-| `src/users/page.abide` | `getUser` | `/users/getUser` |
-| `src/layout.abide` | `health` | `/health` |
+| File | Answers at |
+| --- | --- |
+| `src/data/read-data-without-writing-an-api/getInvoice.ts` | `/data/read-data-without-writing-an-api/getInvoice` |
+| `src/users/getUser.ts` | `/users/getUser` |
+| `src/health.ts` | `/health` |
 
-The file's own name is never part of it. Split a directory's handlers across as many files as you like, or keep them in the page that calls them. Two files exporting one name there is a build error naming both.
+One file is one handler, and exporting anything else from it is a build error (16.73). A handler file is the app's API: a page imports it, a script calls its address, and the CLI and MCP offer it as a command and a tool.
 
-You never write that address down. It is there so a log line or a network tab tells you which export you are looking at.
+Inside the app you never write that address down. It is there so a log line or a network tab tells you which handler you are looking at.
 
 ## A page reaches the handler through an ordinary import
 
-```abide src/invoices/[id]/page.abide — excerpt
+```abide src/invoices/[id]/index.abide — excerpt
 <script>
 import { reactive, route } from '@abide/abide'
-import { getInvoice } from '../Invoice.abide'
+import getInvoice from '../getInvoice.ts'
 
 const invoice = reactive(() => getInvoice({ id: route.params.id }))
 </script>
@@ -4143,23 +4146,65 @@ The import is real — name, argument type and return type are the ones you just
 
 The page reads `invoice`, which starts the load. The document goes out immediately with holes where the values are. The holes fill when the row lands.
 
-## The browser receives a generated client, not your server block
+## A handler only one file calls is declared in that file
+
+**`const getTerms = GET(fn)` — a handler its own file calls** — An invoice's payment terms, which only this card shows. The handler sits in the card's own server block, and nothing else in the app can import it.
+
+```abide lib/InvoiceTerms.abide
+<script server>
+import { GET } from '@abide/abide/server'
+
+const TERMS: Record<string, { due: string; lateFee: string }> = {
+    '4021': { due: 'Net 30', lateFee: '1.5% a month' },
+}
+
+// No export: this file is its one caller.
+const getTerms = GET(
+    async ({ id }: { id: string }) => {
+        await Bun.sleep(400) // a slow database, so the wait is on screen
+        const row = TERMS[id]
+        if (row === undefined) throw new Error(`no terms for ${id}`)
+        return row
+    },
+    { description: "An invoice's payment terms, by id." },
+)
+</script>
+
+<script>
+import { reactive } from '@abide/abide'
+
+const terms = reactive(() => getTerms({ id: '4021' }))
+</script>
+
+<ul class="fields stacked">
+    <li><span>terms</span><strong>{terms.due}</strong></li>
+    <li><span>late fee</span><strong>{terms.lateFee}</strong></li>
+</ul>
+```
 
-The browser never sees the `<script server>`. Its copy of the file **generates** one export per handler in the block's place, carrying:
+A `<script server>` declares `getTerms` as a `const`, and the same file's `<script>` and template call it by name. A `.abide` exports nothing (34.17), so no other file can reach it.
+
+It still answers over http — the browser's copy of the card calls it — at its file's path below `/__abide/handlers` and then its name: `/__abide/handlers/data/read-data-without-writing-an-api/lib/InvoiceTerms/getTerms` (16.70). That address is listed on no surface: not OpenAPI, not MCP, not the CLI (16.71). It takes nothing from the path, and it runs under the middleware filed at this page's route, the directory holding the card's `lib` (16.72).
+
+When a second file needs it, or a script does, move it into a handler file. The call is unchanged: `const getTerms =` becomes `export default`, and the file's name becomes its address.
+
+## The browser receives a generated client, not your server code
+
+The browser never sees a handler file or a `<script server>`. Importing a handler file into a page hands the browser a **generated** call in its place (16.74), and a `.abide`'s own copy carries one per handler its server block declares (16.70). Each carries:
 
 - the HTTP method
 - the mount-relative address
 - the description
 
-Nothing else. Your database import and the block's own module-level work were never part of the module the browser got — so "no server code shipped" is how the build works, not something an optimizer is trusted to have achieved.
+Nothing else. Your database import and the module-level work around the handler were never part of the module the browser got — so "no server code shipped" is how the build works, not something an optimizer is trusted to have achieved.
 
-A server block exports handlers alone, and anything else is a build error. Import a module under a `server` directory into a page and you get a compile error naming it. Never a stub that silently does nothing.
+Import a module under a `server` directory into a page and you get a compile error naming it. Never a stub that silently does nothing.
 
 ## You get a `Reactive`, not a promise
 
 **A call hands back a `Reactive`, not a promise** — An invoice and the reminder button that must not fire before it lands. Wait for the total, then press Reload.
 
-```abide InvoiceReminder.abide
+```abide lib/InvoiceReminder.abide
 <script server>
 import { GET } from '@abide/abide/server'
 
@@ -4167,7 +4212,7 @@ const INVOICES: Record<string, { total: string }> = {
     '4021': { total: '$1,240.00' },
 }
 
-export const getInvoiceTotal = GET(
+const getInvoiceTotal = GET(
     async ({ id }: { id: string }) => {
         await Bun.sleep(700) // a slow database, so the wait is on screen
         const row = INVOICES[id]
@@ -4207,7 +4252,7 @@ See [Loading states](/values/show-a-value-that-isnt-there-yet.md).
 
 **A `GET` over a `global` value follows the server** — The open deals, and a button that moves one on the server. Open this page in a second tab and press it in either: both move, and nothing on the page reloads the list.
 
-```abide Deals.abide
+```abide lib/Deals.abide
 <script server>
 import { GET, POST, reactive } from '@abide/abide/server'
 
@@ -4222,11 +4267,11 @@ const pipeline = reactive(
     { global: true },
 )
 
-export const openDeals = GET(pipeline, {
+const openDeals = GET(pipeline, {
     description: 'The open deals, and the stage each is at.',
 })
 
-export const advanceDeal = POST(
+const advanceDeal = POST(
     ({ id }: { id: string }) => {
         pipeline.patch((deals) => {
             const deal = deals.find((each) => each.id === id)
@@ -4261,9 +4306,9 @@ A browser that reads a `GET` stays subscribed to it over one web socket the whol
 The first read and the socket are two paths, and a change landing between them would be lost. So the answer names its version as an ordinary `ETag`, the browser names that version when it subscribes, and the server sends the value only if it has moved since (18.6). The same `ETag` serves any reader: a `GET` carrying `If-None-Match` with the version it holds is answered `304 Not
         Modified` and no body (18.19), so `curl` and a browser's cache revalidate the way the page does.
 
-The follow itself is standard too. Ask the same address for `text/event-stream` and it is a stream of server-sent events: `event:
-        value` with the value and its version as the event `id`, then `event:
-        patch` with each change as JSON Patch (18.20). An `EventSource` reconnecting sends the last `id` back as `Last-Event-ID` and is sent only what moved after it — so `curl -N -H 'Accept: text/event-stream'` follows a value with nothing abide-shaped on its side, and `abide watch` does the same from a shell.
+The follow itself is standard too. `openDeals` is the card's own, so its address is one no listing names. To hand the follow to a script, make it a handler file — `src/deals/openDeals.ts`, answering at `/deals/openDeals` — with the pipeline in a module under `server` that it and `advanceDeal` both import. Ask that address for `text/event-stream` and it is a stream of server-sent events: `event: value` with the value and its version as the event `id`, then `event: patch` with each change as JSON Patch (18.20). An `EventSource` reconnecting sends the last `id` back as `Last-Event-ID` and is sent only what moved after it.
+
+So `curl -N -H 'Accept: text/event-stream'` follows a value with nothing abide-shaped on its side, and `abide watch` does the same from a shell.
 
 A trigger reaches browsers too, for any `GET`: `getContact.invalidate({ id })` inside a handler marks every browser's copy of that contact stale, whether or not the value is `global`.
 
@@ -4275,16 +4320,14 @@ The `reactive` a handler becomes is not ceremony. A keyed value is identity per
 
 Name the caching yourself in the same object as the description:
 
-```abide src/invoices/api.abide — excerpt
-<script server>
-export const getInvoiceTotals = GET(
+```ts src/invoices/getInvoiceTotals.ts — excerpt
+export default GET(
     ({ id }: { id: string }) => database.invoice.totals(id),
     {
         ttl: 30_000,
         description: "One invoice's totals, by id. Cached for 30 seconds.",
     },
 )
-</script>
 ```
 
 `GET` accepts three things:
@@ -4333,20 +4376,20 @@ A read is safe to repeat. A write is not — and a browser repeats one for you:
 | `PATCH(handler, options?)` | the same, for a partial change |
 | `DELETE(handler, options?)` | a mutation whose arguments travel in the URL |
 
-Each takes exactly what [`GET`](/data/read-data-without-writing-an-api.md) takes — a `reactive`, a channel, or a plain function that becomes a `reactive` — mounts at the same file-path address, and accepts the same options. The method is the whole per-method difference, and what it changes is retention, how the arguments travel, and whether a browser may cache the answer. Every signature is in the [Transports](/reference/transports.md) reference.
+Each takes exactly what [`GET`](/data/read-data-without-writing-an-api.md) takes — a `reactive`, a channel, or a plain function that becomes a `reactive` — answers where a `GET` would, and accepts the same options. The method is the whole per-method difference, and what it changes is retention, how the arguments travel, and whether a browser may cache the answer. Every signature is in the [Transports](/reference/transports.md) reference.
 
 ## Two presses inside one flight are one write
 
 **`POST(handler)` — a write the browser cannot repeat** — An invoice being paid. Press Pay twice, quickly — one payment lands on the record, not two.
 
-```abide PayInvoice.abide
+```abide lib/PayInvoice.abide
 <script server>
 import { POST } from '@abide/abide/server'
 
 // The writes that landed: a double press must not bill twice.
 let payments = 0
 
-export const payInvoice = POST(
+const payInvoice = POST(
     async ({ id }: { id: string }) => {
         await Bun.sleep(1500) // a slow database, so the wait is on screen
         payments += 1
@@ -4392,14 +4435,12 @@ Read on: [Caching](/values/load-once-per-set-of-arguments.md) · [Failures](/dat
 
 Where a write genuinely must not run twice in a period, declare the `ttl` on the `reactive` and hand that to the method:
 
-```abide src/invoices/api.abide — excerpt
-<script server>
+```ts src/invoices/remindAboutInvoice.ts — excerpt
 const sendReminder = reactive(({ id }: { id: string }) => mailer.remind(id), {
     ttl: 3_600_000,
 })
 
-export const remindAboutInvoice = POST(sendReminder)
-</script>
+export default POST(sendReminder)
 ```
 
 One reminder per invoice per hour, whoever asks and however often.
@@ -4414,7 +4455,7 @@ The shapes wanted the repair anyway. A read and a write have different `Args`.
 
 **`PATCH`, `PUT` and `DELETE` — the verb says what the write does** — A contact's phone changed, a tag taken off, the tags put back: three writes, each declared with the method that names it.
 
-```abide Contact.abide
+```abide lib/Contact.abide
 <script server>
 import { DELETE, GET, PATCH, PUT } from '@abide/abide/server'
 
@@ -4442,23 +4483,23 @@ const contacts = {
     },
 }
 
-export const getContact = GET(({ id }: { id: string }) => contacts.find(id), {
+const getContact = GET(({ id }: { id: string }) => contacts.find(id), {
     description: 'A contact, by id.',
 })
 
-export const updatePhone = PATCH(
+const updatePhone = PATCH(
     ({ id, phone }: { id: string; phone: string }) =>
         contacts.update(id, { phone }),
     { description: 'Changes the phone of a contact.' },
 )
 
-export const replaceTags = PUT(
+const replaceTags = PUT(
     ({ id, tags }: { id: string; tags: string[] }) =>
         contacts.update(id, { tags }),
     { description: 'Replaces the tags of a contact.' },
 )
 
-export const removeTag = DELETE(
+const removeTag = DELETE(
     async ({ id, tag }: { id: string; tag: string }) => {
         const { tags } = await contacts.find(id)
         return contacts.update(id, {
@@ -4517,16 +4558,18 @@ Three body encodings are accepted, which lets a plain `<form>` reach the same ad
 | `multipart/form-data` | a form with a file in it |
 | `application/x-www-form-urlencoded` | a form without one |
 
-## A folder is part of the address
+## A write answers where its file says
 
-A handler answers at the route of the directory it is declared in, then its name. Nesting nests the address, and nothing else changes:
+Both cards declare their writes in their own `<script server>`, so each write is that card's alone. `payInvoice` answers at `/__abide/handlers/data/change-something-on-the-server/lib/PayInvoice/payInvoice`, listed on no surface, and runs under this page's middleware (16.70, 16.71, 16.72). A write only the button beside it sends belongs there.
 
-| File | Export | Answers at |
-| --- | --- | --- |
-| `src/invoices/api.abide` | `payInvoice` | `/invoices/payInvoice` |
-| `src/admin/page.abide` | `recent` | `/admin/recent` |
+A write another page, a script or an agent sends is a handler file, and answers at its path. Nesting nests the address, and nothing else changes:
+
+| File | Answers at |
+| --- | --- |
+| `src/invoices/payInvoice.ts` | `/invoices/payInvoice` |
+| `src/admin/recent.ts` | `/admin/recent` |
 
-An address answers each method once. Two files in one directory exporting `recent` answer at the same address, and that is a build error naming both files rather than whichever one won at the first request. A `POST` beside a page is another method, and is the form that page posts to.
+An address answers each method once. A page `src/admin/recent.abide` beside a `GET` in `recent.ts` answers at the same address, and that is a build error naming both files rather than whichever one won at the first request. A `POST` at a page's address is another method, and is the form that page posts to.
 
 Read on: [Handler URLs](/data/find-the-url-a-handler-answers-on.md)
 
@@ -4595,7 +4638,7 @@ Read on: [Response types](/data/answer-with-something-other-than-json.md)
 
 **`rpc.isError(e, name)` — the refusal, matched by name** — Three invoices on one account. Open the second and the third — each is refused for a different reason.
 
-```abide AccountInvoice.abide
+```abide lib/AccountInvoice.abide
 <script server>
 import { refuse } from '@abide/abide'
 import { GET } from '@abide/abide/server'
@@ -4624,7 +4667,7 @@ const INVOICES: Record<string, Row> = {
     '4312': { total: '$512.00', mine: true, owner: 'ada', replacedBy: '4313' },
 }
 
-export const getInvoice = GET(
+const getInvoice = GET(
     async ({ id }: { id: string }) => {
         await Bun.sleep(450) // a slow database, so the wait is on screen
         const invoice = INVOICES[id]
@@ -4685,7 +4728,7 @@ Read on: [Loading states](/values/show-a-value-that-isnt-there-yet.md) · [Condi
 
 **`s.isError(e, name)` — a refusal the page made itself** — A contact's phone, normalized on the way in. Take a digit out and press Save.
 
-```abide Phone.abide
+```abide lib/Phone.abide
 <script>
 import { reactive, refuse } from '@abide/abide'
 import { z } from 'zod'
@@ -4788,11 +4831,11 @@ Read on: [Schemas](/data/check-what-callers-send-you.md)
 
 **`aborted` — what a load reads once every caller stopped waiting** — A contact's year statement from a slow ledger. Load it and cancel before it lands.
 
-```abide Statement.abide
+```abide lib/Statement.abide
 <script server>
 import { GET } from '@abide/abide/server'
 
-export const getStatement = GET(
+const getStatement = GET(
     async ({ id }: { id: string }) => {
         // A slow ledger, so there is time to cancel.
         await Bun.sleep(2500)
@@ -4895,7 +4938,7 @@ That is the default framing and not the only one.
 
 **`sse(values)` — events, whoever asks** — A wallboard by the sales floor reads the visits feed. It sends no Accept header, and what comes back is events anyway.
 
-```abide VisitsFeed.abide
+```abide lib/VisitsFeed.abide
 <script server>
 import { GET, sse } from '@abide/abide/server'
 
@@ -4913,7 +4956,7 @@ async function* latestVisits() {
     }
 }
 
-export const visits = GET(() => sse(latestVisits()), {
+const visits = GET(() => sse(latestVisits()), {
     description: 'Live visits, as server-sent events.',
 })
 </script>
@@ -4951,7 +4994,7 @@ Read on: [Response types](/data/answer-with-something-other-than-json.md)
 
 **`jsonl(values)` — a list sent one value per line** — The warehouse loads yesterday's sales a line at a time. The database hands back an array, and the export still goes out as lines.
 
-```abide WarehouseExport.abide
+```abide lib/WarehouseExport.abide
 <script server>
 import { GET, jsonl } from '@abide/abide/server'
 
@@ -4965,7 +5008,7 @@ const BY_DAY: Record<string, Sale[]> = {
     ],
 }
 
-export const salesForWarehouse = GET(
+const salesForWarehouse = GET(
     async ({ day }: { day: string }) => {
         // Read whole: the export is a list before it is a stream.
         await Bun.sleep(400)
@@ -5004,7 +5047,7 @@ An array is a value, so returned bare it goes out as one JSON array (16.30) —
 
 **`bytes(values)` — a file written as its rows are read** — Sales by region as a CSV download. Each line goes into the file as the cursor reaches its row.
 
-```abide SalesCsv.abide
+```abide lib/SalesCsv.abide
 <script server>
 import { bytes, GET } from '@abide/abide/server'
 
@@ -5027,7 +5070,7 @@ async function* csvOf(year: number): AsyncGenerator<Uint8Array> {
     }
 }
 
-export const salesCsv = GET(
+const salesCsv = GET(
     ({ year }: { year: number }) => bytes(csvOf(year)),
     { description: 'Sales by region for a year, as CSV.' },
 )
@@ -5071,7 +5114,7 @@ One input type across `page`, `jsonl`, `sse` and `bytes`. A source that is alrea
 
 **`{#for row of call()}` — the rows, and the whole of them** — Sales per region, a row at a time. Watch the list fill while the count still has nothing to say.
 
-```abide RegionReport.abide
+```abide lib/RegionReport.abide
 <script server>
 import { GET } from '@abide/abide/server'
 
@@ -5083,7 +5126,7 @@ const BY_YEAR: Record<string, { name: string; total: string }[]> = {
     ],
 }
 
-export const salesByRegion = GET(
+const salesByRegion = GET(
     async function* ({ year }: { year: number }) {
         for (const row of BY_YEAR[String(year)] ?? []) {
             await Bun.sleep(1200) // a slow database: each row lands alone
@@ -5133,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
 
@@ -5141,7 +5184,7 @@ Both change more than once, and how the producer produces separates them. A chan
 
 What they share is keying. A `{#for}` over a stream's accumulation is positional unless something names a key (32.13) — the block's own `by`, or a `by` the value declares (32.32) — and a row with an identity of its own says which:
 
-```abide src/reports/page.abide — excerpt
+```abide src/reports/index.abide — excerpt
 {#for region of salesByRegion({ year: 2026 }) by region.code}
     <tr><td>{region.name}</td><td>{region.total}</td></tr>
 {/for}
@@ -5179,8 +5222,8 @@ Nothing on the page polls and nothing on it opens a connection. A page that read
 | You write | What it is |
 | --- | --- |
 | `reactive(fn, { global: true })` | the value every caller shares, one per args key where `fn` declares a parameter |
-| `export const room = GET(rooms)` | its address — a browser reading it follows it |
-| `export const say = POST(…)` | the way in from outside, a handler that patches the value |
+| `const room = GET(rooms)` | its address — a browser reading it follows it |
+| `const say = POST(…)` | the way in, a handler that patches the value |
 
 `global: true` puts the value in one process-wide cache that outlives every request (11.34). Leave it out and the value is request-local on a server (11.32), so every caller gets one of their own and nobody hears anybody. Every signature is in the [Transports](/reference/transports.md) reference, and what a channel is before it has an address is [Channels](/values/let-anything-publish-and-anything-read.md).
 
@@ -5188,7 +5231,7 @@ Nothing on the page polls and nothing on it opens a connection. A page that read
 
 **`GET` + `POST` — your room, every tab** — A support room per browser: a `GET` every tab follows and a `POST` that adds a turn. Open this page in a second tab, send from either, and the last turn changes in both — and in nobody else's.
 
-```abide SupportRoom.abide
+```abide lib/SupportRoom.abide
 <script server>
 import { reactive } from '@abide/abide'
 import { GET, POST } from '@abide/abide/server'
@@ -5208,10 +5251,10 @@ const rooms = reactive(
 )
 
 /** Read, and followed by every tab reading it. */
-export const room = GET(rooms, { description: "A support room's turns." })
+const room = GET(rooms, { description: "A support room's turns." })
 
 /** The server writes the turn, so what a tab sends is only its text. */
-export const say = POST(
+const say = POST(
     ({ id, text }: { id: string; text: string }) => {
         rooms({ id }).patch((turns) => {
             turns.push({ id: crypto.randomUUID(), speaker: 'you', text })
@@ -5263,7 +5306,7 @@ Each turn carries an id the server gives it, and the room declares `by: 'id'`. A
 `say` takes `{ id, text }` and nothing else. The turn's id, its speaker and anything else it carries are written by the handler, so a caller can only ever add a turn that says what they typed. The example writes `'you'`; an app with sign-in writes who is signed in:
 
 ```ts server
-export const say = POST(({ id, text }: { id: string; text: string }) => {
+const say = POST(({ id, text }: { id: string; text: string }) => {
     const { name } = principal.resolved()
     rooms({ id }).patch((turns) => {
         turns.push({ id: crypto.randomUUID(), speaker: name, text })
@@ -5286,7 +5329,7 @@ Read on: [Mutations](/data/change-something-on-the-server.md) · [Auth & princip
 A room anyone can follow is a room anyone can read. Put a rung on the `GET`:
 
 ```ts server
-export const room = GET(rooms, {
+const room = GET(rooms, {
     middleware: [
         async (next, ctx) =>
             (await isMember(ctx.request, ctx.args())) ? next(ctx) : refuse(403),
@@ -5313,11 +5356,11 @@ A `patch` on the room is sent to every follower standing at the version it was m
 
 A write to a followed copy stays in that tab — a `say` is how a turn reaches the room — and lasts until the server next changes the room.
 
-The same follow is open to anything that speaks http. Ask the `GET`'s address for `text/event-stream` and it is server-sent events, each frame's op its `event`, its version the `id`, and the value or the JSON Patch its `data` (18.20):
+The same follow is open to anything that speaks http, from a handler file. The card's `room` is its own, at an address no listing names; to hand the room to a script, put the `GET` in `src/support/room.ts` as its default export, with `rooms` in a module under `server` that it and `say` both import. Ask `/support/room` for `text/event-stream` and it is server-sent events, each frame's op its `event`, its version the `id`, and the value or the JSON Patch its `data` (18.20):
 
 ```
 curl -N -H 'Accept: text/event-stream' \
-  'https://app.example/server/keep-a-room-of-callers-in-sync/room?id=lobby'
+  'https://app.example/support/room?id=lobby'
 ```
 
 An `EventSource` reconnecting sends the last `id` back as `Last-Event-ID`, and is sent only what moved after it.
@@ -5343,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
 
@@ -5386,8 +5429,7 @@ Deriving from an annotation means the build resolves types, so build time is typ
 
 That is the trade "the shape is never declared twice" is bought with, and the repair is an option at each **position**. `args` gates the arguments a keyed value is called with:
 
-```abide src/invoices/api.abide — excerpt
-<script server>
+```ts src/invoices/createInvoice.ts — excerpt
 import { z } from 'zod'
 
 const invoices = reactive(
@@ -5395,13 +5437,12 @@ const invoices = reactive(
     { args: z.object({ lines: z.array(lineSchema).min(1) }) },
 )
 
-export const createInvoice = POST(invoices)
-</script>
+export default POST(invoices)
 ```
 
 `transform` shapes what gets stored:
 
-```ts src/ledger.ts — excerpt
+```ts src/lib/ledger.ts — excerpt
 const paidIds = reactive(() => listInvoices({ year }), {
     transform: (all) => new Set(all.filter((r) => r.paid).map((r) => r.id)),
 })
@@ -5419,7 +5460,7 @@ Either option pins a shape you will not have widened, and either is where a cons
 
 **`reactive(v, { schema })` — a check with no server in it** — A contact's email. Take the dot out of the domain, and watch the record rather than the field.
 
-```abide Email.abide
+```abide lib/Email.abide
 <script>
 import { reactive } from '@abide/abide'
 import { z } from 'zod'
@@ -5477,7 +5518,7 @@ A JSON Schema document is the **native** shape, and it enters as the Standard fo
 
 **`jsonSchema(document)` — a JSON Schema document as a gate** — The seats on a deal, capped at fifty by a JSON Schema document. Press + past the cap and the deal keeps what it had.
 
-```abide Seats.abide
+```abide lib/Seats.abide
 <script>
 import { jsonSchema, reactive } from '@abide/abide'
 
@@ -5511,7 +5552,7 @@ A document is data, so something has to read it, and `jsonSchema` is what brings
 
 **`Issues<T>` — a message under the field it belongs to** — The invoice search. Empty the query, or ask for four — each message lands under its own field.
 
-```abide InvoiceSearch.abide
+```abide lib/InvoiceSearch.abide
 <script server>
 import { reactive } from '@abide/abide'
 import { GET } from '@abide/abide/server'
@@ -5540,7 +5581,7 @@ const matching = reactive(
     },
 )
 
-export const searchInvoices = GET(matching, {
+const searchInvoices = GET(matching, {
     description: 'Invoices matching a query.',
 })
 </script>
@@ -5602,7 +5643,7 @@ Read on: [OpenAPI](/machines/describe-your-api-without-writing-a-spec.md)
 
 **`validateJson(schema, value)` — the issues, with no value to gate** — A contact row pasted from a partner's export, checked before it is imported. Fix the plan and the seats, and watch each issue leave its own field.
 
-```abide PastedRow.abide
+```abide lib/PastedRow.abide
 <script>
 import { reactive, validateJson } from '@abide/abide'
 
@@ -5698,7 +5739,7 @@ Read on: [Failures](/data/refuse-a-request-and-say-why.md)
 
 **`reactive(fn, { args })` — the gate refuses, the arguments key** — One invoice, spelled two ways. Open the second spelling, then go back to the first.
 
-```abide InvoiceKey.abide
+```abide lib/InvoiceKey.abide
 <script server>
 import { reactive } from '@abide/abide'
 import { GET } from '@abide/abide/server'
@@ -5720,7 +5761,7 @@ const invoiceById = reactive(
     { args: z.object({ id: z.string().toLowerCase() }) },
 )
 
-export const getInvoice = GET(invoiceById, {
+const getInvoice = GET(invoiceById, {
     description: 'An invoice, by id.',
 })
 </script>
@@ -5760,7 +5801,7 @@ In channels keyed by their args the same cost is sharper: two spellings of a cha
 
 A channel is an array, so its `schema` checks the whole array on every `set` — the app's own included, because validity is not a question about who is asking:
 
-```ts src/channels.ts — excerpt
+```ts src/lib/channels.ts — excerpt
 export const announcements = reactive<Post[]>([], {
     schema: z.array(messageSchema),
     global: true,
@@ -5771,7 +5812,7 @@ What it does not see is a `patch`. An append through `patch` mutates the array i
 
 A channel keyed by its args also has a **channel key**, and that is the parameter its body declares, so it is `args`. The key picks which channel while the messages flow:
 
-```ts src/channels.ts — excerpt
+```ts src/lib/channels.ts — excerpt
 export const thread = reactive((_args: { id: string }): Post[] => [], {
     args: z.object({ id: z.string().min(1) }),
     schema: z.array(messageSchema),
@@ -5814,12 +5855,12 @@ type Middleware<Ctx, Result> = (
 
 | Lane | `Ctx` | Result | Runs |
 | --- | --- | --- | --- |
-| app | `{ request }` | `Response` | pre-routing, on every request |
+| app | `{ request }` | `Response` | over every request its file's route answers, before routing at the root |
 | rpc | `{ request, args }` | `Value \| Failures` | on every call to that handler |
 
-Two lanes, one type. `Ctx` is a record naming what that lane actually **has** — the app lane runs before the route resolves, so it has a request and no arguments; the rpc lane is typed to one handler's own arguments.
+Two lanes, one type. `Ctx` is a record naming what that lane actually **has** — the app lane runs around a whole route rather than one handler, so it has a request and no arguments; the rpc lane is typed to one handler's own arguments.
 
-The **Result** column is the difference that matters. The rpc lane hands back what the handler would have handed back, not a `Response`, and that lets the same rungs run on an **in-process** call. A page rendering on the server reads through the handler, so a rung that authorizes on an id in the arguments cannot be reachable by a browser and missed by the render. The app lane stays `Response`-shaped because pre-routing there is no value yet, which also makes it the lane where a rung that must set a header belongs.
+The **Result** column is the difference that matters. The rpc lane hands back what the handler would have handed back, not a `Response`, and that lets the same rungs run on an **in-process** call. A page rendering on the server reads through the handler, so a rung that authorizes on an id in the arguments cannot be reachable by a browser and missed by the render. The app lane stays `Response`-shaped because what it wraps is a whole answer rather than a value, which also makes it the lane where a rung that must set a header belongs.
 
 A rung's refusals join the handler's own in what the caller can narrow, so `rpc.isError(error, 'NotYours')` reaches a name the rung declared and never the handler.
 
@@ -5850,7 +5891,7 @@ A rung that wants to observe both — a timer, a log line — calls `next` insid
 
 **`middleware(rung)` — one rung in front of a route's answers** — A CRM behind a load balancer, and the question of which instance answered. Ask, and read a header the handler never wrote.
 
-```abide Ping.abide
+```abide lib/Ping.abide
 <script server>
 import { GET, middleware } from '@abide/abide/server'
 
@@ -5864,7 +5905,7 @@ middleware(async (next) => {
 })
 
 /** Writes no header of its own. */
-export const ping = GET(() => 'pong', { description: 'Answers pong.' })
+const ping = GET(() => 'pong', { description: 'Answers pong.' })
 </script>
 
 <script>
@@ -5886,11 +5927,15 @@ let servedBy = reactive('—')
 ```
 
 `middleware(...)` is a hook you **call** from a `<script
-        server>`, and it runs over the route of the file that called it. The root layout's rungs run before routing, over every request. A section's `layout.abide` files rungs that run after routing, over that section's pages and handlers alone — which is where a guard on `/admin` goes. The card's rung is filed beside `ping`, so it sets a header on the way out of every answer this page's route gives, and no handler wrote it. Filed in the root layout, the same rung would stamp every answer the app gives — a page, a built asset, the health check.
+        server>` or a handler file, and it runs over the route of the file that called it and every route below. The root layout's rungs run before routing, over every request. A section's `layout.abide` files rungs that run after routing, over that section's pages and handlers alone — which is where a guard on `/admin` goes.
+
+The card's file sits in this page's `lib`, so its rung is filed at this page's route (37.1). `ping` is the card's private handler, and its address, `/__abide/handlers/data/decide-who-may-call-what/lib/Ping/ping`, is below no route of this page's. The rung runs over it anyway, because a private handler runs under the middleware filed where its file's hooks are (16.72). No handler wrote the header.
+
+So a guard on a section covers every private handler its files declare, wherever their addresses point. Filed in the root layout, the same rung would stamp every answer the app gives — a page, a built asset, the health check. `abide routes` lists each hook with the route it is filed at.
 
 Rungs compose in registration order. The call hands back the way off again, so a module that is torn down can remove its own.
 
-Pre-routing means this lane has a request and nothing else. Anything resource-aware — authorizing by an id in the arguments — is necessarily a handler's own rung, which is where `ctx.args()` exists.
+Around a route this lane has a request and nothing else. Anything resource-aware — authorizing by an id in the arguments — is necessarily a handler's own rung, which is where `ctx.args()` exists.
 
 Read on: [Lifecycle](/app/run-code-at-start-and-stop.md) · [CSP](/app/lock-down-what-the-page-may-load.md)
 
@@ -5898,7 +5943,7 @@ Read on: [Lifecycle](/app/run-code-at-start-and-stop.md) · [CSP](/app/lock-down
 
 **`middleware: [rung]` — a check that runs before the parse** — The recent invoices. Ask for nine while signed out, then sign in and ask again.
 
-```abide Recent.abide
+```abide lib/Recent.abide
 <script server>
 import { principal, refuse } from '@abide/abide'
 import { GET, POST } from '@abide/abide/server'
@@ -5911,7 +5956,7 @@ const INVOICES = [
     { id: '4023', total: '$76.50' },
 ]
 
-export const searchInvoices = GET(
+const searchInvoices = GET(
     async ({ limit }: { limit: number }) => {
         await Bun.sleep(450) // a slow database, so the wait is on screen
         return INVOICES.slice(0, limit)
@@ -5929,11 +5974,11 @@ export const searchInvoices = GET(
     },
 )
 
-export const signIn = POST(() => principal.set({ id: 'ada' }), {
+const signIn = POST(() => principal.set({ id: 'ada' }), {
     description: 'Signs in as Ada.',
 })
 
-export const signOut = POST(() => principal.clear(), {
+const signOut = POST(() => principal.clear(), {
     description: 'Signs out.',
 })
 </script>
@@ -6003,6 +6048,8 @@ Read on: [CORS](/data/let-another-origin-call-you.md) · [Health](/app/tell-a-lo
 
 `clients` withholds a handler from a **surface** — an OpenAPI listing, an MCP tool list. It is not access control: the http address answers exactly as it did. This rung decides who **may** call, the same one that decides it for a browser.
 
+A private handler is the same. It is listed nowhere and still answers http at its address, so the rungs over its file are what guard it.
+
 Read on: [Withholding a surface](/machines/keep-a-handler-off-a-surface.md) · [Auth & principal](/app/know-who-is-calling.md)
 
 ## Next
@@ -6131,7 +6178,7 @@ Read on: [Mutations](/data/change-something-on-the-server.md)
 
 **`timeout` — milliseconds without progress, not since the first byte** — A sales report streaming a row a second. North takes three seconds under a two-second bound; south has stopped producing.
 
-```abide SalesReport.abide
+```abide lib/SalesReport.abide
 <script server>
 import { GET } from '@abide/abide/server'
 
@@ -6145,7 +6192,7 @@ const BY_REGION: Record<string, { name: string; total: string }[]> = {
     south: [{ name: 'week 1', total: '$2,140.00' }],
 }
 
-export const salesByRegion = GET(
+const salesByRegion = GET(
     async function* ({ region }: { region: string }) {
         for (const row of BY_REGION[region] ?? []) yield row
         // The stall the per-chunk timeout is against, on one region only.
@@ -6264,7 +6311,7 @@ There is one form and no options. It is a server name, imported from `@abide/abi
 
 **`reachable(host)` — ask once, refuse at once** — Invoice 4310, and a billing service that has stopped answering. Send it twice — the first send waits out the check, the second is refused before it leaves.
 
-```abide SendInvoice.abide
+```abide lib/SendInvoice.abide
 <script server>
 import { POST, reachable, refuse } from '@abide/abide/server'
 
@@ -6283,7 +6330,7 @@ function billing(): string {
     return billingOrigin
 }
 
-export const syncInvoice = POST(
+const syncInvoice = POST(
     async ({ id }: { id: string }) => {
         const origin = billing()
         const asked = performance.now()
@@ -6390,13 +6437,11 @@ A binary decodes back to a `Uint8Array` on the caller's side, so an rpc that han
 
 A `Blob` has `size` and `slice`, which is the whole of what range serving needs — so abide reads `Range`, honors `If-Range` against the ETag it derives, and answers `206` with `content-range`, `416` where the range is unsatisfiable and `304` on a matching `If-None-Match`. `Bun.file(path)` IS a `Blob`, so serving a file that seeks is returning one:
 
-```abide src/media/api.abide
-<script server>
-export const playFile = GET(async ({ id }: { id: number }) => {
+```ts src/media/playFile.ts — excerpt
+export default GET(async ({ id }: { id: number }) => {
     const path = await pathFor(id)
     return Bun.file(path)
 })
-</script>
 ```
 
 *0 lines of range parsing* — against the sixty every media server writes once and gets `content-length` on a `206` wrong the first time, a player that will not seek being the only symptom. Reach it from markup with [`playFile.url({ id })`](/data/find-the-url-a-handler-answers-on.md).
@@ -6409,7 +6454,7 @@ Read on: [Reading data](/data/read-data-without-writing-an-api.md) · [Streaming
 
 **`json(value)` — `null` for nobody, not an empty answer** — A sync script reads each contact's account manager as JSON. Grace has none — switch to her.
 
-```abide AccountManager.abide
+```abide lib/AccountManager.abide
 <script server>
 import { GET, json } from '@abide/abide/server'
 
@@ -6418,7 +6463,7 @@ const MANAGERS: Record<string, { name: string } | undefined> = {
     '4022': undefined,
 }
 
-export const accountManager = GET(
+const accountManager = GET(
     async ({ id }: { id: string }) => {
         await Bun.sleep(300) // a slow database, so the wait is on screen
         return json(MANAGERS[id])
@@ -6466,7 +6511,7 @@ A bare `undefined` is a 204 with no body (16.31), which is right for a write wit
 
 **`page(body)` — an invoice as a document of its own** — The invoice exactly as it was issued, kept as the HTML the customer was sent.
 
-```abide IssuedInvoice.abide
+```abide lib/IssuedInvoice.abide
 <script server>
 import { GET, page } from '@abide/abide/server'
 
@@ -6501,7 +6546,7 @@ Analytical Engines Ltd · issued 2026-09-14 · due 2026-10-14</p>
 </html>`,
 }
 
-export const issuedInvoice = GET(
+const issuedInvoice = GET(
     async ({ id }: { id: string }) => {
         await Bun.sleep(300) // a slow database, so the wait is on screen
         const html = ISSUED[id]
@@ -6524,7 +6569,7 @@ export const issuedInvoice = GET(
 
 **`redirect(to)` — one address, sent on to another** — Every contact's avatar has one address that never changes. It sends the browser on to the photo's current version.
 
-```abide Avatar.abide
+```abide lib/Avatar.abide
 <script server>
 import { GET, redirect } from '@abide/abide/server'
 
@@ -6542,7 +6587,7 @@ function contactOf(id: string) {
     return contact
 }
 
-export const photo = GET(
+const photo = GET(
     ({ id, version }: { id: string; version: number }) => {
         const { initials, color } = contactOf(id)
         const svg = [
@@ -6560,7 +6605,7 @@ export const photo = GET(
     { description: 'A contact photo, by id and version.' },
 )
 
-export const avatar = GET(
+const avatar = GET(
     ({ id }: { id: string }) =>
         redirect(photo.url({ id, version: contactOf(id).photoVersion })),
     { description: 'Redirects to the current photo of a contact.' },
@@ -6627,7 +6672,7 @@ Read on: [Mutations](/data/change-something-on-the-server.md) · [Health](/app/t
 
 ## An app route answers with the same helpers
 
-`src/layout.abide` exports one route of the app's own, asked where no page, handler or public file answered, and it uses this same set — there is no second one. Returning `undefined` hands the request on to the 404.
+A `middleware` rung the root `src/layout.abide` files runs before routing, so it can answer an address no page, handler or public file has, and it uses this same set — there is no second one. Calling `next()` hands the request on.
 
 Read on: [Lifecycle](/app/run-code-at-start-and-stop.md)
 
@@ -6647,7 +6692,7 @@ Read on: [Lifecycle](/app/run-code-at-start-and-stop.md)
 
 Inside the app you never write an address down: you import the handler and call it. Something outside the app cannot — a payment provider that needs a webhook URL, a `<form action>`, a colleague who wants a `curl` line.
 
-The handler carries the address, so the string is derived rather than typed. Rename the export and every place that reached for it follows, there being no path written down to miss.
+A handler file's address is its path, so the string is derived rather than typed. Move the file and the address moves with it, there being no path written down to miss. `abide routes` prints every one.
 
 ## The four members an `Rpc` carries
 
@@ -6661,6 +6706,49 @@ The handler carries the address, so the string is derived rather than typed. Ren
 None of the four is a call to the handler. They describe the address rather than reaching it, which is what makes them the surface for everything outside the app — a `<form
         action>`, an `<img src>`, a webhook registration, a `curl` line. Every signature is in the [Transports](/reference/transports.md) reference.
 
+## The address is the handler file's path
+
+| Handler file | Answers at |
+| --- | --- |
+| `src/users/getUser.ts` | `/users/getUser` |
+| `src/admin/recent.ts` | `/admin/recent` |
+| `src/media/[id]/save.ts` | `/media/42/save`, with `id` in its args |
+
+The directories are the address and the file's name is its last segment, so the address is readable from the source tree — which is what a log line or a network panel is for. A parameter in the route reaches the handler's args from the path, so its `Args` declares it — one it leaves out is a build error naming the parameter (16.67).
+
+The address is not a thing to write out. The route table is a build artifact, and two files that answer one method at one address are a build error naming both.
+
+## A private handler answers below `/__abide/handlers`
+
+| Declared in | Answers at |
+| --- | --- |
+| `addComment` in `src/media/[id]/lib/Comments.abide` | `/__abide/handlers/media/id/lib/Comments/addComment` |
+| `markPaid` in `src/crm/[id].abide` | `/__abide/handlers/crm/id/markPaid` |
+
+A handler a `<script server>` declares is its file's alone, and its address says which file: the file's path without `.abide`, each segment's brackets and dots dropped, then the handler's name (16.70). It takes nothing from the path, so `markPaid` under `[id]` is one address for every id, and the id travels in its args.
+
+That address is for reading, in a log line or a network panel. It is listed on no surface (16.71), so it is not one to hand to a webhook or a colleague. The file can still put `markPaid.url()` in a `<form action>` of its own. Anything outside the file gets a handler file instead.
+
+## `abide routes` prints every address
+
+In an app with a page per contact, a handler file and two private handlers, it prints each address with its method and the file answering it, and each hook with the route it is filed at (38.108):
+
+```
+GET   /                                        index.abide
+POST  /__abide/handlers/crm/id/markPaid        crm/[id].abide  (private)
+POST  /__abide/handlers/crm/lib/Notes/addNote  crm/lib/Notes.abide  (private)
+GET   /crm                                     crm/index.abide
+GET   /crm/[id]                                crm/[id].abide
+GET   /crm/getInvoice                          crm/getInvoice.ts
+
+hooks
+  middleware  /crm  crm/layout.abide
+```
+
+Each private handler is marked. Read its file against the hooks: neither address is below `/crm`, and the `middleware` filed there runs over both anyway, their files being under `crm` (16.72). `abide routes --json` prints the same as one document.
+
+Read on: [Authorization](/data/decide-who-may-call-what.md)
+
 ## `rpc.url` is derived, not baked
 
 The generated wrapper carries a **mount-relative** address. `url` resolves it at read time:
@@ -6676,7 +6764,7 @@ A mount is chosen after the build — `APP_URL` of `https://abide.com/v2` serves
 
 An address without its arguments is not something a browser can fetch, so the call takes them. They are written in the same canonical wire form the request itself uses, rather than a query string you assemble and the server parses back differently:
 
-```abide src/media/page.abide — excerpt
+```abide src/media/index.abide — excerpt
 <video src={playFile.url({ id: file.id })} controls></video>
 <img src={getPoster.url({ path, width: 250 })} alt="">
 ```
@@ -6691,17 +6779,6 @@ The method the handler was declared with, as a string. Reading it rather than wr
 
 Read on: [Mutations](/data/change-something-on-the-server.md)
 
-## The address comes from the directory and the export name
-
-| File | Export | Answers at |
-| --- | --- | --- |
-| `src/users/page.abide` | `getUser` | `/users/getUser` |
-| `src/admin/page.abide` | `recent` | `/admin/recent` |
-| `src/media/[id]/page.abide` | `save` | `/media/42/save`, with `id` in its args |
-| `src/media/[id]/comments.abide` | `addComment` | `/media/42/addComment` |
-
-So the address is readable from the source tree, which is what a log line or a network panel is for. A parameter in the route reaches the handler's args from the path, so its `Args` declares it. The address is not a thing to write out: the route table is a build artifact, and two files that answer one method at one address are a build error naming both.
-
 ## `rpc.raw` hands back the `Response`
 
 Where you want the `Response` rather than a decoded value — a header to read, a `Blob` to hand to a download, a body you will frame yourself:
@@ -6725,7 +6802,7 @@ Read on: [Streaming data](/data/send-data-as-it-arrives.md) · [Reading data](/d
 The string you passed as `description`, readable back off the handler. The same one rides onto the OpenAPI operation, the MCP tool and the CLI command — one place to write it, and no surface can carry a different sentence than another.
 
 ```ts server
-export const getInvoice = GET(
+export default GET(
     ({ id }: { id: string }) => database.invoice.find(id),
     { description: 'One invoice, by id.' },
 )
@@ -6766,8 +6843,8 @@ A file is a route. The parts of the path in brackets become values you can read.
 
 | File | Serves |
 | --- | --- |
-| `src/invoices/page.abide` | `/invoices` |
-| `src/invoices/[id]/page.abide` | `/invoices/42`, as `route.params.id` |
+| `src/invoices/index.abide` | `/invoices` |
+| `src/invoices/[id]/index.abide` | `/invoices/42`, as `route.params.id` |
 | `src/layout.abide` | the chrome for everything below it |
 | `src/error.abide` | where a failure renders, 404 included |
 
@@ -6813,38 +6890,87 @@ Read on: [Streaming HTML](/pages/send-the-page-before-the-data-lands.md) · [Hea
 
 *A file becomes a route, and the parts of the path become values you can read.*
 
-A route is a file. Put a `page.abide` in a directory under `src` and the path it sits at is the path it answers on — there is no table to register it in, and nothing to keep in step with the filesystem.
+A route is a file, and its path below `src` is the path it answers on. There is no table to register it in and nothing to keep in step with the filesystem — listing a directory lists its routes.
+
+## A file's path is its address
+
+| File | Answers on |
+| --- | --- |
+| `src/index.abide` | `/` |
+| `src/invoices/index.abide` | `/invoices` |
+| `src/invoices/new.abide` | `/invoices/new` |
+| `src/invoices/[id].abide` | `/invoices/4310` |
+| `src/invoices/[id]/index.abide` | `/invoices/4310`, the same route |
+| `src/docs/[...path].abide` | `/docs/start/install` |
+| `src/invoices/listInvoices.ts` | `GET /invoices/listInvoices` |
+
+An `index.abide` answers its directory's own address, and any other `.abide` adds its name. A `layout.abide` and an `error.abide` are not pages: they take their directory's route, and wrap or catch what is below it.
+
+`[id].abide` and `[id]/index.abide` are two spellings of one route, so writing both fails the build, naming the two files. The directory is the one with room. A handler file inside `[id]/` answers below the invoice, at `/invoices/[id]/markPaid`, and `id` reaches its arguments from the path. One beside `[id].abide` answers for the whole subject. Start with the file, and move it into a directory once the invoice has files of its own.
+
+A `.ts` beside the pages is a handler file. Its default export is the `GET` or the `POST` it declares, it exports nothing else, and its name is its last segment.
+
+Read on: [Reading data](/data/read-data-without-writing-an-api.md)
+
+## A directory lists its routes
+
+Four directory names are never a segment: `lib` for components and modules, `tests` for tests, `server` for code the browser never loads, and `public` for files served as they are. Nothing under one has an address. Every other file directly in a directory is a page, a layout, an error page or a handler file.
+
+```
+src/
+├── index.abide               /
+├── layout.abide              wraps every page
+└── invoices/
+    ├── index.abide           /invoices
+    ├── [id].abide            /invoices/[id]
+    ├── layout.abide          wraps both
+    ├── listInvoices.ts       GET /invoices/listInvoices
+    ├── lib/Row.abide         a component, no address
+    └── tests/Row.test.ts     a test, no address
+```
+
+So the component a page places goes in a `lib` beside it, and is imported as `./lib/Row.abide`. A stylesheet, a helper or a test written straight beside the pages fails the build, naming the file and the `lib` to move it into. That refusal is what keeps a listing honest: what a directory holds is what it answers.
+
+## `abide routes` prints every address and its file
+
+Run in the app above, it prints each route with the method it answers and the file answering it, then the file filing each hook and the route it covers:
+
+```
+$ abide routes
+GET   /                                       index.abide
+POST  /__abide/handlers/invoices/id/markPaid  invoices/[id].abide  (private)
+GET   /invoices                               invoices/index.abide
+GET   /invoices/[id]                          invoices/[id].abide
+GET   /invoices/listInvoices                  invoices/listInvoices.ts
+
+hooks
+  middleware  /invoices  invoices/layout.abide
+  onStart     /          layout.abide
+```
+
+The `(private)` line is the `markPaid` that `[id].abide`'s own `<script server>` declares: it is that file's alone, so it answers below `/__abide/handlers/` rather than at an address of the app's. `--json` prints the same map as one document.
+
+Read on: [Handler URLs](/data/find-the-url-a-handler-answers-on.md)
 
 ## The three dynamic segments
 
-| The directory is named | It matches | In `route.params` |
+| The file or directory is named | It matches | In `route.params` |
 | --- | --- | --- |
 | `[id]` | exactly one segment, required | a required key |
 | `[[tab]]` | one segment or none | an optional key, absent when it did not match |
 | `[...rest]` | the remaining segments, terminal | a list, empty when it matched nothing |
 
-A rest segment is terminal because there is nothing a segment after it could match against. The other two compose freely, so `invoices/[id]/[[tab]]` is one route answering two addresses rather than two routes agreeing about an invoice.
+A rest segment is terminal because there is nothing a segment after it could match against. The other two compose freely, so `invoices/[id]/[[tab]].abide` is one route answering two addresses rather than two routes agreeing about an invoice.
 
 An optional segment that did not match is **absent** rather than empty. That is the difference between `const { tab = 'summary' } = route.params` working and a default that never fires, which is a distinction an empty string would quietly lose.
 
-## What the file path decides
-
-|  |  |
-| --- | --- |
-| `src/page.abide` | `/` |
-| `src/invoices/page.abide` | `/invoices` |
-| `src/invoices/[id]/page.abide` | `/invoices/4310` |
-| `src/docs/[...path]/page.abide` | `/docs/start/install` |
-| `src/billing/page.abide` | `/billing` |
-
-A subject's pages live with the rest of it, and a directory named `server` or `public` is never a segment of an address. Any other file beside a `page.abide` — a component, a helper — is yours, and is no address.
+## `route.params` and `route.name` follow the address
 
 `route.url` comes from the file path and `route.name` is the **resolution path** — the pattern that matched, not the address that arrived. So a log line, a metric and an `{#if}` over the current route all key on `invoices/[id]` for every invoice rather than on one address each.
 
-```abide src/invoices/[id]/page.abide — excerpt
+```abide src/invoices/[id].abide — excerpt
 <script>
 import { reactive, route } from '@abide/abide'
-import { getInvoice } from '#src/invoices/api.abide'
 
 const invoice = reactive(() => getInvoice({ id: route.params.id }))
 </script>
@@ -6855,28 +6981,22 @@ const invoice = reactive(() => getInvoice({ id: route.params.id }))
 
 Reading `route.params` is a live read like any other, so a navigation from one invoice to another moves the value rather than rebuilding the page.
 
-A package can ship pages, layouts, error pages and handlers as `.abide` source, and the address they answer at is yours to choose. Importing one of its directories with `type: 'routes'` puts all of them below the file that imports it:
-
-```abide abide
-<script module>
-import 'admin-kit/admin' with { type: 'routes' }
-</script>
-
-<section class="tools"><slot/></section>
-```
-
-Written in `src/tools/layout.abide`, that line makes `admin-kit/admin/users/[id]/page.abide` answer at `/tools/users/[id]`, inside this layout. Moving the line moves the package. Its files route by their path below the directory named, as yours do, and compile with your app on its abide. A directory mounts once, and naming one of your own directories, or one that is not there, fails the build.
-
-Read on: [Links & navigation](/pages/link-to-another-page.md) · [Reading data](/data/read-data-without-writing-an-api.md)
+Read on: [Links & navigation](/pages/link-to-another-page.md)
 
 ## `Params` is what the segments matched
 
-`Params` carries what `[param]`, `[[optional]]` and `[...rest]` matched: text, or a list for a rest. In a page it is typed from the page's own route rather than declared beside it — `abide check` reads `route.params()` in `invoices/[id]/page.abide` as `RouteParams<'/invoices/[id]'>`, so `id` is text and a key the route does not have is an error (23.9). A layout gets its own segments, and whatever a page below it adds.
+`Params` carries what `[param]`, `[[optional]]` and `[...rest]` matched: text, or a list for a rest. In a page it is typed from the page's own route rather than declared beside it — `abide check` reads `route.params()` in `invoices/[id].abide` as `RouteParams<'/invoices/[id]'>`, so `id` is text and a key the route does not have is an error (23.9). A layout gets its own segments, and whatever a page below it adds.
 
 Nothing else is in it. A query string is not a param — it is not part of what resolved the route, and treating it as one is how a route starts depending on something that never selected it.
 
 Read on: [Links & navigation](/pages/link-to-another-page.md)
 
+## A package's pages answer below the file importing the package
+
+A package can ship pages, layouts, error pages and handler files as source, and the address they answer at is yours to choose. Written in `src/tools/layout.abide`, `import 'admin-kit/admin' with { type: 'routes' }` puts all of them below that layout: `admin-kit/admin/users/[id].abide` answers at `/tools/users/[id]`, inside it.
+
+Moving the line moves the package. Its files route by their path below the directory named, as yours do, and compile with your app on its abide. A directory mounts once, and naming one of your own directories, or one that is not there, fails the build.
+
 ## Next
 
 - [Layouts](/pages/give-pages-the-same-chrome.md) — the chrome a page renders inside
@@ -6985,7 +7105,7 @@ That is the one case where a quiet fallback would be the wrong kindness: an erro
 
 **`onError(fn)` — the tracker hears what the caller is not told** — A contacts export whose worker has stopped answering. Run it: the page gets a bare 500, and the hook beside it gets the reason.
 
-```abide ContactsExport.abide
+```abide lib/ContactsExport.abide
 <script server>
 import { GET, onError, POST } from '@abide/abide/server'
 
@@ -7008,12 +7128,12 @@ const exportWorker = {
 
 onError((error) => tracker.capture(error))
 
-export const exportContacts = POST(() => exportWorker.run(), {
+const exportContacts = POST(() => exportWorker.run(), {
     description: 'Exports every contact.',
 })
 
 /** What the tracker was sent, which the caller of the export never is. */
-export const capturedErrors = GET(() => tracker.captured, {
+const capturedErrors = GET(() => tracker.captured, {
     description: 'The errors the tracker was sent.',
 })
 </script>
@@ -7062,7 +7182,7 @@ Read on: [Lifecycle](/app/run-code-at-start-and-stop.md) · [Logging](/app/recor
 
 A `<head>` element in a `.abide` file contributes its children to the document head. It is markup rather than a call, so what a page adds to the head sits in the page, next to the values it is built from.
 
-```abide src/invoices/[id]/page.abide — excerpt
+```abide src/invoices/[id]/index.abide — excerpt
 <head>
     <title>Invoice {route.params.id}</title>
     <meta name="description" content={invoice.summary}/>
@@ -7088,7 +7208,7 @@ The head goes out with the page once it is built, and a value still in flight do
 
 Nothing is opt-in here either: a `<title>` is a sink like any other, and it fills when the value lands. Metadata a crawler reads — which does not come back for the second version — is the one case that wants the value before the first flush, and that is the server's business rather than the head's.
 
-```abide src/invoices/[id]/page.abide — excerpt
+```abide src/invoices/[id]/index.abide — excerpt
 <head>
     <title>Invoice {invoice.number}</title>
 </head>
@@ -7120,7 +7240,7 @@ Read on: [Links & navigation](/pages/link-to-another-page.md)
 
 `url` builds an address from a **route literal** — the pattern, not the address. So the thing you write down is the thing the router already knows, and a route that moves takes its links with it.
 
-```abide src/invoices/page.abide — excerpt
+```abide src/invoices/index.abide — excerpt
 <a href={url('/invoices/[id]', { id: invoice.id })}>{invoice.number}</a>
 ```
 
@@ -7159,7 +7279,7 @@ Read on: [Routes](/pages/add-a-page.md)
 
 **`navigate(url)` — a new address, the same page** — Three invoices on one account, each with its own address. Type a note, then open another invoice — the address moves and the note is still there.
 
-```abide Invoice.abide
+```abide lib/Invoice.abide
 <script>
 import { navigate, reactive, route } from '@abide/abide'
 
@@ -7227,7 +7347,7 @@ A view transition is a browser feature, and abide's part in it is to get out of
 
 ## The stylesheet is the switch
 
-```abide src/invoices/[id]/page.abide — excerpt
+```abide src/invoices/[id]/index.abide — excerpt
 <style>
 .invoice-total {
     view-transition-name: invoice-total;
@@ -7367,7 +7487,7 @@ Read on: [Request to paint](/start/how-a-page-becomes-html.md) · [Loading state
 
 **`render(component)` — an invoice preview from the component itself** — The invoice a customer will be sent, previewed before it is issued: the handler renders the app's own invoice component into a document of its own.
 
-```abide InvoicePreview.abide
+```abide lib/InvoicePreview.abide
 <script server>
 import { GET, page, render } from '@abide/abide/server'
 import Document from './InvoiceDocument.abide'
@@ -7403,7 +7523,7 @@ async function findInvoice(id: string) {
     return invoice
 }
 
-export const previewInvoice = GET(
+const previewInvoice = GET(
     async ({ id }: { id: string }) => {
         const invoice = await findInvoice(id)
         return page(await render(Document({ invoice })))
@@ -7428,7 +7548,7 @@ let id = reactive('4021')
     class="h-56 w-full rounded-md border border-rule"></iframe>
 ```
 
-```abide InvoiceDocument.abide
+```abide lib/InvoiceDocument.abide
 <script>
 import { props } from '@abide/abide'
 
@@ -7473,7 +7593,7 @@ The component `render` is given is the whole document when it is written inside
 
 An email body wants a document of its own — no bundle, no font preloads, inline styles — and that is the whole of what writing one means. Nothing else about the render changes. A component that writes `<html>` is a whole document, so placing one inside another is refused.
 
-```abide InvoiceDocument.abide — excerpt
+```abide lib/InvoiceDocument.abide — excerpt
 <html lang="en">
 <body style="margin: 0; padding: 1.25rem; background: #fff; color: #1d2a28;
     font: 14px/1.5 system-ui, sans-serif">
@@ -7604,7 +7724,7 @@ Read on: [Local state](/values/show-a-value-that-changes.md) · [Loading states]
 
 **`contact.address.city = v` — a write through a path** — A contact's city, two levels down. Type into the field and watch the line above it.
 
-```abide Contact.abide
+```abide lib/Contact.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -7676,7 +7796,7 @@ Each of them updates the **one thing it names** and nothing around it. That is t
 
 **`{expr}` and `{raw(expr)}` — escaped, and not** — A note imported with markup in it. Type a tag into the field and watch the two rows disagree.
 
-```abide Note.abide
+```abide lib/Note.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -7717,7 +7837,7 @@ Read on: [Handler URLs](/data/find-the-url-a-handler-answers-on.md)
 
 **`class:name={cond}` and `style:prop={value}` — one class, one property** — An invoice's age badge. Press + until it is late, and back down again.
 
-```abide Invoice.abide
+```abide lib/Invoice.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -7799,7 +7919,7 @@ An event handler is an attribute whose value is a function. There is no syntheti
 
 **`bind:element` and `on<event>` — the node, and what happens on it** — A contact's notes. Press New note and the field is cleared and waiting for you.
 
-```abide Note.abide
+```abide lib/Note.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -7866,7 +7986,7 @@ A form is a value you can see. The usual cost of saying so is a handler per fiel
 
 **`bind:value` — the field and the value are one copy** — A contact's email and plan, with the line underneath showing what a save would send. Type into the field.
 
-```abide Contact.abide
+```abide lib/Contact.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -7903,7 +8023,7 @@ Read on: [Local state](/values/show-a-value-that-changes.md)
 
 **`bind:checked` and `bind:open` — a boolean, not a string** — A reminders checkbox and a disclosure. Tick the box and open the panel, and watch the two lines underneath.
 
-```abide Advanced.abide
+```abide lib/Advanced.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -7947,7 +8067,7 @@ The readout reads `showAdvanced` like any other value, which is the point of bin
 
 **`{#if}` over a bound value — the field decides what renders** — A contact form that only asks for a billing address when you say there is one. Tick the box.
 
-```abide BillingContact.abide
+```abide lib/BillingContact.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -7972,7 +8092,7 @@ What was typed into the address goes with it, the input being unbound. Bind it t
 
 **`bind:group` — one value for radios, an array for checkboxes** — A contact's tier and the regions they cover. Change the tier, then tick and untick a region.
 
-```abide Assign.abide
+```abide lib/Assign.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -8042,7 +8162,7 @@ A derived value is writable too, and where its body hands back another `Reactive
 
 A `schema` runs on the way into a value, and a write it refuses is rejected at the boundary rather than stored and checked later:
 
-```abide src/account/page.abide — excerpt
+```abide src/account/index.abide — excerpt
 <script>
 import { reactive } from '@abide/abide'
 import { z } from 'zod'
@@ -8068,7 +8188,7 @@ The field opens empty. An opening `undefined` lands without passing the schema (
 
 Both gates refuse. What you refuse **with** picks between them: a schema refuses as `ValidationError`, and a `transform` refuses as a name of your own — the only way a failure arrives carrying data you chose. `refuse.named` declares it once and resolves on both sides, so the same name serves a form field and a handler.
 
-```ts src/failures.ts
+```ts src/lib/failures.ts
 import { refuse } from '@abide/abide'
 import { z } from 'zod'
 
@@ -8077,10 +8197,10 @@ export const notAnEmail = refuse.named('NotAnEmail', 422, undefined, {
 })
 ```
 
-```abide src/account/page.abide — excerpt
+```abide src/account/index.abide — excerpt
 <script>
 import { reactive } from '@abide/abide'
-import { notAnEmail } from '#src/failures'
+import { notAnEmail } from '#src/lib/failures'
 
 const email = reactive(undefined, {
     transform: (value: string) =>
@@ -8106,7 +8226,7 @@ The call site decides this, not the child.
 
 A prop is a **live read** of the caller's expression. `count={total}` tracks `total`, `count={total * 2}` tracks it as a derived read, and neither reinstantiates the component. The child declares the prop as the type of its value and writes it by name:
 
-```abide src/ui/Stepper.abide
+```abide src/lib/Stepper.abide
 <script>
 import { props } from '@abide/abide'
 
@@ -8167,7 +8287,7 @@ Read on: [Loading states](/values/show-a-value-that-isnt-there-yet.md) · [Strea
 
 **`{#try}` — a boundary over a region, not over a line** — An invoice converted at a rate you type. Clear the field and watch what goes with it.
 
-```abide Total.abide
+```abide lib/Total.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -8236,7 +8356,7 @@ It iterates **zero times** over an absent subject. A list still loading is not a
 
 **`{#for row of rows by row.id}` — a reorder moves nodes** — Three contacts. Swap the top two, then reverse the lot.
 
-```abide Contacts.abide
+```abide lib/Contacts.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -8282,7 +8402,7 @@ Read on: [Patching a list](/values/patch-a-list-from-a-live-feed.md)
 
 **`reactive(contacts, { by: 'id' })` — every list over it moves nodes** — The contacts and the call queue, one list shown twice. Swap the top two.
 
-```abide ContactsAndQueue.abide
+```abide lib/ContactsAndQueue.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -8393,7 +8513,7 @@ A component is a `.abide` file, or a block in one. Invoking it is a capitalized
 
 An inline component is TitleCase like any other, and it exists for the piece of markup that is worth naming but not worth a file — a row in one table, a cell shape used twice on one page. The parentheses hold the pattern a `props()` call would destructure, and an annotation on it is that call's type argument:
 
-```abide src/contacts/[id]/page.abide — excerpt
+```abide src/contacts/[id]/index.abide — excerpt
 {#component Field({ label, value }: { label: string; value: string })}
     <li><span>{label}</span><strong>{value}</strong></li>
 {/component}
@@ -8408,11 +8528,11 @@ It can be written anywhere markup can: at the top of the file, inside an element
 
 **It closes over where it is written.** A value the file's `<script>` declares is read by name inside it, and live, the same as anywhere else in the template. Declared in a row, it reads that row's item without being handed it:
 
-```abide src/contacts/page.abide — excerpt
+```abide src/contacts/index.abide — excerpt
 <script>
 import { reactive } from '@abide/abide'
-import { listContacts } from '#src/contacts/api.abide'
-import type { Contact } from '#src/Contact.ts'
+import listContacts from '#src/contacts/listContacts.ts'
+import type { Contact } from '#src/lib/Contact.ts'
 
 const contacts = listContacts()
 let masked = reactive(true)
@@ -8434,10 +8554,10 @@ Setting `masked` rewrites each `<strong>` in place. Its own `<script>` is set up
 
 An inline component written directly between a component's tags is **passed to it as a prop** of the same name. The component declares that prop as a function of the props it hands over, and invokes it by name:
 
-```abide src/ui/ContactTable.abide
+```abide src/lib/ContactTable.abide
 <script>
 import { props } from '@abide/abide'
-import type { Contact } from '#src/Contact.ts'
+import type { Contact } from '#src/lib/Contact.ts'
 
 const { contacts, Row } = props<{
     contacts: Contact[]
@@ -8455,7 +8575,7 @@ const { contacts, Row } = props<{
 <slot/>
 ```
 
-```abide src/contacts/page.abide — excerpt
+```abide src/contacts/index.abide — excerpt
 <ContactTable contacts={contacts}>
     {#component Row({ contact }: { contact: Contact })}
         <td>{contact.name}</td><td>{masked ? '••• ••••' : contact.phone}</td>
@@ -8470,7 +8590,7 @@ The table decides where each row goes and the page decides what is in it, readin
 
 **`props()` — a prop is a live read, not a snapshot** — An invoice's line count and the total a child component renders. Press + and watch the child.
 
-```abide Invoice.abide
+```abide lib/Invoice.abide
 <script>
 import { reactive } from '@abide/abide'
 import Total from './Total.abide'
@@ -8489,7 +8609,7 @@ let lines = reactive(2)
 </div>
 ```
 
-```abide Total.abide
+```abide lib/Total.abide
 <script>
 import { props } from '@abide/abide'
 
@@ -8516,7 +8636,7 @@ Read on: [Values by name](/templates/read-and-write-a-value-by-name.md) · [Form
 
 **`crm-ui/Initials.abide` — a design system's component, imported by name** — The CRM's contacts carry the avatar its design system ships. Nothing in the app compiled it, and it renders with its own styles.
 
-```abide ContactCard.abide
+```abide lib/ContactCard.abide
 <script>
 import Initials from 'crm-ui/Initials.abide'
 </script>
@@ -8558,7 +8678,7 @@ const initials = name
 
 A package ships its components as `.abide` source, and the app imports one by the specifier its `exports` names, the same as a module. It is compiled with the app that imports it, wherever it lies: in `node_modules`, or in a package a workspace links from outside the app's root. Its props are typed by the app's project, its styles are scoped like the app's own, and it runs on the app's abide rather than on any copy the package installed beside it.
 
-What it is not is an address. A `page.abide` inside a package is the package's own, and a handler a package's `<script server>` declares has no address of its own: the app gives it one by re-exporting it from a `<script server>` of its own, which answers at that file's route.
+What it is not is an address. A page or a handler file inside a package answers nowhere until the app mounts the package's directory with a `type: 'routes'` import, which places them below the file that imports it.
 
 Read on: [Styles](/templates/scope-styles-to-a-component.md) · [Reading data](/data/read-data-without-writing-an-api.md)
 
@@ -8572,7 +8692,7 @@ There is no implicit bag. A component that never calls `props()` takes no props
 
 Whatever a caller puts between the tags arrives as `children`, and `<slot/>` is where it renders. `<slot>fallback</slot>` renders the fallback where a caller passed none, which is how a panel has a default body without the caller having to know what it is:
 
-```abide src/ui/Panel.abide
+```abide src/lib/Panel.abide
 <script>
 import { props } from '@abide/abide'
 
@@ -8582,7 +8702,7 @@ const { title } = props<{ title: string }>()
 <li><span>{title}</span><strong><slot>none yet</slot></strong></li>
 ```
 
-```abide src/contacts/[id]/page.abide — excerpt
+```abide src/contacts/[id]/index.abide — excerpt
 <ul class="fields">
     <Panel title="phone">+1 415 555 0132</Panel>
     <Panel title="notes"/>
@@ -8601,7 +8721,7 @@ Read on: [Expressions](/templates/put-a-value-in-the-markup.md)
 
 A component that wraps a `<button>` usually declares the few props it reads itself and spreads the rest onto the element. `Attributes<'button'>` types that rest as what a `<button>` takes, so a caller is held to the element's own attributes and its `onclick` is handed a `MouseEvent`:
 
-```abide src/ui/Button.abide
+```abide src/lib/Button.abide
 <script>
 import { props, type Attributes } from '@abide/abide'
 
@@ -8648,7 +8768,7 @@ A component's styles are the component's. Writing `.badge` inside one and having
 
 **`<style>` — the same class name in two components** — Two badge components that each style `.badge`, rendered side by side. Neither one reaches the other.
 
-```abide ScopedBadges.abide
+```abide lib/ScopedBadges.abide
 <script>
 import Overdue from './Overdue.abide'
 import Paid from './Paid.abide'
@@ -8660,7 +8780,7 @@ import Paid from './Paid.abide'
 </div>
 ```
 
-```abide Overdue.abide
+```abide lib/Overdue.abide
 <span class="badge">Overdue</span>
 
 <style>
@@ -8672,7 +8792,7 @@ import Paid from './Paid.abide'
 </style>
 ```
 
-```abide Paid.abide
+```abide lib/Paid.abide
 <span class="badge">Paid</span>
 
 <style>
@@ -8696,7 +8816,7 @@ Read on: [Components](/templates/reuse-a-piece-of-markup.md)
 
 **`:global(…)` — the per-selector escape from scoping** — A badge component whose stylesheet also colors a paragraph the page rendered, not the component.
 
-```abide GlobalLegend.abide
+```abide lib/GlobalLegend.abide
 <script>
 import Legend from './Legend.abide'
 </script>
@@ -8707,7 +8827,7 @@ import Legend from './Legend.abide'
 </div>
 ```
 
-```abide Legend.abide
+```abide lib/Legend.abide
 <span class="badge">Overdue</span>
 
 <style>
@@ -8762,24 +8882,29 @@ plugins = ["bun-plugin-tailwind"]
 
 A `.abide` file's `<script>` block is the component's setup. It runs when an instance is created, in order, top to bottom — there is no mount hook to register and nothing to call it from, because the block **is** the hook.
 
-## The two blocks
+## Three script blocks, and when each runs
 
 | You write | Runs |
 | --- | --- |
 | `<script>` | once per instance of the component |
 | `<script module>` | once for the module, on a server as in a browser |
+| `<script server>` | once for the module, on the server alone |
 
-The difference is what a variable declared in each belongs to. One row's `calls` is that row's; a lookup table every row shares belongs to the module and is built once however many rows there are.
+The difference between the first two is what a variable declared in each belongs to. One row's `calls` is that row's; a lookup table every row shares belongs to the module and is built once however many rows there are.
 
-A `<script module>` is module scope, the same as the top of a `.ts` file, so what it exports is the module's: another file imports a helper from it as from any module. A `<script>` cannot export, because it runs once per instance and an export belongs to no one instance.
+The third never reaches a browser. It holds the file's own handlers and its hooks, and the setup calls a handler it declares by name.
+
+None of the three exports anything — the component is the file's one export — so a helper another file imports goes in a module under `lib`.
 
 On a server, module scope is shared by every request. A `reactive` there is still one per request, as a `reactive` is wherever it is declared. A plain `let` is the process's, so state that changes while a page renders belongs in a `reactive`, as `opened` is below.
 
+Read on: [Reading data](/data/read-data-without-writing-an-api.md)
+
 ## Per instance, and once
 
 **`<script>` and `<script module>` — per instance, and once** — Two contact rows from one component. Log a call on the first and read both rows.
 
-```abide Contacts.abide
+```abide lib/Contacts.abide
 <script>
 import Row from './Row.abide'
 </script>
@@ -8790,7 +8915,7 @@ import Row from './Row.abide'
 </ul>
 ```
 
-```abide Row.abide
+```abide lib/Row.abide
 <script module>
 import { reactive } from '@abide/abide'
 
@@ -8903,13 +9028,13 @@ An environment variable is a string or it is missing. What an app wants is a num
 
 **`onConfig(fn)` and `config()` — a default the deployment overrides** — A CRM's retry count: 3 beside the handler, 5 in the deployment's .env. The page adds one for the first try and gets 6, not 51.
 
-```abide Retries.abide
+```abide lib/Retries.abide
 <script server>
 import { config, GET, onConfig } from '@abide/abide/server'
 
 onConfig(() => ({ RETRIES: 3 }))
 
-export const retryPolicy = GET(() => ({ retries: config().RETRIES }), {
+const retryPolicy = GET(() => ({ retries: config().RETRIES }), {
     description: 'How many times a call is retried.',
 })
 </script>
@@ -9018,7 +9143,7 @@ A `<script server>` runs once, on the server, before the first request. The root
 
 **`onStart(fn)` — work the first request cannot race** — A CRM's database pool, connected before the app answers anything. Reload the page and both times stay where the boot put them.
 
-```abide Pool.abide
+```abide lib/Pool.abide
 <script server>
 import { GET, onStart, onStop } from '@abide/abide/server'
 
@@ -9049,7 +9174,7 @@ onStop(async (stop) => {
 })
 
 /** When the pool connected, and when the app came up around it. */
-export const poolState = GET(
+const poolState = GET(
     () => ({ connectedAt: pool.connectedAt, upAt: pool.upAt }),
     { description: 'When the pool connected, and when the app came up.' },
 )
@@ -9080,7 +9205,7 @@ Failing hard is the only useful answer to a failed migration. An app that starts
 
 ## `onStop` closes what `onStart` opened, after the last request
 
-```abide Pool.abide — excerpt
+```abide lib/Pool.abide — excerpt
 onStop(async (stop) => {
     await stop()
     await pool.close()
@@ -9104,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:
-
-```abide src/downloads.abide — 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.
@@ -9151,7 +9259,7 @@ abide does not know how you authenticate somebody. It knows what to do **after**
 
 **`principal.set` — one seal, read everywhere** — A sign-in on a CRM, and the header above it. Sign in, then sign out, and watch a component the form never names.
 
-```abide SignIn.abide
+```abide lib/SignIn.abide
 <script server>
 import { principal, refuse } from '@abide/abide'
 import { POST } from '@abide/abide/server'
@@ -9167,7 +9275,7 @@ async function userByEmail(email: string) {
     return USERS[email] ?? null
 }
 
-export const signIn = POST(
+const signIn = POST(
     async ({ email }: { email: string }) => {
         const user = await userByEmail(email)
         if (user === null) return refuse(401, 'No such account.')
@@ -9176,7 +9284,7 @@ export const signIn = POST(
     { description: 'Signs in by email.' },
 )
 
-export const signOut = POST(() => principal.clear(), {
+const signOut = POST(() => principal.clear(), {
     description: 'Signs out.',
 })
 </script>
@@ -9200,7 +9308,7 @@ let email = reactive('ada@example.com')
 </div>
 ```
 
-```abide Header.abide
+```abide lib/Header.abide
 <script>
 // The seal is ambient, so this reads it with nothing handed down.
 import { principal } from '@abide/abide'
@@ -9240,7 +9348,7 @@ Each is a `Reactive`, so reading one in a template subscribes and a sign-out mov
 
 **`onPrincipal(fn)` — an id in the cookie, a user on the page** — A CRM that seals nothing but an account id. Sign in as either account and the name and role arrive anyway, looked up on the server.
 
-```abide Badge.abide
+```abide lib/Badge.abide
 <script server>
 import { onPrincipal, POST, principal } from '@abide/abide/server'
 
@@ -9270,7 +9378,7 @@ onPrincipal(async (claims) => {
 })
 
 /** Seals the id alone, and answers with what `onPrincipal` made of it. */
-export const signInAs = POST(
+const signInAs = POST(
     async ({ id }: { id: string }) => {
         await principal.set({ id })
         const { name = '', role = '' } = principal.resolved()
@@ -9322,7 +9430,7 @@ type Principal = { authenticated, expiresAt?, error?, …claims }
 
 **`cookies()` — one jar, read on both sides** — The contact list's density, kept in a cookie. Pick one and reload the page — the server paints the one you picked.
 
-```abide Density.abide
+```abide lib/Density.abide
 <script>
 import { cookies, reactive } from '@abide/abide'
 
@@ -9369,13 +9477,11 @@ Three ambient values, all server-side, all **request-local**: the request being
 
 ## `request()` is the real `Request`
 
-```abide src/invoices/api.abide — excerpt
-<script server>
-export const greeting = GET(() => {
+```ts src/invoices/greeting.ts — excerpt
+export default GET(() => {
     const locale = request().headers.get('accept-language') ?? 'en'
     return locale.startsWith('fr') ? 'Bonjour' : 'Hello'
 })
-</script>
 ```
 
 It is the platform's own `Request`, not a wrapper — so everything you already know about one applies, and anything that takes a `Request` takes this.
@@ -9390,7 +9496,7 @@ Read on: [Authorization](/data/decide-who-may-call-what.md) · [Schemas](/data/c
 
 **`response()` — a status the handler decides** — An integration adds contacts through the API, and expects 201 and where the new record lives.
 
-```abide AddContact.abide
+```abide lib/AddContact.abide
 <script server>
 import { POST, response } from '@abide/abide/server'
 
@@ -9404,7 +9510,7 @@ async function insertContact(name: string) {
     return { id, name }
 }
 
-export const addContact = POST(
+const addContact = POST(
     async ({ name }: { name: string }) => {
         const contact = await insertContact(name)
         response().status = 201
@@ -9496,7 +9602,7 @@ log.error('mailer refused', { error })
 
 **`log.named` and `DEBUG` — one namespace on, one off** — A CRM's own log. Send an invoice, then press Poll — only one of them has a namespace that is on.
 
-```abide Console.abide
+```abide lib/Console.abide
 <script>
 import { log } from '@abide/abide'
 
@@ -9569,7 +9675,7 @@ type LogRecord = {
 
 In a template it is a member access rather than a name, so the read is spelled out:
 
-```abide Console.abide — excerpt
+```abide lib/Console.abide — excerpt
 {#for record of log.records().slice(-20)}
 ```
 
@@ -9605,12 +9711,12 @@ Every log line an abide app writes carries a `trace`. It is the id of the operat
 
 **`trace()` — one id for everything one request did** — A contact synced to billing across two modules. Sync it, and both lines it logged carry that request's trace; sync again for a new one.
 
-```abide Sync.abide
+```abide lib/Sync.abide
 <script server>
 import { log, POST, trace } from '@abide/abide/server'
 import { billing } from './billing'
 
-export const syncContact = POST(
+const syncContact = POST(
     async ({ id }: { id: string }) => {
         log(`contact ${id} loaded`)
         await billing.notify(id)
@@ -9650,7 +9756,7 @@ async function sync() {
 </ul>
 ```
 
-```ts billing.ts
+```ts lib/billing.ts
 import { log } from '@abide/abide/server'
 
 /** Another module the sync reaches, handed the contact and nothing else. */
@@ -9771,7 +9877,7 @@ Only what finished **before the head went out** can be in it. A page sends its h
 
 **`onHealth(fn)` — your fields beside the baseline** — The account a load balancer scrapes, read on a CRM's status panel through health(). The database line is the app's own; the rest is abide's.
 
-```abide Account.abide
+```abide lib/Account.abide
 <script server>
 import { onHealth, onStart, onStop } from '@abide/abide/server'
 
@@ -9823,7 +9929,7 @@ Read on: [Lifecycle](/app/run-code-at-start-and-stop.md) · [Logging](/app/recor
 `health` is an `Rpc`, imported from `@abide/abide` and called the same way on both sides: `health()` in a page, `await
         health()` in a handler. The call is what asks, so a page that never makes it loads no account.
 
-```abide Account.abide — excerpt
+```abide lib/Account.abide — excerpt
 const account = health()
 ```
 
@@ -9856,7 +9962,7 @@ A content security policy is worth having and painful to write, because the hard
 
 **`csp()` — your own scripts run, a stranger's do not** — A support widget somebody pasted into the CRM from another origin. Add it, and the policy this page was served with refuses it.
 
-```abide Widget.abide
+```abide lib/Widget.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -9883,21 +9989,24 @@ 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 { 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>
 
 <script>
-import DocsNav from '#src/docs/DocsNav.abide'
-import SiteBar from '#src/docs/SiteBar.abide'
+import DocsNav from '#src/lib/DocsNav.abide'
+import SiteBar from '#src/lib/SiteBar.abide'
 import { url } from '@abide/abide'
-import '#src/app.css'
+import '#src/lib/app.css'
 </script>
 
 <html lang="en">
@@ -10016,7 +10125,7 @@ There is one form and no options, `online` being ambient rather than declared: i
 
 **`online` — the connection, read by name** — An order form with unsaved changes. Take the browser offline — DevTools' Network panel, or the Wi-Fi — and watch the line.
 
-```abide OfflineBanner.abide
+```abide lib/OfflineBanner.abide
 <script>
 import { online } from '@abide/abide'
 </script>
@@ -10070,7 +10179,7 @@ See [Reloading](/values/decide-when-a-value-reloads.md) for the two in full.
 
 That shapes what `online` is good for. It is right for telling a reader what to expect and wrong as the gate on a write: the load that failed is the honest signal, and `online` explains it. Read the failure, then read `online` to say why.
 
-```abide src/orders/page.abide — excerpt
+```abide src/orders/index.abide — excerpt
 {#if orders.error()}
     <p>{online ? 'Could not load orders.' : 'You are offline.'}</p>
 {/if}
@@ -10107,7 +10216,7 @@ Nothing here asks you to annotate a handler for machines specifically. The piece
 
 | Piece | Where it comes from |
 | --- | --- |
-| address | the file path and the export name |
+| address | the handler file's path |
 | method | which handler gave it an address |
 | argument schema | the annotations you already wrote, or the schema you named |
 | result schema | the handler's return type |
@@ -10183,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
 
@@ -10258,8 +10367,7 @@ A `Provider` is one method, `run`, handed the transcript and a `Toolbox` of your
 
 `assistant` has no address of its own. You yield it from a streaming handler, so the address, the middleware and the surfaces are yours to set, as they are for any other handler.
 
-```abide src/support/api.abide — excerpt
-<script server>
+```ts src/support/ask.ts — excerpt
 import {
     assistant,
     type AssistantMessage,
@@ -10269,7 +10377,7 @@ import {
 } from '@abide/abide/server'
 import { onlyStaff } from '#src/server/onlyStaff'
 
-export const ask = POST(
+export default POST(
     async function* ({ messages }: { messages: AssistantMessage[] }) {
         yield* assistant(
             messages,
@@ -10284,7 +10392,6 @@ export const ask = POST(
     },
     { middleware: [onlyStaff], clients: { mcp: false } },
 )
-</script>
 ```
 
 `clients: { mcp: false }` keeps the assistant out of its own tool list. The page reads `ask` like any stream: each event arrives as a production of the value it hands back.
@@ -10306,23 +10413,16 @@ Changing the provider changes nothing downstream of the handler. A page written
 
 **`assistant(messages, provider, { mcp: true })` — your handlers as its tools** — The support assistant, asked about one invoice. The model here is a recording and its lines are fixed; the tool call it makes runs this site's own handler, as you.
 
-```abide Chat.abide
+```abide lib/Chat.abide
 <script server>
 import {
     type AssistantMessage,
     assistant,
-    GET,
     POST,
     type Provider,
 } from '@abide/abide/server'
 
-const PAID = new Set(['INV-4021'])
-
-export const invoiceStatus = GET(
-    ({ id }: { id: string }) => ({ id, paid: PAID.has(id) }),
-    { description: 'Whether an invoice has been paid, by its number.' },
-)
-
+// The MCP tool `invoiceStatus.ts` beside the page is listed as.
 const TOOL = 'get_machines_put-a-claude-assistant-on-your-site_invoiceStatus'
 
 // The model is a recording; the tool call it asks for is made for real.
@@ -10337,7 +10437,7 @@ const recorded: Provider = {
     },
 }
 
-export const askWithTools = POST(
+const askWithTools = POST(
     async function* ({ messages }: { messages: AssistantMessage[] }) {
         yield* assistant(messages, recorded, { mcp: true })
     },
@@ -10381,6 +10481,16 @@ const events = reactive(() =>
 </div>
 ```
 
+```ts invoiceStatus.ts
+import { GET } from '@abide/abide/server'
+
+const PAID = new Set(['INV-4021'])
+
+export default GET(({ id }: { id: string }) => ({ id, paid: PAID.has(id) }), {
+    description: 'Whether an invoice has been paid, by its number.',
+})
+```
+
 *1 option, 0 tool definitions* — against the arm's tool table, which spells each tool's name, description and input schema a second time and dispatches the call by name.
 
 `mcp: true` offers the model the tools `/__abide/mcp` lists, so which handlers it may call is decided where it already is — `clients: { mcp: false }` withholds one from the assistant as it does from every other model. Asking for tools in an app that lists no handler for MCP throws and says so.
@@ -10399,7 +10509,7 @@ The cost is the resend: every call carries the whole transcript, and the API bil
 
 **`claudeApi(config)` — the request body you wrote, sent as written** — The support assistant on claudeApi, its baseURL pointed at a stand-in on this site that answers with the body it was sent. Ask, and read the request.
 
-```abide ApiRequest.abide
+```abide lib/ApiRequest.abide
 <script server>
 import {
     type AssistantMessage,
@@ -10408,9 +10518,9 @@ import {
     POST,
     request,
 } from '@abide/abide/server'
-import { messages as standIn } from './v1/messages.abide'
+import standIn from '../v1/messages.ts'
 
-export const askTheApi = POST(
+const askTheApi = POST(
     async function* ({ messages }: { messages: AssistantMessage[] }) {
         // This site's stand-in for https://api.anthropic.com.
         const standInAt = new URL(standIn.url({}), request().url)
@@ -10456,12 +10566,11 @@ const events = reactive(() =>
 {/for}
 ```
 
-```abide v1/messages.abide
-<script server>
+```ts v1/messages.ts
 import { POST, sse } from '@abide/abide/server'
 
 // A stand-in for the Messages API, streaming back the body it was sent.
-export const messages = POST(
+export default POST(
     (asked: Record<string, unknown>) =>
         sse([
             { type: 'message_start', message: { usage: { input_tokens: 0 } } },
@@ -10487,7 +10596,6 @@ export const messages = POST(
         ]),
     { clients: { ui: false, mcp: false, cli: false, openapi: false } },
 )
-</script>
 ```
 
 `claudeApi` takes a Messages API request body as Anthropic documents it, snake_case, with the client's `apiKey` and `baseURL` beside it. abide writes `messages` and `stream`; every other field goes on the body as you wrote it, and the `tools` you list — a server tool like web search — are sent beside your own.
@@ -10502,7 +10610,7 @@ Read on: [Config](/app/configure-the-app.md)
 
 **`claudeCode(config)` — a turn on the reader's own Claude Code** — The support assistant on whatever Claude Code is paired with this browser. Ask first and it is refused; connect, run the command in a terminal, and ask again.
 
-```abide Bridge.abide
+```abide lib/Bridge.abide
 <script server>
 import {
     type AssistantMessage,
@@ -10512,12 +10620,12 @@ import {
     POST,
 } from '@abide/abide/server'
 
-export const bridge = GET(() => claudeCode.bridge(), {
+const bridge = GET(() => claudeCode.bridge(), {
     timeout: Infinity,
     clients: { mcp: false },
 })
 
-export const askClaudeCode = POST(
+const askClaudeCode = POST(
     async function* ({ messages }: { messages: AssistantMessage[] }) {
         yield* assistant(
             messages,
@@ -10586,8 +10694,8 @@ The relay at `/__abide/bridge` opens the first time `claudeCode` hands out a com
 
 `claudeCode.bridge()` streams this browser's pairing: unpaired with the command to run, then paired the moment the visitor's bridge connects.
 
-```abide Bridge.abide — excerpt
-export const bridge = GET(() => claudeCode.bridge(), {
+```abide lib/Bridge.abide — excerpt
+const bridge = GET(() => claudeCode.bridge(), {
     timeout: Infinity,
     clients: { mcp: false },
 })
@@ -10620,20 +10728,26 @@ A handler declared once is reached four ways: imported by a page, listed in an O
 type Clients = { ui?: boolean; mcp?: boolean; cli?: boolean; openapi?: boolean }
 ```
 
-```abide src/admin/api.abide — excerpt
-<script server>
-export const rebuildSearchIndex = POST(rebuild, {
+```ts src/admin/rebuildSearchIndex.ts — excerpt
+export default POST(rebuild, {
     clients: { ui: false, mcp: false },
 })
-</script>
 ```
 
 ## Every key defaults to true
 
-A handler you declare is on every surface unless you say otherwise. That is the right default because the alternative — opting each handler into each surface — is four decisions per handler and a fifth surface later that nothing is on.
+A handler file is on every surface unless its `clients` says otherwise (20.2). That is the right default because the alternative — opting each handler into each surface — is four decisions per handler and a fifth surface later that nothing is on.
 
 Every surface is **derived from the route table** rather than authored beside it, so a handler added is a handler listed, and there is no second file to keep in step.
 
+## A private handler is on no surface
+
+A handler a `<script server>` declares is not listed on OpenAPI, on MCP or by the CLI, whatever its `clients` says (16.71). Its file exports nothing (34.17), so no other page can import it either: the one caller is the file that declared it. So `clients` is a handler file's option, and the first decision is which of the two to write: a handler only one file calls stays in that file, and one meant for anything else is a handler file.
+
+Off every surface is still not off the network. A private handler answers http at its address below `/__abide/handlers`, under the rungs filed over its file (16.72).
+
+Read on: [Reading data](/data/read-data-without-writing-an-api.md)
+
 ## `clients` decides what is generated, never who may call
 
 **`clients` is not access control.** A handler with `mcp:
@@ -10738,11 +10852,11 @@ abide dev
 
 |  |  |
 | --- | --- |
-| `src/page.abide` | the page at `/` |
+| `src/index.abide` | the page at `/` |
 | `src/layout.abide` | the root layout: the document its pages are served in, and the `<script server>` holding the lifecycle hooks |
-| `package.json`, `tsconfig.json`, `biome.json` | the toolchain, configured |
+| `package.json`, `tsconfig.json`, `biome.json`, `bunfig.toml` | the toolchain, configured — tests included |
 
-`#src/*` is the one import alias, mapping onto `src/`. Grow the app by subject — a `src/billing/` with its own pages, components and `server` — and its pages answer below `/billing`, with no file moved to make room.
+`#src/*` is the one import alias, mapping onto `src/`. Grow the app by subject — a `src/billing/` with its own pages and handlers, a `lib` for its components and a `server` — and its pages answer below `/billing`, with no file moved to make room.
 
 Nothing generated is a framework file you are asked not to edit. The layout is a real component writing a real HTML document, and the page is a component too.
 
@@ -10797,7 +10911,7 @@ Read on: [Config](/app/configure-the-app.md) · [Build & start](/ship/build-and-
 abide run scripts/backfill.ts --since 2026-01-01
 ```
 
-Runs a script under the abide runtime, which is what lets a one-off import `#src/server/database` and `#src/failures` without a build and without a second tsconfig.
+Runs a script under the abide runtime, which is what lets a one-off import `#src/server/database` and `#src/lib/failures` without a build and without a second tsconfig.
 
 That is the shape a backfill, a migration and a fixture loader want. They are not endpoints and should not become endpoints just to reach the app's own modules — which is what happens in a stack where the only thing that can import them is the server.
 
@@ -10927,9 +11041,12 @@ Every one of these is caught before the code runs, which is why the ergonomic sp
 | a `Failed` built and discarded | the refusal did not happen |
 | a `reactive` handed to two handlers | names both |
 | a nested object argument on a `GET` or `DELETE` | names the method, and says a `POST` is the fix |
-| two files mounting at one address | names both files |
+| two files answering one address | names both files |
+| a stylesheet or a helper directly beside the pages | names the file, and the `lib` to move it into |
+| a handler file exporting anything but its handler | names the export, and where it belongs instead |
+| an `export` in a `.abide` | the component is the file's one export, and a handler another file calls is a handler file |
 
-The last three are build errors rather than type errors, and they are here for the same reason: each is a mistake that otherwise fails at the first request, or worse, quietly succeeds.
+The last six are build errors rather than type errors, and they are here for the same reason: each is a mistake that otherwise fails at the first request, or worse, quietly succeeds.
 
 Read on: [`.abide` files](/reference/abide-files.md) · [Failures](/data/refuse-a-request-and-say-why.md)
 
@@ -10952,13 +11069,20 @@ A hover, a jump to a definition and the members offered after a `.` are answered
 
 Read on: [CLI](/reference/cli.md)
 
-## `abide sync` types a `.ts` that imports a `.abide`
+## A handler another file calls is a `.ts`
+
+A `.abide` exports its component and nothing else, so a handler a second file calls is a handler file — a `.ts` — and `tsc` reads it as it reads any other. A `.ts` importing it is typed with nothing generated in between and nothing to keep current.
+
+## `abide routes` is the table the build will serve
 
 ```
-abide sync
+abide routes
+abide routes --json
 ```
 
-`tsc` does not read a `.abide` either, so a `.ts` importing a handler from one would see nothing it exports. `abide sync` writes each file's exported types to `.abide/types`, which the scaffold's `tsconfig.json` already reaches. It parses and nothing more, so the scaffold runs it on `bun install`, and `abide lsp` keeps it current as you edit.
+Every address the app answers, the method and the file behind each, and the file filing each hook. It is the build's own reading of the tree, so an address you meant to add and did not is missing here before it is missing in production.
+
+Read on: [Routes](/pages/add-a-page.md) · [Handler URLs](/data/find-the-url-a-handler-answers-on.md)
 
 ## In CI
 
@@ -10966,7 +11090,7 @@ abide sync
 abide check && abide build && bun test
 ```
 
-`check` first, because a type error is the cheapest failure to report and the fastest to get. `build` next, because it catches the mount collisions and the value-shared-between-handlers errors that only a whole route table can see.
+`check` first, because a type error is the cheapest failure to report and the fastest to get. `build` next, because a bundle that will not build is the next cheapest, and the tests last, since they are the slowest to tell you anything.
 
 Read on: [Build & start](/ship/build-and-serve-the-app.md)
 
@@ -11074,21 +11198,21 @@ The launch remembers the choice in `APP_DATA_DIR`. If you started the app with t
 
 **Disconnect** in the File menu stops the app served here and goes back to the forms, and the next launch opens there too. **Connect…** opens the forms without stopping anything until you choose.
 
-## `launcher` sets the window and the forms
+## `onLauncher` sets the window and the forms
 
 ```abide abide
-<script module>
-import type { LauncherOptions } from '@abide/abide/server'
+<script server>
+import { onLauncher } from '@abide/abide/server'
 
-export const launcher: LauncherOptions = {
+onLauncher(() => ({
     width: 960,
     height: 640,
     connect: false,
-}
+}))
 </script>
 ```
 
-`src/launcher.abide` sits beside your root layout, and the `launcher` its `<script module>` exports is read when the app launches. A file of that block alone keeps the built-in page. `width` and `height` are the first window's size, and `minWidth` and `minHeight` its floor. After the first launch, the window opens where it was last left.
+`src/launcher.abide` sits beside your root layout, and what the `onLauncher` its `<script server>` calls answers is read when the app launches. It is the one file that may call it: an `onLauncher` anywhere else fails the build, naming the file. A file of that block alone keeps the built-in page. `width` and `height` are the first window's size, and `minWidth` and `minHeight` its floor. After the first launch, the window opens where it was last left.
 
 `start` and `connect` turn a button off. An app that only ever talks to its server turns `start` off. An app that only runs locally turns `connect` off, and Connect… leaves the File menu with it. Turning both off is a type error, because the launcher would have nothing to offer, and an app that slips one past the checker refuses to launch.
 
@@ -11117,42 +11241,48 @@ const { name, start, fields, failure } = props<Launch>()
 {/if}
 ```
 
-Markup in `src/launcher.abide` replaces the built-in page, and receives the same `Launch` the built-in page is drawn from. `start` and `connect` are the addresses the two forms post to, and each is `undefined` where `launcher` turned that form off. `fields` is one `ConfigField` per input the start form asks for, prefilled. `failure` is what the last attempt was refused with, and `icon` and `accent` are the icon and the color the built-in page uses.
+Markup in `src/launcher.abide` replaces the built-in page, and receives the same `Launch` the built-in page is drawn from. `start` and `connect` are the addresses the two forms post to, and each is `undefined` where `onLauncher` turned that form off. `fields` is one `ConfigField` per input the start form asks for, prefilled. `failure` is what the last attempt was refused with, and `icon` and `accent` are the icon and the color the built-in page uses.
 
 It is rendered by `render` before the app it belongs to is running, so it is a document rather than a live page: its forms post and its `<style>` applies, but an `onclick` does nothing. Written inside `<html>`, it writes its own document. A launch page that fails to render reaches `onError`, and the built-in page shows in its place.
 
 Read on: [Manual rendering](/pages/render-a-document-yourself.md)
 
-## A page adds to the menu bar by exporting `menu`
+## A page adds to the menu bar with `onMenu`
 
 ```abide abide
-<script module>
-import { menuItem } from '@abide/abide'
+<script>
+import { menuItem, onMenu, reactive, watch } from '@abide/abide'
+
+let selected = reactive<string[]>([])
+
+const exportInvoices = menuItem({ label: 'Export…', key: 'cmd+e' })
+const markPaid = menuItem({ label: 'Mark Paid', key: 'cmd+p' })
 
-export const exportInvoices = menuItem({ label: 'Export…', key: 'cmd+e' })
-export const menu = [
+onMenu(() => [
     { label: 'File', items: ['separator', exportInvoices] },
     {
         label: 'Invoices',
-        items: [{ label: 'Overdue', href: '/invoices/overdue' }],
+        items: [
+            { label: 'Overdue', href: '/invoices/overdue' },
+            ...(selected.length > 0 ? [markPaid] : []),
+        ],
     },
-]
-</script>
-
-<script>
-import { watch } from '@abide/abide'
+])
 
 watch(() => exportInvoices.on(() => download()))
+watch(() => markPaid.on(() => payAll(selected)))
 </script>
 ```
 
-The menu bar is the route's. Every desktop app has the app's own menu, File, Edit, View and Window, and each layout around the page and then the page itself adds what its `<script module>` exports as `menu`. A layout's menus are there on every page under it, and a page's are there only while it is showing. Navigate away and they go.
+The menu bar is the route's. Every desktop app has the app's own menu, File, Edit, View and Window, and each layout around the page and then the page itself adds what its `onMenu` answers. A layout's menus are there on every page under it, and a page's are there only while it is showing. Navigate away and they go.
+
+The function is read the way a template is, so the menus follow the page's state. Mark Paid is in the Invoices menu while something is selected, and leaves it when the selection empties — the menu bar is told again each time a value the function read moves.
 
 A menu with the same `label` as one already there adds its items to the end of it, so Export… lands in File. Any other menu stands before Window, where macOS puts an app's own.
 
 | An item | When picked |
 | --- | --- |
-| made by `menuItem` | runs every function its `on` filed, in the page that exported it |
+| made by `menuItem` | runs every function its `on` filed, in the page that filed it |
 | with an `href` | navigates there, as a link in the page would |
 | with a `role` | does what the platform does: `copy` copies, `quit` stops the app and quits |
 | with `items` | is a menu of its own |
@@ -11244,7 +11374,7 @@ abide
 > watch chat/room id=onboarding
 ```
 
-The address is the handler's route without its leading `/` — the directory under `src` and the export — and the args are `name=value` words or one JSON object, as `call` takes them. Against a deployed app it is a command of its own: `abide watch chat/room id=onboarding --url https://app.example`.
+The address is the handler's route without its leading `/` — its file's path under `src` — and the args are `name=value` words or one JSON object, as `call` takes them. Against a deployed app it is a command of its own: `abide watch chat/room id=onboarding --url https://app.example`.
 
 ## The channel is the same channel
 
@@ -11313,9 +11443,9 @@ Read on: [Build & start](/ship/build-and-serve-the-app.md) · [Lifecycle](/app/r
 
 **`createApp()` — the app a test holds, with no port** — The test beside the card asks for the pool through app.fetch, then stops the app. Fetch the same handler over the wire and read the same answer.
 
-```abide Answer.abide
+```abide lib/Answer.abide
 <script server>
-import { GET, onStart, onStop } from '@abide/abide/server'
+import { onStart, onStop } from '@abide/abide/server'
 import { pool } from './pool'
 
 onStart(async (start) => {
@@ -11327,14 +11457,11 @@ onStop(async (stop) => {
     await stop()
     await pool.close()
 })
-
-export const poolState = GET(() => ({ connected: pool.connected }), {
-    description: 'Whether the pool is connected.',
-})
 </script>
 
 <script>
 import { reactive } from '@abide/abide'
+import poolState from '../poolState.ts'
 
 let status = reactive('—')
 let traced = reactive('—')
@@ -11354,7 +11481,16 @@ let traced = reactive('—')
 </ul>
 ```
 
-```ts pool.ts
+```ts poolState.ts
+import { GET } from '@abide/abide/server'
+import { pool } from './lib/pool.ts'
+
+export default GET(() => ({ connected: pool.connected }), {
+    description: 'Whether the pool is connected.',
+})
+```
+
+```ts lib/pool.ts
 /** The pool `onStart` opens and `onStop` closes. */
 export const pool = {
     connected: false,
@@ -11367,10 +11503,10 @@ export const pool = {
 }
 ```
 
-```ts app.test.ts
+```ts tests/app.test.ts
 import { expect, test } from 'bun:test'
 import { createApp } from '@abide/abide/server'
-import { pool } from './pool'
+import { pool } from '../lib/pool'
 
 // Run from the app's own directory: `createApp` finds the app there (38.25).
 test('the pool handler answers in process as it does on the wire', async () => {
@@ -11396,8 +11532,72 @@ A `Request` in and a `Response` out, through everything a served request goes th
 
 Those are the parts a handler called directly does not have, which is the reason to reach for a request at all. Assert on the response and you are asserting on what a browser would have been sent.
 
+`poolState.ts` is a handler file, so the address the test asks for is its path. The test is `tests/app.test.ts`, beside the page it tests: nothing under a `tests` directory has an address, so a test sits next to the page or the handler it reaches and is never served.
+
 Read on: [Call a handler](/ship/call-a-handler-from-the-terminal.md)
 
+## A test renders a `.abide` it imports
+
+**`render(component)` — the `.abide` a test imports** — The pipeline sums the deals still open. Its test renders the same component and reads the total off the markup.
+
+```abide lib/Pipeline.abide
+<script>
+import { reactive } from '@abide/abide'
+
+let deals = reactive([
+    { name: 'Analytical Engines', amount: 8000, won: false },
+    { name: 'Hopper & Co', amount: 4400, won: false },
+])
+const open = reactive(() => deals.filter((deal) => !deal.won))
+const total = reactive(() => open.reduce((sum, deal) => sum + deal.amount, 0))
+
+const usd = (amount: number) => `$${amount.toLocaleString('en-US')}`
+
+function win(name: string) {
+    deals = deals.map((deal) =>
+        deal.name === name ? { ...deal, won: true } : deal,
+    )
+}
+</script>
+
+<ul class="fields">
+    {#for deal of open by deal.name}
+        <li><span>{deal.name}</span><strong>{usd(deal.amount)}</strong>
+            <button onclick={() => win(deal.name)}>Won</button></li>
+    {/for}
+</ul>
+
+<ul class="tiles">
+    <li><span>open pipeline</span><strong>{usd(total)}</strong></li>
+</ul>
+```
+
+```ts tests/Pipeline.test.ts
+import { expect, test } from 'bun:test'
+import { render } from '@abide/abide/server'
+import Pipeline from '../lib/Pipeline.abide'
+
+// bunfig.toml preloads `@abide/abide/test`, which makes the import a component.
+test('the pipeline totals the deals still open', async () => {
+    const html = new TextDecoder().decode(await render(Pipeline({})))
+    expect(html).toContain('Hopper &amp; Co')
+    expect(html).toContain('$12,400')
+})
+```
+
+The import is the component the build compiles, with no `createApp` run first, and `render` turns it into a document's bytes as a page's render does. The test asserts on markup, so what it checks is what a reader would see.
+
+One line in the app's `bunfig.toml` makes that so, and the scaffold writes it:
+
+```toml bunfig.toml
+[test]
+preload = ["@abide/abide/test"]
+```
+
+Without it, `bun test` resolves a `.abide` import to the file's path, and the test fails on `Pipeline is not a function`.
+
+Read on: [Manual rendering](/pages/render-a-document-yourself.md)
+
 ## `app.run` is a scope and nothing else
 
 Calling a handler by name already runs its body, its rungs and its schema. What it needs from you is a scope — the thing a cache entry is filed under, and the lifetime a request-local value belongs to.
@@ -11437,7 +11637,7 @@ Read on: [Request](/app/read-the-incoming-request.md)
 
 Hold it with `await using` and it stops where the block ends, a failed assertion included. The test's second case stops the app by hand and finds the pool `onStart` opened closed again:
 
-```ts app.test.ts — excerpt
+```ts tests/app.test.ts — excerpt
 test('stopping the app closes the pool onStart opened', async () => {
     const app = await createApp()
     expect(pool.connected).toBe(true)
@@ -11595,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
 
@@ -11850,7 +12050,7 @@ export const notMember = refuse.named('NotMember', 403, undefined, {
 ### Returning a refusal
 
 ```ts server
-export const invite = POST(async ({ group }: { group: string }) => {
+export default POST(async ({ group }: { group: string }) => {
     if (!(await isMember(group))) return notMember({ group })
     return send(group)
 })
@@ -12015,13 +12215,11 @@ There is no `schemas` option on `GET` or `POST`. A shape is a fact about the val
 
 ### A read any surface may call
 
-```abide src/invoices/page.abide — excerpt
-<script server>
-export const getInvoice = GET(
+```ts src/invoices/getInvoice.ts — excerpt
+export default GET(
     ({ id }: { id: string }) => database.invoice.find(id),
     { description: 'One invoice, by id.' },
 )
-</script>
 ```
 
 ### A value every caller follows
@@ -12032,9 +12230,9 @@ const rooms = reactive((_room: { id: string }): Turn[] => [], {
     by: 'id',
 })
 
-export const room = GET(rooms)
+const room = GET(rooms)
 
-export const say = POST(({ id, text }: { id: string; text: string }) => {
+const say = POST(({ id, text }: { id: string; text: string }) => {
     rooms({ id }).patch((turns) => {
         turns.push({ id: crypto.randomUUID(), text })
     })
@@ -12169,9 +12367,9 @@ An ambient that is a `Reactive` is read the way any value is read, so reading it
 
 ### The caller, in a rung
 
-```abide src/invoices/page.abide — excerpt
+```abide src/invoices/index.abide — excerpt
 <script server>
-export const voidInvoice = POST(
+const voidInvoice = POST(
     ({ id }: { id: string }) => database.invoice.void(id),
     {
         middleware: [
@@ -12361,7 +12559,7 @@ A **`.abide`** file is a component: a template, with `<script>` and `<style>` bl
 </script>
 
 <script server>
-// module scope, on the server alone; exports handlers
+// module scope, on the server alone; private handlers, hooks
 </script>
 
 <script>
@@ -12376,7 +12574,7 @@ A **`.abide`** file is a component: a template, with `<script>` and `<style>` bl
 ```
 
 Every block is optional and order is free. A file with no `<script>` is markup, which is what a presentational component usually is. A `<script
-        server>` is written outside a `server` or `public` directory, and the browser's copy of the file carries a client per handler it exports in its place.
+        server>` is written outside a `server` or `public` directory, and the browser's copy of the file carries a client per handler it declares in its place. No block exports: the component is the file's one export (34.17).
 
 ## Reading and writing by name
 
@@ -12403,25 +12601,22 @@ The rule is **position**. An operand, a text hole, an attribute and a value-type
 | Spelling | Meaning |
 | --- | --- |
 | `{expr}` | Reactive text, escaped. |
-
-### Expressions
-
-| formatting whitespace | What a run of whitespace renders as. | 33.17, 33.18 |
-| --- | --- | --- |
-| `{raw(...)}` | Raw HTML. | 32.2 |
-| `name={expr}` | A reactive attribute or property. | 32.3, 32.20 |
-| `on<event>={fn}` | A native listener on an element, and an ordinary prop on a component. | 32.4 |
-| `name="…{expr}…"` | An interpolated quoted value. | 32.3 |
-| `bind:value` | Two-way bind on an element. | 5.16, 32.5 |
-| `bind:prop={state}` | Hands a component prop the caller's `Reactive`, or a `{get, set}` pair, to write through. | 32.6, 33.6, 33.8, 14.18 |
-| `bind:checked` | A boolean bind on an input. | 32.7 |
-| `bind:open` | The same, on a `<details>`. | 32.7 |
-| `bind:group` | Radio or checkbox membership. | 32.8 |
-| `bind:value={{get, set}}` | Two-way bind over an explicit accessor pair, on an element or a component. | 32.5, 32.6 |
-| `bind:element={Reactive<Element> \| ((element: Element) => void \| Disposer)}` | A node reference. | 32.9 |
-| `class:name={cond}` | Toggles a class. | 32.10 |
-| `style:prop={value}` | Sets one style property. | 32.10, 32.19 |
-| `{...expr}` | Spreads props or attributes. | 32.11, 33.12, 33.13 |
+| formatting whitespace | What a run of whitespace renders as. |
+| `{raw(...)}` | Raw HTML. |
+| `name={expr}` | A reactive attribute or property. |
+| `on<event>={fn}` | A native listener on an element, and an ordinary prop on a component. |
+| `name="…{expr}…"` | An interpolated quoted value. |
+| `bind:value` | Two-way bind on an element. |
+| `bind:prop={state}` | Hands a component prop the caller's `Reactive`, or a `{get, set}` pair, to write through. |
+| `bind:checked` | A boolean bind on an input. |
+| `bind:open` | The same, on a `<details>`. |
+| `bind:group` | Radio or checkbox membership. |
+| `bind:value={{get, set}}` | Two-way bind over an explicit accessor pair, on an element or a component. |
+| `bind:element={Reactive<Element> \| ((element: Element) => void \| Disposer)}` | A node reference. |
+| `class:name={cond}` | Toggles a class. |
+| `style:prop={value}` | Sets one style property. |
+| `{...expr}` | Spreads props or attributes. |
+| static template text | What an author writes outside a slot, in body text and in an attribute value. |
 
 Static text is markup. An author-written `&amp;` or `&copy;` renders the same in body text and in an attribute value, and only an interpolated value is escaped — the one exception being a URL-typed attribute, where the encoding is what stops an entity forming a scheme.
 
@@ -12466,28 +12661,27 @@ Static text is markup. An author-written `&amp;` or `&copy;` renders the same in
 | --- | --- |
 | `<script>` | Per-instance component setup. |
 | `<script module>` | Module scope. |
-| `<script server>` | Module scope on a server alone, exporting the file's handlers. |
+| `<script server>` | Module scope on a server alone, declaring its file's private handlers and filing its hooks. |
 | `<style>` | Component-scoped styles. |
 | `import './app.css'` | A stylesheet the component depends on. |
 | `:global(…)` | The per-selector escape from scoping. |
 
-A `.ts` file imports what a `<script module>` or a `<script server>` exports by name, as from any module. TypeScript reads no `.abide`, so abide writes each file's exported types to `.abide/types` — `abide sync` does it alone, the scaffold runs it on `bun install`, every other command and your editor keep it current — and the scaffold's `tsconfig.json` names that directory in `rootDirs` and `paths`.
+An `export` in any block is a compile error, so what two files share is a module under a `lib`, and a handler two files call is a handler file of its own — a `.ts` that TypeScript reads as it reads any other.
 
 ## Tracking
 
-| branch-local `<script>` | no | Setup, once per item. | 14.8 |
-| --- | --- | --- | --- |
-| `reactive` body, unkeyed | **yes** | Pushes its own subscriber. | 14.3, 14.11, 14.15, 14.16 |
-| `reactive` body, keyed | **no** | Untracked by handler. | 14.4 |
-
-| block body binding | yes | A live read, like a prop. | 14.5 |
-| --- | --- | --- | --- |
-| `watch` effect, bare | **yes** | Pushes its own subscriber. | 14.6, 14.14, 14.16 |
-| `watch` effect, over sources | **no** | The sources decide the reruns. | 12.3, 14.6 |
-
-| event handler | no | Not the flow. | 14.9 |
-| --- | --- | --- | --- |
-| `Transformer`, `Disposer`, middleware, lifecycle hooks | **no** | Not the flow. | 14.10 |
+| Context | Tracks | Meaning |
+| --- | --- | --- |
+| template expression | **yes** | The flow itself. |
+| branch-local `<script>` | **no** | Setup, once per item. |
+| `reactive` body, unkeyed | **yes** | Pushes its own subscriber. |
+| `reactive` body, keyed | **no** | Untracked by handler. |
+| block body binding | **yes** | A live read, like a prop. |
+| `watch` effect, bare | **yes** | Pushes its own subscriber. |
+| `watch` effect, over sources | **no** | The sources decide the reruns. |
+| component `<script>` setup | **no** | Setup, once per instance. |
+| event handler | **no** | Not the flow. |
+| `Transformer`, `Disposer`, middleware, lifecycle hooks | **no** | Not the flow. |
 
 A context that tracks reruns when what it read changes. A context that does not is one where a read is a read — an event handler runs because something happened, and a setup body runs once — so nothing is arranged by accident and the arrangement you want is `reactive` or `watch`.
 
@@ -12497,8 +12691,14 @@ A context that tracks reruns when what it read changes. A context that does not
 
 A run of whitespace carrying newlines but no space or tab is **dropped wherever it stands**, and a run that renders nothing but carries a newline and indentation is dropped at both ends of every block body and of the top-level template. So indentation in a template is layout for the reader rather than text in the document.
 
+### Where a `.abide` lives
+
+A `.abide` directly in a directory under no fence is a page at its path, save a `layout.abide`, an `error.abide` and the root's `launcher.abide` (23.21). A component is a `.abide` under a `lib`, imported by path, and a test under a `tests` directory imports one the same way once `@abide/abide/test` is preloaded (38.109). The [Routing](/reference/routing.md) reference has the whole map.
+
 ### What the compiler refuses
 
+- An `export` in any block, however the language spells it.
+- A `<script server>` in a file under a `server` or a `public` directory.
 - A read spelled `foo()` with an argument.
 - `props()` from a `<script module>` block.
 - A prop passed to a component that never calls `props()`.
@@ -12510,7 +12710,7 @@ Each is caught before the code runs, which is why the ergonomic form does not ha
 
 ### A component that owns a value
 
-```abide src/ui/Handle.abide
+```abide src/lib/Handle.abide
 <script>
 import { reactive } from '@abide/abide'
 
@@ -12523,7 +12723,7 @@ let handle = reactive('ada')
 
 ### A component with props and children
 
-```abide src/ui/Panel.abide
+```abide src/lib/Panel.abide
 <script>
 import { props } from '@abide/abide'
 
@@ -12547,7 +12747,7 @@ const { title } = props<{ title: string }>()
 
 *File patterns, precedence, head merging and render.*
 
-Every address an abide app answers on comes from a **file path**. A page is a `page.abide`, and a handler is an export of a `<script server>` in any `.abide`, both answering at the path of their directory under `src`. So there is no route table, and nothing to keep in step with the filesystem.
+Every address an abide app answers on comes from a **file path**. A page is a `.abide` and a handler is a `.ts`, each directly in a directory under `src` and answering at its own path. So there is no route table, and nothing to keep in step with the filesystem.
 
 ## Page patterns
 
@@ -12564,19 +12764,18 @@ A file or directory named `[id]` matches exactly one segment and is a required k
 
 ## Mount paths
 
-| File | Export | Served at |
+| File | Declares | Served at |
 | --- | --- | --- |
-| `users/page.abide` | `getUser` | `/users/getUser` |
-| `layout.abide` | `health` | `/health` |
-| `admin/page.abide` | `recent` | `/admin/recent` |
-| `media/[id]/page.abide` | `save` | `/media/[id]/save`, `id` reaching its `Args` |
-| `media/[id]/comments.abide` | `addComment` | `/media/[id]/addComment` |
+| `users/getUser.ts` | `export default GET(…)` | `/users/getUser` |
+| `health.ts` | `export default GET(…)` | `/health` |
+| `media/[id]/save.ts` | `export default POST(…)` | `/media/[id]/save`, `id` reaching its `Args` |
+| `media/[id]/lib/Comments.abide` | `const addComment = POST(…)` in its `<script server>` | `/__abide/handlers/media/id/lib/Comments/addComment` |
 
-A handler answers at its file's DIRECTORY, then its export's name — the file's own name is never part of it, so a directory's handlers sit in as many files as you like.
+A handler file answers at its PATH, and declares one handler as its default export, exporting nothing else. A handler a `<script server>` declares is its file's alone: it answers below `/__abide/handlers`, takes nothing from the path, is listed on no other surface, and runs under the rungs filed where its file's hooks are.
 
 A parameter in the route reaches the handler's args from the path, whatever the method, so the handler's `Args` has to declare it — one it does not is a build error naming the parameter. A request that names it in the query or the body as well is refused `400`.
 
-A route answers each method **once**. A page answers `GET` at its own route, so a `GET` handler beside it is a build error naming both files, and a `POST` beside it is the form the page posts to. Two routes that differ only in a parameter's name are one route.
+A route answers each method **once**. A page answers `GET` at its own route, so a `GET` handler file at that route is a build error naming both files, and a `POST` there is the form the page posts to. Two routes that differ only in a parameter's name are one route.
 
 ## `render`
 
@@ -12608,12 +12807,34 @@ The batching unit of a fill is the **flush**, not the production: a value that p
 
 ## Description
 
+### From file to route
+
+```
+src/
+  index.abide           GET /
+  layout.abide          around every page below /
+  crm/
+    index.abide         GET /crm
+    [id].abide          GET /crm/[id]
+    getInvoice.ts       GET /crm/getInvoice
+    layout.abide        around every page and handler below /crm
+    lib/                no route: components and modules
+      Notes.abide       its handlers below /__abide/handlers/crm/lib/Notes
+    tests/              no route: tests
+  server/               no route: modules the browser never loads
+  public/
+    robots.txt          the file, at /robots.txt
+```
+
+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, 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
 
 A request goes to the most specific route **answering its method**, a literal segment beating a dynamic one at the same depth — so `POST
-            /media/new` reaches the `new` handler a `<script
-            server>` in `media/` exports, while `GET
-            /media/new` falls through to the page at `media/[id]/page.abide`. `layout.abide` and `error.abide` are both resolved **nearest-ancestor by route**, which is what lets a section answer for itself and the app answer for the rest.
+            /media/new` reaches the handler file `media/new.ts`, while `GET
+            /media/new` falls through to the page at `media/[id]/index.abide`. `layout.abide` and `error.abide` are both resolved **nearest-ancestor by route**, which is what lets a section answer for itself and the app answer for the rest.
 
 ### The head
 
@@ -12623,7 +12844,7 @@ A request goes to the most specific route **answering its method**, a literal se
 
 ### A route with a required and an optional segment
 
-```abide src/crm/invoices/[id]/[[tab]]/page.abide — excerpt
+```abide src/crm/invoices/[id]/[[tab]]/index.abide — excerpt
 <script>
 import { route } from '@abide/abide'
 
@@ -12635,8 +12856,8 @@ const { id, tab = 'summary' } = route.params
 
 ### A document rendered outside the page pipeline
 
-```abide src/pages/render-a-document-yourself/InvoicePreview.abide — excerpt
-export const previewInvoice = GET(
+```abide src/pages/render-a-document-yourself/lib/InvoicePreview.abide — excerpt
+const previewInvoice = GET(
     async ({ id }: { id: string }) => {
         const invoice = await findInvoice(id)
         return page(await render(Document({ invoice })))
@@ -12648,6 +12869,7 @@ export const previewInvoice = GET(
 ## See also
 
 - [Routes](/pages/add-a-page.md) — the guide to page files
+- [Handler URLs](/data/find-the-url-a-handler-answers-on.md) — every address a handler answers on, and `abide routes`
 - [Manual rendering](/pages/render-a-document-yourself.md) — `render` in use
 - [Streaming HTML](/pages/send-the-page-before-the-data-lands.md) — what a sink is for
 
@@ -12659,7 +12881,7 @@ export const previewInvoice = GET(
 
 *Environment variables, files and lifecycle hooks.*
 
-An abide app is configured by three things: the **environment** it starts in, the **files** it finds under `src/`, and the **hooks** its `<script server>` blocks register. There is no config file format, because a typed `config()` read is what an app actually wants and an environment variable is what a deployment actually has.
+An abide app is configured by three things: the **environment** it starts in, the **files** it finds under `src/`, and the **hooks** its server blocks and handler files call. There is no config file format, because a typed `config()` read is what an app actually wants and an environment variable is what a deployment actually has.
 
 ## Environment variables
 
@@ -12694,23 +12916,28 @@ The `ABIDE_`-prefixed ceilings default to no ceiling. That is the honest default
 | --- | --- |
 | `src/**` | The app's source. |
 | `**/server/**` | Source the browser never loads. |
+| `**/lib/**` | The app's code that is no address: components and modules, on both sides. |
+| `**/tests/**` | The app's tests. |
 | `**/public/**` | The files answered as authored, at their path below that directory. |
 | `src/public/favicon.ico` | The file answered at `/favicon.ico`. |
 | `src/public/robots.txt` | The file answered at `/robots.txt`. |
 | `src/public/icon.png` · `src/public/icon.icns` | The files answered at `/icon.png` and `/icon.icns`, and the desktop app's icon. |
-| `src/**/` | The app's addresses, each at its route. |
-| `**/page.abide` | A route: its page, and the handlers its `<script server>` exports. |
+| `src/**/` | A directory of the app's, a segment of the route of every file directly in it. |
+| `**/index.abide` | The page at its directory's route. |
+| `**/<name>.abide` | The page at its directory's route and then `<name>`. |
+| `**/<name>.ts` | A handler file: the handler its default export declares, at its directory's route and then `<name>`. |
 | `**/layout.abide` | A layout, rendering every page below its route through a slot, and the hooks over that route. |
-| `src/launcher.abide` | The desktop launcher, beside the root layout: the `launcher` options its `<script module>` exports, and its page in place of the launcher's own where it has markup. |
+| `src/launcher.abide` | The desktop launcher, beside the root layout: the `onLauncher` it calls, and its page in place of the launcher's own where it has markup. |
 | `src/layout.abide` | The root layout, whose `<script server>` is the app's own, and whose `<html>` is the document its pages are served in. |
 | `**/error.abide` | The page a refusal renders in. |
 | `**/node_modules/**/*.abide` | A component a dependency ships as source, compiled with the app that imports it. |
-| `import '…' with { type: 'routes' }` | A package's directory mounted at the importing file's directory, its pages, layouts, error pages and handlers answering below it. |
+| `import '…' with { type: 'routes' }` | A package's directory mounted at the importing file's directory, its pages, layouts, error pages and handler files answering below it. |
 | `bunfig.toml` | Under `[serve.static] plugins`, the bundler plugins the client is built with. |
+| `preload = ["@abide/abide/test"]` | The `[test]` preload a test imports the app's `.abide` files through. |
 
-Every directory under `src` is a segment of an address, so `src/billing/page.abide` is `/billing`. A `public` or `server` directory can sit anywhere under it and is never a segment: nothing under one has an address, a page there is a build error, and one inside the other is a build error too. A `public` directory's files answer below the path of the directories above it. Everything outside a `server` directory is both sides. `#src/*` is the one import alias, mapping onto `src/`.
+Every directory under `src` is a segment of an address, so `src/billing/index.abide` is `/billing`. A `server`, `public`, `lib` or `tests` directory can sit anywhere under it and is never a segment: nothing under one has an address, an `index.abide`, a `layout.abide` or an `error.abide` there is a build error, and one inside another is a build error too. Any other directory holds pages, layouts, error pages, handler files and directories alone, and a file of any other kind directly in it is a build error naming the `lib` to move it into. A `public` directory's files answer below the path of the directories above it. Everything outside a `server` directory is both sides. `#src/*` is the one import alias, mapping onto `src/`.
 
-`page.abide`, `layout.abide` and `error.abide` are **addresses rather than names** — the framework's own conventions, where every other file in an app is named after what it exports.
+A page and a handler file are **addresses rather than names**, and so are `index.abide`, `layout.abide` and `error.abide` — the framework's own conventions. A file under a `lib` is named after what it exports.
 
 ## Lifecycle hooks
 
@@ -12723,8 +12950,11 @@ Every directory under `src` is a segment of an address, so `src/billing/page.abi
 | `onConfig` | `(fn: ConfigDefaults \| null, options?: ConfigOptions) => () => void` | The app's config defaults. |
 | `onHealth` | `(report: () => unknown \| Promise<unknown>) => () => void` | The app's health reporter. |
 | `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** from a `<script server>` rather than an export the framework looks for, and it is filed at the route of the file that called it. `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.
+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.
 
 Every one hands back the way off again, so a module that is torn down can remove its own.
 
@@ -12738,6 +12968,10 @@ Every one hands back the way off again, so a module that is torn down can remove
 
 `config()` is ambient, and the same name on both sides. On a server it reads the process environment merged over the app's declared defaults; in a browser it reads what the document was served with, which is the subset an app marked as public. A secret is not in that subset, and that is a property of the declaration rather than of a naming convention.
 
+### `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>` 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
 
 It is the environment name as given, not a boolean and not a three-way enum. An app comparing it against `'production'` is comparing against the string it was started with.
@@ -12746,17 +12980,17 @@ It is the environment name as given, not a boolean and not a three-way enum. An
 
 ### Declaring the app's own config
 
-```abide src/app/configure-the-app/Retries.abide — excerpt
+```abide src/app/configure-the-app/lib/Retries.abide — excerpt
 onConfig(() => ({ RETRIES: 3 }))
 …
-export const retryPolicy = GET(() => ({ retries: config().RETRIES }), {
+const retryPolicy = GET(() => ({ retries: config().RETRIES }), {
     description: 'How many times a call is retried.',
 })
 ```
 
 ### Running work around the boot
 
-```abide src/app/run-code-at-start-and-stop/Pool.abide — excerpt
+```abide src/app/run-code-at-start-and-stop/lib/Pool.abide — excerpt
 onStart(async (start) => {
     await pool.connect()
     await start()
@@ -12816,7 +13050,7 @@ abide --help
 | `abide scaffold <name>` | Writes a starter project. |
 | `abide run <file> [args…]` | Runs a script under the abide runtime. |
 | `abide check [dir…]` | Type-checks `.abide`, on the `.abide` line. |
-| `abide sync` | Writes the types a `.ts` reads a `.abide` by. |
+| `abide routes [--json]` | Every address the app answers, the file answering it, and where each hook is filed. |
 | `abide dev [--port <n>]` | Watches the project and keeps the app up. |
 | `abide build` | Builds the client into content-hashed chunks and a manifest. |
 | `abide start [--port <n>]` | Boots the built app. |