@abide/abide 0.123.2 → 0.124.0

package/src/server/createApp.ts

@@ -16,14 +16,16 @@ import { MOUNT, unmounted } from '#shared/mount.ts'
 import { PRINCIPAL_HEADER } from '#shared/PRINCIPAL_HEADER.ts'
 import { RPC_SERVER } from '#shared/RPC_SERVER.ts'
 
-import { servedTable } from './abideModules.ts'
 import { laneFailure } from './answerFailure.ts'
 import { answerRequest, type AppSources } from './answerRequest.ts'
-import type { Mount } from './answerRpc.ts'
 import { Mux, type MuxConnection } from './answerSocket.ts'
-import { appDirectories } from './appDirectories.ts'
+import {
+    type Builder,
+    processBuild,
+    servedBuild,
+    spawnedBuild,
+} from './appBuild.ts'
 import { holdsApp } from './appTree.ts'
-import { buildDirectory } from './buildDirectory.ts'
 import {
     APP_PACKAGE,
     type AppPackage,
@@ -31,11 +33,14 @@ import {
     packageUnder,
     positiveSetting,
 } from './config.ts'
+import { Followers } from './Followers.ts'
 import { McpSurface } from './generatedSurfaces.ts'
 import { HOOKS, inOrder, reportUnexpected, rootRungs } from './hooks.ts'
 import { IDLE_TIMEOUT_SECONDS } from './IDLE_TIMEOUT_SECONDS.ts'
 import { installServer } from './installServer.ts'
+import { followedIn, type Mount } from './mountHandlers.ts'
 import { admitsMux, muxSocketOptions, upgraded } from './muxUpgrade.ts'
+import { packageDirectory } from './packageDirectory.ts'
 import { plainAnswer } from './plainAnswer.ts'
 import { presumePrincipal } from './principal.ts'
 import { realOrAsGiven } from './realOrAsGiven.ts'
@@ -50,7 +55,6 @@ import {
     serverTiming,
 } from './requestScope.ts'
 import { heldBody } from './streamEvent.ts'
-import { testBuild } from './testBuild.ts'
 import { traceResponse } from './trace.ts'
 
 // 28.8 — one line per request.
@@ -80,13 +84,16 @@ export interface App {
 /**
  * The app this process was started in, booted off what `abide build` left beside it.
  *
- * 42.1 — found where the CLI finds it (38.25), and booted off the build (38.27).
+ * 42.1 — found where the CLI finds it (38.25), and booted off the build (38.27) — under `bun test`,
+ * the build of its sources as they stand (42.16), which the test preload served already (38.109).
  */
 export async function createApp(): Promise<App> {
     const root = appRoot(undefined)
     const app = await appOnDisk(
-        root === undefined ? undefined : { root, out: buildDirectory(root) },
-        (root) => servedBuild(root),
+        root === undefined
+            ? undefined
+            : { root, out: await processBuild(root) },
+        spawnedBuild,
     ).boot()
     if (typeof app === 'string')
         throw new Error(`abide: createApp found ${app}`)
@@ -117,13 +124,11 @@ export function noAppHere(): string {
 
 /**
  * The app on disk at `found` — its source root and build directory, both absolute — or the
- * refusal where nothing was found. `built` makes its build this process's (`serveBuild`, which
- * builds one nobody built — 38.100) and answers the directory it is in, or `undefined` where
- * nothing under the root builds.
+ * refusal where nothing was found. Its boot builds it with `build` where nobody has (38.100).
  */
 export function appOnDisk(
     found: { root: string; out: string } | undefined,
-    built: (root: string, out: string) => Promise<string | undefined>,
+    build: Builder,
 ): AppHandle {
     if (found === undefined)
         return {
@@ -132,49 +137,25 @@ export function appOnDisk(
             boot: async () => noAppHere(),
         }
     const { root, out } = found
-    const origin = originUnder(root)
     return {
-        package: origin.package,
-        handlers: async () => {
-            const { serveBuild } = await import('./serveBuild.ts')
-            if (!(await serveBuild(root, out, async () => undefined))) return []
-            return (await servedTable(root)).handlers
-        },
+        package: packageUnder(root),
+        handlers: async () =>
+            (await servedBuild(root, out, undefined))?.table.handlers ?? [],
         boot: async () => {
-            const served = await built(root, out)
+            const served = await servedBuild(root, out, build)
             if (served === undefined) return `nothing under ${root} to build.`
-            const { loadBuild } = await import('./serveBuild.ts')
-            return bootApp(origin, () => loadBuild({ root, out: served }))
+            return bootApp(served.origin, served.load)
         },
     }
 }
 
-/**
- * The build of the app under `root`, served to this process's imports — or `undefined` where
- * nothing under it builds. `fresh` builds it for its sources as they stand.
- *
- * 42.16 — under `bun test` the app is built for its sources as they stand rather than read off
- * whatever `abide build` last left, which a test run would otherwise need first and could find
- * stale. One answer for `createApp` and the test preload (38.109), so a test that boots the app
- * reuses the build its imports were served from.
- */
-export async function servedBuild(
-    root: string,
-    fresh = process.env.NODE_ENV === 'test',
-): Promise<string | undefined> {
-    const out = fresh ? await testBuild(root) : buildDirectory(root)
-    const { serveBuild } = await import('./serveBuild.ts')
-    return (await serveBuild(root, out)) ? out : undefined
-}
-
 /**
  * The app's root — `--root`, else `src` where the working directory holds one, else the working
  * directory — or `undefined` where it is no app's.
  *
- * 38.25 and 38.26 — `undefined` is a refusal and not a guess. An app's root is in a package — it or
- * the directory above it holds the `package.json` (`appDirectories`) — and holds a `.abide`
- * file; the package is asked first, so a command run from `/` answers at once rather than
- * walking the disk.
+ * 38.25 and 38.26 — `undefined` is a refusal and not a guess. An app's root is in a package
+ * (`packageDirectory`) and holds a `.abide` file; the package is asked first, so a command run from
+ * `/` answers at once rather than walking the disk.
  *
  * ITS REAL PATH, as the bundler and the resolver name every file under it: an app under `/tmp` is
  * `/private/tmp` to both, and one spelling here is one fewer at every reader downstream.
@@ -183,18 +164,18 @@ export function appRoot(given: string | undefined): string | undefined {
     if (given !== undefined) return realOrAsGiven(resolve(given))
     const under = resolve('src')
     const root = realOrAsGiven(existsSync(under) ? under : process.cwd())
-    let packaged = false
-    for (const directory of appDirectories(root))
-        packaged ||= existsSync(`${directory}/package.json`)
-    return packaged && holdsApp(root) ? root : undefined
+    return existsSync(`${packageDirectory(root)}/package.json`) &&
+        holdsApp(root)
+        ? root
+        : undefined
 }
 
 /**
  * What an app is booted as besides its sources: its hooks module and its `package.json`.
  *
- * The two things `bootApp` reads before the boot and not through it. Found under the source root
- * for an app on disk (`originUnder`), and handed over by a compiled app, which has no root to look
- * under.
+ * The two things `bootApp` reads before the boot and not through it — off the server's table of
+ * the compilation this process serves (`serveApp`), or handed over by a compiled app's entry, which
+ * holds the table itself.
  */
 export type AppOrigin = {
     /**
@@ -207,20 +188,6 @@ export type AppOrigin = {
     package: AppPackage
 }
 
-/**
- * The `AppOrigin` of an app on disk: its package under `root`, and its server blocks, out of the
- * compilation this process serves (`serveCompilation`) — the build's, or `abide dev`'s.
- */
-export function originUnder(root: string): AppOrigin {
-    return {
-        hooks: async () => {
-            const table = await servedTable(root)
-            await Promise.all(table.servers.map((load) => load()))
-        },
-        package: packageUnder(root),
-    }
-}
-
 /**
  * An `App` as a command boots it: with the mux over its tables, which `listen` opens and `abide dev`'s
  * worker opens in its stead — one `AnsweringApp`, and one MCP surface, per app either way.
@@ -361,6 +328,7 @@ export async function bootEntered(
         answer: fetch,
         mcp: new McpSurface(booted.handlers, fetch),
         held: new Set(),
+        followers: new Followers(),
     }
 
     // 16.42, 42.12 — A `raw` CALL MADE ON THIS SERVER IS ANSWERED IN PROCESS, by the app answering the
@@ -370,7 +338,11 @@ export async function bootEntered(
     RPC_SERVER.raw = answerRaw
 
     const openMux = (): Mux => {
-        mux = new Mux(booted.handlers, answering)
+        mux = new Mux(
+            followedIn(booted.handlers),
+            answering.followers,
+            answering,
+        )
         return mux
     }
 

package/src/server/csp.ts

@@ -7,8 +7,8 @@
 
 import type { Rung } from '#shared/Middleware.ts'
 
+import { EARLY_CALL_HASH } from './PageRender.ts'
 import { randomToken } from './randomToken.ts'
-import { EARLY_CALL_HASH } from './render.ts'
 import { within } from './requestScope.ts'
 
 // 29.5.

package/src/server/deferredBuilds.ts

@@ -9,24 +9,11 @@
 // nonce is never written anywhere, so no text an author or a caller supplies can stand in for one.
 
 import { regionMarkup } from '#shared/anchorMarkup.ts'
-import { isReactive, isStreaming, loadOf } from '#shared/reactive/index.ts'
+import { isReactive } from '#shared/reactive/index.ts'
+import { isStreaming, loadOf } from '#shared/reactive/producer.ts'
 
+import type { PageCall } from './PageRender.ts'
 import type { Rendered } from './render.ts'
-import type { PageCall } from './requestScope.ts'
-
-// SYNCHRONOUS SETUP IS WHAT MAKES ONE COUNTER ENOUGH. 34.3 keeps a setup from awaiting, so no other
-// request's render runs between a component's two reads, however many renders are in flight.
-let callsInRenders = 0
-
-/** How many calls renders have made, read on either side of a component's setup. */
-export function callsInRender(): number {
-    return callsInRenders
-}
-
-/** Counts a call a page's render made (`reachedInRender`). */
-export function noteCallInRender(): void {
-    callsInRenders += 1
-}
 
 /** A deferred child: its record, and the page's calls its setup made, marked with its build. */
 type Deferred = { rendered: Rendered; callsFrom: number; callsTo: number }

package/src/server/devWorker.ts

@@ -21,12 +21,8 @@
 import { DEV_ADDRESS } from '#shared/ADDRESSES.ts'
 import { escapeText } from '#shared/escapeText.ts'
 
-import {
-    type Compilation,
-    serveCompilation,
-    servedTable,
-} from './abideModules.ts'
-import { type AppSources, appSources } from './answerRequest.ts'
+import type { Compilation } from './abideModules.ts'
+import type { AppSources } from './answerRequest.ts'
 import type { Mux, MuxConnection } from './answerSocket.ts'
 import { publishedUnder } from './appTree.ts'
 import {
@@ -35,7 +31,7 @@ import {
     clientBundle,
     type ServedFile,
 } from './clientBundle.ts'
-import { bootApp, type BootedApp, originUnder } from './createApp.ts'
+import { bootApp, type BootedApp } from './createApp.ts'
 import { keepServing } from './faultPolicy.ts'
 import { type Manifest, NO_MANIFEST } from './manifestOf.ts'
 import { admitsMux, muxSocketOptions } from './muxUpgrade.ts'
@@ -46,6 +42,7 @@ import {
     serveOver,
     type ToRelay,
 } from './responseRelay.ts'
+import { appSources, serveApp } from './servedApp.ts'
 import { withAbideSources } from './withAbideSources.ts'
 
 // The reload client, which the worker serves and every document it answers loads.
@@ -211,31 +208,30 @@ async function open(
         // the bundler resolves the browser's graph through it, so the two lanes cannot disagree
         // about what a specifier means. Registering it is process-wide — which is a worker rather
         // than the command, so a reload is a new registry rather than a cache to bust.
-        serveCompilation(root, compilation)
+        const serving = serveApp(root, compilation)
 
         // ASKED FOR TOGETHER. The bundle, the public directory and the server's own
-        // tables depend on none of each other — the plugin is registered above, before any of
-        // them asks it anything — and on a reload every one of them is latency the author waits on,
-        // so the bundle is handed over still building (`SourceParts.client`).
+        // tables depend on none of each other — `serveApp` registered the plugin as it was called,
+        // before any of them asks it anything — and on a reload every one of them is latency the
+        // author waits on, so the bundle is handed over still building (`SourceParts.client`).
         //
         // ONE LISTING of the public directories — the compile's — for the bundle's externals and for
         // what is served. 38.19 — OUT OF THE SOURCE TREE. `abide build` copies these into its output
         // and dev has no output, so the address answers where the author's file actually is.
         const published = publishedUnder(root, start.published)
         const bundling = bundleInMemory(root, compilation, start.published)
-        const table = await servedTable(root)
-        const handlers = table.handlers
+        const { origin, table } = await serving
 
         // THE SAME `App` `abide start` boots, so an app's hooks and middleware run in dev too — and its
         // sources are read INSIDE the boot, as `abide start` reads them: a document's head carries
         // what the resolved configuration says (28.4's app name), which is not resolved before it.
-        app = await bootApp(originUnder(root), async () => {
+        app = await bootApp(origin, async () => {
             // 38.17 — THE RELOAD CLIENT IS THIS WORKER'S, not the bundle's, and it goes in whether or
             // not there is an entry beside it: a bundle that failed is exactly when a reader needs the
             // next save to reach them. `clientTags` writes nothing for a manifest with no entry.
             const sources = await appSources({
                 table,
-                handlers,
+                handlers: table.handlers,
                 published,
                 client: bundling.then((bundle) => ({
                     manifest: bundle.manifest,

package/src/server/faceOf.ts

@@ -34,7 +34,7 @@ export type Lane = { bundling: boolean; browser: boolean }
 export type Face = { path: string; namespace: string }
 
 /**
- * What an import asks of a file, by its spelling: its text (`?text`), a component's stylesheet
+ * What an import asks of a file, by its spelling: its text (`.abide-text`), a component's stylesheet
  * (`?style`), the module it compiles to (`?component`), its browser module (`?client`), its server
  * module (`?server`), a `.abide` named bare, or a module that may be a handler file.
  */

package/src/server/generatedSurfaces.ts

@@ -22,12 +22,13 @@ import { parseRoutePattern, type Segment } from '#shared/routePattern.ts'
 import { argsInURL, rpcRequest } from '#shared/rpcRequest.ts'
 
 import { answered } from './answerFailure.ts'
-import { bodyWithin, type Mounted } from './answerRpc.ts'
+import { bodyWithin } from './answerRpc.ts'
 import type { ToolAnswer, ToolDefinition } from './assistant.ts'
 import { appIdentity } from './config.ts'
 import { crossingOrigin, crossingRefusal } from './crossingOrigin.ts'
 import { IMAGE_TYPES } from './IMAGE_TYPES.ts'
 import { MCP_PROTOCOL_VERSION } from './MCP_PROTOCOL_VERSION.ts'
+import type { Mounted } from './mountHandlers.ts'
 import { type Listed, surfaceOf } from './surfaceOf.ts'
 
 const OPENAPI_LOG = namedLogger('abide:openapi')

package/src/server/handlerFileMount.ts

@@ -0,0 +1,40 @@
+import type { Mount } from './mountHandlers.ts'
+
+/**
+ * The row of a handler file (16.73): its default, answered at the route the file is placed at and
+ * named for the file — what its declaration says of it laid over that.
+ */
+export function handlerFileMount(
+    file: Pick<Mount, 'address' | 'source' | 'scope' | 'matchers'>,
+    declared: Pick<
+        Mount,
+        | 'method'
+        | 'ui'
+        | 'cli'
+        | 'mcp'
+        | 'description'
+        | 'copy'
+        | 'defaults'
+        | 'args'
+        | 'result'
+    >,
+): Mount {
+    return {
+        address: file.address,
+        method: declared.method,
+        source: file.source,
+        name: file.address.slice(file.address.lastIndexOf('/') + 1),
+        export: 'default',
+        scope: file.scope,
+        matchers: file.matchers,
+        private: false,
+        ui: declared.ui,
+        cli: declared.cli,
+        mcp: declared.mcp,
+        description: declared.description,
+        copy: declared.copy,
+        defaults: declared.defaults,
+        args: declared.args,
+        result: declared.result,
+    }
+}

package/src/server/index.ts

@@ -14,7 +14,7 @@ import { installServer } from './installServer.ts'
 // markup with, 32.20's `safeUrl`, and 31.8's `writePath`.
 export * from '#shared'
 // 18.11 — one write a patch made, as a followed `GET`'s `patch` carries it.
-export type { PatchOp } from '#shared/reactive/PATCH_SINKS.ts'
+export type { PatchOp } from '#shared/reactive/patchLog.ts'
 export {
     type Clients,
     DELETE,
@@ -51,10 +51,10 @@ export type { ConfigField } from './configFields.ts'
 export { type App, createApp } from './createApp.ts'
 // 41.28's run-time half: an emitted component reads it on either side of its setup, and one whose
 // setup made a call answers as a page does. Not an app's name.
-export { callsInRender } from './deferredBuilds.ts'
+export { callsInRender } from './PageRender.ts'
 // 19.9's run-time half: what the module a handler is loaded through calls to hold it to the schema
 // its annotation derives (15.8). Not an app's name.
-export { derivedArgs } from './derivedArgs.ts'
+export { derivedArgs } from './argsContract.ts'
 // 37.1's run-time half: what a compiled server module calls around its `<script server>`, so the
 // hooks it makes are filed at its route.
 export {

package/src/server/installServer.ts

@@ -2,9 +2,9 @@
 // whichever server module a process happened to import — a compiler or a test that reaches one of
 // them for a function is not made a server by it. Called where a server is entered: `bootApp`,
 // `abide run`, and `@abide/abide/server`, which an app imports to be one. Filling the same functions again
-// changes nothing, so each entry calls it. Three are filled elsewhere: `SCOPING.provider` at
-// `requestScope.ts`'s import (its comment says why), `RPC_SERVER.raw` per boot, and
-// `LISTENING.timeout` by the dev worker alone.
+// changes nothing, so each entry calls it. Four are filled elsewhere: `SCOPING.provider` at
+// `requestScope.ts`'s import (its comment says why), `RPC_SERVER.raw` per boot,
+// `RPC_SERVER.following` by each app's followers, and `LISTENING.timeout` by the dev worker alone.
 
 import { COOKIES } from '#shared/cookies.ts'
 import { CSP } from '#shared/csp.ts'
@@ -15,12 +15,11 @@ import { PRINCIPAL } from '#shared/principal.ts'
 import { RPC_SERVER } from '#shared/RPC_SERVER.ts'
 import { UNEXPECTED } from '#shared/UNEXPECTED.ts'
 
-import { reachedInRender } from './answerRequest.ts'
 import { environmentTimeout } from './answerRpc.ts'
-import { broadcast, feedFromServed, swept } from './answerSocket.ts'
 import { configuredMount, derivedAppName } from './config.ts'
 import { cspRung, nonce } from './csp.ts'
 import { handOnError } from './hooks.ts'
+import { recordInRender } from './PageRender.ts'
 import { SERVER_PRINCIPAL } from './principal.ts'
 import { reportHealth } from './reportHealth.ts'
 import { handlerTook, request, requestCookies } from './requestScope.ts'
@@ -40,9 +39,6 @@ export function installServer(): void {
     // 16.11 — the request a handler's rung is handed.
     RPC_SERVER.request = request
     RPC_SERVER.timeout = environmentTimeout
-    RPC_SERVER.reached = reachedInRender
-    RPC_SERVER.broadcast = broadcast
-    RPC_SERVER.swept = swept
-    RPC_SERVER.served = feedFromServed
+    RPC_SERVER.reached = recordInRender
     RPC_SERVER.handled = handlerTook
 }