@abide/abide 0.123.2 → 0.124.0

package/src/ui/TryRegion.ts

@@ -19,13 +19,8 @@ import { type Disposer, watchTracked } from '#shared/reactive/watch.ts'
 
 import { type Arm, type ArmMakers, ArmRegion } from './ArmRegion.ts'
 import { Mismatch } from './Mismatch.ts'
-import {
-    fillRegion,
-    isEmptyRegion,
-    type Region,
-    removeUntil,
-} from './regions.ts'
-import { BOUNDARY, type Scope, type Stoppable } from './Scope.ts'
+import { fillRegion, type Region, removeUntil } from './regions.ts'
+import { type Scope, type Stoppable, underBoundary } from './Scope.ts'
 
 /**
  * The body until something in it fails, then the catch until the failure clears. Arm `0` is the
@@ -40,7 +35,7 @@ import { BOUNDARY, type Scope, type Stoppable } from './Scope.ts'
  * anchor names as arm 1 (`namedArm`) — it keeps until the body has been tried behind it
  * (`mountBehind`), and adopts where the body fails here too, so the catch the server sent is the
  * one on the page. A body that succeeds here after failing there replaces it. So 41.24 is already
- * this region's shape — its open names the arm — and `paintedOther` is never asked here.
+ * this region's shape — its open names the arm — and `paintedOther` answers no.
  */
 export class TryRegion extends ArmRegion {
     readonly failure: Reactive<unknown>
@@ -114,17 +109,13 @@ export class TryRegion extends ArmRegion {
      * `again` IS WHAT A RETRY RERUNS: the binding that threw, or the body mounted again.
      */
     guard<T>(run: () => T, again: () => unknown): T | undefined {
-        const previous = BOUNDARY.current
-        BOUNDARY.current = this
         try {
-            return run()
+            return underBoundary(this, run)
         } catch (thrown) {
             if (thrown instanceof Mismatch || thrown instanceof NotLanded)
                 throw thrown
             this.fail(thrown, again)
             return undefined
-        } finally {
-            BOUNDARY.current = previous
         }
     }
 
@@ -139,11 +130,9 @@ export class TryRegion extends ArmRegion {
         const scope = this.scope as Scope
         let next = first
         while (next !== this.at) {
-            const painted = this.at === undefined && !isEmptyRegion(region)
+            const filling = this.fills(next)
             this.at = next
-            const arm = (this.arms[next as number] as ArmMakers[number])(
-                this.failure.peek(),
-            )
+            const arm = this.armOf(next)
             const standing = next === 0 ? this.standing : undefined
             if (standing !== undefined) {
                 this.standing = undefined
@@ -151,7 +140,7 @@ export class TryRegion extends ArmRegion {
                 scope.own(standing)
                 continue
             }
-            if (!painted) {
+            if (filling) {
                 scope.stop()
                 if (
                     next === 0 &&
@@ -175,6 +164,17 @@ export class TryRegion extends ArmRegion {
         }
     }
 
+    /** The catch is handed the failure it binds. */
+    override armOf(next: unknown): Arm {
+        return (this.arms[next as number] as ArmMakers[number])(
+            this.failure.peek(),
+        )
+    }
+
+    override paintedOther(): boolean {
+        return false
+    }
+
     private fail(error: unknown, again: () => unknown): void {
         if (this.trying) {
             if (this.triedFailed) return
@@ -238,14 +238,14 @@ export class TryRegion extends ArmRegion {
             open: region.close.previousSibling as Comment,
             close: region.close,
         }
-        const previous = BOUNDARY.current
-        BOUNDARY.current = this
         this.trying = true
         this.triedFailed = false
         let mounted: Stoppable | undefined
         try {
-            fillRegion(body, arm.build)
-            mounted = arm.mount(body)
+            mounted = underBoundary(this, () => {
+                fillRegion(body, arm.build)
+                return arm.mount(body)
+            })
         } catch (thrown) {
             fillRegion(body)
             if (thrown instanceof Mismatch || thrown instanceof NotLanded)
@@ -254,7 +254,6 @@ export class TryRegion extends ArmRegion {
             this.triedError = thrown
             this.triedAgain = undefined
         } finally {
-            BOUNDARY.current = previous
             this.trying = false
         }
         if (!this.triedFailed) {

package/src/ui/bindSpread.ts

@@ -5,7 +5,7 @@
 import { spreadEntries } from '#shared/spread.ts'
 
 import type { Scope } from './Scope.ts'
-import { addAttribute } from './setAttribute.ts'
+import { writeAttribute } from './setAttribute.ts'
 
 /** Keeps an element's spread attributes and `on<event>` listeners written as the value changes. */
 export function bindSpread(
@@ -21,9 +21,7 @@ export function bindSpread(
         const next = new Set<string>()
         for (const [name, text] of spreadEntries(read(), explicit, wanted)) {
             next.add(name)
-            const standing = element.getAttribute(name)
-            if (standing === null) addAttribute(element, name, text)
-            else if (standing !== text) element.setAttribute(name, text)
+            writeAttribute(element, name, text)
         }
         for (const name of written)
             if (!next.has(name)) element.removeAttribute(name)

package/src/ui/listenForRoutes.ts

@@ -29,11 +29,8 @@ export function listenForRoutes(router: Router): () => void {
         if (url !== undefined) router.prefetch(url.pathname)
     }
 
-    // BACK AND FORWARD HAVE ALREADY MOVED THE ADDRESS BAR by the time this runs, so the page is
-    // mounted where the bar already points and nothing is pushed for it. 30.20 — a step within the
-    // standing page, back over an in-page `#anchor` jump, is `go`'s to keep: nothing asked, nothing
-    // remounted. 30.29 — the scroll is the router's to put back, once the page it belongs to is
-    // mounted: the browser's own restoration runs before that page exists.
+    // BACK AND FORWARD HAVE ALREADY MOVED THE ADDRESS BAR by the time this runs (`popped`). 30.29 —
+    // the browser's own scroll restoration runs before the page it restores exists, so it is off.
     const onPop = (): void => {
         if (router.match(location.pathname) === undefined) {
             // The bar already stands at the entry being loaded, so the `pagehide` this reload
@@ -42,11 +39,7 @@ export function listenForRoutes(router: Router): () => void {
             location.reload()
             return
         }
-        void router.go(
-            location.href,
-            { replace: true, keepScroll: true },
-            router.stepped(),
-        )
+        void router.popped()
     }
 
     const listening = new AbortController()

package/src/ui/outboxQueue.ts

@@ -19,14 +19,8 @@ import { failedFrom, isFailed, problemOf } from '#shared/Failed.ts'
 import type { Problem } from '#shared/Failed.ts'
 import { showLine, type ShownCall, showSending } from '#shared/outbox.ts'
 import { onPrincipalRotated } from '#shared/principalRotated.ts'
-import {
-    isReactive,
-    produceInto,
-    type Reactive,
-    reactive,
-    refuseInto,
-    standIn,
-} from '#shared/reactive/index.ts'
+import { isReactive, type Reactive, reactive } from '#shared/reactive/index.ts'
+import { produceInto, refuseInto, standIn } from '#shared/reactive/producer.ts'
 import { rpcRequest } from '#shared/rpcRequest.ts'
 
 const DATABASE = 'abide-outbox'
@@ -69,9 +63,9 @@ let askedToPersist = false
  */
 const VALUES = new Map<string, Reactive<unknown>>()
 /** What wants to hear the line empty of calls not yet delivered (18.35). */
-const DRAINED: (() => void)[] = []
+const DRAINED = new Set<() => void>()
 
-const shelf: Shelf =
+let shelf: Shelf =
     typeof indexedDB === 'undefined' ? memoryShelf() : databaseShelf()
 const channel =
     typeof BroadcastChannel === 'undefined'
@@ -87,7 +81,25 @@ export function undelivered(): number {
 
 /** Runs `listener` each time the line holds no call waiting to be delivered (18.35). */
 export function whenDelivered(listener: () => void): void {
-    DRAINED.push(listener)
+    DRAINED.add(listener)
+}
+
+/**
+ * Empties the line and its timers onto a fresh in-memory shelf.
+ *
+ * A page never does; a test does between cases, rather than discarding a call at a time and waiting
+ * out each discard's write.
+ */
+export function resetOutbox(): void {
+    clearTimeout(retrying)
+    retrying = undefined
+    backoff = RETRY_FLOOR_MS
+    held = false
+    waiting = false
+    LINE = []
+    VALUES.clear()
+    shelf = memoryShelf()
+    publish()
 }
 
 /**

package/src/ui/outcomeOf.ts

@@ -0,0 +1,120 @@
+import type { Params } from '#shared/matchRoute.ts'
+
+/** A route an address matched, and the params it matched with. */
+export type Found<RouteRow> = { route: RouteRow; params: Params }
+
+/**
+ * What a navigation knows before it asks anything: where it is going, and what stands.
+ *
+ * `match` is the router's own, so 16.10's mount and 30.9's ranking are decided where they always
+ * were.
+ */
+export type Bearing<RouteRow> = {
+    target: URL
+    /** The document's origin, which an address outside of is no route (30.10). */
+    origin: string
+    /** 35.18 — the document is an error page's, so leaving it is a document load. */
+    errorPage: boolean
+    /** The route the standing page was matched by. */
+    standing: RouteRow | undefined
+    /** The path the standing chain was mounted for. */
+    mounted: string | undefined
+    match: (pathname: string) => Found<RouteRow> | undefined
+}
+
+/** What the ask and the load came back with (30.15). */
+export type Heard<RouteRow> = {
+    /** The route the ask was made for — the `ask` outcome's `found`. */
+    found: Found<RouteRow>
+    /** The server's answer; `undefined` where the fetch failed. */
+    answer: { status: number; url: string; redirected: boolean } | undefined
+    /** Whether the asked-for route's chunks loaded. */
+    loaded: boolean
+    online: boolean
+    /** Whether the navigation pushes, rather than arriving at a history step the bar already took. */
+    pushed: boolean
+}
+
+/**
+ * How a navigation ends.
+ *
+ * `document` hands `href` to a document load. `follow` moves the address within the standing page.
+ * `ask` is the first call's answer where the server must be asked first. `offline` is 30.32's: the
+ * page stays, unless the service worker saved `href` (45.12). `mount` mounts `found` at `at`.
+ */
+type Outcome<RouteRow> =
+    | Settled<RouteRow>
+    | { kind: 'ask'; found: Found<RouteRow> }
+    | { kind: 'offline'; href: string }
+    | { kind: 'mount'; at: URL; found: Found<RouteRow> }
+
+/** An outcome that loads nothing, which either call can answer. */
+export type Settled<RouteRow> =
+    | { kind: 'document'; href: string }
+    | { kind: 'follow'; at: URL; found: Found<RouteRow> }
+
+/**
+ * Decides how a navigation ends, from what it knows: called once before the ask, and once more
+ * with what was `heard` where the first call answered `ask`.
+ *
+ * Decides and touches nothing — the router executes the answer. A `mount` whose `found` is not
+ * `heard.found` lands on a route whose chunks were not loaded yet, and the router hands that
+ * address to the document where they will not load (30.27).
+ */
+export function outcomeOf<RouteRow>(
+    bearing: Bearing<RouteRow>,
+): Settled<RouteRow> | Extract<Outcome<RouteRow>, { kind: 'ask' }>
+export function outcomeOf<RouteRow>(
+    bearing: Bearing<RouteRow>,
+    heard: Heard<RouteRow>,
+): Settled<RouteRow> | Extract<Outcome<RouteRow>, { kind: 'offline' | 'mount' }>
+export function outcomeOf<RouteRow>(
+    bearing: Bearing<RouteRow>,
+    heard?: Heard<RouteRow>,
+): Outcome<RouteRow> {
+    const target = bearing.target
+    if (heard === undefined) {
+        // A CROSS-ORIGIN ADDRESS IS NOT A ROUTE. Handing it to `pushState` throws, and treating
+        // it as a miss would leave the caller with a navigation that silently did nothing.
+        if (target.origin !== bearing.origin || bearing.errorPage)
+            return { kind: 'document', href: target.href }
+        const found = bearing.match(target.pathname)
+        // 30.10 — NOT A ROUTE THIS BUILD KNOWS, so it is the server's to answer — which is a
+        // document load, and the one case where 30.7 does not apply because there is no route.
+        if (found === undefined) return { kind: 'document', href: target.href }
+        // 30.21, 30.23, 30.24 — THE ROUTE STANDING, AT ITS OWN PATH: another query, another
+        // fragment or the same address. The page reads its address through `route`, so it follows
+        // rather than being rebuilt, and there is no path for `middleware` to decide anything new
+        // about.
+        if (
+            found.route === bearing.standing &&
+            bearing.mounted === target.pathname
+        )
+            return { kind: 'follow', at: target, found }
+        return { kind: 'ask', found }
+    }
+    const answer = heard.answer
+    // 30.32 — OFFLINE, THE DOCUMENT LOAD BELOW CAN ONLY PAINT THE BROWSER'S ERROR PAGE over a page
+    // that works. A history step has already moved the bar, so it is left to the document.
+    if (answer === undefined && !heard.online && heard.pushed)
+        return { kind: 'offline', href: target.href }
+    // 30.18 — A REFUSAL, A RESPONSE MIDDLEWARE ANSWERED ITSELF, or no answer at all: the document
+    // asks again and paints whatever the server says. A fetch that failed — offline, or a redirect
+    // to another origin that CORS will not let it follow — goes to the address it was sent to.
+    // 30.27 — AND CHUNKS THAT WOULD NOT LOAD, with the server down or a deploy that removed them.
+    if (answer?.status !== 204 || !heard.loaded)
+        return { kind: 'document', href: answer?.url ?? target.href }
+    // 30.17 — REDIRECTED, and the server already said yes to where it landed: the answer is the
+    // 204 at the end of the chain. That address is mounted in place of the one asked for, and a
+    // route the client has no row for is the document's (30.10).
+    const landed = answer.redirected ? new URL(answer.url) : target
+    const landing = answer.redirected
+        ? bearing.match(landed.pathname)
+        : heard.found
+    if (landing === undefined) return { kind: 'document', href: landed.href }
+    // 30.23 — THE ROUTE STANDING, AT ANOTHER PATH: `middleware` has said yes to the path, and the
+    // page it matched is the one already mounted, so it follows.
+    if (landing.route === bearing.standing)
+        return { kind: 'follow', at: landed, found: landing }
+    return { kind: 'mount', at: landed, found: landing }
+}

package/src/ui/reconcile.ts

@@ -1,4 +1,4 @@
-import { PATCHES } from '#shared/reactive/PATCHES.ts'
+import { patchEpoch, writtenSince } from '#shared/reactive/patchMarks.ts'
 
 import { LAYER_RECONCILE } from './LAYER_NAMES.ts'
 import type { List } from './List.ts'
@@ -116,7 +116,7 @@ export function reconcile(list: List, data: unknown[]): void {
             const value = data[at]
             if (!Object.is(existing.data, value) || patchedSince(existing))
                 updateRow(existing, value)
-            existing.seen = PATCHES.epoch
+            existing.seen = patchEpoch()
             survivor[at] = existing
             from[at] = existing.at
             if (existing.at < lastSurvivor) ordered = false
@@ -210,10 +210,8 @@ function clear(list: List): void {
  * one integer compare a row and never reaches the map.
  */
 function patchedSince(row: Row): boolean {
-    if (row.seen === PATCHES.epoch) return false
-    const item = row.data
-    if (item === null || typeof item !== 'object') return false
-    return (PATCHES.written.get(item) ?? 0) > row.seen
+    if (row.seen === patchEpoch()) return false
+    return writtenSince(row.data, row.seen)
 }
 
 /**

package/src/ui/routing.ts

@@ -16,4 +16,5 @@
 
 export { listenForRoutes } from './listenForRoutes.ts'
 export { registerWorker } from './registerWorker.ts'
-export { type PageMount, type Route, Router, startRouter } from './Router.ts'
+export { type PageMount } from './LevelChain.ts'
+export { type Route, Router, startRouter } from './Router.ts'

package/src/ui/rows.ts

@@ -1,6 +1,6 @@
 import { REGION_CLOSE, ROW_OPEN } from '#shared/ANCHORS.ts'
 import { moveItem, rowItem } from '#shared/reactive/index.ts'
-import { PATCHES } from '#shared/reactive/PATCHES.ts'
+import { patchEpoch } from '#shared/reactive/patchMarks.ts'
 
 import { leave } from './leave.ts'
 import { moveNode } from './moveNode.ts'
@@ -291,7 +291,7 @@ function newRow(key: unknown, data: unknown, node: ChildNode, at: number): Row {
         // for the record's whole life.
         scope: EMPTY_SCOPE,
         at,
-        seen: PATCHES.epoch,
+        seen: patchEpoch(),
     }
 }
 

package/src/ui/setAttribute.ts

@@ -35,10 +35,19 @@ export function setAttribute(
         if (element.hasAttribute(name)) element.removeAttribute(name)
         return
     }
+    writeAttribute(element, name, next)
+}
+
+/** Writes `text` to `element`'s `name` unless it already reads `text` — `setAttribute`'s compare, shared with a spread. */
+export function writeAttribute(
+    element: Element,
+    name: string,
+    text: string,
+): void {
     const standing = element.getAttribute(name)
-    if (standing === next) return
-    if (standing === null) addAttribute(element, name, next)
-    else element.setAttribute(name, next)
+    if (standing === text) return
+    if (standing === null) addAttribute(element, name, text)
+    else element.setAttribute(name, text)
 }
 
 /**

package/src/ui/socketWire.ts

@@ -7,16 +7,16 @@ import { applyPatch } from '#shared/applyPatch.ts'
 import { mounted } from '#shared/mount.ts'
 import type { BrowserFrame, ServerFrame } from '#shared/muxFrames.ts'
 import { onPrincipalRotated } from '#shared/principalRotated.ts'
-import { canonicalKey } from '#shared/reactive/canonicalKey.ts'
+import { canonicalKey } from '#shared/reactive/argsContract.ts'
+import { type Reactive } from '#shared/reactive/index.ts'
+import { patchEpoch, writtenSince } from '#shared/reactive/patchMarks.ts'
 import {
     heldGenerationOf,
     loadOf,
     patchInto,
     produceInto,
-    type Reactive,
     writtenLocally,
-} from '#shared/reactive/index.ts'
-import { PATCHES } from '#shared/reactive/PATCHES.ts'
+} from '#shared/reactive/producer.ts'
 
 import { HYDRATE_LOG } from './Mismatch.ts'
 import { undelivered, whenDelivered } from './outboxQueue.ts'
@@ -64,18 +64,13 @@ class Following {
     inStep(): void {
         const copy = this.entry()
         this.generation = loadOf(copy) ?? heldGenerationOf(copy)
-        this.epoch = PATCHES.epoch
+        this.epoch = patchEpoch()
     }
 
     /** Whether the copy was written to since it was last in step. 18.21. */
     diverged(copy: unknown): boolean {
         if (heldGenerationOf(copy) !== this.generation) return true
-        const held = (copy as Reactive<unknown>).peek()
-        return (
-            held !== null &&
-            typeof held === 'object' &&
-            (PATCHES.written.get(held) ?? 0) > this.epoch
-        )
+        return writtenSince((copy as Reactive<unknown>).peek(), this.epoch)
     }
 
     /**
@@ -241,10 +236,17 @@ class Mux {
     receive(frame: ServerFrame): void {
         this.subscriptions.get(frame.id)?.receive(frame)
     }
+
+    /** Lets go of every subscription and the socket, so a sign-in or a retry reaches nothing. */
+    dispose(): void {
+        clearTimeout(this.retrying)
+        this.retrying = undefined
+        this.subscriptions.clear()
+        this.reopen()
+    }
 }
 
-// Exported for a test to forget: a page never does, and a test process outlives one.
-export const MUXES = new Map<string, Mux>()
+const MUXES = new Map<string, Mux>()
 
 /**
  * The mux a handler's address is carried over, made on first use.
@@ -276,6 +278,19 @@ function muxFor(address: string): Mux {
  */
 const FOLLOWING = new Map<string, Following>()
 
+/**
+ * Forgets every mux and follow this page opened, their timers and sockets with them.
+ *
+ * A page never does; a test process outlives one, and a later file's sign-in (18.25) would reopen
+ * every mux an earlier file left standing.
+ */
+export function resetSocketWire(): void {
+    for (const following of FOLLOWING.values()) clearTimeout(following.expiry)
+    FOLLOWING.clear()
+    for (const mux of MUXES.values()) mux.dispose()
+    MUXES.clear()
+}
+
 /**
  * Reads again every followed copy written here, once the outbox holds no call waiting.
  *

package/src/ui/wire.ts

@@ -29,13 +29,13 @@ import { isFailed } from '#shared/Failed.ts'
 import { answerChunks } from '#shared/framing.ts'
 import { HandlerRoute } from '#shared/HandlerRoute.ts'
 import type { JsonValue } from '#shared/JsonValue.ts'
-import { LOAD_OFFLINE } from '#shared/LOAD_OFFLINE.ts'
-import { LOAD_SIGNAL } from '#shared/LOAD_SIGNAL.ts'
-import { reactive, standIn, structural } from '#shared/reactive/index.ts'
+import { standForLoadCall, startingLoadCall } from '#shared/loadCall.ts'
+import { reactive, structural } from '#shared/reactive/index.ts'
 import {
     declareDefaults,
     type Defaults,
 } from '#shared/reactive/parameterDefaults.ts'
+import { standIn } from '#shared/reactive/producer.ts'
 import { declare, type Method } from '#shared/rpc.ts'
 import { type RpcRequest, rpcRequest } from '#shared/rpcRequest.ts'
 
@@ -72,11 +72,11 @@ export function wire(
     // ONE PARAMETER, so the value is keyed by args whatever the handler declared (16.6's arity rule):
     // an unkeyed handler is reached with no args, which is one key.
     const body = (args: Record<string, unknown> | undefined) => {
-        // 16.49, 16.81 — the load's own signal and stand-in, set by the call starting it and read
-        // before anything awaits.
-        const signal = LOAD_SIGNAL.current
+        // 16.49, 16.81 — the load's own signal and stand-in, as the call starting it carried them.
+        const starting = startingLoadCall()
+        const signal = starting.signal
         const request = requestOf(args)
-        let offline = LOAD_OFFLINE.current
+        let offline = starting.offline
         // A reload no call started — a refresh, or the one `whenOnline` asks — that gets no answer
         // waits before asking again, where asking at once would get none on every tick.
         const retryIn = offline === undefined ? UNANSWERED_RETRY_MS : 0
@@ -93,8 +93,7 @@ export function wire(
                 ? queuedCall(request, address, args)
                 : undefined
         let standing: { value: unknown } | undefined
-        if (queued !== undefined)
-            LOAD_OFFLINE.standing = standing = { value: undefined }
+        if (queued !== undefined) standing = standForLoadCall()
         const stoodIn = (failed: Answer): unknown => {
             const value = (offline as (args: unknown) => unknown)(args)
             if (queued === undefined) {
@@ -145,7 +144,7 @@ export function wire(
     ): AsyncGenerator<unknown> {
         // 16.49 — read on the first line: the core's pump takes the first step inside the reach, so
         // this runs while the call that started the load still has its signal set.
-        const signal = LOAD_SIGNAL.current
+        const signal = startingLoadCall().signal
         const request = requestOf(args)
         const answer = await answerOf(request, true, signal)
         if (answer.ok) answeredOnce.add(request.key)

package/src/compiler/Finding.ts

@@ -1,2 +0,0 @@
-/** A warning or a refusal at a projection offset. */
-export type Finding = { at: number; message: string }

package/src/compiler/Refusals.ts

@@ -1,65 +0,0 @@
-import { resolve } from 'node:path' // bun exposes no path helpers of its own
-
-import { formatDiagnosis } from './formatDiagnosis.ts'
-import { diagnosisAt } from './lineOf.ts'
-import { PositionedRefusal } from './PositionedRefusal.ts'
-import type { Diagnosis } from './TypeSession.ts'
-
-/**
- * Where everything the compile refuses goes, each at the file it was refused in.
- *
- * TWO MODES AND ONE CALL: a build stops at a refusal, so a throwing sink throws it; `abide
- * check` reports every one at its file and goes on (38.33), so a collecting sink keeps each as a
- * finding at the file's first line. Every stage takes this and nothing else, so no stage decides for
- * itself what a refusal does, and none spells a path its own way: a file is named relative to `root`
- * or absolutely, and kept absolute.
- */
-export class Refusals {
-    /** Every refusal kept, in the order met; empty in a throwing sink. */
-    readonly found: Diagnosis[] = []
-    /** What a file below the root is named relative to. */
-    readonly root: string
-    /** Whether a refusal is kept and the compile goes on, rather than thrown. */
-    readonly collecting: boolean
-
-    constructor(root: string, collecting: boolean) {
-        this.root = root
-        this.collecting = collecting
-    }
-
-    /**
-     * Refuses at `file`, below the root or absolute: `thrown` is thrown, or kept. Handed the file's
-     * `text`, a `PositionedRefusal` is placed on its line and column, and thrown as that line.
-     */
-    at(file: string, thrown: unknown, text?: string): void {
-        const positioned =
-            text !== undefined && thrown instanceof PositionedRefusal
-        if (!this.collecting && !positioned) throw thrown
-        const diagnosis = diagnosisAt(
-            resolve(this.root, file),
-            positioned ? text : undefined,
-            positioned ? thrown.offset : 0,
-            'error',
-            thrown instanceof Error ? thrown.message : String(thrown),
-        )
-        if (!this.collecting)
-            throw new Error(formatDiagnosis(diagnosis, process.cwd()))
-        this.found.push(diagnosis)
-    }
-
-    /**
-     * What another stage kept, as this one takes it: every one kept, or every one thrown as one
-     * error, each at its file — a build that stops names all it found rather than a first one and a
-     * second run (11.37).
-     */
-    adopt(found: readonly Diagnosis[]): void {
-        if (found.length === 0) return
-        if (this.collecting) {
-            this.found.push(...found)
-            return
-        }
-        const lines: string[] = []
-        for (const one of found) lines.push(formatDiagnosis(one, process.cwd()))
-        throw new Error(lines.join('\n'))
-    }
-}

package/src/compiler/formatDiagnosis.ts

@@ -1,20 +0,0 @@
-import { relative } from 'node:path' // bun exposes no path helpers of its own
-
-import type { Diagnosis } from './TypeSession.ts'
-
-/**
- * One finding as one `tsc`-style line.
- *
- * ONE LINE A FINDING, in the shape `tsc` and every editor's problem matcher already read:
- * `file:line:column - error TS2322: …`, the path relative to where the command was run. A finding
- * with no line — a whole-file or whole-app refusal — names the file alone.
- */
-export function formatDiagnosis(diagnosis: Diagnosis, from: string): string {
-    const path = relative(from, diagnosis.path) || diagnosis.path
-    const where =
-        diagnosis.line === 0
-            ? path
-            : `${path}:${diagnosis.line}:${diagnosis.column}`
-    const code = diagnosis.code === 0 ? '' : ` TS${diagnosis.code}`
-    return `${where} - ${diagnosis.category}${code}: ${diagnosis.message}`
-}

package/src/server/appDirectories.ts

@@ -1,9 +0,0 @@
-/**
- * The directories an app's own files stand in: `root`, and the one above it.
- *
- * `root` is the app's root — `src/` — and the one above it is the package beside
- * it. The app's `package.json` and `bunfig.toml` are found in the first that has one.
- */
-export function appDirectories(root: string): string[] {
-    return [root, `${root}/..`]
-}