@abide/abide 0.104.0 → 0.105.1

package/src/ui/wire.ts

@@ -17,10 +17,11 @@
 // An entry of its own (`@abide/abide/wire`) rather than a name on the runtime barrel: only a generated
 // wrapper imports it, and a page with no handler pays nothing for it.
 
-import { answered, answerOf } from '#shared/answerOf.ts'
+import { type Answer, answered, answerOf } from '#shared/answerOf.ts'
 import type { CopyOptions } from '#shared/CopyOptions.ts'
 import { isFailed } from '#shared/Failed.ts'
-import { answerChunks, carriesBytes } from '#shared/framing.ts'
+import { answerChunks } from '#shared/framing.ts'
+import { HandlerRoute } from '#shared/HandlerRoute.ts'
 import { LOAD_SIGNAL } from '#shared/LOAD_SIGNAL.ts'
 import { reactive, structural } from '#shared/reactive/index.ts'
 import {
@@ -29,8 +30,6 @@ import {
 } from '#shared/reactive/parameterDefaults.ts'
 import { declare, type Method } from '#shared/rpc.ts'
 import { rpcRequest } from '#shared/rpcRequest.ts'
-import type { Answer } from '#shared/takeEarlyCall.ts'
-import { versionInEtag } from '#shared/versionInEtag.ts'
 import { followRpc } from './socketWire.ts'
 
 /** The browser's `Rpc` for a handler: the server's declaration over a body that fetches. */
@@ -42,6 +41,8 @@ export function wire(
     // 11.29 — and the defaults its parameter writes, which the copy keys by as the server does.
     defaults?: Defaults,
 ): unknown {
+    // 16.9 — the handler's route, compiled once for every call through the copy.
+    const route = new HandlerRoute(address)
     // 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) => {
@@ -51,11 +52,7 @@ export function wire(
             follow(args, answer)
             return answered(answer)
         }
-        const answer = answerOf(
-            rpcRequest(method, address, args),
-            false,
-            signal,
-        )
+        const answer = answerOf(rpcRequest(method, route, args), false, signal)
         return answer instanceof Promise ? answer.then(settle) : settle(answer)
     }
     // 16.32 — A STREAMING HANDLER'S COPY IS A STREAM OF ITS OWN, whose chunks land as the answer's
@@ -68,13 +65,13 @@ export function wire(
         // this runs while the call that started the load still has its signal set.
         const signal = LOAD_SIGNAL.current
         const answer = await answerOf(
-            rpcRequest(method, address, args),
+            rpcRequest(method, route, args),
             true,
             signal,
         )
         follow(args, answer)
         if (answer.body !== undefined && answer.body !== null) {
-            yield* answerChunks(answer.body, answer.type)
+            yield* answerChunks(answer.body, answer.framing)
             return
         }
         const value = answered(answer)
@@ -88,22 +85,10 @@ export function wire(
     // so a caller signed out since would be fed what this answer just refused it. Nor a binary,
     // which the mux's JSON frames cannot carry.
     const follow = (args: unknown, answer: Answer): void => {
-        if (
-            method !== 'GET' ||
-            answer.status === undefined ||
-            answer.status < 200 ||
-            answer.status >= 300 ||
-            carriesBytes(answer.type)
-        )
-            return
-        const seconds = /max-age=(\d+)/.exec(answer.life ?? '')?.[1]
-        followRpc(
-            address,
-            args,
-            versionInEtag(answer.version),
-            seconds === undefined ? undefined : Number(seconds) * 1000,
-            () => (value as (args: unknown) => unknown)(args),
-        )
+        if (method === 'GET' && answer.followable)
+            followRpc(address, args, answer.version, answer.life, () =>
+                (value as (args: unknown) => unknown)(args),
+            )
     }
     // A KEYED VALUE OF ITS OWN where the handler's declares what its copy behaves by, so every entry —
     // the copy a page walks — carries it: its key (32.32), its tags (11.43) and its comparator (5.3). A `GET` alone: a mutation's value is written and read once.

package/src/compiler/hooksCalled.ts

@@ -1,35 +0,0 @@
-import { tokenize } from './tokenize.ts'
-
-/** Every hook abide exports, by name. */
-export const HOOK_NAMES: ReadonlySet<string> = new Set([
-    'middleware',
-    'onStart',
-    'onStop',
-    'onError',
-    'onConfig',
-    'onHealth',
-    'onPrincipal',
-    'onLauncher',
-    'onMenu',
-])
-
-/**
- * Each of abide's hook names called in `source`, in the order written: the name, then `(`, and not
- * a declaration — a member call included, since `server.onStart(…)` is abide's hook all the same.
- * Read, not run — what `abide routes` lists and the build's refusals of a hook called where it is
- * never read (38.107) go by.
- */
-export function hooksCalled(source: string): string[] {
-    const called: string[] = []
-    let previous = ''
-    let named: string | undefined
-    for (const token of tokenize(source)) {
-        if (named !== undefined && token.text === '(') called.push(named)
-        named =
-            HOOK_NAMES.has(token.text) && previous !== 'function'
-                ? token.text
-                : undefined
-        previous = token.text
-    }
-    return called
-}

package/src/server/clientBuildOptions.ts

@@ -1,54 +0,0 @@
-import { CLIENT_ADDRESS } from '#shared/ADDRESSES.ts'
-import { tablePath } from './abideModules.ts'
-import { CLIENT_ENTRY } from './CLIENT_BUILD.ts'
-
-/**
- * The `Bun.build` options for the client bundle both lanes build.
- *
- * `abide build` builds it to disk and `abide dev` in memory. 30.8 says dev resolves an address the
- * way the built app does, so what decides resolution is written once here and each lane adds only
- * where the output goes and how it is named.
- */
-export function clientBuildOptions(
-    root: string,
-    plugins: Bun.BunPlugin[],
-    publicAddresses: string[],
-) {
-    return {
-        // The entry is a table the plugin serves (`abideModules`), below the root.
-        entrypoints: [tablePath(root, `${CLIENT_ENTRY}.ts`)] as string[],
-        // The app's own root, because `Bun.build` opens the entry's directory otherwise, and the
-        // tables' is not on disk to open.
-        root,
-        // 16.28, 16.29 — a `<script server>` is its stand-ins here, and a `server/` module refuses.
-        plugins,
-        target: 'browser',
-        format: 'esm',
-        splitting: true,
-        metafile: true,
-        // 36.15 — a stylesheet's `url('/fonts/…')` is the public file's address, not a path here,
-        // and `Bun.build` reads a leading `/` as a path on this disk and fails on it not being
-        // there. The list is the files that exist rather than every `/…`: a URL naming nothing the
-        // app serves is still worth a build error.
-        external: publicAddresses,
-    } as const
-}
-
-// From the bundle's own directory up to the app's root: `../../` below `/__abide/client`.
-const UP_TO_ROOT = '../'.repeat(CLIENT_ADDRESS.split('/').length - 1)
-
-/**
- * A built stylesheet with every root-absolute `url()` written relative to the bundle's directory.
- *
- * 16.10, 36.15 — THE SAME MECHANISM AS THE HANDLER WRAPPERS: the address is written relative to
- * where the bundle is served and the browser resolves it against the sheet, so one build serves
- * at the root and below a mount. What survives the build as `url(/…)` is a public file's address
- * (the `external` list above), and the browser would resolve it against the origin. `//` is
- * another host's.
- */
-export function stylesheetUnderMount(css: string): string {
-    return css.replace(
-        /url\((["']?)\/(?!\/)/g,
-        (_whole, quote: string) => `url(${quote}${UP_TO_ROOT}`,
-    )
-}

package/src/server/refuseAddressCollision.ts

@@ -1,37 +0,0 @@
-/**
- * Throws, naming both, when a public file claims a route's address or another public file's.
- *
- * 36.13 — the walks that find routes and public files cannot see each other's collisions from
- * inside either one; this is the one place they meet, and naming BOTH is the clause — naming one
- * leaves the reader to find the other. Two `public` directories can claim one address too, since
- * each mounts at the path above it (36.11).
- *
- * THE BUILD AND DEV, and `abide start` trusts the build: `answerRequest` answers a public file
- * AHEAD of any route on the ground that 36.13 makes a collision impossible at run time, and 30.8
- * says dev must resolve an address the way the built app does.
- *
- * `published` is each public file's source path to its address, as `appTree` reads them.
- */
-export function refuseAddressCollision(
-    pages: readonly { pattern: string }[],
-    handlers: readonly { address: string }[],
-    published: Map<string, string>,
-    command: string,
-): void {
-    const patterns = new Set<string>()
-    for (const page of pages) patterns.add(page.pattern)
-    for (const handler of handlers) patterns.add(handler.address)
-    const claimed = new Map<string, string>()
-    for (const [source, address] of published) {
-        if (patterns.has(address))
-            throw new Error(
-                `${command}: ${source} and the route ${address} claim the same address. RULEBOOK 36.13.`,
-            )
-        const other = claimed.get(address)
-        if (other !== undefined)
-            throw new Error(
-                `${command}: ${other} and ${source} are both answered at ${address}. RULEBOOK 36.13.`,
-            )
-        claimed.set(address, source)
-    }
-}

package/src/shared/reactive/chunksOfStream.ts

@@ -1,33 +0,0 @@
-import { isFailed } from '../Failed.ts'
-import { chunksFrom, wakeOf } from './Reactive.ts'
-
-/**
- * The chunks of a streaming value, as they land, ending when its run closes.
- *
- * WHAT A READ WOULD SERVE, chunk by chunk (16.32), rather than the ring `for await` walks: a gated
- * value's chunks are its gated accumulation's (9.8). A cursor is the wake and the settling is the
- * end (`Cursor.closeOn`).
- */
-export async function* chunksOfStream(value: unknown): AsyncGenerator<unknown> {
-    const cursor = wakeOf(value)
-    cursor.closeOn(Promise.resolve(value as PromiseLike<unknown>))
-    let sent = 0
-    try {
-        for (;;) {
-            for (const chunk of chunksFrom(value, sent)) {
-                sent += 1
-                yield chunk
-            }
-            if (cursor.closed) break
-            await cursor.turn()
-        }
-    } finally {
-        cursor.stop()
-    }
-    if (cursor.failure !== undefined) throw cursor.failure
-    // 16.59, 16.60 — A RUN ENDED BY ITS TIMEOUT SETTLES with the chunks it had and holds its refusal
-    // rather than rejecting, so the refusal is read off the value and thrown after them: a stream
-    // answered over http then ends on it (16.68) rather than as though it had finished.
-    const held = (value as { error?: () => unknown }).error?.()
-    if (isFailed(held)) throw held
-}

package/src/ui/MOUNTING_LEVEL.ts

@@ -1,18 +0,0 @@
-// 39.1, 39.6 — THE ROUTER'S LEVEL BEING MOUNTED, set by the router around a page's or a layout's
-// setup and markup: a component mounted inside one adds its `<head>` to that level's
-// (`contributeHead`), and one mounted later — a row a list grew by — finds none and leaves the
-// document's head alone. `unapplied` is the head the components built on the client contributed
-// while it was set, which the router applies once it is unset rather than once a component.
-export const MOUNTING_LEVEL: {
-    current:
-        | {
-              head: (() => string) | undefined
-              /** Every component head joined to the level's own, in the order they mounted. */
-              contributed: (() => string)[] | undefined
-          }
-        | undefined
-    unapplied: string
-} = {
-    current: undefined,
-    unapplied: '',
-}