@abide/abide 0.123.2 → 0.123.3

package/src/server/claudeCode.ts

@@ -14,24 +14,16 @@ import { refuse } from '#shared/refuse.ts'
 
 import {
     type AssistantContent,
-    type AssistantEvent,
     type AssistantMessage,
     blocksOf,
     forwardOf,
     type Provider,
 } from './assistant.ts'
 import { BRIDGE_VERSION } from './BRIDGE_VERSION.ts'
-import {
-    followSignIn,
-    mintCode,
-    openTurn,
-    pairedBridge,
-    watchPairing,
-} from './bridgeRelay.ts'
+import { mintCode, pairingStatus, runTurn } from './bridgeRelay.ts'
 import { callerOf } from './callerOf.ts'
 import { appOrigin } from './config.ts'
 import { mcpFailure } from './generatedSurfaces.ts'
-import { Inbox } from './Inbox.ts'
 import { signedInAs } from './principal.ts'
 import { request } from './requestScope.ts'
 
@@ -65,53 +57,19 @@ export type BridgeStatus = {
 function claudeCodeProvider(config: ClaudeCodeConfig = {}): Provider {
     return {
         async *run(messages, tools, { maxTurns, signal }) {
-            const bridge = pairedBridge(askingCaller(), signedInAs())
-            // 44.13, 44.33 — nothing paired by this sign-in is the page's cue to show the command.
-            if (bridge === undefined)
-                throw refuse(
-                    409,
-                    'No Claude Code is paired with this browser as the one signed in. claudeCode.bridgeCommand() is the command that pairs one.',
-                )
-            const turn = openTurn(bridge)
-            bridge.frames.push({
-                type: 'turn',
-                id: turn.id,
+            yield* runTurn({
+                caller: askingCaller(),
+                signedIn: signedInAs(),
                 prompt: foldedContent(messages),
                 config,
                 maxTurns,
+                // 44.17 — answered by the app's own MCP surface, through the turn's `Toolbox`.
+                answer: (method, params) =>
+                    forwardOf(tools)(method, params).catch((thrown: unknown) =>
+                        mcpFailure(-32603, String(thrown)),
+                    ),
+                signal,
             })
-            // 44.18 — a caller hanging up ends the run on the bridge.
-            const cancel = (): void => {
-                bridge.frames.push({ type: 'cancel', turn: turn.id })
-            }
-            signal.addEventListener('abort', cancel)
-            try {
-                for await (const item of turn.inbox) {
-                    if (item.kind === 'event')
-                        yield item.event as AssistantEvent
-                    else if (item.kind === 'mcp')
-                        // 44.17 — answered by the app's own MCP surface, through the turn's `Toolbox`.
-                        void forwardOf(tools)(item.method, item.params)
-                            .catch((thrown: unknown) =>
-                                mcpFailure(-32603, String(thrown)),
-                            )
-                            .then((reply) => {
-                                bridge.frames.push({
-                                    type: 'reply',
-                                    turn: turn.id,
-                                    id: item.id,
-                                    reply,
-                                })
-                            })
-                    else if (item.kind === 'end') return
-                    // 44.21.
-                    else
-                        throw refuse(502, `Claude Code failed: ${item.message}`)
-                }
-            } finally {
-                signal.removeEventListener('abort', cancel)
-                turn.close()
-            }
         },
     }
 }
@@ -157,25 +115,25 @@ function askingCaller(): string {
     return caller
 }
 
-/** One pairing code, as the command a visitor runs and the link they open, and when it stops standing. */
-type Pairing = { command: string; link: string; expires: number }
-
 /**
  * The command and the link that pair a bridge with this browser, and when their code stops standing.
  * 44.14. The `tools` it is given are written after the command's `--` and in the link, so the visitor
  * running either grants them (44.29, 44.32, 44.40).
  */
-function bridgeCommand(options: PairingOptions = {}): Pairing {
-    return commandFor(askingCaller(), signedInAs(), options)
+function bridgeCommand(options: PairingOptions = {}): {
+    command: string
+    link: string
+    expires: number
+} {
+    const { code, expires } = mintCode(askingCaller(), signedInAs())
+    return { ...commandFor(code, options), expires }
 }
 
-/** The command and the link pairing a bridge with `caller` signed in as `signedIn` (44.33). */
+/** The command and the link that pair a bridge by `code`, granting `tools`. */
 function commandFor(
-    caller: string,
-    signedIn: string,
+    code: string,
     { tools }: PairingOptions,
-): Pairing {
-    const { code, expires } = mintCode(caller, signedIn)
+): { command: string; link: string } {
     const site = `${appOrigin() ?? new URL(request().url).origin}${mounted('')}`
     const granted = tools?.length ? tools.join(',') : undefined
     const query = new URLSearchParams({ site, code, version: BRIDGE_VERSION })
@@ -184,80 +142,25 @@ function commandFor(
     return {
         command: `bunx @abide/bridge@${BRIDGE_VERSION} ${site} ${code}${grant}`,
         link: `${BRIDGE_SCHEME}://pair?${query}`,
-        expires,
     }
 }
 
 /**
  * This browser's pairing as it changes: unpaired with the command to run and the link to open, then
- * paired the moment a bridge connects, and unpaired again if it goes. 44.20.
- *
- * 44.34 — IT FOLLOWS WHOEVER SIGNS IN AT THE BROWSER, though its own request carries the cookies it
- * opened with: a sign-in or a sign-out made since is the pairing it watches from then on, and the
- * command it offers is that sign-in's.
+ * paired the moment a bridge connects, and unpaired again if it goes — following whoever signs in at
+ * the browser since. 44.20, 44.34.
  */
 async function* bridge(
     options: PairingOptions = {},
 ): AsyncGenerator<BridgeStatus> {
-    let caller = askingCaller()
-    let signedIn = signedInAs()
-    const signal = request().signal
-    // A change landing while the loop was not waiting — paused at its `yield` — stays queued, so it
-    // looks again; a look that finds nothing new yields nothing.
-    const changes = new Inbox<undefined>()
-    const waiting = changes[Symbol.asyncIterator]()
-    const rouse = (): void => changes.push(undefined)
-    let watchingAs = ''
-    let unwatch = (): void => {}
-    let unfollow = (): void => {}
-    const follow = (now: string, next: string): void => {
-        caller = now
-        signedIn = next
-        rouse()
-    }
-    signal.addEventListener('abort', rouse)
-    let pairing: Pairing | undefined
-    let said = ''
-    try {
-        while (!signal.aborted) {
-            const watching = `${caller} ${signedIn}`
-            if (watching !== watchingAs) {
-                unwatch()
-                unfollow()
-                unwatch = watchPairing(caller, signedIn, rouse)
-                unfollow = followSignIn(caller, follow)
-                watchingAs = watching
-                pairing = undefined
-            }
-            const paired = pairedBridge(caller, signedIn) !== undefined
-            if (
-                !paired &&
-                (pairing === undefined || pairing.expires <= Date.now())
-            )
-                pairing = commandFor(caller, signedIn, options)
-            const status: BridgeStatus = {
-                paired,
-                command: paired ? undefined : pairing?.command,
-                link: paired ? undefined : pairing?.link,
-            }
-            // The link is minted with the command, so the command alone tells a new pairing.
-            const saying = `${status.paired} ${status.command}`
-            if (saying !== said) {
-                said = saying
-                yield status
-            }
-            // A code that expires while nothing is paired is replaced with a fresh one.
-            const renew = paired
-                ? undefined
-                : setTimeout(rouse, (pairing?.expires ?? 0) - Date.now())
-            await waiting.next()
-            clearTimeout(renew)
-        }
-    } finally {
-        signal.removeEventListener('abort', rouse)
-        unwatch()
-        unfollow()
-    }
+    for await (const code of pairingStatus(
+        askingCaller(),
+        signedInAs(),
+        request().signal,
+    ))
+        yield code === undefined
+            ? { paired: true, command: undefined, link: undefined }
+            : { paired: false, ...commandFor(code, options) }
 }
 
 /** The visitor's own Claude Code as a provider, with the pairing that reaches it. */

package/src/server/config.ts

@@ -12,8 +12,8 @@ import { reactive } from '#shared/reactive/index.ts'
 import { validationError } from '#shared/refuse.ts'
 import { runSchema } from '#shared/Schema.ts'
 
-import { appDirectories } from './appDirectories.ts'
 import { type Env, HOOKS, inOrder } from './hooks.ts'
+import { packageDirectory } from './packageDirectory.ts'
 import { withoutTrailingSlash } from './withoutTrailingSlash.ts'
 
 /** The fields of an app's `package.json` 27.3 derives from. */
@@ -27,14 +27,13 @@ export type AppPackage = { name?: string; version?: string }
  */
 export const APP_PACKAGE: { current: AppPackage } = { current: {} }
 
-/** The `package.json` beside an app on disk, in the first of `appDirectories` that has one. */
+/** The `package.json` of an app on disk (`packageDirectory`), or nothing where it has none. */
 export function packageUnder(root: string): AppPackage {
-    for (const directory of appDirectories(root)) {
-        try {
-            return require(`${directory}/package.json`) as AppPackage
-        } catch {}
+    try {
+        return require(`${packageDirectory(root)}/package.json`) as AppPackage
+    } catch {
+        return {}
     }
-    return {}
 }
 
 /**

package/src/server/createApp.ts

@@ -16,14 +16,17 @@ 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,
@@ -36,6 +39,7 @@ import { HOOKS, inOrder, reportUnexpected, rootRungs } from './hooks.ts'
 import { IDLE_TIMEOUT_SECONDS } from './IDLE_TIMEOUT_SECONDS.ts'
 import { installServer } from './installServer.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 +54,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 +83,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 +123,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 +136,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 +163,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 +187,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.

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/handlerFileMount.ts

@@ -0,0 +1,40 @@
+import type { Mount } from './answerRpc.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,
@@ -54,7 +54,7 @@ export { type App, createApp } from './createApp.ts'
 export { callsInRender } from './deferredBuilds.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/packageDirectory.ts

@@ -0,0 +1,14 @@
+import { existsSync } from 'node:fs' // bun exposes no sync existence check of its own
+import { dirname } from 'node:path' // bun exposes no path helpers of its own
+
+/**
+ * The package the app under `root` belongs to: `root` where it holds a `package.json`, else the
+ * directory above it.
+ *
+ * `root` is the app's root — `src/` beside its package, or the package itself where it has no
+ * `src`. What is the package's rather than the source's — its `package.json`, its `bunfig.toml`, its
+ * build (38.27) — is found here and nowhere else.
+ */
+export function packageDirectory(root: string): string {
+    return existsSync(`${root}/package.json`) ? root : dirname(root)
+}

package/src/server/preload.ts

@@ -5,8 +5,9 @@
 // one place that runs first. The build is `createApp`'s own under `bun test` (42.16), so a test that
 // boots the app afterwards reuses it rather than building twice.
 
+import { processBuild, servedBuild, spawnedBuild } from './appBuild.ts'
 import { addDerived } from './config.ts'
-import { appRoot, servedBuild } from './createApp.ts'
+import { appRoot } from './createApp.ts'
 
 // 38.120 — a sign-in seals under test where the app declared no secret: derived, so the app's
 // `onConfig` default and the env both still win (27.2), where an env value would beat the default.
@@ -17,7 +18,7 @@ const root = appRoot(undefined)
 // packages' `.abide` files are each their own app's rather than one app laid out across them.
 // Fresh whatever `NODE_ENV` says: `bun test` sets it only where nothing else has.
 if (root !== undefined && !(await isWorkspaceRoot(root)))
-    await servedBuild(root, true)
+    await servedBuild(root, await processBuild(root, true), spawnedBuild)
 
 async function isWorkspaceRoot(directory: string): Promise<boolean> {
     const manifest = Bun.file(`${directory}/package.json`)

package/src/server/principal.ts

@@ -19,11 +19,11 @@ import { refuse } from '#shared/refuse.ts'
 import { declare } from '#shared/rpc.ts'
 
 import { mountedOwn } from './answerRpc.ts'
-import { signedInAt } from './bridgeRelay.ts'
 import { callerOf, callerOrMint, mintCaller } from './callerOf.ts'
 import { config, positiveSetting } from './config.ts'
 import { HOOKS, inOrder } from './hooks.ts'
 import { type RequestScope, type Sealed, within } from './requestScope.ts'
+import { signInChanged } from './signInChanged.ts'
 
 // 26.18.
 const PRINCIPAL_COOKIE = 'abide-principal'
@@ -268,7 +268,7 @@ async function set(claims: Record<string, unknown>): Promise<void> {
     // 44.34 — a status stream opened before this sign-in follows it.
     const caller = callerOf()
     if (caller !== undefined)
-        signedInAt(caller, caller, identityOf(scope.opened))
+        signInChanged(caller, caller, identityOf(scope.opened))
     principalMembers().document.set(await resolved)
     PRINCIPAL_LOG.debug('set')
 }
@@ -288,7 +288,8 @@ function clear(): void {
     scope.principal = Promise.resolve(ANONYMOUS)
     scope.opened = null
     // 44.34 — and one opened before this sign-out follows it to the caller it rotated to.
-    if (signedOut !== undefined) signedInAt(signedOut, minted, identityOf(null))
+    if (signedOut !== undefined)
+        signInChanged(signedOut, minted, identityOf(null))
     principalMembers().document.set(ANONYMOUS)
     principalMembers().caller.set(minted)
     PRINCIPAL_LOG.debug('clear')

package/src/server/remote.ts

@@ -7,7 +7,7 @@ import { applyPatch } from '#shared/applyPatch.ts'
 import { eventsOf } from '#shared/framing.ts'
 import { HandlerRoute } from '#shared/HandlerRoute.ts'
 import { firstMatch, partsOf } from '#shared/matchRoute.ts'
-import type { PatchOp } from '#shared/reactive/PATCH_SINKS.ts'
+import type { PatchOp } from '#shared/reactive/patchLog.ts'
 import { rankRoutes } from '#shared/routePattern.ts'
 import type { Method } from '#shared/rpc.ts'
 import { argsInURL, rpcRequest } from '#shared/rpcRequest.ts'

package/src/server/runCompiled.ts

@@ -4,7 +4,7 @@
 
 import { type Host, runCommands } from './commands.ts'
 import { type AppHandle, type AppOrigin, bootApp } from './createApp.ts'
-import { type BuildParts, builtSources } from './serveBuild.ts'
+import { type BuildParts, builtSources } from './servedApp.ts'
 
 export async function runCompiled(
     origin: AppOrigin,

package/src/server/runDesktop.ts

@@ -36,7 +36,7 @@ import { randomToken } from './randomToken.ts'
 import { type Component, renderDocument } from './render.ts'
 import { LISTENING } from './requestScope.ts'
 import { runCompiled } from './runCompiled.ts'
-import { type BuildParts, builtSources } from './serveBuild.ts'
+import { type BuildParts, builtSources } from './servedApp.ts'
 
 /** What the launcher did last, and what its forms held, kept across launches. 38.73. */
 type Remembered = {

package/src/server/seedBuffer.ts

@@ -23,7 +23,7 @@
 // refresh, and says nothing.
 
 import { namedLogger } from '#shared/log.ts'
-import { canonicalKey } from '#shared/reactive/canonicalKey.ts'
+import { canonicalKey } from '#shared/reactive/argsContract.ts'
 import {
     chunksOfStream,
     isReactive,