@abide/abide 0.57.1 → 0.100.0

package/src/lib/server/sockets/socketRegistry.ts

@@ -1,9 +0,0 @@
-import type { SocketRegistryEntry } from './types/SocketRegistryEntry.ts'
-
-/*
-Process-wide registry of every Socket declared in the app. defineSocket
-inserts on first construction; the dispatcher reads on every `sub` /
-`pub` frame and every REST request so it can find the right Socket by
-name and check the opted-in `allowClientPublish` policy.
-*/
-export const socketRegistry = new Map<string, SocketRegistryEntry>()

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

@@ -1,22 +0,0 @@
-import type { HttpMethod } from '../../../shared/types/HttpMethod.ts'
-
-/*
-One operation a socket exposes to the non-browser surfaces. A socket
-always offers a `tail` (read recent / stream live) and, when
-`clientPublish` is set, a `publish` (send a message). This is the shared
-skeleton — name, kind, HTTP face — that the CLI manifest, the MCP tool
-list, and the MCP dispatcher all read instead of re-deriving the naming
-convention and existence rule independently. Each surface dresses it with
-its own presentation (descriptions, input schema, annotations).
-*/
-export type SocketOperation = {
-    kind: 'tail' | 'publish'
-    // Command/tool name: the socket's command-name base plus `-tail` / `-publish`.
-    name: string
-    // Raw socket name, for the HTTP path and human-facing descriptions.
-    socketName: string
-    // HTTP face of the operation: `/__abide/sockets/<name>`.
-    restUrl: string
-    // GET for tail, POST for publish.
-    method: HttpMethod
-}

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

@@ -1,26 +0,0 @@
-import type { ClientFlags } from '../../../shared/types/ClientFlags.ts'
-import type { StandardSchemaV1 } from '../../../shared/types/StandardSchemaV1.ts'
-
-/*
-Server-side options passed when declaring a socket via `socket<T>(opts)`.
-`tail` opts the topic into retention: the socket keeps its last `tail`
-frames so readers that weren't there — late joiners, reconnects, the
-CLI/MCP/SSE read surfaces — can seed from `.tail(count)`. Omitted, the
-socket is a pure live pipe and storage is the consumer's concern (a
-`tail(chat, { last: n })` window fills from live frames only). Per-frame
-TTL (retained frames older than `ttl` ms are evicted before replay), and
-the client-publish gate (off by default — server-only topics ignore pub
-frames coming over the wire). Optional Standard Schema validates payloads on
-publish and gives MCP / CLI a typed payload to describe (projected via the
-schema's own `toJSONSchema()` — wrap with withJsonSchema if its library lacks
-one). `clients` controls which non-browser surfaces (mcp / cli) expose this
-socket; browser is the historical default. All server-only state the bundler
-strips out of the client stub.
-*/
-export type SocketOptions<Schema extends StandardSchemaV1 = StandardSchemaV1> = {
-    tail?: number
-    ttl?: number
-    clientPublish?: boolean
-    schema?: Schema
-    clients?: Partial<ClientFlags>
-}

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

@@ -1,19 +0,0 @@
-import type { ClientFlags } from '../../../shared/types/ClientFlags.ts'
-import type { Socket } from '../../../shared/types/Socket.ts'
-import type { StandardSchemaV1 } from '../../../shared/types/StandardSchemaV1.ts'
-
-/*
-Per-socket registry record. The Socket itself stays uniform between
-server and client by parking policy state (retained-tail snapshot, client
-publish gate, payload schema, client targeting) here instead of leaking
-into the public Socket shape.
-*/
-export type SocketRegistryEntry = {
-    socket: Socket<unknown>
-    allowClientPublish: boolean
-    schema: StandardSchemaV1 | undefined
-    clients: ClientFlags
-    /* last `count` retained frames (whole tail when omitted) — the read-only
-       face shared by the ws sub replay, the HTTP rest() face, and MCP tail */
-    snapshotTail(count?: number): unknown[]
-}

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

@@ -1,10 +0,0 @@
-import type { Socket } from '../../../shared/types/Socket.ts'
-
-/*
-Manifest of socket-name → module loader. Produced by the resolver
-plugin from each `.ts` under src/server/sockets/. Each module has exactly one
-named export, a Socket whose `.name` was stamped in by the bundler
-rewrite. The dispatcher imports a module on first access and caches the
-resolved Socket against its name.
-*/
-export type SocketRoutes = Record<string, () => Promise<Record<string, Socket<unknown>>>>

package/src/lib/server/sse.ts

@@ -1,58 +0,0 @@
-/*
-Wraps an AsyncIterable<Frame> in a Response whose body is
-Server-Sent Events (text/event-stream) — each frame becomes one
-`data: <json>\n\n` event. Used inside an rpc handler to expose a
-generator over plain HTTP so EventSource (or `tail(fn.stream(args))`
-on the client) can consume it frame-by-frame.
-
-  export const orderFeed = GET((args: Args) =>
-      sse(async function* () {
-          for await (const order of db.watchOrders(args)) yield order
-      }())
-  )
-
-A 15s keepalive comment (`: keepalive\n\n`) is sent between frames so
-intermediaries (proxies, load balancers) don't drop an idle connection.
-Comments are ignored by EventSource per the spec, so they're invisible to
-consumers.
-
-Cancellation flows from the consumer through ReadableStream's `cancel`
-into `iter.return()` so the handler's `for await` exits via its normal
-control path. Errors are emitted as an `event: error` frame carrying only
-the message (full error logged server-side) before the stream closes;
-EventSource surfaces this via its `error` listener and `tail()`
-maps it to the entry's `error` field.
-*/
-import { NO_STORE } from '../shared/CACHE_CONTROL_VALUES.ts'
-import { encodeWireBody } from '../shared/encodeWireBody.ts'
-import { sseErrorFrame } from '../shared/sseErrorFrame.ts'
-import type { TypedResponse } from './rpc/types/TypedResponse.ts'
-import { streamFromIterator } from './runtime/streamFromIterator.ts'
-import { withResponseDefaults } from './runtime/withResponseDefaults.ts'
-
-const KEEPALIVE_INTERVAL_MS = 15000
-
-// @documentation response
-export function sse<Frame>(
-    iterable: AsyncIterable<Frame>,
-    init?: ResponseInit,
-): TypedResponse<AsyncIterable<Frame>> {
-    const body = streamFromIterator(iterable, {
-        /* Honest-JSON encode (same encoder as `json()`) so a frame carrying a Set/Map/bigint
-           crosses losslessly instead of the silent `{}` / bigint-throw plain JSON.stringify gave
-           — parseSse's JSON.parse reads it unchanged since the wire stays honest JSON. */
-        encodeFrame: (value) => `data: ${encodeWireBody(value)}\n\n`,
-        encodeError: (message) => sseErrorFrame.encode(message),
-        keepaliveMs: KEEPALIVE_INTERVAL_MS,
-        keepalivePayload: ': keepalive\n\n',
-    })
-    return new Response(
-        body,
-        withResponseDefaults(init, {
-            'Content-Type': 'text/event-stream; charset=utf-8',
-            'Cache-Control': NO_STORE,
-            'X-Content-Type-Options': 'nosniff',
-            Connection: 'keep-alive',
-        }),
-    ) as TypedResponse<AsyncIterable<Frame>>
-}

package/src/lib/shared/ABIDE_PACKAGE_NAME.ts

@@ -1,7 +0,0 @@
-/*
-The package's published npm name. The codegen and the import-name resolver
-match a consuming project's dependency (direct or aliased) against this to
-decide which specifier to emit, so keeping it in one place means a future
-rename touches a single constant.
-*/
-export const ABIDE_PACKAGE_NAME = '@abide/abide'

package/src/lib/shared/ABIDE_VERSION.ts

@@ -1,9 +0,0 @@
-import packageJson from '../../../package.json' with { type: 'json' }
-
-/*
-The framework's own version, inlined at build time from abide's package.json
-(a compiled binary has no node_modules to read at runtime). Rides the health
-payload's `abide` field — truthy for the "is this a abide server" check,
-informative for skew diagnosis.
-*/
-export const ABIDE_VERSION: string = packageJson.version

package/src/lib/shared/AMEND_TOPIC_PREFIX.ts

@@ -1,9 +0,0 @@
-/*
-Reserved topic-family prefix for the per-call amend value channel (ADR-0043). A
-server-side `amend(args, value)` broadcasts on `${AMEND_TOPIC_PREFIX}${cacheKey}`, and
-a client with a live reader of that exact call subscribes to the same topic — so a
-pushed value only ever reaches a browser already reading (and therefore authorized
-for) that key. Under the reserved `__abide/` namespace so user code can't shadow it,
-and per-call (not per-rpc) so the subscription set doubles as the authorized-reader set.
-*/
-export const AMEND_TOPIC_PREFIX = '__abide/amend/'

package/src/lib/shared/ASYNC_CELL.ts

@@ -1,5 +0,0 @@
-/* Brand on an async cell's facet (`AsyncComputed`/`AsyncState`). The probe family
-   (`peek`/`pending`/`refreshing`/`refresh`) tests for it to route a cell to its own
-   methods, the way `Symbol.asyncIterator` routes a stream. A well-known symbol (not a
-   string key) so it never collides with a resolved value's own properties. */
-export const ASYNC_CELL: unique symbol = Symbol.for('abide.asyncCell')

package/src/lib/shared/CACHE_CONTROL_VALUES.ts

@@ -1,16 +0,0 @@
-/*
-Cache-Control values used by abide's framework responses. Centralised so
-the framework's policy (no-store on errors and rpc dispatch helpers,
-private/no-cache on SSR HTML, the static-asset policies) lives in one place
-and can't drift between the server core, the asset servers, and the respond
-helpers.
-*/
-export const NO_STORE = 'no-store'
-export const SSR_CACHE_CONTROL = 'private, no-cache'
-
-// Content-addressed `/_app/` chunks (name carries the hash) — cache forever.
-export const IMMUTABLE_ASSET_CACHE_CONTROL = 'public, max-age=31536000, immutable'
-// Unhashed `/_app/` entries (entry bundle, shell) — must revalidate each time.
-export const REVALIDATE_ASSET_CACHE_CONTROL = 'public, max-age=0, must-revalidate'
-// Files served from public/ at the site root — short shared cache.
-export const PUBLIC_ASSET_CACHE_CONTROL = 'public, max-age=3600'

package/src/lib/shared/CACHE_STALENESS_SOCKET.ts

@@ -1,8 +0,0 @@
-/*
-The reserved internal socket the server broadcasts cache-staleness frames on
-(ADR-0041): server-publish-only (`clientPublish: false`) and a pure live pipe
-(`tail: 0`, no retention) — delivery is live-only, never replayed, so an offline
-client falls back to SWR staleness. Named in the reserved `__abide/` namespace so
-user code can't shadow it.
-*/
-export const CACHE_STALENESS_SOCKET = '__abide/cache'

package/src/lib/shared/CLI_PATH.ts

@@ -1,7 +0,0 @@
-/*
-Path of the CLI install endpoint: the bare path returns the platform-detecting
-install script, `${CLI_PATH}/<platform>` the platform tarball. Shared so the
-server mount (createServer) and the script the install endpoint emits
-(installScript) agree on the path.
-*/
-export const CLI_PATH = '/__abide/cli'

package/src/lib/shared/DEFER.ts

@@ -1,8 +0,0 @@
-/*
-The sentinel `bodyValueForKind` returns for the `streaming` and `binary` body kinds —
-those whose handling is side-specific (the live read throws on streaming and blobs on
-binary; the warm read has no synchronous equivalent), so the caller branches on it
-rather than receiving a directly-usable value. A `unique symbol` so a body value can
-never collide with it.
-*/
-export const DEFER: unique symbol = Symbol('defer')

package/src/lib/shared/DEV_REBUILD_PATH.ts

@@ -1,6 +0,0 @@
-/*
-Dev-only manual-rebuild trigger: POSTing here signals the orchestrator to rebuild +
-restart. Mounted only under `abide dev`. Shared so the router mount and the launcher's
-"POST … to apply" hint name the one path.
-*/
-export const DEV_REBUILD_PATH = '/__abide/reload'

package/src/lib/shared/DEV_RELOAD_PATH.ts

@@ -1,6 +0,0 @@
-/*
-Path of the dev-only live-reload SSE channel. Shared so the server mount
-(createServer) and the client script injected into dev pages
-(DEV_RELOAD_CLIENT_SCRIPT) agree on the path.
-*/
-export const DEV_RELOAD_PATH = '/__abide/dev'

package/src/lib/shared/HEALTH_PATH.ts

@@ -1,7 +0,0 @@
-/*
-The canonical liveness/health endpoint: the identity payload plus whatever
-the app's optional `health(request)` hook contributes. `/__abide/identity`
-stays as a compatibility alias serving the same payload (older launchers
-probe it; probeAbideServer falls back to it for older servers).
-*/
-export const HEALTH_PATH = '/__abide/health'

package/src/lib/shared/HTTP_METHODS.ts

@@ -1,6 +0,0 @@
-/*
-The canonical RPC/HTTP verbs abide understands. One source of truth so the `HttpMethod`
-type, the loader's rpc-export detection, and the compiler's helper set can't drift on which
-export names are rpc entrypoints.
-*/
-export const HTTP_METHODS = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'HEAD'] as const

package/src/lib/shared/HttpError.ts

@@ -1,30 +0,0 @@
-/*
-Thrown by remote-function calls when the server responds with a non-2xx
-status. Carries the raw Response so callers can inspect body, headers, or
-status text — useful for showing user-friendly error UI without having to
-opt every call site into the `.raw()` escape hatch.
-*/
-// @documentation response
-export class HttpError extends Error {
-    readonly status: number
-    readonly statusText: string
-    readonly response: Response
-    /* Set when the handler returned a typed error (`error.typed(...)` constructor) or a
-       validation 422: `kind` is the declared error name (or 'validation'), `data` the
-       payload it carried — parsed off the `{ $abideError, data }` body by decodeResponse.
-       `data` is typed `unknown` (a throw can't carry the rpc's per-kind type to the
-       catch); narrow it yourself — for `kind: 'validation'` the shape is the exported
-       `ValidationErrorData` (`{ issues, fields }`). Both undefined for a plain `error(status, text)`. */
-    readonly kind?: string
-    readonly data?: unknown
-
-    constructor(response: Response, kind?: string, data?: unknown) {
-        super(`HTTP ${response.status} ${response.statusText || 'error'}`)
-        this.name = 'HttpError'
-        this.status = response.status
-        this.statusText = response.statusText
-        this.response = response
-        this.kind = kind
-        this.data = data
-    }
-}

package/src/lib/shared/IDENTITY_PATH.ts

@@ -1,6 +0,0 @@
-/*
-Path of the identity probe answering `{ abide, name, version }` ahead of any
-app middleware. Shared so the server mount (createServer) and the launcher's
-probe (probeAbideServer) agree on the path.
-*/
-export const IDENTITY_PATH = '/__abide/identity'

package/src/lib/shared/INSPECTOR_PATH.ts

@@ -1,7 +0,0 @@
-/*
-Mount root of the opt-in inspector surface (the `@abide/inspector` package,
-activated by ABIDE_ENABLE_INSPECTOR=true). The UI sits at this exact path; its
-data endpoints (`/surface`, `/events`) live under `${INSPECTOR_PATH}/`. Shared
-so createServer's route gate and the inspector handler agree on the prefix.
-*/
-export const INSPECTOR_PATH = '/__abide/inspector'

package/src/lib/shared/MCP_PATH.ts

@@ -1,6 +0,0 @@
-/*
-The MCP endpoint: inbound JSON-RPC over HTTP delegated to the app's `McpServer.handle`,
-mounted only when an `mcp` is configured. Framework-internal (`/__abide/*`). Shared so the
-router mount and the boot-time disclosure warning name the one path.
-*/
-export const MCP_PATH = '/__abide/mcp'

package/src/lib/shared/NAV_HEADER.ts

@@ -1,8 +0,0 @@
-/*
-Request header the client router stamps (value '1') on its SPA navigation probe:
-a bare fetch of the destination that exists only to run app.handle server-side
-(auth, redirect, header gating) without paying for a render. Presence tells the
-page dispatcher to answer 204 once handle() has passed — a redirect or block from
-handle() never reaches that point. Absence is an ordinary document/render request.
-*/
-export const NAV_HEADER = 'abide-nav'

package/src/lib/shared/OFFLINE_HEADER.ts

@@ -1,8 +0,0 @@
-/*
-Request header a abide client fetch sets (value '1') only when navigator.onLine
-is false, so a handler's online() reflects the calling client's connectivity.
-Presence = offline; absence = online/unknown. In a bundle the client and the
-embedded server share a machine, so this carries exactly the outbound
-reachability a handler reaching external sites needs.
-*/
-export const OFFLINE_HEADER = 'abide-offline'

package/src/lib/shared/PROXIED_SERVER_SUBDIRS.ts

@@ -1,15 +0,0 @@
-/*
-Single source of truth for the proxied/server-only split. These are the only
-subdirectories under src/server/ whose modules the client bundle replaces with
-proxy stubs instead of shipping their real source: src/server/rpc (each
-HTTP-method handler → remoteProxy) and src/server/sockets (each socket
-declaration → socketProxy). Every OTHER module under src/server/ is server-only
-and must never reach the browser bundle.
-
-Expressed as bare `src/server/`-relative segments so each caller joins them
-against its own base — the resolver plugin against the absolute serverDir, the
-dev orchestrator's changeAffectsClient against the `server/` string prefix —
-rather than re-spelling the set. Adding a proxied directory is one edit here and
-both side-classifiers move in lockstep.
-*/
-export const PROXIED_SERVER_SUBDIRS = ['rpc', 'sockets'] as const

package/src/lib/shared/REF_JSON_HEADER.ts

@@ -1,9 +0,0 @@
-/*
-Request header the RPC client stamps (value '1') when an `application/json` body is
-ref-json-encoded (encodeRefJson), so the server decodes with the matching codec.
-Its presence is the unambiguous discriminator: ref-json's `[rootValue, slots]`
-envelope collides with a legitimate plain-JSON 2-element array body, so the shape
-alone can't be trusted. Absence means an ordinary JSON body from a non-abide client
-(curl, an OpenAPI-generated SDK, a webhook) — parseArgs reads it with plain JSON.parse.
-*/
-export const REF_JSON_HEADER = 'abide-ref-json'

package/src/lib/shared/REF_JSON_TAGS.ts

@@ -1,43 +0,0 @@
-/*
-Value tags for the ref-json codec (encodeRefJson / decodeRefJson). The output is
-a `[rootValue, slots]` pair: `slots` holds only the hoisted CONTAINERS (objects,
-arrays, Maps, Sets) addressed by index; every other value is encoded INLINE at its
-position — a bare JSON primitive, or one of these tagged arrays. Primitives never
-get their own slot, so a primitive-heavy payload stays close to plain-JSON size and
-speed. A tag is always the first element of a JSON array at a value position; bare
-JSON values are literal primitives, and plain objects only ever appear AS slots
-(hoisted), so user data — even an object keyed `~r` or an array shaped like a tag —
-can't collide with these. Shared between encoder and decoder so the tokens can't drift.
-*/
-export const REF_JSON_TAGS = {
-    // ['~r', slotIndex] — reference to a hoisted container; breaks cycles, preserves shared identity.
-    REF: '~r',
-    // ['~a', ...values]
-    ARRAY: '~a',
-    // ['~m', [[keyValue, valValue], …]]
-    MAP: '~m',
-    // ['~s', [value, …]]
-    SET: '~s',
-    // ['~d', epochMs]
-    DATE: '~d',
-    // ['~x', source, flags]
-    REGEXP: '~x',
-    // ['~g', decimalString] — BigInt can't go through JSON natively.
-    BIGINT: '~g',
-    // ['~u'] — undefined (and functions/symbols, folded to it).
-    UNDEFINED: '~u',
-    // ['~n', token] — the numbers JSON flattens to null; the token is one of REF_JSON_NUMBER_TOKENS.
-    NUMBER: '~n',
-} as const
-
-/*
-The tokens carried by a `['~n', token]` tag — the numbers JSON can't represent. Shared by
-`encodeRefJson`'s `numberToken` (produces them) and `decodeRefJson`'s `decodeNumberToken`
-(parses them) so the wire form can't drift between the two ends.
-*/
-export const REF_JSON_NUMBER_TOKENS = {
-    NAN: 'NaN',
-    INFINITY: 'Infinity',
-    NEG_INFINITY: '-Infinity',
-    NEG_ZERO: '-0',
-} as const

package/src/lib/shared/REMOTE_FUNCTION.ts

@@ -1,8 +0,0 @@
-/*
-Brand set by createRemoteFunction on both the decoded callable and its raw
-sibling — the exact answer to "is this a abide remote?" where structural
-checks ('url' in fn) would misclassify any user function that happens to
-carry a url property. Read by cache()'s remote/producer discriminator,
-selectorPrefix's identity branch, and the route dispatcher's export scan.
-*/
-export const REMOTE_FUNCTION: unique symbol = Symbol('abide.remoteFunction')

package/src/lib/shared/REPLAYABLE_METHODS.ts

@@ -1,12 +0,0 @@
-/*
-Methods whose remote-call cache entries can be replayed on the client from an
-SSR snapshot: the key (method + url + args-in-url) carries everything needed to
-re-issue the request, and re-issuing is safe. Only GET qualifies — it is the
-one safe (read-only) method. DELETE is idempotent but still a write, and
-body-carrying writes (POST/PUT/PATCH) additionally don't round-trip through
-the snapshot; none of them may re-fire unprompted. Shared by snapshot
-serialization and the invalidate-policy guard so both agree on which methods
-are replayable. Deliberately not consulted by the server's ttl: 0 keep —
-within one request, writes coalesce like everything else.
-*/
-export const REPLAYABLE_METHODS: ReadonlySet<string> = new Set(['GET'])

package/src/lib/shared/RESERVED_SOCKET_PREFIX.ts

@@ -1,8 +0,0 @@
-/*
-The reserved socket-name namespace (ADR-0041). Framework-minted internal topics
-live under `__abide/` (e.g. the cache-staleness pipe); user socket files under
-`src/server/sockets` may not declare a name in this namespace — createServer rejects
-the boot, and the dispatcher resolves these names straight from the registry
-(bypassing the user-module loader) so an internal topic can never be shadowed.
-*/
-export const RESERVED_SOCKET_PREFIX = '__abide/'

package/src/lib/shared/RPC_ARGS_TYPE.ts

@@ -1,7 +0,0 @@
-/*
-The `RpcArgs<Fn>` type alias both rpc d.ts writers emit verbatim: it lifts the
-args type out of a RemoteFunction, dropping the FormData upload variant so a
-url()/test-client call types against the rpc's plain args.
-*/
-export const RPC_ARGS_TYPE =
-    'type RpcArgs<Fn> = Fn extends (args: infer Args) => unknown ? Exclude<Args, FormData> : never'

package/src/lib/shared/RPC_SHIM_GLOBALS.ts

@@ -1,9 +0,0 @@
-/*
-The reserved global alias names the `$rpc`/`$socket` module rewrites target: the bundler's
-banner binds each (`import { defineRpc as __abideDefineRpc__ }`, see abideResolverPlugin) and
-the codegen emit (`prepareRpcModule` / `prepareSocketModule`) calls it. Shared so the emitted
-call and the banner binding can't drift into an unbound-name ReferenceError at load.
-*/
-export const DEFINE_RPC_GLOBAL = '__abideDefineRpc__'
-export const REMOTE_PROXY_GLOBAL = '__abideRemoteProxy__'
-export const DEFINE_SOCKET_GLOBAL = '__abideDefineSocket__'

package/src/lib/shared/SEEDS.ts

@@ -1,33 +0,0 @@
-/*
-The ONE hydration seed manifest (ADR-0048): every passive server→client warm-seed
-partition — await resumes, async-cell values, doc snapshots, socket frames — rides a single
-`globalThis.__abideSeeds` global, kind-partitioned. Each partition is a Record of ref-json
-STRINGS decoded lazily at its read site, so the inline pre-bundle scripts (the SSR swap
-script, the resume seed script) can write entries without the codec. The per-kind module
-names (`RESUME`, `CELL_SEED`, `DOC_SEED`, `SOCKET_SEED`) are views onto these partitions,
-so consumers keep their domain name while the wire carries one global.
-
-Each partition initializes with its own `??=` — NOT one whole-object create — because the
-vanilla scripts and the bundle race in either order and a script that ran first may have
-created the root with only its own partition; whoever arrives later must fill the gaps and
-adopt the same references. The live streamed-cell machinery (`STREAMED_CELLS`) and the head
-collector buffer (`__abideResumeCache`) deliberately stay separate: they are apply-timing
-phases (ADR-0040), not passive manifests.
-*/
-type SeedPartitions = {
-    resume: Record<string, string>
-    cells: Record<string, string>
-    docs: Record<string, string>
-    sockets: Record<string, string>
-}
-
-const globalScope = globalThis as { __abideSeeds?: Partial<SeedPartitions> }
-globalScope.__abideSeeds ??= {}
-const root = globalScope.__abideSeeds
-root.resume ??= {}
-root.cells ??= {}
-root.docs ??= {}
-root.sockets ??= {}
-
-// @documentation plumbing
-export const SEEDS: SeedPartitions = root as SeedPartitions

package/src/lib/shared/SOCKETS_PATH.ts

@@ -1,7 +0,0 @@
-/*
-Mount path of the framework's socket multiplex: the single ws upgrade point,
-with the per-socket HTTP face under `${SOCKETS_PATH}/<name>`. Shared so the
-server mount (createServer), the browser channel's dial (socketChannel), and
-the REST face advertised to the CLI/MCP (socketOperations) agree on the path.
-*/
-export const SOCKETS_PATH = '/__abide/sockets'

package/src/lib/shared/SOCKET_SEED.ts

@@ -1,12 +0,0 @@
-import { SEEDS } from './SEEDS.ts'
-
-/* The socket warm-seed manifest: a socket's retained latest frame as read via `peek(socket)` during
-   SSR, keyed by the socket's name, as a ref-json-encoded STRING (decoded at the read site in
-   `socketProxy`). `startClient` drains `__SSR__.sockets` into here before mount; a hydrating
-   `socketProxy` reads its key to seed the socket's `lastFrame` WARM, so `peek(socket)` returns the
-   SAME retained value the server rendered instead of `undefined` on the not-yet-connected client —
-   killing the SSR/hydration divergence that would otherwise discard the server markup and cold-render.
-
-   The `sockets` partition of the one `__abideSeeds` manifest (ADR-0048, see SEEDS). */
-// @documentation plumbing
-export const SOCKET_SEED: Record<string, string> = SEEDS.sockets

package/src/lib/shared/SSR_SCRIPT_ID.ts

@@ -1,11 +0,0 @@
-/*
-The id of the `<script type="application/json">` element the server emits the
-`window.__SSR__` payload into and the client (`startClient`) parses back out
-(ADR-0051). Shipping the payload as inert JSON data — not a `window.__SSR__ = {…}`
-executable statement — means the browser never COMPILES a multi-MB object literal
-as JavaScript on the critical path; the deferred client bundle reads it with one
-`JSON.parse` (a restricted grammar parsed several times faster than equivalent JS
-source). Both sides import this constant so the write id and read id can't drift.
-*/
-// @documentation plumbing
-export const SSR_SCRIPT_ID = 'abide-ssr'

package/src/lib/shared/STREAMING_CONTENT_TYPES.ts

@@ -1,12 +0,0 @@
-/*
-Content-Type prefixes abide treats as streaming bodies — SSE for the
-`sse()` helper, JSONL / NDJSON for the `jsonl()` helper. Used by
-contentBodyKind (called by decodeResponse and the one-shot path in
-streamResponse) to classify content, and by streamResponse to select the
-JSONL frame parser.
-*/
-export const STREAMING_CONTENT_TYPES = [
-    'text/event-stream',
-    'application/jsonl',
-    'application/x-ndjson',
-]

package/src/lib/shared/SocketDisconnectedError.ts

@@ -1,13 +0,0 @@
-/*
-Typed transport-loss signal: the multiplexed ws channel went down and tore this
-subscription with it. Distinct from an application error (a server `err` frame)
-because it is recoverable — tail() catches this type to reconnect with the
-last value retained (refreshing), while raw `for await` consumers surface it
-like any other error and keep manual control over reconciliation.
-*/
-export class SocketDisconnectedError extends Error {
-    constructor() {
-        super('socket channel disconnected')
-        this.name = 'SocketDisconnectedError'
-    }
-}

package/src/lib/shared/TEXT_PLAIN.ts

@@ -1,7 +0,0 @@
-/*
-Content-Type for the framework's plain-text responses (404, 405, CSRF refusal,
-internal error). Explicit so intermediaries don't sniff the body and browsers
-render it inline — a bodied Response with no Content-Type ships as
-`application/octet-stream`, which the browser downloads instead of displaying.
-*/
-export const TEXT_PLAIN = 'text/plain; charset=utf-8'

package/src/lib/shared/abideImportName.ts

@@ -1,44 +0,0 @@
-import { ABIDE_PACKAGE_NAME } from './ABIDE_PACKAGE_NAME.ts'
-import { readPackageJson } from './readPackageJson.ts'
-
-/*
-Resolves the bare specifier prefix a consuming project imports abide under —
-the name abide is installed as in its package.json. A project may depend on
-abide directly (`abide`) or behind a package alias
-(`"abide": "npm:abide@..."`, or `workspace:abide@*`
-inside this repo). An alias-only install resolves only under the alias key and
-a direct install only under the canonical name, so the generated rpc / socket
-/ prompt modules must import under whichever name the project
-declared.
-
-Prefers a `abide` alias (the ergonomic surface the docs use) when present, then
-a direct canonical dependency, then any other alias targeting abide. Falls back
-to the canonical name when abide isn't found in package.json — the build can't
-resolve abide at all in that case, and the canonical name yields the clearest
-resolution error.
-*/
-export async function abideImportName(cwd: string): Promise<string> {
-    const packageJson = (await readPackageJson(cwd)) as
-        | { dependencies?: Record<string, string>; devDependencies?: Record<string, string> }
-        | undefined
-    if (!packageJson) {
-        return ABIDE_PACKAGE_NAME
-    }
-    const dependencies = { ...packageJson.devDependencies, ...packageJson.dependencies }
-    /*
-    Alias entries whose target is abide — `npm:` for a published install,
-    `workspace:` for the in-repo examples. The key is the name the project
-    imports under; the version suffix (`@^0.2.0`, `@*`) is optional.
-    */
-    const aliasPattern = new RegExp(`^(npm|workspace):${ABIDE_PACKAGE_NAME}(@.*)?$`)
-    const aliasNames = Object.entries(dependencies)
-        .filter(([, specifier]) => aliasPattern.test(specifier))
-        .map(([name]) => name)
-    if (aliasNames.includes('abide')) {
-        return 'abide'
-    }
-    if (ABIDE_PACKAGE_NAME in dependencies) {
-        return ABIDE_PACKAGE_NAME
-    }
-    return aliasNames[0] ?? ABIDE_PACKAGE_NAME
-}