@abide/abide 0.58.0 → 0.100.0

package/src/lib/shared/url.ts

@@ -1,141 +0,0 @@
-import { basePath } from './basePath.ts'
-import type { RouteSegment } from './parseRouteSegments.ts'
-import { parseRouteSegments } from './parseRouteSegments.ts'
-import { queryStringFromArgs } from './queryStringFromArgs.ts'
-
-/* `undefined` is allowed and dropped (queryStringFromArgs skips it), so an
-   optional field — url('/p', { ref: maybeUndefined }) — types without a guard. */
-type QueryValue = string | number | boolean | undefined
-type Query = Record<string, QueryValue>
-
-/* Compiled once — a scheme-qualified URL (`http:`, `mailto:`). */
-const SCHEME_QUALIFIED = /^[a-z][a-z0-9+.-]*:/i
-
-/*
-Augmentable rpc map. Codegen emits a `declare module '<importName>/shared/url'`
-block filling this with `'/rpc/<file>': args` for each query-carrying (GET)
-rpc, so url('/rpc/search', { q }) types its args against the rpc's own
-signature. Empty by default — an absent entry falls through to the page/asset
-branch, so the helper works before the generated d.ts lands.
-*/
-// @documentation url
-// biome-ignore lint/suspicious/noEmptyInterface: augmented by the generated rpc.d.ts
-export interface RpcRoutes {}
-
-/*
-Augmentable autocomplete sets — keys only, values unused. The page codegen
-(writeRoutesDts) fills PageRoutes with each route path, the public codegen
-(writePublicAssetsDts) fills PublicAssets with each `public/` file path. They
-exist purely so editors suggest known paths; PathParams still derives a page's
-params from the literal, so neither map drives typing.
-*/
-// biome-ignore lint/suspicious/noEmptyInterface: augmented by the generated routes.d.ts
-export interface PageRoutes {}
-// biome-ignore lint/suspicious/noEmptyInterface: augmented by the generated publicAssets.d.ts
-export interface PublicAssets {}
-
-/*
-Known in-app paths for autocomplete. `(string & {})` at the call site keeps any
-string accepted (dynamic/raw/external paths) — there's no hard route-existence
-error, which would reject assets and interpolated strings — while these light
-up suggestions once codegen lands.
-*/
-type KnownPath = keyof PageRoutes | keyof RpcRoutes | keyof PublicAssets
-
-/*
-Pulls the `[name]` / `[...rest]` params a route literal declares straight from
-the path type, so url('/product/[id]', …) requires `id` without a generated
-shape map. Values accept string | number (stringified on output). A path with
-no bracket segments yields {}, which collapses the params slot away. The
-catch-all branch recurses on its head too, so `[name]` segments before a
-`[...rest]` are kept.
-*/
-export type PathParams<P extends string> = P extends `${infer Head}[[${infer Name}]]${infer Tail}`
-    ? Name extends `...${infer Rest}`
-        ? // `[[...rest]]` normalizes to a plain catch-all (see parseRouteSegments)
-          PathParams<Head> & { [K in Rest]: string | number } & PathParams<Tail>
-        : PathParams<Head> & { [K in Name]?: string | number } & PathParams<Tail>
-    : P extends `${infer Head}[...${infer Rest}]${infer Tail}`
-      ? PathParams<Head> & { [K in Rest]: string | number } & PathParams<Tail>
-      : P extends `${string}[${infer Name}]${infer Tail}`
-        ? { [K in Name]: string | number } & PathParams<Tail>
-        : // biome-ignore lint/complexity/noBannedTypes: {} is the "no params" base case — keyof {} is never, which collapses the params slot; Record<string, never> would not (keyof is string)
-          {}
-
-/*
-Resolves any in-app URL to its base-correct, typed form — the single chokepoint
-so a project mounted under APP_URL's subpath (e.g. /v2) generates links, asset
-refs, and rpc hrefs that stay within the mount. Three disjoint URL kinds, keyed
-off the path:
-  - rpc (flat /rpc/*, present in RpcRoutes): the rpc's args, serialised to query.
-  - page route (has [name] segments): path params, then optional query.
-  - asset / paramless / raw: bare path, then optional query.
-External URLs (scheme-qualified or protocol-relative) skip the base untouched,
-as do non-rooted specifiers — base only ever prefixes a rooted internal path.
-*/
-export function url<P extends KnownPath | (string & {})>(
-    path: P,
-    ...args: P extends keyof RpcRoutes
-        ? undefined extends RpcRoutes[P]
-            ? [args?: RpcRoutes[P]]
-            : [args: RpcRoutes[P]]
-        : keyof PathParams<P> extends never
-          ? [query?: Query]
-          : [params: PathParams<P>, query?: Query]
-): string
-export function url(path: string, first?: Query, second?: Query): string {
-    // Scheme-qualified (http:, mailto:) or protocol-relative URLs are external — leave them whole.
-    if (SCHEME_QUALIFIED.test(path) || path.startsWith('//')) {
-        return appendQuery(path, first)
-    }
-    const segments = parseRouteSegments(path)
-    const hasParams = segments.some((segment) => segment.kind === 'param')
-    // With path params the second arg is the query; without, the first arg is.
-    const query = hasParams ? second : first
-    const resolved = hasParams ? interpolate(segments, first ?? {}) : path
-    // Base only prefixes rooted internal paths; relative specifiers are left alone.
-    const prefixed = resolved.startsWith('/') ? basePath() + resolved : resolved
-    return appendQuery(prefixed, query)
-}
-
-/* Substitutes `[name]` / `[[name]]` / `[...rest]` segments with their stringified,
-   URL-encoded param values (matching the query side, which encodes too). A `[name]`
-   value is encoded whole so `/`, `?`, `#`, and spaces can't alter the path structure;
-   a `[...rest]` catch-all keeps its `/` separators and encodes each sub-segment. An
-   absent `[[optional]]` — undefined OR empty string, since the matcher never captures
-   an empty optional segment — drops its segment (and slash) entirely; a path that
-   empties out (`/[[lang]]` with no lang) resolves to the root. Dropping empty here
-   also avoids emitting a `//about` that a browser reads as a protocol-relative URL. */
-function interpolate(segments: RouteSegment[], params: Query): string {
-    const resolved = segments
-        .map((segment) => {
-            if (segment.kind === 'literal') {
-                return segment.value
-            }
-            const value = params[segment.name]
-            if (segment.optional && (value === undefined || value === '')) {
-                return undefined
-            }
-            /* A required `[name]`/`[...rest]` with no value would otherwise stringify to the
-               literal "undefined" and silently mis-route; fail loudly instead. */
-            if (value === undefined || value === null) {
-                throw new Error(`abide url(): missing required param "${segment.name}"`)
-            }
-            const text = String(value)
-            return segment.catchAll
-                ? text.split('/').map(encodeURIComponent).join('/')
-                : encodeURIComponent(text)
-        })
-        .filter((part) => part !== undefined)
-        .join('/')
-    return resolved === '' ? '/' : resolved
-}
-
-/* Appends a `?`-query built from the same encoder buildRpcRequest uses, or nothing. */
-function appendQuery(target: string, query: Query | undefined): string {
-    if (!query) {
-        return target
-    }
-    const queryString = queryStringFromArgs(query, false)
-    return queryString ? `${target}?${queryString}` : target
-}

package/src/lib/shared/validationHttpError.ts

@@ -1,33 +0,0 @@
-import { fieldErrorsFromIssues } from './fieldErrorsFromIssues.ts'
-import { HttpError } from './HttpError.ts'
-import type { StandardSchemaV1 } from './types/StandardSchemaV1.ts'
-import type { ValidationErrorData } from './types/ValidationErrorData.ts'
-
-/*
-Builds the HttpError a client-side pre-flight validation failure throws (ADR-0026 D2),
-shaped IDENTICALLY to the one a caller gets when the server rejects the same input with a
-422: `kind: 'validation'`, `status: 422`, `data: ValidationErrorData` (`{ issues, fields }`),
-so an `error instanceof HttpError && error.kind === 'validation'` branch — and the
-`error.data.fields` form-error map — read the same whether the rejection came from the
-client pre-flight or the server.
-
-This is a UX optimization ONLY, never a trust boundary: the server's unconditional
-`inputSchema['~standard'].validate` → `validationError` 422 (defineRpc.ts) stays
-authoritative. A client that skips or fakes this check is still fully validated on the
-server.
-
-The `data` mapping (`fieldErrorsFromIssues`) is the same isomorphic helper the server 422
-uses; the response envelope (`{ $abideError, data }`, status 422, reason phrase) mirrors
-`typedErrorResponse('validation', 422, …)` — reconstructed here with a plain web-standard
-`Response` so the browser bundle never imports the server's Response builder. The status
-text mirrors `STATUS_TEXT[422]`.
-*/
-export function validationHttpError(issues: readonly StandardSchemaV1.Issue[]): HttpError {
-    const data: ValidationErrorData = { issues, fields: fieldErrorsFromIssues(issues) }
-    const response = new Response(JSON.stringify({ $abideError: 'validation', data }), {
-        status: 422,
-        statusText: 'Unprocessable Content',
-        headers: { 'content-type': 'application/json' },
-    })
-    return new HttpError(response, 'validation', data)
-}

package/src/lib/shared/warmSeedKey.ts

@@ -1,16 +0,0 @@
-/*
-The single source of the async-cell warm-seed key format: the `${scopeId}:${cellIndex}` string that
-pairs a cell's serialization-stable render-path scope id with its per-scope declaration ordinal.
-
-Both sides of the SSR→client handoff mint the key through THIS callable — the isomorphic
-`createAsyncCell` runs it server-side to key its `resolvedCells`/`streamedCells` entries (which the
-page renderer stamps into `__SSR__.cells` / streams as `{ cellKey }` / `{ cellSeed }` chunks), and
-client-side to look the value up in `CELL_SEED`. Because the two sides now invoke one function, the
-byte-for-byte agreement the warm-seed depends on is a shared definition rather than a template
-literal re-typed at each call site: changing the delimiter here changes it for both sides at once,
-so the SSR-text-≡-first-client-render mismatch class (ADR-0033) cannot silently reopen from a
-one-sided edit. Pure so it stays trivially testable and inlinable.
-*/
-export function warmSeedKey(scopeId: string, cellIndex: number): string {
-    return `${scopeId}:${cellIndex}`
-}

package/src/lib/shared/wireJsonReplacer.ts

@@ -1,30 +0,0 @@
-/*
-The value-directed wire ENCODE step for a rpc response body (ADR-0029 output path). A
-`JSON.stringify` replacer that rewrites the structured runtime values plain JSON can't carry into
-their honest-JSON wire form, so `json()` never drops a `Set`/`Map` to `{}` or throws on a `bigint`:
-
-  - `bigint`  → its digit string (plain JSON.stringify throws on a bigint)
-  - `Set<T>`  → a JSON array of its values (plain JSON.stringify emits `{}`)
-  - `Map<K,V>`→ a JSON array of `[K,V]` entries (uniform, carries non-string keys)
-
-A `Date` needs no branch — its native `toJSON` already rewrote it to an ISO string before the
-replacer runs. Value-directed (not type-directed), so it runs for EVERY client — a non-abide caller
-(curl / an OpenAPI SDK) receives the same honest JSON the projected schema (`jsonSchemaForType`)
-describes. It is naturally recursive: a returned array/object member surfaces through the same
-replacer, so a `Set` nested inside an object still encodes. Never throws — an ordinary value falls
-through untouched.
-*/
-export function wireJsonReplacer(_key: string, value: unknown): unknown {
-    if (typeof value === 'bigint') {
-        return value.toString()
-    }
-    if (value instanceof Set) {
-        return [...value]
-    }
-    if (value instanceof Map) {
-        /* A Map iterates as `[key, value]` pairs, so the spread yields the entries array the
-           client output plan (and the projected schema) expects. */
-        return [...value]
-    }
-    return value
-}

package/src/lib/shared/withBase.ts

@@ -1,10 +0,0 @@
-import { basePath } from './basePath.ts'
-
-/*
-Prefixes a rooted internal path (`/rpc/…`, `/__abide/…`) with the mount base
-so the client's framework requests route through the proxy (`/v2/rpc/…`). The
-single rule the runtime fetch sites (remoteProxy, socketChannel, health) share — '' at root is a no-op.
-*/
-export function withBase(path: string): string {
-    return `${basePath()}${path}`
-}

package/src/lib/shared/withBaseUrl.ts

@@ -1,17 +0,0 @@
-import { basePath } from './basePath.ts'
-
-/*
-Re-homes a URL under the mount base by prefixing its pathname (`/people` →
-`/v2/people`) — the URL-level counterpart of withBase for sites that carry
-whole URLs rather than rooted paths. Identity at root mount, so there is no
-allocation (and no behaviour change) when no base is set.
-*/
-export function withBaseUrl(url: URL): URL {
-    const base = basePath()
-    if (!base) {
-        return url
-    }
-    const prefixed = new URL(url)
-    prefixed.pathname = base + url.pathname
-    return prefixed
-}

package/src/lib/shared/withCacheManaged.ts

@@ -1,18 +0,0 @@
-import { cacheManagedSlot } from './cacheManagedSlot.ts'
-
-/*
-Runs `invoke` with cacheManagedSlot flagged, so any RPC fired synchronously inside
-it (the cache's underlying remote/producer call) skips reactive scope-binding — the
-cache, not the calling reader, owns the shared flight's lifetime. Save/restore keeps
-it correct under nesting (a producer that itself reads cache). The fetch is fired
-synchronously and the flag clears before the await, so it never spans the network.
-*/
-export function withCacheManaged<T>(invoke: () => T): T {
-    const previous = cacheManagedSlot.active
-    cacheManagedSlot.active = true
-    try {
-        return invoke()
-    } finally {
-        cacheManagedSlot.active = previous
-    }
-}

package/src/lib/shared/withJsonSchema.ts

@@ -1,21 +0,0 @@
-import type { StandardSchemaV1 } from './types/StandardSchemaV1.ts'
-
-/*
-Attaches a `toJSONSchema()` projection to a Standard Schema whose library
-doesn't expose one natively. jsonSchemaForSchema probes that method to feed the
-OpenAPI document, the MCP tool schemas, the CLI flag help, and the bundle setup
-form. Zod 4 / Effect / Arktype carry their own; everything else wraps once where
-the schema is declared:
-
-  export const config = env(withJsonSchema(vSchema, (s) => toJsonSchema(s)))
-
-Mutates and returns the same schema with the method attached, so the wrapped
-value stays usable everywhere the bare schema was.
-*/
-// @documentation rpc
-export function withJsonSchema<Schema extends StandardSchemaV1>(
-    schema: Schema,
-    toJsonSchema: (schema: Schema) => Record<string, unknown>,
-): Schema & { toJSONSchema: () => Record<string, unknown> } {
-    return Object.assign(schema, { toJSONSchema: () => toJsonSchema(schema) })
-}

package/src/lib/shared/writeDts.ts

@@ -1,19 +0,0 @@
-/* The banner every generated abide `.d.ts` carries, warning off hand edits. */
-const DTS_BANNER = '// Generated by abide. Do not edit by hand.'
-
-/*
-Writes a generated `.d.ts` to `src/.abide/<name>.d.ts` (the path the consumer's
-src tsconfig include picks up), wrapping `body` in the shared banner + the
-`export {}` footer that makes the file a module. All codegen writers (routes, rpc, publicAssets, testRpc, testSockets, health)
-differ only in `body`, so the envelope lives here.
-*/
-export async function writeDts(cwd: string, name: string, body: string): Promise<void> {
-    const next = `${DTS_BANNER}\n${body}\n\nexport {}\n`
-    const file = Bun.file(`${cwd}/src/.abide/${name}.d.ts`)
-    // Skip the write when byte-identical — an unchanged rebuild (the common case)
-    // otherwise bumps mtime every save, forcing the editor's TS server to re-typecheck.
-    if ((await file.exists()) && (await file.text()) === next) {
-        return
-    }
-    await Bun.write(file, next)
-}

package/src/lib/shared/writeHealthDts.ts

@@ -1,36 +0,0 @@
-import { writeDts } from './writeDts.ts'
-
-/*
-Emits a `.d.ts` that augments abide's `AppHealthMap` interface with the app
-health() hook's resolved return type, so the client `health()` read types
-against the project's own hook (e.g. `health().authenticated`). Conditional
-over `typeof import('../app.ts')` because the hook is optional — absent, the
-fields resolve empty; a non-object return is ignored, matching the runtime
-merge. With no src/app.ts at all the import would be an error, so the file
-carries only the framework shape. Written to `src/.abide/health.d.ts` like
-its routes/rpc siblings.
-*/
-export async function writeHealthDts({
-    cwd,
-    hasAppModule,
-    importName,
-}: {
-    cwd: string
-    hasAppModule: boolean
-    importName: string
-}): Promise<void> {
-    const body = hasAppModule
-        ? `type AppHealthFields<App> = App extends { health: (...args: never[]) => infer Result }
-    ? Awaited<Result> extends object
-        ? Awaited<Result>
-        : Record<never, never>
-    : Record<never, never>
-
-declare module '${importName}/shared/health' {
-    interface AppHealthMap {
-        fields: AppHealthFields<typeof import('../app.ts')>
-    }
-}`
-        : '// src/app.ts absent — health() carries only the framework fields.'
-    await writeDts(cwd, 'health', body)
-}

package/src/lib/shared/writeLastConnection.ts

@@ -1,13 +0,0 @@
-import { mkdir } from 'node:fs/promises'
-import { appDataDir } from './appDataDir.ts'
-import { lastConnectionPath } from './lastConnectionPath.ts'
-import type { LastConnection } from './types/LastConnection.ts'
-
-// Persists the connection intent, creating the data dir on first write.
-export async function writeLastConnection(
-    programName: string,
-    value: LastConnection,
-): Promise<void> {
-    await mkdir(appDataDir(programName), { recursive: true })
-    await Bun.write(lastConnectionPath(programName), JSON.stringify(value))
-}

package/src/lib/shared/writePublicAssetsDts.ts

@@ -1,27 +0,0 @@
-import { augmentModule } from './augmentModule.ts'
-import { writeDts } from './writeDts.ts'
-
-/*
-Emits a `.d.ts` that augments abide's `PublicAssets` interface with one entry
-per file under `public/`, keyed by its site-root path (`/logo.png`) — the same
-key createPublicAssetServer serves it at. Keys only (value `true`): the map
-exists purely so `url('/logo.png')` autocompletes known assets; it carries no
-type beyond the path. Written to `src/.abide/publicAssets.d.ts` so the
-consumer's src tsconfig include picks it up, keyed on the project's abide
-import name like writeRoutesDts / writeRpcDts.
-*/
-export async function writePublicAssetsDts({
-    cwd,
-    publicFiles,
-    importName,
-}: {
-    cwd: string
-    publicFiles: string[]
-    importName: string
-}): Promise<void> {
-    const entries = publicFiles
-        .map((file): [string, string] => [`/${file}`, 'true'])
-        .toSorted(([a], [b]) => (JSON.stringify(a) < JSON.stringify(b) ? -1 : 1))
-    const module = augmentModule(`${importName}/shared/url`, 'PublicAssets', entries)
-    await writeDts(cwd, 'publicAssets', module)
-}

package/src/lib/shared/writeRoutesDts.ts

@@ -1,41 +0,0 @@
-import { augmentModule } from './augmentModule.ts'
-import { pageUrlForFile } from './pageUrlForFile.ts'
-import { routeParamsShape } from './routeParamsShape.ts'
-import { writeDts } from './writeDts.ts'
-
-/*
-Emits a `.d.ts` that augments abide's `Routes` interface with one entry per
-page file in the project. Page picks this up as a discriminated union keyed
-on `route`, so `if (page.route === '/media/[id]') page.params.id` is typed
-automatically without consumers writing route types by hand.
-The file is written to `src/.abide/routes.d.ts` so the consumer's existing
-src tsconfig include picks it up with no extra configuration. The augmented
-module is keyed on the name the project imports abide under (`importName`),
-so the augmentation matches the consumer's `page` import whether abide is
-installed directly (`abide`) or behind an alias.
-*/
-export async function writeRoutesDts({
-    cwd,
-    pageFiles,
-    importName,
-}: {
-    cwd: string
-    pageFiles: string[]
-    importName: string
-}): Promise<void> {
-    const routes = pageFiles
-        .map((file) => ({ route: pageUrlForFile(file) }))
-        .toSorted((a, b) => a.route.localeCompare(b.route))
-    const routesModule = augmentModule(
-        `${importName}/shared/page`,
-        'Routes',
-        routes.map(({ route }): [string, string] => [route, routeParamsShape(route)]),
-    )
-    /* Keys-only mirror for url()'s autocomplete (values unused — PathParams derives the shape). */
-    const urlModule = augmentModule(
-        `${importName}/shared/url`,
-        'PageRoutes',
-        routes.map(({ route }): [string, string] => [route, 'true']),
-    )
-    await writeDts(cwd, 'routes', `${routesModule}\n\n${urlModule}`)
-}

package/src/lib/shared/writeRpcDts.ts

@@ -1,60 +0,0 @@
-import { resolve } from 'node:path'
-import { augmentModule } from './augmentModule.ts'
-import { carriesBodyArgs } from './carriesBodyArgs.ts'
-import { detectRpcMethod } from './detectRpcMethod.ts'
-import { fileStem } from './fileStem.ts'
-import { RPC_ARGS_TYPE } from './RPC_ARGS_TYPE.ts'
-import { rpcUrlForFile } from './rpcUrlForFile.ts'
-import type { HttpMethod } from './types/HttpMethod.ts'
-import { writeDts } from './writeDts.ts'
-
-/*
-Emits a `.d.ts` that augments abide's `RpcRoutes` interface with one entry per
-query-carrying $rpc rpc, so `url('/rpc/search', { q })` types its args against
-the rpc's own signature. Only GET/DELETE/HEAD (non-body) rpcs are included —
-a url() can carry a query string but not a request body, so a POST rpc has no
-URL form. `RpcArgs` lifts the args type out of the rpc's RemoteFunction
-(dropping the FormData upload variant); the file path resolves the export by
-its filename, the abide one-export-per-file convention. Written to
-`src/.abide/rpc.d.ts` so the consumer's src tsconfig include picks it up, keyed
-on the project's abide import name like writeRoutesDts.
-*/
-export async function writeRpcDts({
-    cwd,
-    rpcDir,
-    rpcFiles,
-    importName,
-    methodForModule,
-}: {
-    cwd: string
-    rpcDir: string
-    rpcFiles: string[]
-    importName: string
-    /* Warm server-program method resolver (ADR-0025 D2): reads the method off the export's
-       helper symbol so an aliased/re-exported helper resolves where `detectRpcMethod`'s
-       `RPC_EXPORT` regex misses it. Absent (no warm program) or undefined-per-file falls open to
-       the regex, byte-identical to before. */
-    methodForModule?: (modulePath: string) => HttpMethod | undefined
-}): Promise<void> {
-    const pairs = await Promise.all(
-        rpcFiles.map(async (file): Promise<[string, string] | undefined> => {
-            const method =
-                methodForModule?.(resolve(rpcDir, file)) ??
-                detectRpcMethod(await Bun.file(`${rpcDir}/${file}`).text())
-            // A body rpc's args can't ride a URL — leave it out of the url() rpc map.
-            if (!method || carriesBodyArgs(method)) {
-                return undefined
-            }
-            const importPath = `../server/rpc/${file}`
-            return [
-                rpcUrlForFile(file),
-                `RpcArgs<typeof import(${JSON.stringify(importPath)}).${fileStem(file)}>`,
-            ]
-        }),
-    )
-    const entries = pairs
-        .filter((pair) => pair !== undefined)
-        .toSorted(([a], [b]) => (JSON.stringify(a) < JSON.stringify(b) ? -1 : 1))
-    const module = augmentModule(`${importName}/shared/url`, 'RpcRoutes', entries)
-    await writeDts(cwd, 'rpc', `${RPC_ARGS_TYPE}\n\n${module}`)
-}

package/src/lib/shared/writeTestRpcDts.ts

@@ -1,45 +0,0 @@
-import { augmentModule } from './augmentModule.ts'
-import { commandNameForUrl } from './commandNameForUrl.ts'
-import { fileStem } from './fileStem.ts'
-import { RPC_ARGS_TYPE } from './RPC_ARGS_TYPE.ts'
-import { rpcUrlForFile } from './rpcUrlForFile.ts'
-import { writeDts } from './writeDts.ts'
-
-/*
-Emits a `.d.ts` that augments createTestApp's `RpcClient` interface with one
-entry per $rpc rpc, keyed by command name (the same key `app.rpc.<name>`
-resolves at runtime). Each entry lifts the rpc's args + resolved return out of
-its RemoteFunction so `app.rpc.getProduct({ id })` types against the rpc's own
-signature — args in, decoded body out, plus `.raw` for the Response. `RpcArgs`
-drops the FormData upload variant exactly as writeRpcDts does; `RpcReturn`
-reads the resolved body type. Written to `src/.abide/testRpc.d.ts` so the
-consumer's src tsconfig include picks it up, keyed on the project's abide
-import name.
-*/
-export async function writeTestRpcDts({
-    cwd,
-    rpcFiles,
-    importName,
-}: {
-    cwd: string
-    rpcFiles: string[]
-    importName: string
-}): Promise<void> {
-    const entries = rpcFiles
-        .map((file): [string, string] => {
-            const name = commandNameForUrl(rpcUrlForFile(file))
-            const importPath = `../server/rpc/${file}`
-            return [
-                name,
-                `RpcInvoker<typeof import(${JSON.stringify(importPath)}).${fileStem(file)}>`,
-            ]
-        })
-        .toSorted(([a], [b]) => (JSON.stringify(a) < JSON.stringify(b) ? -1 : 1))
-    const helperTypes = `${RPC_ARGS_TYPE}
-type RpcReturn<Fn> = Fn extends (...args: never[]) => Promise<infer Return> ? Return : never
-type RpcInvoker<Fn> = ((args?: RpcArgs<Fn>) => Promise<RpcReturn<Fn>>) & {
-    raw: (args?: RpcArgs<Fn>) => Promise<Response>
-}`
-    const module = augmentModule(`${importName}/test/createTestApp`, 'RpcClient', entries)
-    await writeDts(cwd, 'testRpc', `${helperTypes}\n\n${module}`)
-}

package/src/lib/shared/writeTestSocketsDts.ts

@@ -1,34 +0,0 @@
-import { augmentModule } from './augmentModule.ts'
-import { fileStem } from './fileStem.ts'
-import { socketNameForFile } from './socketNameForFile.ts'
-import { writeDts } from './writeDts.ts'
-
-/*
-Emits a `.d.ts` that augments createTestApp's `SocketClient` interface with one
-entry per $socket, keyed by socket name (the same key `app.sockets.<name>`
-resolves at runtime). The `socket(...)` helper statically returns `Socket<T>`,
-so each entry is the export's own type directly — `app.sockets.chat` types as
-`Socket<ChatMessage>`, iterable for the live stream with `.tail`/`.publish`.
-Written to `src/.abide/testSockets.d.ts` like its rpc sibling.
-*/
-export async function writeTestSocketsDts({
-    cwd,
-    socketFiles,
-    importName,
-}: {
-    cwd: string
-    socketFiles: string[]
-    importName: string
-}): Promise<void> {
-    const entries = socketFiles
-        .map((file): [string, string] => {
-            const importPath = `../server/sockets/${file}`
-            return [
-                socketNameForFile(file),
-                `typeof import(${JSON.stringify(importPath)}).${fileStem(file)}`,
-            ]
-        })
-        .toSorted(([a], [b]) => (JSON.stringify(a) < JSON.stringify(b) ? -1 : 1))
-    const module = augmentModule(`${importName}/test/createTestApp`, 'SocketClient', entries)
-    await writeDts(cwd, 'testSockets', module)
-}

package/src/lib/test/assertAgentFrameConformance.ts

@@ -1,73 +0,0 @@
-import type { AgentFrame } from '../server/agent.ts'
-
-/*
-Collects an engine's frame stream and asserts the neutral AgentFrame contract
-every provider engine must satisfy, throwing a plain Error (test-framework
-agnostic) on the first violation:
-
-  - the stream ends with exactly one `done` frame and yields nothing after it
-  - every `tool_use` is answered by exactly one `tool_result` carrying the
-    same id and name, in use-then-result order
-  - no `tool_result` arrives for an unannounced id
-  - text deltas are strings
-
-Returns the collected frames plus the `done` frame so a scenario can layer
-its provider-specific assertions on top. This is the conformance seam: one
-suite of invariants, N engine adapters run against it.
-*/
-// @documentation plumbing
-export async function assertAgentFrameConformance(
-    stream: AsyncIterable<AgentFrame>,
-): Promise<{ frames: AgentFrame[]; done: Extract<AgentFrame, { type: 'done' }> }> {
-    const frames: AgentFrame[] = []
-    for await (const frame of stream) {
-        frames.push(frame)
-    }
-    if (frames.length === 0) {
-        throw new Error('conformance: engine yielded no frames — expected at least a done frame')
-    }
-
-    const doneIndexes = frames.flatMap((frame, index) => (frame.type === 'done' ? [index] : []))
-    if (doneIndexes.length !== 1) {
-        throw new Error(`conformance: expected exactly one done frame, saw ${doneIndexes.length}`)
-    }
-    if (doneIndexes[0] !== frames.length - 1) {
-        throw new Error(
-            `conformance: frames continued after done (done at ${doneIndexes[0]} of ${frames.length - 1})`,
-        )
-    }
-
-    const openToolUses = new Map<string, string>()
-    for (const [index, frame] of frames.entries()) {
-        if (frame.type === 'text' && typeof frame.delta !== 'string') {
-            throw new Error(`conformance: text frame at ${index} has a non-string delta`)
-        }
-        if (frame.type === 'tool_use') {
-            if (openToolUses.has(frame.id)) {
-                throw new Error(`conformance: duplicate tool_use id ${frame.id} at ${index}`)
-            }
-            openToolUses.set(frame.id, frame.name)
-        }
-        if (frame.type === 'tool_result') {
-            const expectedName = openToolUses.get(frame.id)
-            if (expectedName === undefined) {
-                throw new Error(
-                    `conformance: tool_result at ${index} answers unannounced id ${frame.id}`,
-                )
-            }
-            if (frame.name !== expectedName) {
-                throw new Error(
-                    `conformance: tool_result at ${index} names ${frame.name}, tool_use said ${expectedName}`,
-                )
-            }
-            openToolUses.delete(frame.id)
-        }
-    }
-    if (openToolUses.size > 0) {
-        const unanswered = Array.from(openToolUses.keys()).join(', ')
-        throw new Error(`conformance: tool_use without a tool_result: ${unanswered}`)
-    }
-
-    const done = frames[frames.length - 1] as Extract<AgentFrame, { type: 'done' }>
-    return { frames, done }
-}