@abide/abide 0.123.2 → 0.123.3

package/src/server/answerRpc.ts

@@ -11,11 +11,11 @@ import { GLOBAL_GETS } from '#shared/GLOBAL_GETS.ts'
 import { isRecord } from '#shared/isRecord.ts'
 import type { JsonValue } from '#shared/JsonValue.ts'
 import { mounted as underMount } from '#shared/mount.ts'
-import type { Gated } from '#shared/reactive/argsContract.ts'
+import type { Gated, HeldToAnnotation } from '#shared/reactive/argsContract.ts'
 import { deadlineOf, heldGenerationOf } from '#shared/reactive/index.ts'
 import type { Defaults } from '#shared/reactive/parameterDefaults.ts'
 import { notFound, refuse } from '#shared/refuse.ts'
-import type { HeldToAnnotation, Method, Rpc } from '#shared/rpc.ts'
+import type { Method, Rpc } from '#shared/rpc.ts'
 import { RPC_SERVER } from '#shared/RPC_SERVER.ts'
 import { argsInURL } from '#shared/rpcRequest.ts'
 import { VERSION_HEADER } from '#shared/VERSION_HEADER.ts'
@@ -29,14 +29,8 @@ import {
 } from './answerFailure.ts'
 import { followAsEvents } from './answerSocket.ts'
 import { answerValue, namesEtag, sseHeaders } from './answerValue.ts'
-import { argsFor } from './argsFor.ts'
+import { argsFor, collapsed, derivedArgs } from './argsContract.ts'
 import { callerOf } from './callerOf.ts'
-import {
-    argsDocumentOf,
-    coerceArgs,
-    collapsed,
-    type Document,
-} from './coerceArgs.ts'
 import { positiveSetting } from './config.ts'
 import {
     allows,
@@ -122,12 +116,6 @@ export type Mounted = Mount & {
      */
     rungs: LaneRung[]
     handler: Rpc<unknown, unknown> & Gated<unknown> & HeldToAnnotation
-    /**
-     * The args' JSON Schema, probed once at mount.
-     *
-     * 19.7, 20.11 — a third-party schema converts itself on every probe.
-     */
-    argsDocument: Document | undefined
 }
 
 /**
@@ -168,7 +156,6 @@ export function mountedOwn(
             args: undefined,
             result: undefined,
             handler: handler as Mounted['handler'],
-            argsDocument: undefined,
         },
     ]
 }
@@ -195,10 +182,12 @@ export async function mountHandlers(
         const mount = table[at] as Mount
         const exported = (modules[at] as Record<string, unknown>)[mount.export]
         const handler = exported as Mounted['handler']
-        const declared = argsDocumentOf(handler)
         // 16.9, 16.10 — the address `rpc.url` and `rpc.raw` build on, under the mount — and what a
         // page's render turns a call it made into the browser's request by (41.20).
         handler.address = underMount(mount.address)
+        // 19.9 — the schema the build derived off its annotation, for a handler whose module did not
+        // file it on load: a bundled executable's faces carry no `derivedArgs` call.
+        if (mount.args !== undefined) derivedArgs(handler, mount.args)
         handlers.set(handlerKey(mount.method, mount.address), {
             ...mount,
             // 37.1, 16.72 — the route its file's hooks are filed at, which the build read off
@@ -206,7 +195,6 @@ export async function mountHandlers(
             // 37.14 — a handler's lane answers a refusal as Problem Details (15.1).
             rungs: rungsOver(mount.scope, answered),
             handler,
-            argsDocument: declared ?? (mount.args as Document | undefined),
         })
     }
     return { handlers }
@@ -254,12 +242,15 @@ export async function answerRpc(
         return answered(crossingRefusal(crossing, found.method))
     const raw = await argsOf(request, url, inUrl, form, handler.maxBodySize)
     if (isFailed(raw)) return answered(raw)
-    const sent = withParameters(raw, params, inUrl || form, found)
-    if (isFailed(sent)) return answered(sent)
     let args: unknown
     try {
         // A URL's and a form's args are text, and the query tells a bare name from `name=` (19.7).
-        args = argsFor(found, sent, inUrl ? url.search : form ? '' : undefined)
+        args = argsFor(
+            handler,
+            raw,
+            inUrl ? url.search : form ? '' : undefined,
+            params,
+        )
     } catch (refused) {
         if (isFailed(refused)) return answered(refused)
         throw refused
@@ -478,39 +469,6 @@ async function argsOf(
     return parsed
 }
 
-/**
- * The args a request sent, with the parameters its route matched laid in.
- *
- * 16.65 — the path's, whatever the method. 16.66 — a parameter the query or the body names as
- * well is refused rather than one of the two chosen. A JSON body's members are typed already, so the
- * path's text is coerced to the declared types before it joins them (19.7); text args are coerced
- * with the rest of the text.
- */
-function withParameters(
-    sent: unknown,
-    params: Record<string, string | string[]>,
-    text: boolean,
-    found: Mounted,
-): unknown | Failed<'HttpError', undefined> {
-    let none = true
-    for (const name in params) {
-        none = false
-        if (isRecord(sent) && name in sent)
-            return refuse(
-                400,
-                `The parameter '${name}' is in the path and in the request as well.`,
-            )
-    }
-    if (none) return sent
-    const fromPath = text
-        ? params
-        : (coerceArgs(params, found.argsDocument, '') as Record<
-              string,
-              unknown
-          >)
-    return isRecord(sent) ? { ...sent, ...fromPath } : { ...fromPath }
-}
-
 /**
  * The request's body, received whole, under the ceiling `maxBodySize` sets, or
  * `ABIDE_MAX_REQUEST_BODY_SIZE` where it is unset, or a 413 refusal past it.

package/src/server/answerSocket.ts

@@ -16,16 +16,14 @@ import { namedLogger } from '#shared/log.ts'
 import { compose } from '#shared/Middleware.ts'
 import { unmounted } from '#shared/mount.ts'
 import type { BrowserFrame, ServerFrame } from '#shared/muxFrames.ts'
-import { FOLLOWED } from '#shared/reactive/FOLLOWED.ts'
-import { servedCellOf } from '#shared/reactive/index.ts'
+import { followServed } from '#shared/reactive/index.ts'
 import { matchesPattern } from '#shared/reactive/matchesPattern.ts'
-import { PATCH_SINKS } from '#shared/reactive/PATCH_SINKS.ts'
 import { unowned } from '#shared/reactive/watch.ts'
 import { refuse } from '#shared/refuse.ts'
 import { rpcRequest } from '#shared/rpcRequest.ts'
 
 import { handlerKey, type Mounted } from './answerRpc.ts'
-import { argsFor } from './argsFor.ts'
+import { argsFor } from './argsContract.ts'
 import { positiveSetting } from './config.ts'
 import { closedTo, crossingOrigin, crossingRefusal } from './crossingOrigin.ts'
 import { failureOf } from './hooks.ts'
@@ -182,7 +180,7 @@ export function broadcast(
     for (const follower of followed.all) {
         if (!matchesPattern(follower.args, pattern)) continue
         // A fed copy is refreshed by the production the reload mints (7.18), and invalidated through
-        // the cell it is fed from (`FOLLOWED`), whichever trigger reached it — where the entry it is
+        // the cell it is fed from (`followServed`), whichever trigger reached it — where the entry it is
         // fed from is still the one standing.
         if (attach(rpc as Mounted['handler'], follower) !== undefined) continue
         follower.peer.send(follower.id, TRIGGERS[member])
@@ -409,7 +407,7 @@ export class MuxConnection {
         const pending = (): void => {}
         try {
             // 18.3 — the args a `GET` over http is answered with, sent as JSON.
-            const args = argsFor(followed, frame.args, undefined)
+            const args = argsFor(followed.handler, frame.args, undefined)
             // 18.8 — A GUARDED `GET`'s RUNGS RUN ONCE, as the subscription opens, in this
             // connection's request: one they admit is fed the value, and one they refuse is sent its
             // triggers alone.
@@ -622,19 +620,12 @@ function feed(serving: unknown, fed: Follower): () => void {
 }
 
 function startFeed(serving: unknown): Feed {
-    const past = servedCellOf(serving)
-    const release = sinkFor(past)
     const fed = new Set<Follower>()
-    // 7.10 — an invalidate of the value, however it was spelled, reaches every copy it feeds.
-    const invalidated = (): void => {
+    // 18.11 — A VALUE FED TO A FOLLOWER KEEPS ITS PATCHES AS DATA while anyone is fed it, and 7.10 —
+    // an invalidate of the value, however it was spelled, reaches every copy it feeds.
+    const release = followServed(serving, () => {
         for (const one of fed) one.peer.send(one.id, TRIGGERS.invalidate)
-    }
-    let followed = FOLLOWED.get(past)
-    if (followed === undefined) {
-        followed = new Set()
-        FOLLOWED.set(past, followed)
-    }
-    followed.add(invalidated)
+    })
     const shared: Feed = {
         fed,
         landed: false,
@@ -642,8 +633,6 @@ function startFeed(serving: unknown): Feed {
             stopWatch()
             release()
             FEEDS.delete(serving as object)
-            followed.delete(invalidated)
-            if (followed.size === 0) FOLLOWED.delete(past)
         },
     }
     FEEDS.set(serving as object, shared)
@@ -698,19 +687,3 @@ function addressIn(named: string): string {
     const path = URL.parse(named)?.pathname ?? named
     return unmounted(path) ?? path
 }
-
-/**
- * Holds a patch sink on `cell`; returns what releases it.
- *
- * 18.11 — A VALUE FED TO A FOLLOWER KEEPS ITS PATCHES AS DATA while anyone is fed it, and stops
- * when the last one goes: a sink nobody drains grows with every patch.
- */
-function sinkFor(cell: object): () => void {
-    const sink = PATCH_SINKS.get(cell) ?? { ops: [], lost: false, fed: 0 }
-    PATCH_SINKS.set(cell, sink)
-    sink.fed += 1
-    return () => {
-        sink.fed -= 1
-        if (sink.fed === 0) PATCH_SINKS.delete(cell)
-    }
-}

package/src/server/appBuild.ts

@@ -0,0 +1,377 @@
+// THE BUILD OF THE APP UNDER A ROOT, ON DISK: where it lives (38.27), what is in it, whether there
+// is one, and making one where there is not (38.100). `abide build` writes it, and `abide start`,
+// `createApp`, the test preload and the CLI's own reads take it — every one through here, so the
+// layout is spelled once and "is there a build" has one answer.
+//
+// THE COMPILATION IS THE MARKER. A build removes it before writing anything and writes it last, so a
+// build that failed partway leaves no build — `abide start` builds again and says why, rather than
+// booting what is left (38.100).
+//
+// 42.16 — UNDER `bun test`, THE BUILD IS ONE PER STATE OF THE APP'S SOURCES: its directory is named
+// after a hash of what made it, so a build either matches the sources or does not exist, and every
+// test process — every `--parallel` worker, every spawned child — reuses the one that does. Eight
+// workers each building their own copy of a 1.3 s build waited 7–10 s apiece.
+
+import { mkdir, rename, rm, utimes, writeFile } from 'node:fs/promises' // bun exposes no directory creation, rename, removal, mtime write or exclusive create of its own
+import { dirname } from 'node:path' // bun exposes no path helpers of its own
+
+import type { Compilation } from './abideModules.ts'
+import type { AppSources } from './answerRequest.ts'
+import type { Manifest } from './manifestOf.ts'
+import { namesUnder } from './namesUnder.ts'
+import { packageDirectory } from './packageDirectory.ts'
+import { builtSources, serveApp, type ServedApp } from './servedApp.ts'
+
+/** What builds the app under `root` into `out` where nobody has: spawned, or the CLI's own. */
+export type Builder = (root: string, out: string) => Promise<unknown>
+
+/** Where each part of the build in `out` is. */
+export type BuildFiles = {
+    /** The compilation — every `.abide` compiled, and the build's tables — and the marker. */
+    compilation: string
+    /** 38.5 — beside the bundle rather than in it: everything under `client` is the browser's. */
+    manifest: string
+    /** The browser bundle, each file beside its precompressed copies (38.5). */
+    client: string
+    /** 38.18 — every `public` directory, each file at its address. */
+    published: string
+}
+
+// The CLI, spawned rather than imported: the compiler is not reachable from the server seam.
+const ABIDE_BIN = Bun.fileURLToPath(
+    new URL('../../bin/abide.ts', import.meta.url),
+)
+// The framework's own source is part of what made a build: a compiler change is a new build.
+const FRAMEWORK = Bun.fileURLToPath(new URL('../..', import.meta.url))
+const POLL_MS = 50
+// A test build no process has reused for this long is swept by the next one that builds.
+const UNUSED_FOR_MS = 24 * 60 * 60 * 1000
+
+// One lookup per app per test process, however many files in it call `createApp`.
+const TEST_BUILDS = new Map<string, Promise<string>>()
+
+/** Where the build of the app under `root` goes: `.abide` in its package. 38.27. */
+export function buildDirectory(root: string): string {
+    return `${packageDirectory(root)}/.abide`
+}
+
+export function buildFiles(out: string): BuildFiles {
+    return {
+        compilation: `${out}/compilation.json`,
+        manifest: `${out}/manifest.json`,
+        client: `${out}/client`,
+        published: `${out}/public`,
+    }
+}
+
+/**
+ * The files a build into `out` writes, its previous marker removed first — so that from here until
+ * `markBuild`, `out` holds no build.
+ */
+export async function unmarkedBuild(out: string): Promise<BuildFiles> {
+    const files = buildFiles(out)
+    await rm(files.compilation, { force: true })
+    return files
+}
+
+/** Ends a build: its compilation, written whole and last, is what says there is one. */
+export function markBuild(
+    files: BuildFiles,
+    compilation: Compilation,
+): Promise<void> {
+    return writeWhole(files.compilation, JSON.stringify(compilation))
+}
+
+/**
+ * Writes `path` whole: to a name of its own beside it, then renamed over it.
+ *
+ * 38.66 — a reader, or a second build, finds the last complete file there and never a partial one.
+ */
+export async function writeWhole(
+    path: string,
+    content: string | Blob,
+): Promise<void> {
+    const partial = `${path}.${crypto.randomUUID()}.partial`
+    await Bun.write(partial, content)
+    await rename(partial, path)
+}
+
+/** What a build in `out` holds beside its compilation: the manifest, and every file it serves. */
+export async function builtFiles(out: string): Promise<{
+    manifest: Manifest
+    client: Map<string, string>
+    published: Map<string, string>
+}> {
+    const files = buildFiles(out)
+    return {
+        manifest: (await Bun.file(files.manifest).json()) as Manifest,
+        client: pathsUnder(files.client),
+        published: pathsUnder(files.published),
+    }
+}
+
+/**
+ * The build in `out` served to this process's imports, with the sources an `App` is booted over —
+ * or `undefined` where `out` holds no build and `build` made none.
+ *
+ * 38.6 — what `abide start` boots: no compiler is loaded, and every `.abide` the app imports is
+ * answered out of what the build compiled. 38.100 — AN APP NOBODY BUILT IS BUILT, by `build`,
+ * rather than refused; `undefined` builds nothing, for a reader aimed at a build already there.
+ */
+export async function servedBuild(
+    root: string,
+    out: string,
+    build: Builder | undefined,
+): Promise<(ServedApp & { load: () => Promise<AppSources> }) | undefined> {
+    const marker = buildFiles(out).compilation
+    if (!(await Bun.file(marker).exists())) {
+        if (build === undefined) return undefined
+        await build(root, out)
+        // A FRESH HANDLE: one taken before the build wrote the file reads it as empty.
+        if (!(await Bun.file(marker).exists())) return undefined
+    }
+    // Read beside the table's import rather than after it; a boot that never loads drops it.
+    const files = builtFiles(out)
+    files.catch(() => {})
+    const served = await serveApp(
+        root,
+        (await Bun.file(marker).json()) as Compilation,
+    )
+    return {
+        ...served,
+        load: async () =>
+            builtSources({
+                table: served.table,
+                handlers: served.table.handlers,
+                ...(await files),
+            }),
+    }
+}
+
+/** `abide build` of the app under `root` into `out`, run as the CLI. */
+export async function spawnedBuild(root: string, out: string): Promise<void> {
+    const child = Bun.spawn(
+        [process.execPath, ABIDE_BIN, 'build', '--root', root, '--out', out],
+        { stdout: 'ignore', stderr: 'pipe' },
+    )
+    const [exitCode, said] = await Promise.all([
+        child.exited,
+        new Response(child.stderr).text(),
+    ])
+    if (exitCode !== 0)
+        throw new Error(
+            `abide: could not build the app under ${root}.\n${said}`,
+        )
+}
+
+/**
+ * Where this process reads the build of the app under `root` from: its `buildDirectory`, or — `fresh`,
+ * which `bun test` is (42.16) — the build of its sources as they stand, made if no process has.
+ */
+export async function processBuild(
+    root: string,
+    fresh = process.env.NODE_ENV === 'test',
+): Promise<string> {
+    if (!fresh) return buildDirectory(root)
+    let built = TEST_BUILDS.get(root)
+    if (built === undefined) {
+        // UNDER `node_modules`, so a bare import in the built modules resolves as it does from the
+        // app, and so it is ignored wherever `node_modules` is.
+        built = sourceHash(root).then((key) =>
+            sharedBuild(
+                `${packageDirectory(root)}/node_modules/.cache/abide`,
+                `build-${key}`,
+                (out) => spawnedBuild(root, out),
+            ),
+        )
+        TEST_BUILDS.set(root, built)
+    }
+    return built
+}
+
+/** Every file under `directory`, by the name below it to its path. */
+function pathsUnder(directory: string): Map<string, string> {
+    const paths = new Map<string, string>()
+    for (const name of namesUnder(directory))
+        paths.set(name, `${directory}/${name}`)
+    return paths
+}
+
+/**
+ * `builds/key`, made by `build` in exactly one process however many ask at once.
+ *
+ * THE FIRST TO CREATE `key.lock` BUILDS — an exclusive create is atomic, so one process wins — into
+ * a staging directory renamed into place, so nothing reads a half-written build. The rest wait for
+ * it, and take the lock over if the process holding it has ended.
+ */
+export async function sharedBuild(
+    builds: string,
+    key: string,
+    build: (out: string) => Promise<void>,
+): Promise<string> {
+    const out = `${builds}/${key}`
+    const lock = `${out}.lock`
+    await mkdir(builds, { recursive: true })
+    for (;;) {
+        if (await isDirectory(out)) {
+            const now = new Date()
+            await utimes(out, now, now)
+            return out
+        }
+        if (await claim(lock)) {
+            try {
+                if (!(await isDirectory(out))) await buildInto(out, build)
+            } finally {
+                await rm(lock, { force: true })
+            }
+            await sweep(builds, key)
+            return out
+        }
+        if (await holderEnded(lock)) await rm(lock, { force: true })
+        else await Bun.sleep(POLL_MS)
+    }
+}
+
+async function buildInto(
+    out: string,
+    build: (out: string) => Promise<void>,
+): Promise<void> {
+    const staging = `${out}.tmp-${process.pid}`
+    await rm(staging, { recursive: true, force: true })
+    try {
+        await build(staging)
+        await rename(staging, out)
+    } catch (thrown) {
+        await rm(staging, { recursive: true, force: true })
+        // TWO HOLDERS, where one took over a lock the other had just taken over: the first rename
+        // stands, and it is the same build.
+        if (await isDirectory(out)) return
+        throw thrown
+    }
+}
+
+/**
+ * A hash of everything a build of the app under `root` is made from.
+ *
+ * The app's files, its package's manifest and tsconfig and the lockfile above them, the framework's
+ * own source, and `root` itself, since a build carries the paths it was made at.
+ */
+export async function sourceHash(root: string): Promise<string> {
+    const app = packageDirectory(root)
+    const paths = [
+        ...filesUnder(root),
+        ...filesUnder(`${FRAMEWORK}src`),
+        ...filesUnder(`${FRAMEWORK}bin`),
+        `${app}/package.json`,
+        `${app}/tsconfig.json`,
+    ]
+    const lockfile = await lockfileAbove(app)
+    if (lockfile !== undefined) paths.push(lockfile)
+    const contents = await Promise.all(
+        paths.map((path) =>
+            Bun.file(path)
+                .bytes()
+                .catch(() => undefined),
+        ),
+    )
+    const hasher = new Bun.CryptoHasher('sha256')
+    hasher.update(root)
+    for (let at = 0; at < paths.length; at += 1) {
+        const bytes = contents[at]
+        if (bytes === undefined) continue
+        hasher.update(paths[at] as string)
+        hasher.update(bytes)
+    }
+    return hasher.digest('hex').slice(0, 16)
+}
+
+// Sorted, so the hash does not depend on the order a directory lists in. Dot entries and
+// `node_modules` are skipped: neither is the app's source, and the builds live in one.
+function filesUnder(directory: string): string[] {
+    const found: string[] = []
+    for (const name of namesUnder(directory))
+        if (!`/${name}`.includes('/node_modules/'))
+            found.push(`${directory}/${name}`)
+    return found.sort()
+}
+
+async function lockfileAbove(directory: string): Promise<string | undefined> {
+    for (let at = directory; ; at = dirname(at)) {
+        for (const name of ['bun.lock', 'bun.lockb'])
+            if (await Bun.file(`${at}/${name}`).exists()) return `${at}/${name}`
+        if (dirname(at) === at) return undefined
+    }
+}
+
+async function claim(lock: string): Promise<boolean> {
+    try {
+        await writeFile(lock, String(process.pid), { flag: 'wx' })
+        return true
+    } catch (thrown) {
+        if ((thrown as { code?: string }).code === 'EEXIST') return false
+        throw thrown
+    }
+}
+
+async function holderEnded(lock: string): Promise<boolean> {
+    const text = await Bun.file(lock)
+        .text()
+        .catch(() => undefined)
+    // Gone is not ended: the holder finished, and the next pass finds its build.
+    if (text === undefined) return false
+    // Empty is a holder between creating the lock and writing its pid.
+    return text !== '' && !isRunning(Number(text))
+}
+
+/** Removes builds unused for a day, and what an ended process left half-made. */
+async function sweep(builds: string, kept: string): Promise<void> {
+    const names = new Bun.Glob('*').scanSync({ cwd: builds, onlyFiles: false })
+    const removals: Promise<void>[] = []
+    const now = Date.now()
+    for (const name of names) {
+        if (name === kept) continue
+        const staged = /\.tmp-(\d+)$/.exec(name)
+        if (staged !== null) {
+            if (!isRunning(Number(staged[1])))
+                removals.push(
+                    rm(`${builds}/${name}`, { recursive: true, force: true }),
+                )
+            continue
+        }
+        if (name.endsWith('.lock')) continue
+        removals.push(
+            Bun.file(`${builds}/${name}`)
+                .stat()
+                .then((found) =>
+                    now - found.mtimeMs > UNUSED_FOR_MS
+                        ? rm(`${builds}/${name}`, {
+                              recursive: true,
+                              force: true,
+                          })
+                        : undefined,
+                )
+                .catch(() => undefined),
+        )
+    }
+    await Promise.all(removals)
+}
+
+async function isDirectory(path: string): Promise<boolean> {
+    return (
+        (
+            await Bun.file(path)
+                .stat()
+                .catch(() => undefined)
+        )?.isDirectory() === true
+    )
+}
+
+function isRunning(pid: number): boolean {
+    try {
+        process.kill(pid, 0)
+        return true
+    } catch (thrown) {
+        // EPERM is a process that exists and is someone else's.
+        return (thrown as { code?: string }).code === 'EPERM'
+    }
+}

package/src/server/appPlugins.ts

@@ -1,26 +1,24 @@
-import { appDirectories } from './appDirectories.ts'
+import { packageDirectory } from './packageDirectory.ts'
 
 /**
  * The app's own bundler plugins, loaded from `bunfig.toml`'s `[serve.static] plugins`.
  *
  * 38.43 — declared where bun already has an app declare them, the key `bun-plugin-tailwind`
- * documents. `Bun.build` reads no bunfig, so both client builds read this one — in
- * `appDirectories`, as `config` finds the app's `package.json`.
+ * documents. `Bun.build` reads no bunfig, so both client builds read this one — the app's
+ * package's (`packageDirectory`), beside the `package.json` `config` reads.
  */
 export async function appPlugins(root: string): Promise<Bun.BunPlugin[]> {
-    for (const directory of appDirectories(root)) {
-        const file = Bun.file(`${directory}/bunfig.toml`)
-        if (!(await file.exists())) continue
-        const parsed = Bun.TOML.parse(await file.text()) as {
-            serve?: { static?: { plugins?: string[] } }
-        }
-        const plugins: Bun.BunPlugin[] = []
-        for (const specifier of parsed.serve?.static?.plugins ?? [])
-            plugins.push(
-                (await import(Bun.resolveSync(specifier, directory)))
-                    .default as Bun.BunPlugin,
-            )
-        return plugins
+    const directory = packageDirectory(root)
+    const file = Bun.file(`${directory}/bunfig.toml`)
+    if (!(await file.exists())) return []
+    const parsed = Bun.TOML.parse(await file.text()) as {
+        serve?: { static?: { plugins?: string[] } }
     }
-    return []
+    const plugins: Bun.BunPlugin[] = []
+    for (const specifier of parsed.serve?.static?.plugins ?? [])
+        plugins.push(
+            (await import(Bun.resolveSync(specifier, directory)))
+                .default as Bun.BunPlugin,
+        )
+    return plugins
 }

package/src/server/appTree.ts

@@ -12,15 +12,16 @@
 // A WALK RATHER THAN A GLOB: a glob descends `node_modules` and the build output before a filter
 // can drop them.
 
-import { type Dirent, existsSync, readdirSync } from 'node:fs' // bun has no directory listing or sync existence check of its own
+import { type Dirent, readdirSync } from 'node:fs' // bun has no directory listing of its own
 
-import type { Refusals } from '#compiler/Refusals.ts'
+import type { Diagnostics } from '#compiler/Diagnostics.ts'
 import { ABIDE_ADDRESS } from '#shared/ADDRESSES.ts'
 import {
     PUBLIC_DIRECTORY,
     RESERVED_DIRECTORIES,
 } from '#shared/RESERVED_DIRECTORIES.ts'
 
+import { packageDirectory } from './packageDirectory.ts'
 import {
     DIRECTORY_FILES,
     isBenchFile,
@@ -54,7 +55,7 @@ type AppFiles = {
  *
  * A missing root is an app with nothing in it, not a fault.
  */
-export function appFiles(root: string, refusals: Refusals): AppFiles {
+export function appFiles(root: string, refusals: Diagnostics): AppFiles {
     const files: AppFiles = {
         abide: [],
         handlers: [],
@@ -64,7 +65,7 @@ export function appFiles(root: string, refusals: Refusals): AppFiles {
     }
     // 23.22, 38.25 — a root that is its package's directory holds the package's own files beside its
     // pages.
-    const packaged = existsSync(`${root}/package.json`)
+    const packaged = packageDirectory(root) === root
     walk(root, '', undefined, files, refusals, packaged)
     files.abide.sort()
     files.handlers.sort()
@@ -81,7 +82,7 @@ function walk(
     relative: string,
     reserved: { path: string; name: string } | undefined,
     files: AppFiles,
-    refusals: Refusals,
+    refusals: Diagnostics,
     packaged = false,
 ): void {
     let entries: Dirent[]