@abide/abide 0.102.0 → 0.104.0

package/src/shared/reactive/Reactive.ts

@@ -19,7 +19,13 @@ import { type Found, runSchema, type Schema } from '../Schema.ts'
 import { UNEXPECTED } from '../UNEXPECTED.ts'
 import { WORK } from '../WORK.ts'
 import { CELL } from './CELL.ts'
-import { Cursor, hasCursorBehind, keepPlaces, type Retained } from './Cursor.ts'
+import {
+    CAUGHT_UP,
+    Cursor,
+    hasCursorBehind,
+    keepPlaces,
+    type Retained,
+} from './Cursor.ts'
 import { ENTRY_LIVES } from './ENTRY_LIVES.ts'
 import { armTimer, type Expiry, expiryFor } from './Expiry.ts'
 import { FOLLOWED } from './FOLLOWED.ts'
@@ -257,7 +263,7 @@ export type Reactive<
     invalidate(): void
     // biome-ignore lint/suspicious/noConfusingVoidType: `void` is the RETURN POSITION of an author's effect, and it is load-bearing. `undefined` there refuses `(v) => { read(v) }` — a block body returning nothing infers `void`, which is not assignable to `undefined` — so the rule's fix would reject the ordinary effect.
     watch(effect: (value: Stored) => void | (() => void)): () => void
-    /** The production in flight, and then what follows it (2.5). */
+    /** What one run produced: the settled value once, or a stream's chunks to its close (2.5, 2.6). */
     [Symbol.asyncIterator](): AsyncIterator<Produced>
     then<Result>(
         onSettled?: (value: Stored) => Result | PromiseLike<Result>,
@@ -459,7 +465,7 @@ type Stream = {
      * Whether what is served is a run that closed.
      *
      * WHETHER WHAT IS SERVED IS A RUN THAT CLOSED, which is the only accumulation a deadline
-     * reaches (6.11). A run in flight has minted nothing, so `expiry.at` says nothing about it —
+     * reaches (6.10). A run in flight has minted nothing, so `expiry.at` says nothing about it —
      * without this the standing arm reads `at` as 0 and drops the value on its first read.
      */
     closed: boolean
@@ -494,7 +500,7 @@ function becomeStream(cell: Cell, source: Cell | null): Stream {
 }
 
 /**
- * Starts a closed run's clock: the close is a streaming producer's mint (6.11), as `produce` is
+ * Starts a closed run's clock: the close is a streaming producer's mint (6.10), as `produce` is
  * every other producer's. A failed or superseded run never reaches here, so it starts no clock.
  */
 function closeRun(cell: Cell, stream: Stream): void {
@@ -651,8 +657,8 @@ class Cell {
      */
     declare schema: Schema<unknown> | null
     /**
-     * A streaming producer's chunk buffer, for a cursor to walk (2.5); `EMPTY_RING` on every
-     * other value, whose cursor answers the standing production from `value`.
+     * A streaming producer's chunk buffer, for a cursor to walk (2.6); `EMPTY_RING` on every
+     * other value.
      */
     declare ring: unknown[]
     /**
@@ -1519,9 +1525,7 @@ function produce(cell: Cell, produced: unknown): number {
     // `ttl` must not pay.
     const expiry = cell.expiry
     const mintedAt = expiry === null ? 0 : Date.now()
-    // 6.10: AN `undefined` IS SERVED AND MOVES NO ORDINAL, so no cursor is handed one — it is not a
-    // message, and not a JSON value either.
-    if (produced !== undefined) cell.ordinal += 1
+    cell.ordinal += 1
     if (expiry !== null) {
         expiry.at = mintedAt
         // A production is what 6.7 released being replaced, so the value is no longer
@@ -2336,7 +2340,7 @@ function adoptAnswer(cell: Cell, produced: unknown): void {
  *
  * 4.16: AN OPENING `undefined` IS LOADED AND IS NOT A PRODUCTION THROUGH THE PIPELINE. No `schema`
  * judges it, no `transform` shapes it, no window holds it and no `store` writes it — it is the value
- * being empty, and the first real production is what those are for. It mints no ordinal (6.10).
+ * being empty, and the first real production is what those are for. It mints no ordinal.
  */
 function landOpening(cell: Cell): void {
     const moved = settleProbes(cell)
@@ -2495,7 +2499,7 @@ async function pump(
     cell.loading = false
     // 3.7: `busy` held until the close, and this is the close.
     if (moved) probesMoved(cell)
-    // 6.11, AFTER THE CASCADE ABOVE: the entry is what a read would answer with, so it is taken
+    // 6.10, AFTER THE CASCADE ABOVE: the entry is what a read would answer with, so it is taken
     // once the last chunk has landed and the value is servable.
     closeRun(cell, stream)
     // 8.9: a stream is written once, at the close, with the accumulation and never a partial.
@@ -2773,7 +2777,7 @@ function beginLoad(cell: Cell): void {
  *
  * AND WHAT IS SERVED WAS MINTED, which every producer but a streaming one answers yes to the moment
  * it is servable. A stream serves the run it is building (9.1), and that run has minted nothing
- * until it closes (6.11) — so a deadline has nothing to measure from and must not drop it.
+ * until it closes (6.10) — so a deadline has nothing to measure from and must not drop it.
  */
 function standingLive(cell: Cell, expiry: Expiry): boolean {
     if (!reloads(cell) || expiry.dropped || !cell.servable) return false
@@ -2936,6 +2940,53 @@ function failureOf(cell: Cell): unknown {
     return at.failure
 }
 
+/**
+ * What one run of `cell` produced, as `for await` walks it.
+ *
+ * 2.5 AND 2.6 — the settling, yielded once, or a stream's chunks from the first to the close. Which
+ * of the two is asked of the settling, since a value may only turn out to stream once its load
+ * resolves (9.6).
+ *
+ * THE CURSOR IS THE WAKE AND THE SETTLING IS THE END (`Cursor.closeOn`).
+ */
+async function* producedRun(cell: Cell): AsyncGenerator<unknown> {
+    const first = await settled(cell, true)
+    if (first !== STREAMING) {
+        yield first
+        return
+    }
+    // THE RUN IS ITS RING: a new run's first chunk replaces the array, where a patch mutates it in
+    // place (9.13) and only moves the base. A run with no chunk yet holds `EMPTY_RING`.
+    let ring = cell.ring
+    // 9.15 — a failure already standing is a revalidation's (2.4), and not this run's.
+    const standing = failureOf(cell)
+    const cursor = new Cursor(cell, cell.ringBase)
+    cursor.closeOn(settled(cell))
+    try {
+        for (;;) {
+            if (cell.ring !== ring) {
+                // 9.16.
+                if (ring !== EMPTY_RING) return
+                ring = cell.ring
+            }
+            const chunk = cursor.take()
+            if (chunk !== CAUGHT_UP) {
+                yield chunk
+                continue
+            }
+            if (cursor.closed) break
+            await cursor.turn()
+        }
+    } finally {
+        cursor.stop()
+    }
+    if (cursor.failure !== undefined) throw cursor.failure
+    // 9.15 AND 16.59 — a run that failed after its first chunk, or one its timeout ended, settles
+    // with what it had; the refusal stands beside it.
+    const ended = failureOf(cell)
+    if (ended !== undefined && ended !== standing) throw ended
+}
+
 /**
  * `busy` without subscribing.
  *
@@ -4034,20 +4085,7 @@ const MEMBERS = {
         return watchCell(this[CELL], effect)
     },
     [Symbol.asyncIterator](this: Callable): AsyncIterator<unknown> {
-        const cell = this[CELL]
-        // 2.5: "the production in flight, from its start". Starting one ordinal back is
-        // what includes it rather than skipping to whatever comes next — and clamped at
-        // zero, where a value nothing has produced into must WAIT rather than hand over
-        // the `undefined` it is holding.
-        // A STREAM'S PRODUCTION IN FLIGHT IS THE STREAM, so its start is the run's first
-        // chunk rather than the latest one.
-        const from =
-            cell.stream !== null
-                ? cell.ringBase
-                : cell.ordinal > 0
-                  ? cell.ordinal - 1
-                  : 0
-        return new Cursor(cell, from)
+        return producedRun(this[CELL])
     },
     // biome-ignore lint/suspicious/noThenProperty: RULEBOOK 1.4 — a `Reactive` MUST be thenable, which is what this rule warns about. Banning it buys a discrimination rather than a semantics, and 16.4's in-process `Rpc` arm is what that discrimination would have cost. 1.6 is the guard that makes thenability safe — the brand is read before `then`.
     then(
@@ -4166,6 +4204,15 @@ export function isStreaming(value: unknown): boolean {
     return stream !== null && stream !== undefined
 }
 
+/**
+ * A cursor over `value` that reads nothing and only wakes when it changes.
+ *
+ * PLACED PAST EVERY CHUNK, so it holds no place a patch has to keep (5.7) and is never behind.
+ */
+export function wakeOf(value: unknown): Cursor {
+    return new Cursor((value as Callable)[CELL], Number.POSITIVE_INFINITY)
+}
+
 /**
  * The chunks a streaming value has told its readers of, from index `from` on.
  *
@@ -4347,8 +4394,7 @@ const SIMPLE_PROTOTYPE = brandedPrototype({
                 return undefined
             }
             cell.value = value
-            // 6.10: an `undefined` is served and moves no ordinal.
-            if (value !== undefined) cell.ordinal += 1
+            cell.ordinal += 1
             // `setDirect`, with `plain` known true by `simple`.
             cell.direct = cell.state === CLEAN
             if (cell.readers.length !== 0) markReaders(cell, DIRTY)

package/src/shared/reactive/callLoad.ts

@@ -161,33 +161,19 @@ function timeLoad(attended: Attended, milliseconds: number | undefined): void {
         }, milliseconds)
     }
     let settled = false
-    let wake = (): void => {}
     const end = (): void => {
         settled = true
         clearTimeout(timer)
-        wake()
     }
-    // A CHUNK IS PROGRESS. The live cursor wakes on each, and outlives the run — it waits on the
-    // next one — so the run settling is a wake of its own, and is what lets the cursor go.
+    // A CHUNK IS PROGRESS, and the run's close ends the loop (2.6). What the run failed with is the
+    // load's to answer, so the loop only stops on it.
     const followChunks = async (): Promise<void> => {
-        const cursor = (reached as AsyncIterable<unknown>)[
-            Symbol.asyncIterator
-        ]()
         try {
-            while (!settled) {
-                await new Promise<void>((resolve) => {
-                    wake = resolve
-                    cursor.next().then(
-                        () => resolve(),
-                        () => resolve(),
-                    )
-                })
+            for await (const _ of reached as AsyncIterable<unknown>) {
                 if (settled || loadOf(reached) !== load) return
                 arm()
             }
-        } finally {
-            void cursor.return?.(undefined)
-        }
+        } catch {}
     }
     arm()
     // 9.6 — a value behind rungs only turns out to stream once the onion resolves, so the question

package/src/shared/reactive/chunksOfStream.ts

@@ -1,54 +1,30 @@
 import { isFailed } from '../Failed.ts'
-import { chunksFrom } from './Reactive.ts'
+import { chunksFrom, wakeOf } from './Reactive.ts'
 
 /**
  * The chunks of a streaming value, as they land, ending when its run closes.
  *
- * The live cursor is the wake and not the source: a cursor outlives the run (it waits on the next
- * one), and a chunk landing in the same turn as the close could be lost to whichever settled first
- * — so each wake sends what the accumulation holds past what has already gone, and the close sends
- * the rest.
+ * WHAT A READ WOULD SERVE, chunk by chunk (16.32), rather than the ring `for await` walks: a gated
+ * value's chunks are its gated accumulation's (9.8). A cursor is the wake and the settling is the
+ * end (`Cursor.closeOn`).
  */
 export async function* chunksOfStream(value: unknown): AsyncGenerator<unknown> {
-    const stream = value as PromiseLike<unknown> & AsyncIterable<unknown>
-    let closed = false
-    let failure: unknown
-    // ONE REACTION ON THE CLOSE FOR THE WHOLE STREAM, which wakes whichever wait is current. A
-    // `Promise.race` against the close per chunk left one reaction per chunk on it, held until the
-    // stream ended.
-    let wake: () => void = () => {}
-    void Promise.resolve(stream).then(
-        () => {
-            closed = true
-            wake()
-        },
-        (error: unknown) => {
-            closed = true
-            failure = error
-            wake()
-        },
-    )
-    const cursor = stream[Symbol.asyncIterator]()
+    const cursor = wakeOf(value)
+    cursor.closeOn(Promise.resolve(value as PromiseLike<unknown>))
     let sent = 0
-    let woken = cursor.next()
     try {
         for (;;) {
-            if (!closed)
-                await new Promise<void>((resolve, reject) => {
-                    wake = resolve
-                    woken.then(() => resolve(), reject)
-                })
             for (const chunk of chunksFrom(value, sent)) {
                 sent += 1
                 yield chunk
             }
-            if (closed) break
-            woken = cursor.next()
+            if (cursor.closed) break
+            await cursor.turn()
         }
     } finally {
-        void cursor.return?.(undefined)
+        cursor.stop()
     }
-    if (failure !== undefined) throw failure
+    if (cursor.failure !== undefined) throw cursor.failure
     // 16.59, 16.60 — A RUN ENDED BY ITS TIMEOUT SETTLES with the chunks it had and holds its refusal
     // rather than rejecting, so the refusal is read off the value and thrown after them: a stream
     // answered over http then ends on it (16.68) rather than as though it had finished.

package/src/{ui → shared}/reportMenu.ts

@@ -1,9 +1,9 @@
-// 38.88 — A ROUTE'S MENU, TOLD TO THE WINDOW IT IS SHOWN IN. Loaded only inside a desktop app, where
-// the window has opened `abideMenu` to the page; anywhere else the router never imports it.
+// 38.88 — A ROUTE'S MENUS, TOLD TO THE WINDOW IT IS SHOWN IN. Loaded only inside a desktop app, where
+// the window has opened `abideMenu` to the page; anywhere else `onMenu` never imports it.
 
-import { MenuEntry, type MenuItem } from '#shared/menuItem.ts'
-import { navigate } from '#shared/navigate.ts'
 import { menuBridge } from './menuBridge.ts'
+import { MenuEntry, type MenuItem } from './menuItem.ts'
+import { navigate } from './navigate.ts'
 
 /** A menu item as the window builds it: an item the page answers carries the `id` it is told by. */
 type Told =
@@ -20,15 +20,13 @@ type Told =
 let numbered: Exclude<MenuItem, 'separator'>[] = []
 let listening = false
 
-/** Tells the window the menus `chain` exports, layouts outermost first and the page last. */
-export function reportMenu(chain: { menu?: unknown }[]): void {
+/** Tells the window `menus`, the layouts' outermost first and the page's last. */
+export function reportMenu(menus: readonly MenuItem[]): void {
     const bridge = menuBridge()
     if (bridge === undefined) return
     numbered = []
     const told: Told[] = []
-    for (const level of chain)
-        if (Array.isArray(level.menu))
-            for (const menu of level.menu as MenuItem[]) told.push(tell(menu))
+    for (const menu of menus) told.push(tell(menu))
     if (!listening) {
         listening = true
         // 38.90, 38.91 — the window names the item picked; the page does what it means.

package/src/shared/routePattern.ts

@@ -1,5 +1,5 @@
 // A ROUTE LITERAL, PARSED. One grammar for two things that would otherwise drift: the file a
-// page is filed as (`invoices/[id]/page.abide`) and the literal an author writes
+// page is filed as (`invoices/[id].abide`) and the literal an author writes
 // (`'/invoices/[id]'`). The bracket spelling is the file system's, so the address is read off the
 // tree rather than declared beside it and the two cannot disagree.
 //
@@ -10,7 +10,12 @@
 // A LEAF: nothing imported but another leaf, because the compiler, the client router and a server
 // router all read it and a constant crossing a seam lives where nothing pulls a graph in behind it.
 
-import { PUBLIC_DIRECTORY, SERVER_DIRECTORY } from './RESERVED_DIRECTORIES.ts'
+import { LAUNCHER_PAGE } from './LAUNCHER_FILES.ts'
+import {
+    HOLDS_SERVER,
+    RESERVED_DIRECTORIES,
+    SERVER_DIRECTORY,
+} from './RESERVED_DIRECTORIES.ts'
 
 type SegmentKind = 'static' | 'required' | 'optional' | 'rest'
 
@@ -48,9 +53,9 @@ export type FileKind = 'page' | 'layout' | 'error' | 'component'
 /**
  * Whether the `.abide` at `path` is a page, a layout, an error page or a component.
  *
- * AN ADDRESS RATHER THAN A NAME. The file name says which of the three it is, and only a file
- * whose place is an `address` (`placeOf`) is one: a `page.abide` under a `server` directory is a
- * component.
+ * 23.21 — WHERE IT SITS, THEN ITS NAME. Every `.abide` directly in an address directory is a page
+ * but a `layout.abide`, an `error.abide` and the root's `launcher.abide`; one under a fence is a
+ * component whatever it is called.
  * One test for every reader: the build's routes, the checker's `Routes` and the `route.params` a
  * page is typed by.
  *
@@ -58,40 +63,56 @@ export type FileKind = 'page' | 'layout' | 'error' | 'component'
  * read the machine's directories as the app's.
  */
 export function fileKind(path: string): FileKind {
-    if (placeOf(path) !== 'address') return 'component'
-    // The WHOLE basename: `homepage.abide` ends with `page.abide` and is a component.
+    if (placeOf(path) !== 'address' || path === LAUNCHER_PAGE)
+        return 'component'
     const name = path.slice(path.lastIndexOf('/') + 1)
-    if (name === 'page.abide') return 'page'
     if (name === 'layout.abide') return 'layout'
-    return name === 'error.abide' ? 'error' : 'component'
+    if (name === 'error.abide') return 'error'
+    return 'page'
 }
 
 /** Where a file sits in an app, which is what it is to every reader (`placeOf`). */
-export type Place = 'address' | 'server' | 'public' | 'dependency' | 'skipped'
+export type Place =
+    | 'address'
+    | 'server'
+    | 'public'
+    | 'lib'
+    | 'tests'
+    | 'dependency'
+    | 'skipped'
 
 /**
  * Where the file at `path`, relative to the app's root, sits — THE ONE ANSWER every walk, fence and
  * emit reads, so no two of them disagree about a path.
  *
- * - `dependency` — 34.28: a package's, outside the root or under `node_modules`, whose directories
+ * - `dependency` — 34.24: a package's, outside the root or under `node_modules`, whose directories
  *   are its package's layout and none of the app's;
  * - `skipped` — under a dot directory, which no walk of the app enters;
- * - `server` or `public` — 23.15: under that reserved directory, the nearest to the root deciding
- *   (23.16 refuses one inside the other);
+ * - `server`, `public`, `lib` or `tests` — 23.15: under that fence, the nearest to the root deciding,
+ *   save a `server` under a `lib` or a `tests`, which is `server` — the fence the browser's bundle
+ *   is checked against (16.29) is never hidden by one above it (23.16);
  * - `address` — 23.14: everywhere else, its directories the segments of its route.
  */
 export function placeOf(path: string): Place {
     if (path.startsWith('../') || path.startsWith('/')) return 'dependency'
     const parts = path.split('/')
+    // A `lib` or a `tests` met first, which a `server` below it still overrides.
+    let fence: Place | undefined
     // The last part is the file itself, which is never a directory.
     for (let index = 0; index < parts.length - 1; index += 1) {
         const part = parts[index] as string
-        if (part === 'node_modules') return 'dependency'
-        if (part.startsWith('.')) return 'skipped'
-        if (part === SERVER_DIRECTORY) return 'server'
-        if (part === PUBLIC_DIRECTORY) return 'public'
+        if (skipped(part))
+            return (
+                fence ?? (part === 'node_modules' ? 'dependency' : 'skipped')
+            )
+        if (fence !== undefined) {
+            if (part === SERVER_DIRECTORY) return 'server'
+        } else if (RESERVED_DIRECTORIES.has(part)) {
+            if (!HOLDS_SERVER.has(part)) return part as Place
+            fence = part as Place
+        }
     }
-    return 'address'
+    return fence ?? 'address'
 }
 
 /** Whether a walk of the app passes over the entry `name`: a dot file or directory, or `node_modules`. */
@@ -100,18 +121,48 @@ export function skipped(name: string): boolean {
 }
 
 /**
- * The route a file answers at — its DIRECTORY's below the root, whatever its name.
+ * The route a file answers at — its path below the root without its extension.
  *
- * 23.14 — `media/[id]/page.abide` is `/media/[id]`, and so is every other file beside it, which is
- * what lets a directory's handlers sit in as many files as an author likes (16.2). `path` is
- * relative to the app's root, as `fileKind`'s is.
+ * 23.14 — `media/[id].abide` and `media/getGrid.ts` are `/media/[id]` and `/media/getGrid`; an
+ * `index.abide`, a `layout.abide` and an `error.abide` are their directory's. `path` is relative to
+ * the app's root, as `fileKind`'s is.
  */
 export function routeOf(path: string): string {
     const parts = path.split('/')
-    parts.pop()
+    const file = parts.pop() as string
+    // The extension alone: `[...rest].abide` carries dots of its own.
+    if (!DIRECTORY_FILES.has(file)) parts.push(file.replace(EXTENSION, ''))
     return `/${parts.filter((part) => part !== '').join('/')}`
 }
 
+const EXTENSION = /\.(?:abide|ts)$/
+
+/** 23.14, 23.18 — the names whose route is their directory's, and so a route's wherever they stand. */
+export const DIRECTORY_FILES = new Set([
+    'index.abide',
+    'layout.abide',
+    'error.abide',
+])
+
+/**
+ * The route the hooks and private handlers of the file at `path` are filed at.
+ *
+ * 37.1 — an address's own route; under a `lib` or a `tests` directory, the route of the directory
+ * holding it, so a component an admin page renders runs under the admin route's rungs; under a
+ * `server` or a `public` directory, and for a dependency's file, the root's.
+ */
+export function scopeOf(path: string): string {
+    // 38.82 — the launcher answers at no route, and files what it calls at the root's.
+    if (path === LAUNCHER_PAGE) return '/'
+    const place = placeOf(path)
+    if (place === 'address') return routeOf(path)
+    if (place !== 'lib' && place !== 'tests') return '/'
+    const parts = path.split('/')
+    // The fence `placeOf` named is the first one, and its name is its place.
+    const fence = parts.indexOf(place)
+    return `/${parts.slice(0, fence).join('/')}`
+}
+
 /**
  * A `sort` comparator over two parsed patterns: negative where `a` is the more specific.
  *

package/src/shared/rpc.ts

@@ -501,7 +501,7 @@ export const DELETE: Declare = declare('DELETE')
 function addressOf(rpc: { address: string | undefined }): string {
     if (rpc.address === undefined)
         throw new Error(
-            'abide: this handler has no address yet. A handler is given one where it is mounted, exported from a <script server> (16.2).',
+            "abide: this handler has no address yet. A handler is given one where it is mounted: a handler file's default (16.2), or a `const` in a <script server> (16.70).",
         )
     return rpc.address
 }

package/src/ui/Router.ts

@@ -12,7 +12,6 @@ import { applyHead, withdrawHead } from './applyHead.ts'
 import { LAYER_MOUNT, LAYER_NAVIGATE } from './LAYER_NAMES.ts'
 import { MOUNTING_LEVEL } from './MOUNTING_LEVEL.ts'
 import { beginLayer, endLayer } from './measureLayer.ts'
-import { menuBridge } from './menuBridge.ts'
 import { fillRegion, pageRegion, type Region } from './regions.ts'
 import type { Scope, Stoppable } from './Scope.ts'
 
@@ -568,11 +567,6 @@ export class Router {
     ): void {
         arrive(target.href, found.route.pattern, found.params)
         this.chain = modules
-        // 38.88 — inside a desktop app, the window shows the menus this chain exports.
-        if (menuBridge() !== undefined)
-            void import('./reportMenu.ts').then((loaded) =>
-                loaded.reportMenu(modules as { menu?: unknown }[]),
-            )
         this.standing = found.route
         this.mounted = target.pathname
         if (into === undefined) return

package/src/compiler/syncTypes.ts

@@ -1,32 +0,0 @@
-// 34.24 — THE TYPES A PLAIN `.ts` READS A `.abide` BY, written with no checker and no build: the
-// files parsed and projected, and nothing else. What `abide sync` runs — and the scaffold's `prepare`
-// with it, so a project is typed as soon as it is installed — and what the language server runs as
-// a file is edited.
-
-import { sourcesUnder } from './compileApp.ts'
-import { parseSources } from './readSources.ts'
-import type { Diagnosis } from './TypeSession.ts'
-import { writeTypes } from './writeTypes.ts'
-
-/**
- * Writes the types of every `.abide` under `appRoot`, `held` standing in for the text on disk of
- * the files an editor has open; answers how many files it typed and what it refused. A file that
- * does not parse, or whose projection is refused, is left as it last was and the rest are typed.
- */
-export async function syncTypes(
-    appRoot: string,
-    held: ReadonlyMap<string, string> = new Map(),
-): Promise<{ typed: number; refused: Diagnosis[] }> {
-    const { root, sources } = await sourcesUnder(appRoot)
-    const read: { path: string; text: string }[] = []
-    for (const source of sources)
-        read.push({
-            path: source.path,
-            text: held.get(source.path) ?? source.text,
-        })
-    const refused: Diagnosis[] = []
-    const parsed = parseSources(read, refused)
-    const unparsed = refused.length
-    await writeTypes(root, parsed, true, refused)
-    return { typed: parsed.length - (refused.length - unparsed), refused }
-}

package/src/compiler/writeTypes.ts

@@ -1,82 +0,0 @@
-// 34.24 — WHAT A `.abide` EXPORTS, AS A PLAIN `.ts` IMPORTING IT IS TYPED. TypeScript reads no
-// `.abide`, and a wildcard declaration can name a default alone, so the names a `<script module>` or
-// a `<script server>` exports were untyped to every `.ts` outside abide's own checker. Each file's
-// projection — its module and server blocks, exactly what that checker answers a `.abide` import
-// with (`TypeSession.standIn`) — is written to `.abide/types`, mirroring the tree, where the app's
-// `tsconfig` reaches it: `rootDirs` for a relative import, `paths` for `#src/*`.
-//
-// THE CHECKER IS NOT ASKED, because the API it answers over emits no declarations, and the
-// projection is a module TypeScript infers the same types from. `@ts-nocheck` because the blocks are
-// read as written — a reactive read by name is the checker's to answer (31.3) and `abide check`'s to
-// report, and reported here too it would be one finding twice, at a path nobody wrote.
-
-import { rmSync } from 'node:fs' // bun has no file removal of its own
-import { dirname, relative } from 'node:path' // bun exposes no path helpers of its own
-import { buildDirectory } from '#server/buildDirectory.ts'
-import { namesUnder } from '#server/namesUnder.ts'
-import { COMPONENT_MODULE } from './checkedShadow.ts'
-import { formatDiagnosis } from './formatDiagnosis.ts'
-import { projectShadow } from './projectShadow.ts'
-import { type ParsedSource, refusal } from './readSources.ts'
-import type { Diagnosis } from './TypeSession.ts'
-
-/**
- * Writes each source's types beside the build, and removes the ones whose `.abide` is gone.
- *
- * A file is written only where its text moved, so an editor watching the directory re-reads what
- * changed rather than everything. WITH `refused`, A SOURCE WHOSE PROJECTION IS REFUSED (34.3, …) is a
- * finding at its first line and keeps the types it last had, as `parseSources` treats one that does
- * not parse; without it the refusal is thrown, naming the file.
- */
-export async function writeTypes(
-    root: string,
-    sources: readonly Pick<ParsedSource, 'path' | 'file'>[],
-    /** Whether `sources` is every file, so the types of one not among them are stale. */
-    whole = true,
-    refused?: Diagnosis[],
-): Promise<void> {
-    const above = dirname(root)
-    // Mirrored below the directory above `root`, as the scaffold's `tsconfig` names it.
-    const types = `${buildDirectory(root)}/types`
-    const written = new Set<string>()
-    const writes: Promise<unknown>[] = []
-    for (const source of sources) {
-        const path = `${types}/${relative(above, source.path)}.ts`
-        written.add(path)
-        let projected: string
-        try {
-            projected = projectShadow(source.file).text
-        } catch (thrown) {
-            const found = refusal(source.path, thrown)
-            if (refused === undefined)
-                throw new Error(formatDiagnosis(found, process.cwd()))
-            refused.push(found)
-            continue
-        }
-        // The checker's own stand-in for the default: a component taking anything (`COMPONENT_MODULE`).
-        const text = `// @ts-nocheck\n${projected}\n${COMPONENT_MODULE}`
-        if (WRITTEN.get(path) === text) continue
-        writes.push(
-            Bun.file(path)
-                .text()
-                .catch(() => undefined)
-                .then((standing) => {
-                    WRITTEN.set(path, text)
-                    return standing === text ? undefined : Bun.write(path, text)
-                }),
-        )
-    }
-    await Promise.all(writes)
-    if (!whole) return
-    // Only below this root's own mirror: two apps beside one another share the directory above.
-    const mirror = `${types}/${relative(above, root)}`
-    for (const name of namesUnder(mirror))
-        if (!written.has(`${mirror}/${name}`)) {
-            rmSync(`${mirror}/${name}`)
-            WRITTEN.delete(`${mirror}/${name}`)
-        }
-}
-
-// What this process last left at each path, so a compile run again (`abide dev`, the language
-// server) reads back only the files whose text moved since.
-const WRITTEN = new Map<string, string>()

package/src/server/LAUNCHER_FILES.ts

@@ -1,9 +0,0 @@
-// THE DESKTOP LAUNCHER'S FILES. Its page and the `launcher` options it exports sit at the app's root
-// beside the root layout, a name the framework finds rather than an address (23.14); the icon is a
-// public file, so it is wherever the address it answers at says (36.11).
-
-/** The launcher's page and options. 38.80, 38.82. */
-export const LAUNCHER_PAGE = 'launcher.abide'
-
-/** The addresses of the desktop app's icon, the `.icns` first. 38.79. */
-export const ICON_ADDRESSES = { icns: '/icon.icns', png: '/icon.png' } as const