@abide/abide 0.123.3 → 0.124.0

package/src/server/answerSocket.ts

@@ -11,32 +11,25 @@
 // subscription its rungs admitted when it opened (18.8) — they run once, in the connection's request.
 
 import { problemOf } from '#shared/Failed.ts'
-import { GLOBAL_GETS } from '#shared/GLOBAL_GETS.ts'
 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 { followServed } from '#shared/reactive/index.ts'
-import { matchesPattern } from '#shared/reactive/matchesPattern.ts'
-import { unowned } from '#shared/reactive/watch.ts'
+import type { BrowserFrame } from '#shared/muxFrames.ts'
+import { isThenable } from '#shared/reactive/isThenable.ts'
 import { refuse } from '#shared/refuse.ts'
-import { rpcRequest } from '#shared/rpcRequest.ts'
 
-import { handlerKey, type Mounted } from './answerRpc.ts'
-import { argsFor } from './argsContract.ts'
 import { positiveSetting } from './config.ts'
-import { closedTo, crossingOrigin, crossingRefusal } from './crossingOrigin.ts'
+import { crossingOrigin } from './crossingOrigin.ts'
+import { type Followers, Frame, type Peer } from './Followers.ts'
 import { failureOf } from './hooks.ts'
+import { admitsFollower, followedArgs } from './invokeHandler.ts'
+import type { FollowedHandler } from './mountHandlers.ts'
 import { sendOrClose } from './muxUpgrade.ts'
 import {
-    heldByApp,
     inOpenScope,
     releaseScope,
     type RequestScope,
     scopeFor,
 } from './requestScope.ts'
-import { EVENT_STREAM_OPENER, streamEvent } from './streamEvent.ts'
-import { patchesSince, versionOf } from './versionOf.ts'
 
 /**
  * The far end of one connection to the mux, which its frames are written to as text.
@@ -49,78 +42,9 @@ export type Socket = {
     close(code: number, reason: string): unknown
 }
 
-const ENCODER = new TextEncoder()
-
 // 18.31 — a page follows each value it reads once, so a thousand is a page no one could read.
 const MAX_SUBSCRIPTIONS = 1024
 
-/**
- * One `ServerFrame`, for every follower it is sent to.
- *
- * 18.6 — ITS BODY IS SERIALIZED ONCE PER VERSION, and each encoding of it once however many
- * followers it reaches: a socket is sent the JSON with its follower's id spliced in, and an event
- * stream the event, which names no follower and is the same text for every stream.
- */
-class Frame {
-    readonly op: ServerFrame['op']
-    readonly base: number | undefined
-    readonly version: number | undefined
-    // The value, the patch's ops or the refusal, as JSON.
-    readonly body: string | undefined
-    // What follows the id in the JSON, and the event's bytes, each written on first use.
-    private tail: string | undefined = undefined
-    private event: Uint8Array | undefined = undefined
-
-    constructor(
-        op: ServerFrame['op'],
-        base: number | undefined,
-        version: number | undefined,
-        body: string | undefined,
-    ) {
-        this.op = op
-        this.base = base
-        this.version = version
-        this.body = body
-    }
-
-    /** As `ServerFrame` JSON for `id`: `base` and `version` where it has them, then the body under its op's member. */
-    json(id: number): string {
-        if (this.tail === undefined) {
-            let tail = ''
-            if (this.base !== undefined) tail += `,"base":${this.base}`
-            if (this.version !== undefined) tail += `,"version":${this.version}`
-            if (this.body !== undefined)
-                tail += `,"${this.op === 'patch' ? 'ops' : this.op}":${this.body}`
-            this.tail = `${tail}}`
-        }
-        return `{"op":"${this.op}","id":${id}${this.tail}`
-    }
-
-    /** As the SSE event 18.20 makes it, encoded: the op its name, the version its id. */
-    asEvent(): Uint8Array {
-        this.event ??= ENCODER.encode(
-            streamEvent(
-                this.op,
-                this.version,
-                this.body ?? (this.op === 'value' ? 'null' : ''),
-            ),
-        )
-        return this.event
-    }
-}
-
-/** A trigger's frame (7.10, 7.18), the same for every follower and every trigger. */
-const TRIGGERS = {
-    invalidate: new Frame('invalidate', undefined, undefined, undefined),
-    refresh: new Frame('refresh', undefined, undefined, undefined),
-}
-
-/** What a frame is written to, under the follower's id: a socket, or an event stream. */
-type Peer = {
-    send(id: number, frame: Frame): void
-    close(code: number, reason: string): unknown
-}
-
 /** A socket's peer: each frame as the `ServerFrame` JSON a browser parses. */
 class SocketPeer implements Peer {
     readonly socket: Socket
@@ -137,114 +61,6 @@ class SocketPeer implements Peer {
 
 const SOCKET_LOG = namedLogger('abide:socket')
 
-// 18.3 — EVERY SUBSCRIPTION TO A HANDLER, by handler, for its triggers to reach (7.10, 7.18).
-// PROCESS-WIDE because a trigger is: `rpc.invalidate({ id })` inside one request reaches every browser
-// holding that key, whichever connection it came over.
-type Follower = {
-    peer: Peer
-    id: number
-    args: unknown
-    // The entry key its args are filed under (`GLOBAL_GETS`), taken once as it subscribes.
-    key: string
-    // The `global` entry its productions are pushed from, which is what a refresh would otherwise
-    // re-fetch — or `undefined`, and it is sent triggers instead.
-    serving: unknown
-    stopFeed: (() => void) | undefined
-    // 18.6 — the version it was last sent, or named on subscribing.
-    sent: number | undefined
-    // 18.8 — whether the handler's rungs let it through when it opened: a guarded `GET` feeds only
-    // a follower they admitted, and sends the rest its triggers alone.
-    admitted: boolean
-}
-type Followed = {
-    // 13.15 — the literal `tags` the build copied onto the browser's copy, for a sweep to match:
-    // the handler's, so one for all of its followers.
-    tags: string[] | undefined
-    // What a trigger walks, matching each follower's args against its pattern.
-    all: Set<Follower>
-    // BY ENTRY KEY, so an entry answered walks the followers of its own args alone (18.8). Filed
-    // apart from `all` rather than instead of it: a walk of every follower through a set per key
-    // measured twice a flat set's.
-    byKey: Map<string, Set<Follower>>
-}
-const FOLLOWERS = new Map<object, Followed>()
-
-// 13.12 — narrowed by the pattern the trigger was handed, as the handler's own entries are.
-export function broadcast(
-    rpc: object,
-    member: 'invalidate' | 'refresh',
-    pattern: unknown,
-): void {
-    const followed = FOLLOWERS.get(rpc)
-    if (followed === undefined) return
-    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 (`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])
-    }
-}
-
-// 13.15 — A SWEEP REACHES EVERY COPY A BROWSER FOLLOWS that carries one of its `tags`, or every copy
-// where it is bare, as that copy's own trigger. A fed copy is skipped for `broadcast`'s reason: the
-// sweep reloaded the entry it is fed from here, and the production that mints is its refresh.
-export function swept(
-    member: 'invalidate' | 'refresh',
-    tags: string[] | null,
-): void {
-    for (const [rpc, followed] of FOLLOWERS) {
-        if (tags !== null && !sharesTag(followed.tags, tags)) continue
-        for (const follower of followed.all) {
-            if (attach(rpc as Mounted['handler'], follower) !== undefined)
-                continue
-            follower.peer.send(follower.id, TRIGGERS[member])
-        }
-    }
-}
-
-function sharesTag(held: string[] | undefined, swept: string[]): boolean {
-    if (held === undefined) return false
-    for (const tag of swept) if (held.includes(tag)) return true
-    return false
-}
-
-// 18.8 — AN ENTRY ANSWERED THAT NOBODY IS FED FROM: one made after a follower subscribed for its
-// args, or rebuilt after the one it was fed from was evicted. An entry already fed is the common
-// answer, and asks nothing more; one that is not reaches the followers filed under its key.
-export function feedFromServed(
-    rpc: object,
-    serving: unknown,
-    key: string,
-): void {
-    if (FEEDS.has(serving as object)) return
-    const followers = FOLLOWERS.get(rpc)?.byKey.get(key)
-    if (followers === undefined) return
-    for (const follower of followers)
-        attach(rpc as Mounted['handler'], follower)
-}
-
-/**
- * Feeds the follower from the entry standing for its args; returns what it is fed from now.
- *
- * Only where that entry is not the one it is fed from already.
- */
-function attach(rpc: Mounted['handler'], follower: Follower): unknown {
-    // 18.8, 18.26 — what its own rungs or its route's refused is sent its triggers alone.
-    const serving = !follower.admitted
-        ? undefined
-        : GLOBAL_GETS.get(rpc)?.at(follower.key)
-    if (serving === follower.serving) return serving
-    follower.stopFeed?.()
-    // A version is one entry's count, so what it was sent of another says nothing about this one.
-    if (follower.serving !== undefined) follower.sent = undefined
-    follower.serving = serving
-    follower.stopFeed =
-        serving === undefined ? undefined : feed(serving, follower)
-    return serving
-}
-
 /** A refusal's frame: the failure `error` is, as Problem Details (15.21). */
 function refusal(error: unknown): Frame {
     return new Frame(
@@ -260,13 +76,21 @@ function refusal(error: unknown): Frame {
  * and what closes them all when the app stops (42.11).
  */
 export class Mux {
-    readonly handlers: Map<string, Mounted>
+    /** The `GET` a browser follows at an address below the mount, or `undefined` (`followedIn`). */
+    readonly followedAt: (address: string) => FollowedHandler | undefined
+    /** Who follows what in the app this mux carries for. 18.3. */
+    readonly followers: Followers
     // 42.12 — the app a frame's scope answers `rpc.raw` and the MCP surface through.
     readonly app: RequestScope['app']
     readonly connections = new Set<MuxConnection>()
 
-    constructor(handlers: Map<string, Mounted>, app: RequestScope['app']) {
-        this.handlers = handlers
+    constructor(
+        followedAt: (address: string) => FollowedHandler | undefined,
+        followers: Followers,
+        app: RequestScope['app'],
+    ) {
+        this.followedAt = followedAt
+        this.followers = followers
         this.app = app
     }
 
@@ -375,11 +199,8 @@ export class MuxConnection {
                 return
             }
         }
-        const handler =
-            frame.op === 'sub'
-                ? this.mux.handlers.get(handlerKey('GET', address))
-                : undefined
-        const followed = handler?.ui ? handler : undefined
+        const followed =
+            frame.op === 'sub' ? this.mux.followedAt(address) : undefined
         if (followed === undefined) {
             this.peer.send(
                 id,
@@ -392,45 +213,23 @@ export class MuxConnection {
             )
             return
         }
-        // 18.2 — ANOTHER ORIGIN IS CLOSED OUT unless the handler declared it: the same gate, and the
-        // same own origin, as its http answer's (16.13, 16.24, 36.2).
-        if (closedTo(followed.handler.crossOrigin, this.crossing)) {
-            this.peer.send(
-                id,
-                refusal(crossingRefusal(this.crossing, 'subscription')),
-            )
-            return
-        }
         // A SUBSCRIPTION IS HELD FROM THE FRAME ON, not from when its rungs let it through: an
         // `unsub` or the connection's close that lands while a rung is pending stops this
         // placeholder, and the rungs resolving to find another in its place install nothing.
         const pending = (): void => {}
         try {
-            // 18.3 — the args a `GET` over http is answered with, sent as JSON.
-            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.
-            // 18.26 — AND THE MIDDLEWARE ITS FILE'S ROUTE FILED, over the request a `GET` of it
-            // would be: one a rung answers in the handler's place is not fed, as an http call it
-            // answered would never reach the handler.
-            const routed = followed.rungs.length > 0
-            let admitted = !followed.handler.guarded && !routed
-            if (!admitted) {
-                subscriptions.get(id)?.()
-                subscriptions.set(id, pending)
-                // No route rungs, no turn: a guarded `GET`'s rungs start in this frame's own run.
-                admitted =
-                    !routed || (await routeAdmits(this.scope, followed, args))
-                if (admitted && followed.handler.guarded)
-                    admitted = await Promise.resolve(
-                        followed.handler(args as never) as PromiseLike<unknown>,
-                    ).then(
-                        () => true,
-                        () => false,
-                    )
-                if (subscriptions.get(id) !== pending) return
-            }
+            // 18.2, 18.3 — the origin gate and the args a `GET` over http is answered with.
+            const args = followedArgs(followed, frame.args, this.crossing)
+            subscriptions.get(id)?.()
+            subscriptions.set(id, pending)
+            // 18.8, 18.26 — run once, in this connection's request.
+            const admits = admitsFollower(
+                followed,
+                args,
+                this.scope.request as Request,
+            )
+            const admitted = isThenable(admits) ? await admits : admits
+            if (subscriptions.get(id) !== pending) return
             follow(this, id, followed, args, frame.version, admitted)
         } catch (thrown) {
             if (subscriptions.get(id) === pending) subscriptions.delete(id)
@@ -439,50 +238,11 @@ export class MuxConnection {
     }
 }
 
-/**
- * Whether the rungs over `mounted`'s route let a `GET` of it with `args` through, asked over the
- * upgrade's own request at the handler's address. 18.26.
- */
-async function routeAdmits(
-    scope: RequestScope,
-    mounted: Mounted,
-    args: unknown,
-): Promise<boolean> {
-    const upgrade = scope.request as Request
-    const asked = rpcRequest(
-        'GET',
-        mounted.address,
-        args as Record<string, unknown> | undefined,
-    )
-    const request = new Request(new URL(asked.url, upgrade.url), {
-        headers: upgrade.headers,
-        signal: upgrade.signal,
-    })
-    // REACHED BY A FLAG, not by the answer's identity: a rung that wraps or re-heads what `next`
-    // answered still let the call through, and a shared answer would carry every rung's headers.
-    let reached = false
-    try {
-        const answered = await compose(mounted.rungs, async () => {
-            reached = true
-            return new Response(null, { status: 204 })
-        })({ request })
-        return reached && answered.ok
-    } catch {
-        return false
-    }
-}
-
-/**
- * Follows a handler for `id`: its triggers always, its value where `global` and unguarded.
- *
- * 18.3, 18.8. STATE, NOT A LOG: nothing is replayed. 18.6 — the value is sent where the version
- * the subscription named is not the one standing, and after that once per change, a burst in one
- * turn going out as the value it left.
- */
+/** Follows `followed` for `id` on the connection, in place of whatever `id` followed. 18.3, 18.32. */
 function follow(
     connection: MuxConnection,
     id: number,
-    mounted: Mounted,
+    followed: FollowedHandler,
     args: unknown,
     held: number | undefined,
     admitted: boolean,
@@ -490,199 +250,17 @@ function follow(
     connection.subscriptions.get(id)?.()
     connection.subscriptions.set(
         id,
-        followWith(connection.peer, id, mounted, args, held, admitted),
+        connection.mux.followers.follow(
+            connection.peer,
+            id,
+            followed,
+            args,
+            held,
+            admitted,
+        ),
     )
 }
 
-/** Follows a handler for `id` on `peer`, however the peer writes; returns what stops it. */
-function followWith(
-    peer: Peer,
-    id: number,
-    mounted: Mounted,
-    args: unknown,
-    held: number | undefined,
-    admitted: boolean,
-): () => void {
-    const rpc = mounted.handler
-    const key = GLOBAL_GETS.get(rpc)?.key(args) ?? ''
-    const follower: Follower = {
-        peer,
-        id,
-        args,
-        key,
-        serving: undefined,
-        stopFeed: undefined,
-        sent: held,
-        admitted,
-    }
-    attach(rpc, follower)
-    let followed = FOLLOWERS.get(rpc)
-    if (followed === undefined) {
-        followed = {
-            tags: mounted.copy?.tags,
-            all: new Set(),
-            byKey: new Map(),
-        }
-        FOLLOWERS.set(rpc, followed)
-    }
-    const byKey = followed.byKey
-    let followers = byKey.get(key)
-    if (followers === undefined) {
-        followers = new Set()
-        byKey.set(key, followers)
-    }
-    followers.add(follower)
-    const all = followed.all
-    all.add(follower)
-    return () => {
-        follower.stopFeed?.()
-        all.delete(follower)
-        // A key nobody follows leaves, or the index grows with every key ever followed.
-        if (followers.delete(follower) && followers.size === 0)
-            byKey.delete(key)
-    }
-}
-
-/**
- * A handler followed as an event stream: the same follow a browser's mux makes, written as SSE.
- *
- * 18.20 — EACH MUX FRAME IS ONE EVENT, field for field: its `op` the event's name, its version the
- * event's `id`, and what it carries the `data` — the value for `value`, the JSON Patch for `patch`,
- * nothing for a trigger. So an `EventSource` reconnecting hands the version back as `Last-Event-ID`,
- * which is `held` here, and is sent nothing until the value moves past it.
- */
-export function followAsEvents(
-    mounted: Mounted,
-    args: unknown,
-    held: number | undefined,
-): ReadableStream<Uint8Array> {
-    let stop = (): void => {}
-    let unhold = (): void => {}
-    let ended = false
-    return new ReadableStream({
-        start(controller) {
-            controller.enqueue(EVENT_STREAM_OPENER)
-            // Ended by the app's stop as any body it holds open is, or that stop waits on it.
-            unhold = heldByApp(() => {
-                if (ended) return
-                ended = true
-                stop()
-                controller.close()
-            })
-            stop = followWith(
-                {
-                    // 18.6 — the event written and encoded once for every stream, from the body
-                    // serialized once for every follower: nothing is parsed back.
-                    send(_id, frame) {
-                        controller.enqueue(frame.asEvent())
-                    },
-                    close() {
-                        if (ended) return
-                        ended = true
-                        unhold()
-                        controller.close()
-                    },
-                },
-                0,
-                mounted,
-                args,
-                held,
-                // The request this stream answers passed the rungs already, or it would not be here.
-                true,
-            )
-        },
-        cancel() {
-            ended = true
-            unhold()
-            stop()
-        },
-    })
-}
-
-// 18.6 — ONE WATCH PER VALUE SERVED, however many follow it, and each frame's body serialized once
-// per version: every follower standing where the others stand is sent the same bytes, with its own
-// id spliced in front.
-type Feed = {
-    fed: Set<Follower>
-    landed: boolean
-    stop: () => void
-}
-const FEEDS = new WeakMap<object, Feed>()
-
-function feed(serving: unknown, fed: Follower): () => void {
-    const shared = FEEDS.get(serving as object) ?? startFeed(serving)
-    shared.fed.add(fed)
-    if (shared.landed) sendAll(serving, [fed])
-    return () => {
-        shared.fed.delete(fed)
-        if (shared.fed.size === 0) shared.stop()
-    }
-}
-
-function startFeed(serving: unknown): Feed {
-    const fed = new Set<Follower>()
-    // 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)
-    })
-    const shared: Feed = {
-        fed,
-        landed: false,
-        stop: () => {
-            stopWatch()
-            release()
-            FEEDS.delete(serving as object)
-        },
-    }
-    FEEDS.set(serving as object, shared)
-    // UNOWNED: the feed is stopped when its last follower leaves, and the request it may have been
-    // started in is answered long before that (12.5).
-    const stopWatch = unowned(() =>
-        (serving as { watch(effect: () => void): () => void }).watch(() => {
-            shared.landed = true
-            sendAll(serving, fed)
-        }),
-    )
-    return shared
-}
-
-function sendAll(serving: unknown, fed: Iterable<Follower>): void {
-    const version = versionOf(serving)
-    let valueFrame: Frame | undefined
-    // ONE FRAME PER VERSION A FOLLOWER STANDS AT, since followers a burst left at different places
-    // along the chain are each sent the writes since their own.
-    let patchFrames: Map<number, Frame> | undefined
-    for (const one of fed) {
-        if (one.sent === version) continue
-        // 18.11 — the writes, where the follower stands on the chain they were written along.
-        const since = one.sent
-        let frame = since === undefined ? undefined : patchFrames?.get(since)
-        if (frame === undefined && since !== undefined) {
-            const ops = patchesSince(serving, since)
-            if (ops !== undefined) {
-                frame = new Frame('patch', since, version, JSON.stringify(ops))
-                patchFrames ??= new Map()
-                patchFrames.set(since, frame)
-            }
-        }
-        if (frame === undefined) {
-            if (valueFrame === undefined) {
-                const held = (serving as { peek(): unknown }).peek()
-                valueFrame = new Frame(
-                    'value',
-                    undefined,
-                    version,
-                    held === undefined ? undefined : JSON.stringify(held),
-                )
-            }
-            frame = valueFrame
-        }
-        one.peer.send(one.id, frame)
-        one.sent = version
-    }
-}
-
 function addressIn(named: string): string {
     const path = URL.parse(named)?.pathname ?? named
     return unmounted(path) ?? path

package/src/server/appKit.ts

@@ -1,4 +1,4 @@
-// THE OBJECTIVE-C RUNTIME, over `bun:ffi` — what the desktop launcher (`runDesktop`) drives AppKit
+// THE OBJECTIVE-C RUNTIME, over `bun:ffi` — what the desktop window (`openDesktopWindow`) drives AppKit
 // and WebKit with. Bun's own `WebView` is headless, so a window and a menu bar are this module's.
 //
 // NO STRUCT IS PASSED BY VALUE. A `CGRect` is four doubles in registers on arm64 and a block on the

package/src/server/argsContract.ts

@@ -23,7 +23,7 @@ import {
 import { refuse } from '#shared/refuse.ts'
 import { validateJson } from '#shared/validateJson.ts'
 
-import type { Mounted } from './answerRpc.ts'
+import type { Mounted } from './mountHandlers.ts'
 
 export type Document = {
     type?: string | string[]

package/src/server/createApp.ts

@@ -18,7 +18,6 @@ import { RPC_SERVER } from '#shared/RPC_SERVER.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 {
     type Builder,
@@ -34,10 +33,12 @@ 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'
@@ -327,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
@@ -336,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 }