@abide/abide 0.46.0 → 0.47.0

package/src/lib/ui/watch.ts

@@ -0,0 +1,140 @@
+import { cache } from '../shared/cache.ts'
+import { REMOTE_FUNCTION } from '../shared/REMOTE_FUNCTION.ts'
+import type { CacheOnContext } from '../shared/types/CacheOnContext.ts'
+import type { RemoteFunction } from '../shared/types/RemoteFunction.ts'
+import type { Subscribable } from '../shared/types/Subscribable.ts'
+import { effect } from './effect.ts'
+import { generationGuard } from './runtime/generationGuard.ts'
+import type { EffectResult } from './runtime/types/EffectResult.ts'
+import type { State } from './runtime/types/State.ts'
+
+/*
+The single reaction primitive: `watch(source, handler)` names its trigger and runs
+`handler` with the source's new value whenever it changes. It unifies three
+previously-separate things — the author `effect`, `socket.on`, and `cache.on` —
+and it is also the compiler's binding primitive (emitted as `$$watch(thunk)` for
+`{expr}` / `class:` / `bind:*`). Client-only: SSR-inert here and stripped by the
+compiler. Returns a scope-tied disposer.
+
+Instance sugar mirrors the global for the two subscribable/rpc sources (the other
+sources have no instance home): `socket.watch(handler)` ≡ `watch(socket, handler)`, and
+`getUser.watch(handler)` / `getUser.watch(args, handler)` ≡ `watch(getUser, …)`. The
+method is client-attached (socketProxy / remoteProxy) so this ui primitive never rides
+into a server bundle; server-side it is an inert no-op. Unlike bare `watch(…)` — which
+the SSR back-end strips — a `.watch(…)` member call survives to the server and relies on
+that inert stub.
+
+Sources (discriminated at runtime, monomorphic per branch):
+  watch(thunk)                       // compiler binding form — auto-tracked, == effect(thunk)
+  watch(count, n => …)               // a state cell → handler(newValue)
+  watch([a, b], vals => …)           // multiple cells → fires on any change
+  watch(socket, frame => …)          // a subscribable → handler per frame (cache.on loop)
+  watch(getUser, user => …)          // an rpc → runs the smart read, handler(resolved value)
+  watch(getUser, args, user => …)    // an rpc with args
+*/
+// @documentation reactive-state
+export function watch(thunk: () => EffectResult): () => void
+export function watch<T>(source: State<T>, handler: (value: T) => void): () => void
+export function watch(
+    sources: ReadonlyArray<State<unknown>>,
+    handler: (values: unknown[]) => void,
+): () => void
+export function watch<Frame>(
+    source: Subscribable<Frame>,
+    handler: (frame: Frame, context: CacheOnContext) => void | Promise<void>,
+): () => void
+export function watch<Args, Return>(
+    fn: RemoteFunction<Args, Return>,
+    handler: (value: Return) => void,
+): () => void
+export function watch<Args, Return>(
+    fn: RemoteFunction<Args, Return>,
+    args: Args,
+    handler: (value: Return) => void,
+): () => void
+export function watch(
+    source: unknown,
+    argsOrHandler?: unknown,
+    maybeHandler?: unknown,
+): () => void {
+    /* Client lifecycle, exactly like the effect it wraps: no runtime window guard (that would
+       also silence the compiler's generated bindings, which build on the client where the test
+       DOM sets no global `window`). SSR-safety comes from the compiler stripping author
+       `watch(...)` calls, and the subscribable branch's own server guard (cache.on). */
+    /* Compiler binding form watch(thunk): a bare auto-tracked effect (== today's $$effect). */
+    if (argsOrHandler === undefined) {
+        return effect(source as () => EffectResult)
+    }
+    /* watch(fn, args, handler): an rpc selector with explicit args. */
+    if (maybeHandler !== undefined) {
+        return reactToRpc(source, argsOrHandler, maybeHandler as (value: unknown) => void)
+    }
+    const handler = argsOrHandler as (value: unknown, context?: CacheOnContext) => void
+    /* A subscribable (socket / stream): per-frame delivery with reconnect-replay — the
+       existing cache.on loop is the single implementation this branch delegates to. */
+    if (isSubscribable(source)) {
+        return cache.on(
+            source as Subscribable<unknown>,
+            handler as (frame: unknown, context: CacheOnContext) => void | Promise<void>,
+        )
+    }
+    /* An rpc without args → run the smart read reactively, pipe its value to the handler. A
+       RemoteFunction is a callable, so accept `function` too — a state cell is a branded-free
+       object and never matches, and a streaming rpc was already caught by isSubscribable above. */
+    if (
+        source !== null &&
+        (typeof source === 'object' || typeof source === 'function') &&
+        REMOTE_FUNCTION in source
+    ) {
+        return reactToRpc(source, undefined, handler)
+    }
+    /* Multiple cells → fire on any change; hand the handler the current values. */
+    if (Array.isArray(source)) {
+        const cells = source as ReadonlyArray<State<unknown>>
+        return effect(() => {
+            const values = cells.map((cell) => cell.value)
+            handler(values)
+        })
+    }
+    /* A single state cell → handler(newValue) on change. */
+    const cell = source as State<unknown>
+    return effect(() => {
+        handler(cell.value)
+    })
+}
+
+/* True for a socket / rpc stream — anything async-iterable. */
+function isSubscribable(source: unknown): boolean {
+    return (
+        source !== null &&
+        (typeof source === 'object' || typeof source === 'function') &&
+        typeof (source as { [Symbol.asyncIterator]?: unknown })[Symbol.asyncIterator] === 'function'
+    )
+}
+
+/*
+Reacts to an rpc's cached value: an effect that runs the smart read (subscribing
+its key synchronously, so the effect re-runs when the value changes — a refresh,
+a patch, an invalidate) and pipes the resolved value to the handler. Triggers the
+read, unlike peek: `watch` observes a live query, so it keeps it flowing.
+*/
+function reactToRpc(fn: unknown, args: unknown, handler: (value: unknown) => void): () => void {
+    const call = fn as (args: unknown) => Promise<unknown>
+    /* The bare call routes through cache.read (cache-managed flight, not scope-abortable), so
+       a slow flight can settle AFTER a faster re-run's flight OR after the owner tears down.
+       Guard the handler on the generation so only the current flight's value lands and a
+       post-teardown settle is dropped — a re-run renews, teardown bumps (both via the shared
+       generationGuard). */
+    const guard = generationGuard()
+    return effect(() => {
+        const generation = guard.renew()
+        void Promise.resolve(call(args)).then(
+            (value) => {
+                if (guard.live(generation)) {
+                    handler(value)
+                }
+            },
+            () => undefined,
+        )
+    })
+}

package/src/serverEntry.ts

@@ -29,12 +29,12 @@ import { loadEnvFromBinaryDir } from './lib/cli/loadEnvFromBinaryDir.ts'
 import { createServer } from './lib/server/runtime/createServer.ts'
 import { requestContext } from './lib/server/runtime/requestContext.ts'
 import { resolvePageSnapshot } from './lib/server/runtime/resolvePageSnapshot.ts'
+import { cacheStoreSlot } from './lib/shared/cacheStoreSlot.ts'
 import { createCacheStore } from './lib/shared/createCacheStore.ts'
+import { globalCacheStoreSlot } from './lib/shared/globalCacheStoreSlot.ts'
 import { loadEnvFromDataDir } from './lib/shared/loadEnvFromDataDir.ts'
+import { pageSlot } from './lib/shared/pageSlot.ts'
 import { runningAsStandaloneBinary } from './lib/shared/runningAsStandaloneBinary.ts'
-import { setCacheStoreResolver } from './lib/shared/setCacheStoreResolver.ts'
-import { setGlobalCacheStoreResolver } from './lib/shared/setGlobalCacheStoreResolver.ts'
-import { setPageResolver } from './lib/shared/setPageResolver.ts'
 
 /*
 Resolve config into process.env before anything reads it (createServer reads
@@ -65,16 +65,16 @@ await import('./_virtual/config.ts')
 // In a bundle, tie this server's life to the launcher's (no-op standalone).
 exitWithParent()
 
-setCacheStoreResolver(() => requestContext.getStore()?.cache)
+cacheStoreSlot.resolver = () => requestContext.getStore()?.cache
 
-setPageResolver(resolvePageSnapshot)
+pageSlot.resolver = resolvePageSnapshot
 
 /*
 Process-level store for cache(fn, { global: true }) — one per server process,
 outlives every request so memoised external calls are shared across them.
 */
 const globalCacheStore = createCacheStore()
-setGlobalCacheStoreResolver(() => globalCacheStore)
+globalCacheStoreSlot.resolver = () => globalCacheStore
 
 await createServer({
     pages,

package/template/CLAUDE.md

@@ -14,7 +14,7 @@ at `node_modules/@abide/abide/README.md`.
 ## Conventions (see AGENTS.md for the full list)
 
 - One export per file, named after the file. No barrels — import each name by its
-  own path (`@abide/abide/server/GET`, `@abide/abide/shared/cache`, …).
+  own path (`@abide/abide/server/GET`, `@abide/abide/shared/refresh`, …).
 - RPCs live in `src/server/rpc/<name>.ts`; sockets in `src/server/sockets/`;
   pages are `**/page.abide`, layouts `**/layout.abide`.
 - Generated types land in `src/.abide/` — do not hand-edit them; run `abide dev`/

package/template/package.json

@@ -13,7 +13,7 @@
         "test": "bun test"
     },
     "dependencies": {
-        "@abide/abide": "^0.27.0"
+        "@abide/abide": "^0.46.0"
     },
     "devDependencies": {
         "@types/bun": "^1.3.14"

package/template/src/server/rpc/getHello.ts

@@ -25,9 +25,9 @@ dedupe). Other helpers are siblings, one per file: `abide/server/error`,
 `abide/server/redirect`, `abide/server/sse`, `abide/server/jsonl`.
 
 Every rpc value also exposes `.raw(args?)` (returns the underlying
-`Response`) and `.stream(args?)` (returns a `Subscribable` over the frames —
-feed it to `tail()`) for callers that need headers/status or want to iterate
-jsonl/sse frames.
+`Response`) for callers that need headers or status. A streaming rpc — a
+jsonl/sse handler — returns a `Subscribable` over the frames from its bare
+call (`fn(args)`); iterate it with `for await` or react to it with `watch(fn(args), frame => …)`.
 */
 
 import { GET } from '@abide/abide/server/GET'

package/template/src/ui/pages/page.abide

@@ -5,15 +5,15 @@ page.abide mounts at that folder's URL; the root layout.abide wraps it.
 
 The blocking await-block below (the `then` clause sits in the `{#await}` head)
 resolves on the server during SSR and renders inline — no pending placeholder. The
+bare rpc call IS the smart read: cached, coalesced, and reactive by default. The
 decoded body is captured into the per-request cache, serialized into the HTML, and
 replayed on the client during hydration with no second fetch. A `{:then}` *branch*
 instead would stream the resolution in out of order.
 */
-import { cache } from '@abide/abide/shared/cache'
 import { getHello } from '$server/rpc/getHello.ts'
 </script>
 
-{#await cache(getHello)() then hello}
+{#await getHello() then hello}
     <h1>{hello.message}</h1>
 {/await}
 <p>Edit <code>src/ui/pages/page.abide</code> and the page hot-reloads.</p>

package/template/test/app.test.ts

@@ -5,7 +5,7 @@ same wiring as `abide start`, no fixtures) and hands back the whole surface:
   app.fetch(path)        — pages and raw HTTP, origin + mount base resolved
   app.rpc.<name>(args)   — RPCs over the real pipeline (CSRF, cookies, base),
                            typed and decoded; .raw(args) for the Response
-  app.sockets.<name>     — a live Socket: iterate it, .tail(n), .publish(m)
+  app.sockets.<name>     — a live Socket: iterate it (for await), .peek(), .broadcast(m)
   app.health()           — the /__abide/health payload
 
 `app.rpc` / `app.sockets` are typed from your own RPCs and sockets — generated

package/src/lib/server/reachable.ts

@@ -1,45 +0,0 @@
-import { parseBoundedEnvInt } from '../shared/parseBoundedEnvInt.ts'
-import { createReachable } from './runtime/createReachable.ts'
-
-/*
-Server-only outbound reachability for an external host. `await reachable(host)`
-HEADs the host's origin: the first call awaits a real probe (faithful — a down
-host costs the full timeout, an up host one handshake) and starts a background
-poll that re-probes every TTL, so every later call resolves instantly off the
-warm value, fresh within one TTL. A down host going down is caught within
-~failureLimit polls; recovery flips it back automatically.
-
-  if (!(await reachable('api.example.com'))) return error(503)
-
-A bare host defaults to https; pass an explicit http://… for a non-TLS host.
-Answers "can I connect to this host," NOT "is my endpoint healthy": any
-completed HTTP response (even 4xx/5xx, even a 405 to HEAD) counts as reachable;
-only a connection failure or timeout reads as unreachable. There is no ambient
-server-side connectivity signal, so this is the honest way to fail a doomed
-outbound call fast — see online() for the inbound/client-reported counterpart.
-
-ABIDE_REACHABLE_TTL (poll cadence / freshness, ms) and ABIDE_REACHABLE_TIMEOUT
-(per-HEAD bound, ms) tune the defaults; the timeout is deliberately generous so
-a healthy-but-distant host over a slow link is not mis-read as down.
-*/
-const TTL_MS = parseBoundedEnvInt(process.env.ABIDE_REACHABLE_TTL, 1_000, 600_000) ?? 30_000
-const TIMEOUT_MS = parseBoundedEnvInt(process.env.ABIDE_REACHABLE_TIMEOUT, 100, 60_000) ?? 3_000
-/* Stop polling a host nobody has read in a few TTLs; the next read restarts it cold. */
-const IDLE_MS = TTL_MS * 3
-
-/* Status-agnostic HEAD: a completed response proves connectivity; reject/timeout does not. */
-async function probeOrigin(origin: string): Promise<boolean> {
-    try {
-        await fetch(origin, { method: 'HEAD', signal: AbortSignal.timeout(TIMEOUT_MS) })
-        return true
-    } catch {
-        return false
-    }
-}
-
-// @documentation observability
-export const reachable = createReachable({
-    probe: probeOrigin,
-    intervalMs: TTL_MS,
-    idleMs: IDLE_MS,
-}).reachable

package/src/lib/server/sockets/types/Socket.ts

@@ -1,23 +0,0 @@
-import type { ClientFlags } from '../../../shared/types/ClientFlags.ts'
-import type { TailHooks } from '../../../shared/types/TailHooks.ts'
-
-/*
-Bidirectional named broadcast primitive. Declared once with `socket<T>()`
-inside a file under `src/server/sockets/`; the same import resolves to a server-side
-fan-out and a client-side ws proxy by build target. Iterating the socket
-is the live stream — no replay. `.tail(count)` opens a subscription seeded
-with the last `count` frames of the retained tail (declared via
-`{ tail: n }`; no-arg = the whole retained tail) before going live — the
-optional Subscribable retention capability the reactive `tail()` consumer
-seeds from. `publish` is isomorphic: server code publishes in-process
-and fans out to remote subscribers; client code sends a `pub` frame the
-dispatcher validates against the topic's `clientPublish` flag. `clients`
-exposes which adapter surfaces (browser / mcp / cli) advertise this
-socket.
-*/
-export interface Socket<T> extends AsyncIterable<T> {
-    readonly name: string
-    readonly clients: ClientFlags
-    publish(message: T): void
-    tail(count?: number, hooks?: TailHooks): AsyncIterable<T>
-}

package/src/lib/shared/CACHE_WRAPPED.ts

@@ -1,9 +0,0 @@
-/*
-Brand on the invoker cache() returns; its property value is the wrapped fn,
-so inspection shows what a wrapper wraps. Detection is certain (set by us,
-never heuristic), which is why misuse throws instead of warning: a wrapper
-used as a selector matches nothing (no url/method, no producer id), and
-without detection a re-wrapped wrapper would silently downgrade a remote to
-an anonymous producer (no url/method, no shared key, no SSR snapshot).
-*/
-export const CACHE_WRAPPED: unique symbol = Symbol('abide.cacheWrapped')

package/src/lib/shared/DEFER_MIN_ARRAY_LENGTH.ts

@@ -1,14 +0,0 @@
-/*
-The array-length above which a blocking `{#await cache()}` value is worth deferring (shipped
-inert, materialized on idle) rather than inlined and hydrated eagerly at boot. Deferral trades
-a live boot for a cheaper one; below this many rows the boot decode is cheap enough that the
-trade doesn't pay, so the block stays eager — fully interactive from the first frame, no wake
-needed. Only genuinely large grids cross it and take the inert-then-idle-wake path.
-
-An O(1) `.length` heuristic (measured on the resolved value, before serialization): array-shaped
-cache reads — lists, grids, tables — are the payloads big enough to matter, and the ones the
-inert path was built for. Non-array values never defer. A deliberately generous default: with
-idle-wake, a deferred block is interactive anyway (live before a human acts), so this is a
-boot-performance knob, not a correctness one — set high so eager-and-simple is the common case.
-*/
-export const DEFER_MIN_ARRAY_LENGTH = 500

package/src/lib/shared/baseResolver.ts

@@ -1,10 +0,0 @@
-import { createResolverSlot } from './createResolverSlot.ts'
-
-/*
-The mount-base slot/resolver/reader bundle. The server entry installs an
-APP_URL-derived resolver at boot; the client entry one reading
-window.__SSR__.base. No lazy fallback creator — `fallback` is a plain string set
-directly by isolated tests, and basePath() supplies the '' default. baseSlot /
-basePath re-export the slot and reader; setBaseResolver the setter.
-*/
-export const baseResolver = createResolverSlot<string>()

package/src/lib/shared/cacheKeyOf.ts

@@ -1,7 +0,0 @@
-import { cacheKeyStore } from './cacheKeyStore.ts'
-
-/* The store key behind a cache() read's promise, or undefined if it carries none
-   (a producer read, a raw Response read, or a non-cache promise). */
-export function cacheKeyOf(promise: Promise<unknown>): string | undefined {
-    return cacheKeyStore.get(promise)
-}

package/src/lib/shared/cacheKeyStore.ts

@@ -1,8 +0,0 @@
-/*
-WeakMap recording the cache key behind a `cache()` read's returned promise, so a
-consumer holding only the promise can recover its key. Mirrors remoteMetaStore (which
-records the synthesized Request the same way). The SSR resume path uses it to decide
-whether a `{#await cache()}` value is a large cache-backed read it can defer — shipping a
-`{ defer, key }` marker instead of the value. Collected with the promise.
-*/
-export const cacheKeyStore = new WeakMap<Promise<unknown>, string>()

package/src/lib/shared/cacheStoreResolver.ts

@@ -1,12 +0,0 @@
-import { createCacheStore } from './createCacheStore.ts'
-import { createResolverSlot } from './createResolverSlot.ts'
-import type { CacheStore } from './types/CacheStore.ts'
-
-/*
-The active-CacheStore slot/resolver/reader bundle. The server entry installs an
-ALS-backed resolver (request-scoped); the client entry a module-singleton one.
-With no resolver registered, a single fallback store is created lazily so
-isolated tests work without booting the runtime. cacheStoreSlot / activeCacheStore
-re-export the slot and reader; setCacheStoreResolver the setter.
-*/
-export const cacheStoreResolver = createResolverSlot<CacheStore>(createCacheStore)

package/src/lib/shared/globalCacheStoreResolver.ts

@@ -1,12 +0,0 @@
-import { createResolverSlot } from './createResolverSlot.ts'
-import type { CacheStore } from './types/CacheStore.ts'
-
-/*
-Slot + setter for the process-level cache store resolver used by cache() entries
-opting into `global: true`. The server entry registers a module-singleton store
-outliving any one request; the client entry points it at its single tab store so
-`global` is a no-op there. No fallback creator — when unset, globalCacheStore()
-falls through to the active store rather than minting an isolated one.
-globalCacheStoreSlot / setGlobalCacheStoreResolver re-export the slot and setter.
-*/
-export const globalCacheStoreResolver = createResolverSlot<CacheStore>()

package/src/lib/shared/pageResolver.ts

@@ -1,16 +0,0 @@
-import { createResolverSlot } from './createResolverSlot.ts'
-import type { PageSnapshot } from './types/PageSnapshot.ts'
-
-/*
-The active-page slot/resolver/reader bundle. The server entry installs an
-ALS-backed resolver (request-scoped, so concurrent and streaming renders never
-share state); the client entry a module-singleton one. With no resolver
-registered, a single empty snapshot is created lazily so isolated tests work.
-pageSlot / activePage re-export the slot and reader; setPageResolver the setter.
-*/
-export const pageResolver = createResolverSlot<PageSnapshot>(() => ({
-    route: '',
-    params: {},
-    url: new URL('http://localhost/'),
-    navigating: false,
-}))

package/src/lib/shared/recordCacheKey.ts

@@ -1,6 +0,0 @@
-import { cacheKeyStore } from './cacheKeyStore.ts'
-
-/* Tags a cache() read's returned promise with its store key (see cacheKeyStore). */
-export function recordCacheKey(promise: Promise<unknown>, key: string): void {
-    cacheKeyStore.set(promise, key)
-}

package/src/lib/shared/requestScopeResolver.ts

@@ -1,12 +0,0 @@
-import { createResolverSlot } from './createResolverSlot.ts'
-import type { RequestScopeInfo } from './types/RequestScopeInfo.ts'
-
-/*
-Slot + setter for the request-scope resolver. The server installs an ALS-backed
-resolver (createServer, reading the RequestStore); the client a module-singleton
-seeded from __SSR__ (startClient). No fallback creator — an unset resolver (or one
-returning undefined outside any request) means "no scope": callers read
-`.resolver?.()` and treat undefined as absent. requestScopeSlot /
-setRequestScopeResolver re-export the slot and setter.
-*/
-export const requestScopeResolver = createResolverSlot<RequestScopeInfo>()

package/src/lib/shared/setBaseResolver.ts

@@ -1,4 +0,0 @@
-import { baseResolver } from './baseResolver.ts'
-
-// Registers the runtime's mount-base resolver. Called once per side at boot.
-export const setBaseResolver = baseResolver.set

package/src/lib/shared/setCacheStoreResolver.ts

@@ -1,4 +0,0 @@
-import { cacheStoreResolver } from './cacheStoreResolver.ts'
-
-// Registers the runtime's active-CacheStore resolver. Called once per side at boot.
-export const setCacheStoreResolver = cacheStoreResolver.set

package/src/lib/shared/setGlobalCacheStoreResolver.ts

@@ -1,4 +0,0 @@
-import { globalCacheStoreResolver } from './globalCacheStoreResolver.ts'
-
-// Registers the process-level cache store resolver. Called once per side at boot.
-export const setGlobalCacheStoreResolver = globalCacheStoreResolver.set

package/src/lib/shared/setPageResolver.ts

@@ -1,4 +0,0 @@
-import { pageResolver } from './pageResolver.ts'
-
-// Registers the runtime's page resolver. Called once per side at boot.
-export const setPageResolver = pageResolver.set

package/src/lib/shared/setRequestScopeResolver.ts

@@ -1,4 +0,0 @@
-import { requestScopeResolver } from './requestScopeResolver.ts'
-
-// Registers the runtime's request-scope resolver. Called once per side at boot.
-export const setRequestScopeResolver = requestScopeResolver.set

package/src/lib/shared/toBunRoutePattern.ts

@@ -1,28 +0,0 @@
-import { parseRouteSegments } from './parseRouteSegments.ts'
-
-/*
-Translates a abide route URL (`/media/[id]/[...rest]`) into the pattern Bun
-needs (`/media/:id/*`) for `Bun.serve({ routes })`. Returns the catch-all
-segment's original name alongside so the server can rename Bun's `*` param
-back to that name on the way out, keeping page-prop destructuring consistent
-with the route file path.
-*/
-export function toBunRoutePattern(routeUrl: string): {
-    pattern: string
-    catchAllName: string | undefined
-} {
-    let catchAllName: string | undefined
-    const pattern = parseRouteSegments(routeUrl)
-        .map((segment) => {
-            if (segment.kind === 'literal') {
-                return segment.value
-            }
-            if (segment.catchAll) {
-                catchAllName = segment.name
-                return '*'
-            }
-            return `:${segment.name}`
-        })
-        .join('/')
-    return { pattern, catchAllName }
-}

package/src/lib/shared/types/TailOptions.ts

@@ -1,10 +0,0 @@
-/*
-Window form of `tail()`: `last` is the rolling window size — the reader holds
-the last ≤`last` frames, however they arrived. A source that retains a tail
-(a socket declared with `{ tail: n }`) seeds the window by replaying up to
-`last` retained frames; a source with no retention (an rpc stream, an
-undeclared socket) fills it from live frames only. Integer ≥ 1.
-*/
-export interface TailOptions {
-    readonly last: number
-}

package/src/lib/ui/deferResume.ts

@@ -1,36 +0,0 @@
-import { activeCacheStore } from '../shared/activeCacheStore.ts'
-import { cacheKeyOf } from '../shared/cacheKeyOf.ts'
-import { DEFER_MIN_ARRAY_LENGTH } from '../shared/DEFER_MIN_ARRAY_LENGTH.ts'
-import { snapshotShippable } from '../shared/snapshotShippable.ts'
-import type { DeferMarker, ResumeEntry } from './runtime/RESUME.ts'
-
-/*
-The resume-manifest entry for a blocking `{#await expr then value}`. When the awaited value
-is a shippable cache-backed read, DEFER it: flag the store entry so its SSR snapshot seeds
-lazily (the body is decoded on first read, not at hydration) and return a `{ defer, key }`
-marker in place of the value. Hydration then adopts the server branch inert and decodes
-neither copy — the blocking form's contract: "render it on the server, keep the page, refetch
-only when I read or invalidate it." A non-cache value (a plain promise, a computation) or a
-cache read whose entry can't ship inlines its value as before. Server-only in practice — the
-client codegen never calls it. */
-// @documentation plumbing
-export function deferResume(promise: unknown, value: unknown): ResumeEntry | DeferMarker {
-    const isPromise =
-        promise !== null && typeof (promise as { then?: unknown })?.then === 'function'
-    const key = isPromise ? cacheKeyOf(promise as Promise<unknown>) : undefined
-    if (key === undefined) {
-        return { ok: true, value }
-    }
-    const entry = activeCacheStore().entries.get(key)
-    if (entry === undefined || !snapshotShippable(entry)) {
-        return { ok: true, value }
-    }
-    /* Only defer a genuinely large grid: below the threshold, inline the value and hydrate
-       eagerly — the block is interactive from the first frame, no inert phase, no wake. This is
-       what keeps a modest searchable list live instead of frozen-until-idle (the reported gap). */
-    if (!Array.isArray(value) || value.length < DEFER_MIN_ARRAY_LENGTH) {
-        return { ok: true, value }
-    }
-    entry.deferred = true
-    return { defer: true, key }
-}

package/src/lib/ui/dom/firstElementBetween.ts

@@ -1,14 +0,0 @@
-import { isElement } from './isElement.ts'
-
-/* The first Element in the sibling run `[start, end)` — the node a visible-wake observes for a
-   deferred region (await branch or component island). Undefined when the run holds no element
-   (text/comment only), so the caller falls back to an idle wake. Element detection is
-   method-based (`isElement`), not `nodeType`, so the walk runs under the test mini-dom too. */
-export function firstElementBetween(start: Node | null, end: Node | null): Element | undefined {
-    for (let node = start; node !== null && node !== end; node = node.nextSibling) {
-        if (isElement(node)) {
-            return node
-        }
-    }
-    return undefined
-}