@abide/abide 0.123.2 → 0.124.0

package/src/server/answerRequest.ts

@@ -8,86 +8,47 @@
 
 import {
     ABIDE_ADDRESS,
-    APP_MANIFEST_ADDRESS,
     BRIDGE_ADDRESS,
-    CLIENT_ADDRESS,
     HEALTH_ADDRESS,
     MCP_ADDRESS,
     OPENAPI_ADDRESS,
     PRIVATE_HANDLERS_ADDRESS,
-    WORKER_ADDRESS,
 } from '#shared/ADDRESSES.ts'
-import { APP_META } from '#shared/APP_META.ts'
-import { DEBUG_META } from '#shared/DEBUG_META.ts'
 import { decodedOrKept } from '#shared/decodedOrKept.ts'
-import { ERROR_META } from '#shared/ERROR_META.ts'
-import { escapeAttribute } from '#shared/escapeText.ts'
 import { isFailed } from '#shared/Failed.ts'
-import { HandlerRoute } from '#shared/HandlerRoute.ts'
 import { health } from '#shared/health.ts'
-import { KEEP_HEADER } from '#shared/KEEP_HEADER.ts'
-import { KEEP_OPENED } from '#shared/KEEP_OPENED.ts'
-import { ICON_ADDRESSES } from '#shared/LAUNCHER_FILES.ts'
-import { appName } from '#shared/log.ts'
 import { matchOf, type Params, partsOf } from '#shared/matchRoute.ts'
 import { compose } from '#shared/Middleware.ts'
-import { MOUNT, mounted } from '#shared/mount.ts'
-import { MOUNT_META } from '#shared/MOUNT_META.ts'
+import { mounted } from '#shared/mount.ts'
 import { NAVIGATION_HEADER } from '#shared/NAVIGATION_HEADER.ts'
-import { OFFLINE_META } from '#shared/OFFLINE_META.ts'
 import { notFound as refusedNotFound, refuse } from '#shared/refuse.ts'
 import { arrive } from '#shared/route.ts'
-import {
-    parseRoutePattern,
-    rankRoutes,
-    type Segment,
-} from '#shared/routePattern.ts'
-import type { Method, Rpc } from '#shared/rpc.ts'
-import { rpcRequest } from '#shared/rpcRequest.ts'
+import type { Segment } from '#shared/routePattern.ts'
+import type { Method } from '#shared/rpc.ts'
 
 import { answerFailure, laneFailure } from './answerFailure.ts'
-import {
-    answerRpc,
-    type Mounted,
-    mountedOwn,
-    mountHandlers,
-    type MountRow,
-} from './answerRpc.ts'
-import { answerBlobTagged, answerValue, contentEtag } from './answerValue.ts'
-import { answerWorker } from './answerWorker.ts'
-import { appManifest } from './appManifest.ts'
+import { answerRpc } from './answerRpc.ts'
+import { answerBlobTagged, answerValue } from './answerValue.ts'
 import { answerBridge } from './bridgeRelay.ts'
-import { callerOrMint } from './callerOf.ts'
-import { CLIENT_ENTRY } from './CLIENT_BUILD.ts'
 import { compressAnswer } from './compressAnswer.ts'
-import { settingOn } from './config.ts'
-import { noteCallInRender } from './deferredBuilds.ts'
 import { DOCUMENT_HEADERS } from './DOCUMENT_HEADERS.ts'
 import { answerMcp, openApi } from './generatedSurfaces.ts'
-import { failureOf, type LaneRung, rungsOver } from './hooks.ts'
-import { chunksOf, type Manifest } from './manifestOf.ts'
+import { failureOf, type LaneRung } from './hooks.ts'
+import { type Mounted, mountedOwn } from './mountHandlers.ts'
 import { muxAdmission } from './muxUpgrade.ts'
 import { OFFLINE_STALE } from './OFFLINE_STALE.ts'
+import { beginPageRender } from './PageRender.ts'
 import { plainAnswer } from './plainAnswer.ts'
 import { PRINCIPAL_MOUNT } from './principal.ts'
-import {
-    boundPage,
-    type Component,
-    DEFAULT_DOCUMENT,
-    intoHead,
-    renderDocument,
-} from './render.ts'
+import { boundPage, type Component, renderDocument } from './render.ts'
 import {
     adoptRequest,
     type AnsweringApp,
-    beginRender,
     currentRequestScope,
-    type PageRender,
     type RequestScope,
     within,
     writtenStatus,
 } from './requestScope.ts'
-import { callsOnly, seedFor } from './seedBuffer.ts'
 
 // One row of the server's table the compiler writes (`SERVER_TABLE`). The loader is a dynamic import
 // so a page's markup is off the boot path until an address asks for it, which is the same reason
@@ -107,9 +68,9 @@ type ServerRoute = {
 // 35.2 — an error page, and the directory it answers for.
 type ServerError = Omit<ServerRoute, 'clientModules'>
 
-type RankedError = ServerError & { segments: Segment[] }
+export type RankedError = ServerError & { segments: Segment[] }
 
-type Ranked = RankedError & {
+export type Ranked = RankedError & {
     // The document this route is painted into, with the tags that load the app already in its
     // head (38.22, 38.23) and the preloads for this route's own modules (38.28). One per route and
     // built at boot, so a request pays for none of it.
@@ -122,7 +83,7 @@ type Ranked = RankedError & {
  * 19.1 — one file per method per route, so a route is a row and a method is a column, and 19.20's
  * "the most specific route answering the method" is a walk down the rows asking each column.
  */
-type RouteRow = {
+export type RouteRow = {
     pattern: string
     matchers: Record<string, string>
     segments: Segment[]
@@ -141,7 +102,7 @@ type RouteRow = {
 }
 
 /** A public file, read once at boot: where the bytes are, the etag off them, and its type. */
-type PublicFile = { path: string; etag: string; type: string }
+export type PublicFile = { path: string; etag: string; type: string }
 
 /** Everything `answerRequest` answers from: the ranked routes, the lanes and the handlers. */
 export type AppSources = {
@@ -178,9 +139,6 @@ export type AppSources = {
     explained: ((thrown: unknown) => Response) | undefined
 }
 
-// 41.29 — the seed sink of a render no page hydrates: every call is left to run when it is made.
-const SEEDS_NOTHING: PageRender['seed'] = () => false
-
 // 35.19 — what fetch calls a navigation request's destinations, and a script's `fetch`.
 const PAGE_DESTINATIONS = new Set([
     'document',
@@ -368,9 +326,6 @@ async function answerMatched(
     // minted for a request that never becomes a page.
     if (request.method === 'HEAD')
         return new Response(null, { status: writtenStatus(), headers })
-    // 26.5 — the caller the seed buffer is keyed by, minted where the browser carries none: the same
-    // one `principal.caller` reads for the rest of the request.
-    const caller = callerOrMint()
     // 23.1 — WHERE THIS PAGE IS, for its setup to read, in the request's own instances (11.32).
     // 16.10 — AT THE ADDRESS IT IS SERVED AT, which is the one the browser's router arrives at: the
     // request reached here with the mount taken off, and a page reading `route.url()` on both sides
@@ -379,23 +334,8 @@ async function answerMatched(
     at.pathname = mounted(at.pathname)
     arrive(at.href, page.pattern, params)
     // 11.32 — the page renders in a scope of its own, so what its values hold is this request's —
-    // and 41.13, every call it makes is left for the browser's own call to be answered from.
-    // 41.29 — BUT NOT A PAGE A SCRIPT FETCHED, which nothing hydrates: its entries would answer the
-    // next call this caller makes with what the render saw, a sign-in since included — save the one
-    // the worker fetched for the navigation it answers, which is the page that hydrates (45.23).
-    const keep = request.headers.get(KEEP_HEADER)
-    const hydrated =
-        keep === KEEP_OPENED ||
-        request.headers.get('sec-fetch-dest') !== 'empty'
-    // 41.30 — SAVE ONE THE WORKER KEEPS, whose early calls are what a later open of it starts.
-    beginRender({
-        seed: hydrated
-            ? seedFor(caller)
-            : keep !== null
-              ? callsOnly()
-              : SEEDS_NOTHING,
-        calls: [],
-    })
+    // and 41.13, every call it makes is recorded into its render.
+    beginPageRender(request)
     // 41.1, 35.2 — THE DOCUMENT IS THE BUILT PAGE, read whole before there is a `Response` to commit a
     // status to: a refusal the page read, or a throw, is answered by the nearest error page at its own
     // status rather than as a 200 the stream then abandons.
@@ -443,42 +383,6 @@ const SURFACES = new Map<
     [BRIDGE_ADDRESS, (_app, request) => answerBridge(request)],
 ])
 
-// Each handler's route, compiled once rather than per render that calls it — as its `Rpc` keeps its
-// own; compiled again only where it was mounted at another address since.
-const ROUTE_OF = new WeakMap<object, HandlerRoute>()
-
-// What a call made in a page's render reports into: the seed buffer (41.13), and — where the handler
-// is mounted — the request the browser will make for it, for the early-call script (41.20). Once per
-// render, as the browser's `Rpc` makes it once, and the seed buffer is what says which is the once.
-export function reachedInRender(
-    rpc: object,
-    args: unknown,
-    reached: unknown,
-): void {
-    const page = currentRequestScope()?.page
-    if (page === undefined) return
-    noteCallInRender()
-    if (!page.seed(rpc, args, reached)) return
-    // 16.10 — the address the browser's own call is made at, stamped under the mount by
-    // `mountHandlers` — and `undefined` on a handler nothing mounted.
-    const { address, method } = rpc as Rpc<unknown, unknown>
-    if (address === undefined) return
-    let route = ROUTE_OF.get(rpc)
-    if (route?.address !== address) {
-        route = new HandlerRoute(address)
-        ROUTE_OF.set(rpc, route)
-    }
-    page.calls.push({
-        request: rpcRequest(
-            method,
-            route,
-            args as Record<string, unknown> | undefined,
-        ),
-        reached,
-        painted: undefined,
-    })
-}
-
 /**
  * The server's table the compiler writes (`SERVER_TABLE`): the routes and the error pages.
  *
@@ -486,168 +390,8 @@ export function reachedInRender(
  */
 export type ServerTable = { routes: ServerRoute[]; errors: ServerError[] }
 
-/**
- * What a command hands `appSources`: the parts it read, built or compiled, and the client lane.
- *
- * ONE SHAPE FOR EVERY SUPPLIER — `abide start` off disk, a compiled app out of itself, `abide dev` out
- * of memory, and a test handing over modules it already holds — so what differs between them is
- * where a part came from and never how the app is assembled from it.
- */
-export type SourceParts = {
-    table: ServerTable
-    /** The handler table the build wrote, each row with its module's loader. 16.2. */
-    handlers: MountRow[]
-    /** Every public file, by its name below the directory to its path. 38.18, 38.19. */
-    published: Map<string, string>
-    /**
-     * The bundle's manifest, its lane, and `head` — `abide dev`'s reload client (38.17), after the
-     * app's own tags.
-     *
-     * A PROMISE WHERE THE BUNDLE IS STILL BUILDING: `abide dev`'s handlers mount and its public files
-     * hash while the bundler runs, rather than after it — ~40 ms of a docs-app reload.
-     */
-    client: ClientLane | Promise<ClientLane>
-    explained: AppSources['explained']
-}
-
-type ClientLane = {
-    manifest: Manifest
-    framework: AppSources['framework']
-    head: string
-    /**
-     * 45.1, 45.9 — whether the worker saves `manifest`'s bundle and the pages register it: `abide
-     * build`'s, unless `ABIDE_OFFLINE` is off. Where not, the worker address answers the removing one.
-     */
-    offline: boolean
-}
-
-/**
- * The sources an `App` is booted over, off the parts a command supplies.
- *
- * 30.9 — MOST SPECIFIC FIRST, ranked off the table rather than in it. The ordering IS the client
- * router's own: both seams compile through `rankRoutes` and walk a route with `matchOf` — the
- * server past a route that has no answer for the method asked, which the router never is — so
- * "the two cannot resolve one address differently" is a grep rather than a promise. 35.2 — the
- * error pages deepest directory first, so the nearest answers.
- */
-export async function appSources(parts: SourceParts): Promise<AppSources> {
-    const [mounted, published, client] = await Promise.all([
-        mountHandlers(parts.handlers),
-        publicFilesAt(parts.published),
-        parts.client,
-    ])
-    // 35.6 — every page is served in abide's own document; what it carries beyond that, the root
-    // `layout.abide` writes (35.15).
-    // 45.15 — installable where the pages are kept offline and the app has an icon to install by.
-    const icon = published.get(ICON_ADDRESSES.png)
-    const install =
-        icon !== undefined && settingOn('ABIDE_OFFLINE', true)
-            ? await appManifest(icon.path)
-            : undefined
-    const documentOf = (modules: string[]): string =>
-        intoHead(
-            DEFAULT_DOCUMENT,
-            clientTags(client.manifest, modules) +
-                (client.offline ? `<meta name="${OFFLINE_META}">` : '') +
-                (install?.tags ?? '') +
-                client.head,
-        )
-    const pages: Omit<Ranked, 'segments'>[] = []
-    for (const route of parts.table.routes)
-        pages.push({
-            pattern: route.pattern,
-            load: route.load,
-            layouts: route.layouts,
-            matchers: route.matchers,
-            document: documentOf(route.clientModules),
-        })
-    // 19.1 — the build refused two files at one route and method, so a route is one row however
-    // many methods answer at it — and 23.27 one matcher per position, so whichever file opens the
-    // row brings what every file at it would.
-    const rows = new Map<string, Omit<RouteRow, 'segments'>>()
-    const rowAt = (
-        pattern: string,
-        matchers: Record<string, string>,
-    ): Omit<RouteRow, 'segments'> => {
-        let row = rows.get(pattern)
-        if (row === undefined) {
-            row = {
-                pattern,
-                matchers,
-                page: undefined,
-                handlers: new Map(),
-                answers: new Map(),
-            }
-            rows.set(pattern, row)
-        }
-        return row
-    }
-    for (const page of rankRoutes(pages))
-        rowAt(page.pattern, page.matchers).page = page
-    for (const handler of mounted.handlers.values())
-        rowAt(handler.address, handler.matchers).handlers.set(
-            handler.method,
-            handler,
-        )
-    const errors: RankedError[] = []
-    for (const error of parts.table.errors)
-        errors.push({
-            ...error,
-            segments: parseRoutePattern(error.pattern, error.matchers),
-        })
-    errors.sort((a, b) => b.segments.length - a.segments.length)
-    const sources: AppSources = {
-        routes: rankRoutes([...rows.values()]),
-        errors,
-        // 35.18 — marked, so the browser hydrates no page over what an error page painted.
-        errorDocument: intoHead(documentOf([]), `<meta name="${ERROR_META}">`),
-        framework: (pathname, request) => {
-            if (pathname === WORKER_ADDRESS)
-                return answerWorker(
-                    client.offline ? client.manifest : undefined,
-                )
-            if (pathname === APP_MANIFEST_ADDRESS && install !== undefined)
-                return new Response(install.body, {
-                    headers: {
-                        'content-type': 'application/manifest+json',
-                        'cache-control': 'no-cache',
-                    },
-                })
-            return client.framework(pathname, request)
-        },
-        published,
-        explained: parts.explained,
-        offline: client.offline,
-        ...mounted,
-    }
-    for (const row of sources.routes) {
-        if (row.page !== undefined)
-            row.answers.set(
-                row.page,
-                answerInside(
-                    sources,
-                    row.page,
-                    // 37.14 — a page's lane paints a refusal as its error page does (35.2).
-                    rungsOver(row.pattern, (failure, request) =>
-                        answerFailure(
-                            sources,
-                            new URL(request.url).pathname,
-                            failure,
-                        ),
-                    ),
-                ),
-            )
-        for (const handler of row.handlers.values())
-            row.answers.set(
-                handler,
-                answerInside(sources, handler, handler.rungs),
-            )
-    }
-    return sources
-}
-
 /** `found`'s answer inside the rungs filed over its route. 16.14, 37.2. */
-function answerInside(
+export function answerInside(
     app: AppSources,
     found: Ranked | Mounted,
     rungs: LaneRung[],
@@ -655,103 +399,6 @@ function answerInside(
     return compose(rungs, ({ request }) => answerMatched(app, request, found))
 }
 
-/**
- * The head tags that load the app: its metas, stylesheet, entry script and the route's preloads.
- *
- * 38.22, and 38.23 for the stylesheet beside it. An app does not write either: the bundle's
- * address is the build's, and a hand-written one is a path that goes stale the first time the
- * output layout moves.
- *
- * THE STYLESHEET GOES FIRST, and ahead of the page's own head contributions for the same reason:
- * a document that parses its script before its styles paints once unstyled. It is a plain `<link>`
- * rather than anything the client does, so a page the server painted is styled with no JS at all.
- *
- * ONE STYLESHEET FOR THE APP: the bundler collects every stylesheet reachable from the entry — each
- * component's scoped `<style>` (34.4) and each one a component imports (34.6) — into one file, so a
- * page that renders none of those components is served them too. For a `<style>` block that costs
- * bytes rather than correctness: every rule requires its component's scope token, so on a page the
- * component is not on it matches nothing. An imported stylesheet carries no token and applies as
- * written, wherever it is served.
- *
- * 38.28 — THE ROUTE'S CHUNKS ARE PRELOADED BESIDE THE ENTRY. Left to the client, the page's chunk
- * and the shared runtime it imports are only asked for once the entry has arrived and run the
- * router — a whole round trip after the document, for the largest file in the bundle. Named here,
- * they are requested while the document is still being parsed.
- *
- * EVERY NAME IS THE MANIFEST'S, the entry's included: a build hashes it (38.5). A manifest with no
- * entry is a bundle that failed under `abide dev` (38.17), and gets no tags rather than a
- * `<script>` at a 404.
- */
-export function clientTags(manifest: Manifest, modules: string[]): string {
-    if (manifest.entry === undefined) return ''
-    // 28.10 — `DEBUG`, through the document rather than the bundle, where the server has one.
-    const debug = process.env.DEBUG
-    let tags =
-        debug === undefined || debug === ''
-            ? ''
-            : `<meta name="${DEBUG_META}" content="${escapeAttribute(debug)}">`
-    // 28.4 — the app's name, so a browser's `log.named` prefixes the one the server's does.
-    tags += `<meta name="${APP_META}" content="${escapeAttribute(appName())}">`
-    // 16.10 — the mount the browser resolves every address against, the root's `''` included: a
-    // lookup that finds no tag has walked the whole document to say so.
-    tags += `<meta name="${MOUNT_META}" content="${escapeAttribute(MOUNT.current())}">`
-    const client = mounted(CLIENT_ADDRESS)
-    tags +=
-        manifest.stylesheet === undefined
-            ? ''
-            : `<link rel="stylesheet" href="${client}/${manifest.stylesheet}">`
-    tags += `<script type="module" src="${client}/${manifest.entry}"></script>`
-    for (const chunk of chunksOf([`${CLIENT_ENTRY}.ts`, ...modules], manifest))
-        tags += `<link rel="modulepreload" href="${client}/${chunk}">`
-    return tags
-}
-
-/**
- * The public files by address, off each file's name and where its bytes are.
- *
- * 38.18 and 38.19's directory, as an address per file — or a compiled app's, whose bytes are
- * inside itself. Read at boot rather than per request, and the ETAG IS READ WITH IT: 21.13
- * derives it from the bytes, so there is no cheaper moment than the one read that is happening
- * anyway. The bytes are hashed and dropped — `Bun.file` streams the body when somebody asks, so a
- * large file is not held in memory for the life of the process.
- */
-async function publicFilesAt(
-    paths: Map<string, string>,
-): Promise<Map<string, PublicFile>> {
-    const files = new Map<string, PublicFile>()
-    // THE READS OVERLAP. They are independent, and `abide dev` runs this again on every
-    // reload rather than once at boot — so it is reload latency an author waits on, not just
-    // a boot cost. Each is hashed as it lands, so no more than the reads in flight are held.
-    const names = [...paths.keys()]
-    const etags = await Promise.all(
-        names.map(async (name) =>
-            contentEtag(await Bun.file(paths.get(name) as string).bytes()),
-        ),
-    )
-    for (let index = 0; index < names.length; index += 1) {
-        const name = names[index] as string
-        files.set(`/${name}`, {
-            path: paths.get(name) as string,
-            etag: etags[index] as string,
-            type: publicType(name),
-        })
-    }
-    return files
-}
-
-/**
- * A public file's content type, off its name's extension.
- *
- * 36.14, 36.17 — a text type without a charset is given UTF-8's rather than whatever a browser
- * guesses.
- */
-function publicType(name: string): string {
-    const type = Bun.file(name).type
-    return type.startsWith('text/') && !type.includes('charset')
-        ? `${type}; charset=utf-8`
-        : type
-}
-
 function notFound(): Response {
     return plainAnswer('not found', 404)
 }