@abide/abide 0.44.1 → 0.45.0

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

@@ -1,6 +1,6 @@
 import { effect } from '../effect.ts'
 import { claimChild } from '../runtime/claimChild.ts'
-import { OWNER } from '../runtime/OWNER.ts'
+import { generationGuard } from '../runtime/generationGuard.ts'
 import { RENDER } from '../runtime/RENDER.ts'
 import { scopeGroup } from '../runtime/scopeGroup.ts'
 import type { State } from '../runtime/types/State.ts'
@@ -74,12 +74,16 @@ export function eachAsync<T>(
         }
     }
 
-    /* Bumped each run so a superseded drain stops appending and pruning. */
-    let generation = 0
     let iterator: AsyncIterator<T> | undefined
+    /* Bumped each run so a superseded drain stops appending and pruning, and on owner teardown
+       — which also `return()`s the live iterator to release the source (rows and the error
+       branch are disposed by the group, whose scopes were tracked). */
+    const guard = generationGuard(() => {
+        iterator?.return?.(undefined)?.catch(() => undefined)
+        iterator = undefined
+    })
     effect(() => {
-        generation += 1
-        const generationAtStart = generation
+        const generationAtStart = guard.renew()
         iterator?.return?.(undefined)?.catch(() => undefined) // close the superseded run's iterator before re-streaming
         iterator = undefined
         clearError() // a fresh run drops a prior error branch
@@ -92,7 +96,7 @@ export function eachAsync<T>(
             while (true) {
                 const result = await active.next()
                 /* A re-run or teardown bumped the generation while we awaited. */
-                if (generationAtStart !== generation) {
+                if (!guard.live(generationAtStart)) {
                     return
                 }
                 if (result.done === true) {
@@ -126,7 +130,7 @@ export function eachAsync<T>(
             }
         }
         drain().catch((error: unknown) => {
-            if (generationAtStart !== generation) {
+            if (!guard.live(generationAtStart)) {
                 return
             }
             /* No catch branch → surface the rejection (mirrors `<template await>`). */
@@ -137,15 +141,4 @@ export function eachAsync<T>(
             errorRange = insertRange((host) => renderCatch(host, error))
         })
     })
-
-    /* Stop the live stream when the enclosing scope tears down: bump the generation so
-       the drain abandons its loop and `return()` the iterator to release the source. The
-       rows and error branch are disposed by the group (their scopes were tracked). */
-    if (OWNER.current !== undefined) {
-        OWNER.current.push(() => {
-            generation += 1
-            iterator?.return?.(undefined)?.catch(() => undefined)
-            iterator = undefined
-        })
-    }
 }

package/src/lib/ui/installHotBridge.ts

@@ -25,6 +25,7 @@ import { spreadProps } from './dom/spreadProps.ts'
 import { switchBlock } from './dom/switchBlock.ts'
 import { tryBlock } from './dom/tryBlock.ts'
 import { when } from './dom/when.ts'
+import { deferResume } from './deferResume.ts'
 import { effect } from './effect.ts'
 import { enterScope } from './enterScope.ts'
 import { exitScope } from './exitScope.ts'
@@ -68,6 +69,7 @@ export function installHotBridge(): void {
         eachAsync,
         when,
         awaitBlock,
+        deferResume,
         tryBlock,
         switchBlock,
         mountSlot,

package/src/lib/ui/matchRoute.ts

@@ -52,6 +52,18 @@ export function matchRoute(
     return best === undefined ? undefined : { route: best.route, params: best.params }
 }
 
+/* Percent-decodes a captured `[name]` value. Bun's `req.params` decoding is
+   lenient (malformed sequences pass through), so mirror that by falling back to
+   the raw value rather than throwing on a malformed `%` a page navigation would
+   otherwise crash on. */
+function decodeParam(value: string): string {
+    try {
+        return decodeURIComponent(value)
+    } catch {
+        return value
+    }
+}
+
 /* Matches one parsed pattern against the path's segments, capturing params;
    undefined on mismatch. A catch-all consumes every remaining segment. */
 function matchSegments(
@@ -81,7 +93,12 @@ function matchSegments(
             if (value === '') {
                 return undefined
             }
-            params[segment.name] = value
+            /* `url()` encodes a `[name]` value whole, and Bun decodes `req.params`
+               server-side, so decode here to hand the page the same value SSR does
+               (e.g. `The%20Daily%20Show` → `The Daily Show`). The catch-all above
+               stays raw to match the server, which reconstructs it from the raw
+               pathname. */
+            params[segment.name] = decodeParam(value)
         }
     }
     /* No catch-all consumed the tail, so the path must have no extra segments. */

package/src/lib/ui/remoteProxy.ts

@@ -53,11 +53,21 @@ HttpError; and once a backlog exists, a fresh call parks straight to the TAIL
 the app owns when to replay. `rpc.outbox()` exposes the queue.
 */
 // @documentation plumbing
+export function remoteProxy<Args, Return>(
+    method: HttpMethod,
+    url: string,
+    durable: DurableOptions & { outbox: true },
+): RemoteFunction<Args, Return, Record<never, never>, true>
+export function remoteProxy<Args, Return>(
+    method: HttpMethod,
+    url: string,
+    durable?: DurableOptions,
+): RemoteFunction<Args, Return>
 export function remoteProxy<Args, Return>(
     method: HttpMethod,
     url: string,
     durable?: DurableOptions,
-): RemoteFunction<Args, Return> {
+): RemoteFunction<Args, Return, Record<never, never>, boolean> {
     /* Assigned after `createRemoteFunction` so the invoke closure (which runs later, per
        call) parks through the shared queue; undefined leaves the plain fetch path. */
     let queue: OutboxQueue<Args> | undefined

package/src/lib/ui/renderToStream.ts

@@ -1,5 +1,6 @@
+import { deferResume } from './deferResume.ts'
 import { resumeSeedScript } from './resumeSeedScript.ts'
-import type { ResumeEntry } from './runtime/RESUME.ts'
+import type { DeferMarker, ResumeEntry } from './runtime/RESUME.ts'
 import type { SsrAwait, SsrRender } from './runtime/types/SsrRender.ts'
 import { tryEncodeResume } from './tryEncodeResume.ts'
 
@@ -39,8 +40,8 @@ export async function* renderToStream(
        instead of refetching. (`resume` is the render body's live object, so late writes
        appear here.) */
     const seededResume = new Set<number>(Object.keys(resume).map(Number))
-    const resumeDelta = (): Record<number, ResumeEntry> => {
-        const delta: Record<number, ResumeEntry> = {}
+    const resumeDelta = (): Record<number, ResumeEntry | DeferMarker> => {
+        const delta: Record<number, ResumeEntry | DeferMarker> = {}
         for (const [key, entry] of Object.entries(resume)) {
             const id = Number(key)
             if (!seededResume.has(id)) {
@@ -83,18 +84,22 @@ export async function* renderToStream(
     }
 }
 
-type Settled = { id: number; html: string; resume: ResumeEntry }
+type Settled = { id: number; html: string; resume: ResumeEntry | DeferMarker }
 
 /* Awaits one streaming block's promise and renders the resolved or error branch to
    HTML (the renderers are async so a nested `await` block composes), capturing the
    value (serializable) for the resume manifest. Errors serialize as their message —
-   enough for the catch branch, without leaking a stack. */
+   enough for the catch branch, without leaking a stack. A cache-backed value defers via
+   `deferResume` (a `{defer,key}` marker + lazy body seed) — the client adopts the streamed
+   branch inert instead of decoding the value; a non-cache value ships inline as before. */
 function settle(block: SsrAwait): Promise<Settled> {
-    return Promise.resolve(block.promise()).then(
+    /* Keep the promise: cache() tagged it with its key, which `deferResume` reads to defer. */
+    const pending = block.promise()
+    return Promise.resolve(pending).then(
         async (value) => ({
             id: block.id,
             html: await block.then(value),
-            resume: { ok: true, value },
+            resume: deferResume(pending, value),
         }),
         async (error) => {
             /* No catch branch → surface the rejection (500 before the first flush,
@@ -118,6 +123,6 @@ function settle(block: SsrAwait): Promise<Settled> {
    strings. `tryEncodeResume` handles the serialize-or-refetch policy (undefined → no
    script → the swap consumers skip registration → hydration re-runs that one promise).
    `applyResolved`/the inline swap script store it via `.textContent`; `awaitBlock` decodes it. */
-function encodeStreamResume(resume: ResumeEntry, id: number): string | undefined {
+function encodeStreamResume(resume: ResumeEntry | DeferMarker, id: number): string | undefined {
     return tryEncodeResume(resume, id)?.replace(/</g, '\\u003c')
 }

package/src/lib/ui/resumeSeedScript.ts

@@ -1,5 +1,5 @@
 import { safeJsonForScript } from '../shared/safeJsonForScript.ts'
-import type { ResumeEntry } from './runtime/RESUME.ts'
+import type { DeferMarker, ResumeEntry } from './runtime/RESUME.ts'
 import { tryEncodeResume } from './tryEncodeResume.ts'
 
 /* A self-contained `<script>` seeding the await-resume manifest with the blocking
@@ -11,7 +11,7 @@ import { tryEncodeResume } from './tryEncodeResume.ts'
    early or parse as a line terminator. Shared by the buffered (`createUiPageRenderer`)
    and streaming (`renderToStream`) paths. */
 // @documentation plumbing
-export function resumeSeedScript(resume: Record<number, ResumeEntry>): string {
+export function resumeSeedScript(resume: Record<number, ResumeEntry | DeferMarker>): string {
     /* ref-json (not JSON) so a value carrying cycles or shared back-references — a
        media tree with parent↔child links — seeds instead of being dropped. `tryEncodeResume`
        drops just an unserializable entry (the client re-runs that one branch's promise),

package/src/lib/ui/runtime/CURRENT_SCOPE.ts

@@ -1,4 +1,5 @@
 import type { Scope } from '../types/Scope.ts'
+import { ambientScopeBacking } from './ambientScopeBacking.ts'
 
 /*
 The ambient lexical scope. The compiler establishes one per lexical level (a
@@ -6,5 +7,17 @@ component, a control-flow branch) by setting `current` around the build, so the
 bare `scope()` accessor and the scope-bound primitives resolve "where they are"
 with no handle threaded. Undefined outside any scope, where `scope()` mints a
 detached root on first use.
+
+`current` reads/writes through a SWAPPABLE backing (`ambientScopeBacking`) rather
+than a raw field: the default is a module variable, but the server installs an
+AsyncLocalStorage-backed holder so concurrent async SSR renders don't clobber one
+shared global across the inline `await`s they suspend on. See `ambientScopeBacking`.
 */
-export const CURRENT_SCOPE: { current: Scope | undefined } = { current: undefined }
+export const CURRENT_SCOPE: { current: Scope | undefined } = {
+    get current(): Scope | undefined {
+        return ambientScopeBacking.active.get()
+    },
+    set current(value: Scope | undefined) {
+        ambientScopeBacking.active.set(value)
+    },
+}

package/src/lib/ui/runtime/RESUME.ts

@@ -16,6 +16,12 @@
    same reference. */
 export type ResumeEntry = { ok: true; value: unknown } | { ok: false; error: unknown }
 
+/* Deferred-resume marker (Tier 2): a large cache-backed `{#await cache()}` ships this in
+   place of its value — just the cache key, so hydration adopts the server branch inert and
+   pays no value decode. The client seeds that key lazily and materializes it only on a later
+   re-read. Discriminated from a ResumeEntry by the `defer` field. */
+export type DeferMarker = { defer: true; key: string }
+
 const globalScope = globalThis as { __abideResume?: Record<number, string> }
 globalScope.__abideResume ??= {}
 

package/src/lib/ui/runtime/ambientScopeBacking.ts

@@ -0,0 +1,26 @@
+import type { Scope } from '../types/Scope.ts'
+
+/*
+The swappable backing behind `CURRENT_SCOPE.current`. The default is a module
+variable — correct on the client (one render tree) and on the server outside any
+request. The server swaps in an AsyncLocalStorage-backed holder at boot
+(`installAmbientScopeStore`), because SSR is partly async: a render brackets itself
+with `enterScope`/`exitScope` and `await`s inline between them (blocking `{#await}`,
+child renders, slots, a top-level `await`). A module global held across those awaits
+interleaves across concurrent requests — one render resumes to read another's scope.
+Keying the ambient off the per-request store (which the async context propagates
+correctly) isolates it. Mirrors `requestScopeResolver`'s server-installed slot; the
+indirection cost lands at build/effect-creation time, never on the signal hot path.
+*/
+type ScopeBacking = { get(): Scope | undefined; set(value: Scope | undefined): void }
+
+let moduleCurrent: Scope | undefined
+
+export const ambientScopeBacking: { active: ScopeBacking } = {
+    active: {
+        get: () => moduleCurrent,
+        set: (value) => {
+            moduleCurrent = value
+        },
+    },
+}

package/src/lib/ui/runtime/createEffectNode.ts

@@ -1,3 +1,5 @@
+import { CURRENT_SCOPE } from './CURRENT_SCOPE.ts'
+import { inScope } from './inScope.ts'
 import { NODE_STATE } from './NODE_STATE.ts'
 import { OWNER } from './OWNER.ts'
 import { runNode } from './runNode.ts'
@@ -23,13 +25,17 @@ export function createEffectNode(fn: () => EffectResult): () => void {
        ReactiveNode so signals and computeds — which share the node shape and the
        read/write hot path — pay nothing for a feature only effects use. */
     let cleanup: Teardown | undefined
+    /* The teardown fires deferred (before a re-run, on dispose) when the ambient scope
+       has moved on; pin the one current at creation so an ambient `scope()` inside it
+       resolves the owning component, matching how `attach` pins its teardown. */
+    const captured = CURRENT_SCOPE.current
     /* Runs the previous run's teardown before re-running and on dispose, exactly
        once each. */
     const runCleanup = (): void => {
         if (cleanup !== undefined) {
             const teardown = cleanup
             cleanup = undefined
-            teardown()
+            inScope(captured, teardown)
         }
     }
     const node: ReactiveNode = {

package/src/lib/ui/runtime/flushEffects.ts

@@ -11,6 +11,12 @@ drains the captured one — so an effect that dirties further effects re-queues
 for the next pass rather than mutating the array mid-iteration; loops until the
 graph settles. The swap reuses the drained array as the next spare, so a steady
 flush allocates nothing.
+
+Raises `batchDepth` for the whole drain so a write inside an effect body queues
+rather than re-entering the flush: `trigger` gates its flush on `batchDepth === 0`,
+and re-entry would run a just-dirtied effect nested — ahead of effects already in
+this pass and on a JS stack that grows with the write chain. Suppressed, the
+newly-dirtied effect falls to the `do…while` and runs in queue (creation) order.
 */
 export function flushEffects(): void {
     /* Empty-queue fast path allocates nothing — only the length check, matching the
@@ -20,6 +26,18 @@ export function flushEffects(): void {
     if (REACTIVE_CONTEXT.pendingEffects.length === 0) {
         return
     }
+    /* Always entered at depth 0 (trigger/batch-exit gate on it); the bump makes the
+       drain non-reentrant, restored in `finally` so a throwing effect body can't strand
+       the graph batched. */
+    REACTIVE_CONTEXT.batchDepth += 1
+    try {
+        drain()
+    } finally {
+        REACTIVE_CONTEXT.batchDepth -= 1
+    }
+}
+
+function drain(): void {
     let spare: ReactiveNode[] = []
     do {
         const batch = REACTIVE_CONTEXT.pendingEffects

package/src/lib/ui/runtime/generationGuard.ts

@@ -0,0 +1,40 @@
+import { OWNER } from './OWNER.ts'
+
+/*
+A monotonic generation an async block checks before a late continuation touches the DOM. It
+answers one question — "is the work I started still the current work?" — and is bumped on the
+two events that both invalidate in-flight work: a reactive `renew()` (a re-run supersedes the
+prior promise/drain) and the enclosing OWNER's teardown (a settle after disposal must be
+DROPPED, not run `place`/`insertBefore` on a now-detached anchor → NotFoundError). `onTeardown`
+releases extra resources at teardown (e.g. an async iterator's `return()`).
+
+Extracted from the byte-identical guard hand-rolled in `awaitBlock` and `eachAsync`. The
+teardown half is the load-bearing one: a re-run bump alone leaves a promise/drain that settles
+AFTER disposal to still pass the liveness check and crash on the dead anchor — the bug both
+sites independently had to grow.
+*/
+export function generationGuard(onTeardown?: () => void): {
+    renew: () => number
+    token: () => number
+    live: (captured: number) => boolean
+} {
+    let generation = 0
+    /* The teardown bump is load-bearing: without it a promise/drain settling after the owner
+       disposes still passes `live(captured)` and touches a detached anchor. */
+    if (OWNER.current !== undefined) {
+        OWNER.current.push(() => {
+            generation += 1
+            onTeardown?.()
+        })
+    }
+    return {
+        /* Supersede any in-flight generation; call at the start of each (re-)run. Returns the
+           new token so a runner can capture it in the same statement. */
+        renew: () => (generation += 1),
+        /* The live generation to capture before an await and compare after — for when the
+           renew and the capture happen in different functions (as in awaitBlock's render). */
+        token: () => generation,
+        /* Whether `captured` is still the live generation — safe to touch the DOM. */
+        live: (captured: number) => captured === generation,
+    }
+}

package/src/lib/ui/runtime/runNode.ts

@@ -34,7 +34,15 @@ export function runNode(node: ReactiveNode): unknown {
            on read without re-running, never waking downstream. An effect has no value
            worth comparing and no subscribers, so this is a no-op for it (its body ran
            inside compute above). The subscriber list isn't re-linked here — only its
-           members' `status` is bumped — so walking it live is safe. */
+           members' `status` is bumped — so walking it live is safe.
+
+           This bumps status directly, bypassing `mark` — it neither enqueues effects nor
+           propagates CHECK onward, yet nothing is missed: this recompute only happens
+           while settling a subscriber that was itself reached from the originating
+           write's `mark` propagation, which already CHECK-marked (and so enqueued) every
+           effect in this cone on their CLEAN→CHECK edge. So every subscriber here is
+           already CHECK/queued; the direct write only UPGRADES it CHECK→DIRTY so its own
+           settle recomputes instead of memoising back to CLEAN. */
         if (!Object.is(node.value, next)) {
             node.value = next
             let link = node.subsHead

package/src/lib/ui/runtime/types/SsrRender.ts

@@ -1,4 +1,4 @@
-import type { ResumeEntry } from '../RESUME.ts'
+import type { DeferMarker, ResumeEntry } from '../RESUME.ts'
 
 /* One STREAMING await block captured during SSR (no `then` on the `await` tag): its
    boundary id, the promise to await, and the async string-renderers for the resolved
@@ -18,10 +18,11 @@ export type SsrAwait = {
 /* The result of a component's server `render()`: the pending-shell HTML, the
    serializable document snapshot for client resume, the STREAMING await blocks to
    flush out of order, and `resume` — the inline-rendered BLOCKING await values keyed
-   by boundary id, seeded into the manifest so hydration adopts them without a refetch. */
+   by boundary id, seeded into the manifest so hydration adopts them without a refetch. A
+   deferred (cache-backed) blocking value is a `DeferMarker` in place of the value. */
 export type SsrRender = {
     html: string
     state: unknown
     awaits: SsrAwait[]
-    resume: Record<number, ResumeEntry>
+    resume: Record<number, ResumeEntry | DeferMarker>
 }

package/src/lib/ui/scope.ts

@@ -3,17 +3,15 @@ import { CURRENT_SCOPE } from './runtime/CURRENT_SCOPE.ts'
 import type { Scope } from './types/Scope.ts'
 
 /*
-Resolves a lexical scope. `scope()` returns the current one — established per
-lexical level by the compiler, so it reads "where you are" with no handle. Outside
-any scope (boot, a script) it mints a detached root once and reuses it. `scope('/')`
-returns the root of the current tree (the app-global scope). The returned value is
-passable: hand it to a child or a helper and it can read/extend/undo that scope.
+Resolves the current lexical scope — established per lexical level by the compiler,
+so it reads "where you are" with no handle. Outside any scope (boot, a script) it
+mints a detached root once and reuses it. The returned value is passable: hand it to
+a child or a helper and it can read/extend/undo that scope (walk up via `.root()`).
 */
 // @documentation reactive-state
-export function scope(address?: string): Scope {
+export function scope(): Scope {
     if (!CURRENT_SCOPE.current) {
         CURRENT_SCOPE.current = createScope()
     }
-    const current = CURRENT_SCOPE.current
-    return address === '/' ? current.root() : current
+    return CURRENT_SCOPE.current
 }

package/src/lib/ui/tryEncodeResume.ts

@@ -1,5 +1,5 @@
 import { encodeRefJson } from '../shared/encodeRefJson.ts'
-import type { ResumeEntry } from './runtime/RESUME.ts'
+import type { DeferMarker, ResumeEntry } from './runtime/RESUME.ts'
 
 /* ref-json-encode an await-resume entry, or `undefined` if it can't be serialized.
    encodeRefJson is total (cycles become back-references, functions fold to undefined),
@@ -7,7 +7,10 @@ import type { ResumeEntry } from './runtime/RESUME.ts'
    entry and warn, so the client re-runs that one branch's promise while every other
    branch stays seeded. Shared by the streaming (`renderToStream`) and buffered/seed
    (`resumeSeedScript`) paths so the serialize-or-refetch policy lives in one place. */
-export function tryEncodeResume(entry: ResumeEntry, id: number | string): string | undefined {
+export function tryEncodeResume(
+    entry: ResumeEntry | DeferMarker,
+    id: number | string,
+): string | undefined {
     try {
         return encodeRefJson(entry)
     } catch (cause) {

package/src/lib/ui/types/Scope.ts

@@ -1,7 +1,6 @@
 import type { computed } from '../computed.ts'
 import type { effect } from '../effect.ts'
 import type { linked } from '../linked.ts'
-import type { Cell } from '../runtime/types/Cell.ts'
 import type { Patch } from '../runtime/types/Patch.ts'
 import type { state } from '../state.ts'
 import type { SyncTransport } from './SyncTransport.ts'
@@ -9,7 +8,7 @@ import type { SyncTransport } from './SyncTransport.ts'
 /*
 A lexical scope: the unit that owns a region's reactive data, its lifetime, and
 the capabilities applied to it. Its data surface MIRRORS `Doc` (read/replace/add/
-remove/cell/derive/apply/snapshot) so the compiler can target a scope as a
+remove/derive/apply/snapshot) so the compiler can target a scope as a
 component's data binding directly. It nests (`child`/`root`), passes values
 down the tree as context (`share`/`shared`), and carries the capability surface as
 methods so a scope is a passable value: `<Child parentScope={scope} />`.
@@ -33,7 +32,6 @@ export type Scope = {
     add: (path: string, value: unknown) => void
     remove: (path: string) => void
     apply: (patch: Patch) => void
-    cell: <T>(path: string) => Cell<T>
     derive: <T>(path: string, compute: () => T) => () => T
     snapshot: () => unknown
     /* The reactive primitives — namespaced under the scope, but AMBIENT-bound, not
@@ -64,7 +62,8 @@ export type Scope = {
     /* context — values shared DOWN the tree (not in the reactive doc, which doesn't
        inherit): `share` puts a named value on this scope; `shared` reads the closest
        ancestor (self included) that has the key, undefined if none. The value is held
-       by reference, so reactive context = share a `cell`/scope, not a plain object. */
+       by reference, so reactive context = share a scope (its doc is reactive), not a
+       plain object snapshot. */
     share: (key: string, value: unknown) => void
     shared: <T>(key: string) => T | undefined
     /* capabilities — enable where the scope's changes go */

package/src/lib/server/rpc/buildErrorConstructors.ts

@@ -1,19 +0,0 @@
-import type { ErrorConstructors } from '../../shared/types/ErrorConstructors.ts'
-import type { ErrorSpec } from '../../shared/types/ErrorSpec.ts'
-
-/*
-Turns a rpc's declared `ErrorSpec` into the constructor object handed to the
-handler (`(args, { errors })`). Each constructor stamps its name + status onto an
-`ErrorDescriptor` carrying the call's `data`, which `error()` serializes as the
-`{ $abideError, data }` body. Receiver-agnostic on data: a nullary error ignores
-the (absent) argument.
-*/
-export function buildErrorConstructors<Spec extends ErrorSpec>(
-    spec: Spec,
-): ErrorConstructors<Spec> {
-    const entries = Object.entries(spec).map(([name, { status }]) => [
-        name,
-        (data: unknown) => ({ $abideError: name, status, data }),
-    ])
-    return Object.fromEntries(entries) as ErrorConstructors<Spec>
-}

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

@@ -1,17 +0,0 @@
-import type { ErrorDescriptor } from './ErrorDescriptor.ts'
-import type { ErrorSpec } from './ErrorSpec.ts'
-import type { StandardSchemaV1 } from './StandardSchemaV1.ts'
-
-/*
-The constructors handed to the handler via its second arg (`(args, { errors })`),
-derived from the rpc's `ErrorSpec`. An entry with a `data` schema makes its
-constructor require that schema's inferred input; an entry without one is nullary.
-Each returns a typed `ErrorDescriptor` to pass to `error()`.
-*/
-export type ErrorConstructors<Spec extends ErrorSpec> = {
-    [Name in keyof Spec & string]: Spec[Name]['data'] extends StandardSchemaV1
-        ? (
-              data: StandardSchemaV1.InferInput<Spec[Name]['data']>,
-          ) => ErrorDescriptor<Name, StandardSchemaV1.InferInput<Spec[Name]['data']>>
-        : () => ErrorDescriptor<Name, undefined>
-}

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

@@ -1,10 +0,0 @@
-/*
-What a rpc error constructor returns: a plain descriptor (NOT a Response), so it
-flows through the single `error()` funnel — `return error(errors.invalidCoupon({…}))`.
-`error()` reads `status` off it and serializes `{ $abideError: name, data }` as the body.
-*/
-export type ErrorDescriptor<Name extends string = string, Data = unknown> = {
-    readonly $abideError: Name
-    readonly status: number
-    readonly data: Data
-}