snapback2 0.0.1

package/README.md

@@ -0,0 +1,127 @@
+# snapback2
+
+Snapback 2's package contains the Quarry compiler, TypeScript lowering descriptors,
+headless client, React web arm, and CLI shim. It requires Node 20 or newer for Node clients.
+
+```sh
+npm install snapback2 react
+```
+
+```ts
+import { api, createClient } from "snapback2/client";
+
+const client = createClient({ url: process.env.SNAPBACK_URL!, as: "alice" });
+const page = await client.query(api.messages.thread, { conversationId: "conversation-1", c: null });
+
+const sub = client.subscribe(api.messages.thread, { conversationId: "conversation-1", c: null }, console.log);
+await sub.until((delivery) => delivery.state === "complete" && delivery.live);
+sub.close();
+```
+
+The generated `.snapback/build/api.d.ts` is the only source of `api` members, so
+operation and channel arguments flow through the headless client and React hooks
+without committed generated code. Typos and extra arguments are compile errors.
+
+```tsx
+import { SnapbackProvider, useMutation, useQuery } from "snapback2/react";
+import { api } from "snapback2/client";
+
+function Messages() {
+  const messages = useQuery(api.messages.thread, { conversationId: "conversation-1", c: null });
+  const send = useMutation(api.messages.send);
+  if (messages.state === "hydrating") return <>Loading…</>;
+  return <button disabled={send.pending} onClick={() => send.run({ conversationId: "conversation-1", recipientId: "profile-bob", body: "Hi" })}>
+    {messages.state}
+  </button>;
+}
+
+export const App = () => <SnapbackProvider url="http://127.0.0.1:3210" as="alice">
+  <Messages />
+</SnapbackProvider>;
+```
+
+Reads surface exactly seven states: `hydrating`, `complete`, `capped`, `partial`,
+`denied`, `refused`, and `stale`. A subscription frame retains its server receipt
+state and sets the orthogonal `live: true`; stream loss changes the view to
+`stale` with `live: false` only after a receipt has been delivered. An initial
+connection failure remains `hydrating`. Transport status is separately exposed as
+`connection: "connected" | "reconnecting" | "offline"`. `useQuery` subscribes by
+default; pass `{ live: false }` for a one-shot query, which remains `hydrating` and
+retries while its connection is reconnecting.
+
+`useMutation` returns `{ run, pending, last, transport }`. `pending` covers the
+in-flight interval, and `last` is only the most recent server `committed` or
+`rejected` receipt. A retryable HTTP or network failure rejects `run`, leaves
+`last` untouched, and appears separately as `transport` until the next successful
+run. `queued` is reserved for the deferred offline outbox and is not a v1 mutation
+state.
+
+## Assets
+
+Generated image and video arguments accept either their closed record or a
+browser `File`. The client reads the operation's current manifest descriptors,
+preflights every file against its byte bound, uploads them, and substitutes the
+returned records before invoking the mutation. An Expo source may instead be
+`{ uri, size?, fileSize?, type?, mimeType? }`, matching Expo ImagePicker's
+`uri`/`fileSize`/`mimeType` fields. The optional `expo-file-system` peer opens
+`file://` and `content://` URIs as a native Blob-compatible `File`; when neither size
+field is supplied, its `File.size` provides the required upload length. The
+web bundle does not include that peer, and URI bytes never pass through a
+custom owner `fetch` supplied to `createClient`. Native File uploads use the
+documented direct File body through `expo/fetch`; progress reports whole-body
+start and successful completion (0, then total) because that transport does
+not expose streaming request progress.
+
+Native URI uploads require the optional peers `expo >=54` and
+`expo-file-system >=19`. Version 19.0.0
+[made the modern API the package-root default](https://github.com/expo/expo/blob/main/packages/expo-file-system/CHANGELOG.md#1900---2025-08-13),
+and Expo SDK 54 pairs it with `~19.0.24` and documents both the package-root
+`File` import and direct `expo/fetch` upload body in the
+[SDK 54 FileSystem API](https://docs.expo.dev/versions/v54.0.0/sdk/filesystem/).
+
+```ts
+const sent = await client.mutation(api.messages.sendPhoto, {
+  conversationId: "conversation-1",
+  photo: file,
+});
+
+const record = await client.upload(file, {
+  kind: "image",
+  onProgress: ({ loaded, total }) => console.log(loaded, total),
+});
+```
+
+`client.upload` is the explicit two-step form. Pass `kind` to get the nominal
+`ImageAsset`/`VideoAsset` back for a later mutation; the server still decides by
+sniffing the bytes and the client refuses `E_ASSET_TYPE` if the two disagree.
+Without `kind` the result is the union. Upload and transport failures
+reject; a mutation refusal still resolves as a `MutationRejected` receipt.
+
+React renders closed records and keeps authority out of image URLs:
+
+```tsx
+import { AssetImage, AssetVideo, useAssetUrl } from "snapback2/react";
+
+<AssetImage asset={message.photo} alt="attachment" />
+<AssetVideo asset={message.clip} />
+
+const download = useAssetUrl(message.clip, { download: true });
+```
+
+`AssetImage` measures its rendered box and header-fetches an appropriate image
+rung before creating a blob URL. `AssetVideo` mints one short-lived session
+carrier for its stream URL. React Native resolves the same import through the
+package's `react-native` condition; install `react-native`, `expo-video`, and
+`expo-file-system` in that application.
+
+Build and run the package tests against a real debug owner from this directory with:
+
+```sh
+node build.mjs
+env -u SNAPBACK_URL node --test tests/
+```
+
+With `SNAPBACK_URL` unset, the harness builds the chat fixture with the bundled
+compiler, starts `target/debug/snapback2 dev --foreground` on an ephemeral port,
+and exports its URL to the suite. To use an already-running compatible owner, set
+`SNAPBACK_URL=http://127.0.0.1:<port>` instead.

package/bin/snapback2.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+// Resolve the platform binary package and exec it. No other logic lives here.
+import { createRequire } from "node:module";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+const name = `snapback2-${process.platform}-${process.arch}`;
+let bin;
+try {
+  bin = createRequire(import.meta.url).resolve(`${name}/bin/snapback2`);
+} catch {
+  console.error(`snapback2: no binary package for ${process.platform}-${process.arch} (${name} is not installed)`);
+  process.exit(2);
+}
+const env = {
+  ...process.env,
+  SNAPBACK2_COMPILER: fileURLToPath(new URL("../dist/compiler.mjs", import.meta.url)),
+  SNAPBACK2_GUIDE: fileURLToPath(new URL("../dist/guide", import.meta.url)),
+  SNAPBACK2_TEMPLATES: fileURLToPath(new URL("../dist/templates", import.meta.url)),
+  SNAPBACK2_TEST_RUNNER: fileURLToPath(new URL("../dist/test-runner.mjs", import.meta.url)),
+};
+const result = spawnSync(bin, process.argv.slice(2), { stdio: "inherit", env });
+if (result.error) {
+  console.error(`snapback2: failed to spawn ${bin}: ${result.error.message}`);
+  process.exit(1);
+}
+if (result.signal) {
+  try {
+    process.kill(process.pid, result.signal);
+  } catch (error) {
+    console.error(`snapback2: ${bin} terminated by ${result.signal}: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+if (typeof result.status === "number") process.exit(result.status);
+console.error(`snapback2: ${bin} exited without a status or signal`);
+process.exit(1);

package/dist/api.d.ts

@@ -0,0 +1,20 @@
+export declare const referencePath: unique symbol;
+export interface Op<Args, Result> {
+    readonly op: string;
+    readonly [referencePath]: string;
+    readonly __args?: (args: Args) => void;
+    readonly __result?: Result;
+}
+export interface Channel<Args, Payload = unknown> {
+    readonly [referencePath]: string;
+    readonly __channelArgs?: (args: Args) => void;
+    readonly __payload?: Payload;
+}
+export interface Api {
+}
+export type AnyOp = Op<any, any>;
+export interface ApiProxy {
+    readonly [referencePath]: string;
+}
+export declare function referenceName(ref: ApiProxy): string;
+export declare const api: Api;

package/dist/assets.d.ts

@@ -0,0 +1,34 @@
+import type { AssetRecord, AssetUploadOptions, AssetUploadSource, ImageAsset, NativeAssetSource, VideoAsset } from "./types.js";
+export declare class AssetInputError extends Error {
+    readonly code: "E_ASSET_TYPE" | "E_ASSET_TOO_LARGE" | "E_ASSET_NOT_READY" | "E_ASSET_CARRIER_IMAGE" | "E_ASSET_NATIVE_FILE_API";
+    constructor(code: "E_ASSET_TYPE" | "E_ASSET_TOO_LARGE" | "E_ASSET_NOT_READY" | "E_ASSET_CARRIER_IMAGE" | "E_ASSET_NATIVE_FILE_API", message: string);
+}
+export interface BlobLike {
+    readonly size: number;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    stream(): ReadableStream<Uint8Array>;
+}
+type RuntimeAssetUploadSource = AssetUploadSource | BlobLike;
+export interface PreparedAssetSource {
+    readonly source: RuntimeAssetUploadSource;
+    readonly bytes: number;
+    body?: BlobLike | ReadableStream<Uint8Array>;
+}
+export interface AssetPlacement {
+    readonly path: readonly (string | number)[];
+    readonly max: number;
+    readonly prepared: PreparedAssetSource;
+}
+export declare function isBrowserFile(value: unknown): value is File | Blob;
+export declare function isBlobLike(value: unknown): value is BlobLike;
+export declare function isNativeAssetSource(value: unknown): value is NativeAssetSource;
+export declare function mayNeedAssetPlanning(value: unknown, ancestors?: Set<object>): boolean;
+export declare function expoUploadFetch(): Promise<typeof globalThis.fetch>;
+export declare function prepareAssetSource(source: RuntimeAssetUploadSource): Promise<PreparedAssetSource>;
+export declare function planAssetArguments(args: unknown, descriptor: unknown): Promise<AssetPlacement[]>;
+export declare function preparedBody(prepared: PreparedAssetSource): Promise<BlobLike | ReadableStream<Uint8Array>>;
+export declare function withProgress(body: BlobLike | ReadableStream<Uint8Array>, bytes: number, options: AssetUploadOptions): BlobLike | ReadableStream<Uint8Array>;
+export declare function substituteAssetRecords(args: unknown, placements: readonly AssetPlacement[], records: readonly AssetRecord[]): unknown;
+export declare function assetRecord(value: unknown): ImageAsset | VideoAsset;
+export declare function assetPath(baseUrl: string, asset: AssetRecord, width?: number, carrier?: string): string;
+export {};

package/dist/client-assets.d.ts

@@ -0,0 +1,26 @@
+import { SnapbackRefusal } from "./client-wire.js";
+import { type AssetCache, type AssetBytes, type ByteCache } from "./store/byte-cache.js";
+import type { RefusalEnvelope } from "./types.js";
+export interface AssetBlobTarget {
+    url: string;
+    assetId: string;
+    width: number | null;
+}
+/** The tokenless asset URL this client issued, split into the cache key it names. */
+export declare function assetBlobTarget(baseUrl: string, url: string): AssetBlobTarget;
+export declare function viewedRefusal(assetId: string): SnapbackRefusal;
+/**
+ * The one viewed guard every byte path consults after the cache missed and before
+ * a URL is minted or a byte moves: the ids whose view-once row was already viewed
+ * on this partition. `assetBlob` refuses them; `useAssetUrl` mints no URL for them.
+ */
+export declare function viewedAssetIds(cache: AssetCache | undefined, ids: readonly string[]): Promise<Set<string>>;
+/**
+ * Cache-first bytes for one asset rendition. Without a byte cache this is the
+ * network fetch; with one, a held rendition (or what this instance showed for a
+ * view-once row) is answered without the network, a viewed view-once row is refused
+ * before any byte moves, and a fetched rendition is kept under its row's lease.
+ */
+export declare function cachedAssetBlob(cache: ByteCache | undefined, target: AssetBlobTarget, network: () => Promise<Blob>, record: (refusal: RefusalEnvelope) => void, current: () => void, viewing?: object): Promise<Blob>;
+/** Native byte ingress; the caller fences custody after each awaited read. */
+export declare function cachedAssetBytes(cache: ByteCache | undefined, target: AssetBlobTarget, network: () => Promise<AssetBytes>, record: (refusal: RefusalEnvelope) => void, current: () => void, viewing?: object): Promise<AssetBytes>;

package/dist/client-offline.d.ts

@@ -0,0 +1,94 @@
+import { SnapbackRefusal } from "./client-wire.js";
+import { OfflineRuntime, type AcceptedDelivery, type MountedQuery, type ResumeAdjustment } from "./offline.js";
+import { type OfflineClientOptions, type LiveQueryDelivery, type QueryResult, type QueryRefusedDelivery, type RefusalEnvelope, type SnapbackClient, type Subscription, type SubscriptionDelivery } from "./types.js";
+import type { Op } from "./api.js";
+export declare function validateOfflineOptions(options: OfflineClientOptions | undefined): void;
+export declare function createOfflineRuntime(options: OfflineClientOptions | undefined): OfflineRuntime | undefined;
+export declare function offlineRefusal(error: unknown, carrier: string): SnapbackRefusal;
+export declare function offlineNetworkRefusal(): SnapbackRefusal;
+export declare function acceptOffline<Result>(runtime: OfflineRuntime | undefined, op: string, args: unknown, raw: unknown, shape: (message: string) => Error): Promise<AcceptedDelivery<Result>>;
+export declare function commitOffline(runtime: OfflineRuntime | undefined, op: string, args: unknown, accepted: AcceptedDelivery<unknown>, failure: (error: unknown) => Error, revision?: number, current?: () => boolean): Promise<boolean>;
+export declare function decodeOfflineSubscription<Result>(options: {
+    runtime: OfflineRuntime;
+    op: string;
+    args: unknown;
+    data: string;
+    shape(message: string): Error;
+    failure(error: unknown): Error;
+    observe?(): Promise<void>;
+    revision?: number;
+    current?: () => boolean;
+    superseded?(): void;
+}): Promise<LiveQueryDelivery<Result> | QueryRefusedDelivery>;
+export declare function settleSubscription<Result>(value: LiveQueryDelivery<Result> | QueryRefusedDelivery, ensureAuthority: () => void, patch: (value: {
+    connection: "connected";
+    lastRefusal: RefusalEnvelope | undefined;
+}) => void): {
+    seq: number;
+    data?: Result;
+} | undefined;
+export declare function answerOffline<Result>(runtime: OfflineRuntime | undefined, op: string, args: unknown, failure: (error: unknown) => Error): Promise<QueryResult<Result>>;
+export declare function createOfflineDrain<Args, Result>(options: {
+    ref: Op<Args, Result>;
+    op: string;
+    args: Args;
+    callback: (delivery: SubscriptionDelivery<Result>) => void;
+    runtime: OfflineRuntime | undefined;
+    /** Settles once the manifest was loaded or could not be: the cursor argument's name is known after it. */
+    ready?: Promise<void>;
+    mounted: Map<string, MountedQuery>;
+    query(pageArgs: Args): Promise<QueryResult<Result>>;
+    subscribe(tailArgs: Args, callback: (delivery: SubscriptionDelivery<Result>) => void): Subscription<SubscriptionDelivery<Result>>;
+    track(subscription: Subscription<SubscriptionDelivery<Result>>): Subscription<SubscriptionDelivery<Result>>;
+    observe?(): Promise<void>;
+    /** Performs a resume; a drained log that holds no replay grant asks for one here. */
+    resume?(): Promise<void>;
+}): Subscription<SubscriptionDelivery<Result>>;
+export declare function goOffline(options: {
+    ready: Promise<void>;
+    ensureOpen(): void;
+    force(value: boolean): void;
+    connection(value: "offline" | "reconnecting"): void;
+    reconnect(): void;
+}): Promise<void>;
+export declare function goOnline<Authority>(options: {
+    ready: Promise<void>;
+    ensureOpen(): void;
+    force(value: boolean): void;
+    connection(value: "offline" | "reconnecting"): void;
+    authority(): Promise<Authority>;
+    resume(authority: Authority): Promise<void>;
+    setResume(run: Promise<void>): void;
+    reconnect(): void;
+}): Promise<void>;
+export declare function restartOffline(options: {
+    ready: Promise<void>;
+    ensureOpen(): void;
+    forced(): boolean;
+    shutdown(): Promise<void>;
+    create(): SnapbackClient;
+}): Promise<SnapbackClient>;
+export declare function initializeOfflineClient<Principal, Authority>(options: {
+    principal?: Principal;
+    bearer: boolean;
+    authority: Authority;
+    open(principal: Principal, authenticated?: boolean): Promise<void>;
+    confirm(authority: Authority): Promise<Principal>;
+    metadata(authority: Authority): Promise<void>;
+    resume(authority: Authority): Promise<void>;
+    ignore(error: unknown): boolean;
+}): Promise<void>;
+export declare function performOfflineResume<Authority>(options: {
+    signal?: AbortSignal;
+    runtime: OfflineRuntime | undefined;
+    mounted: Map<string, MountedQuery>;
+    authority: Authority;
+    bearerConfirmed: boolean;
+    json(path: string, init: RequestInit, authority: Authority): Promise<unknown>;
+    validated(authority: Authority): void;
+    shape(message: string): Error;
+    failure?(error: unknown): Error;
+    subscriptions: Iterable<Subscription<unknown>>;
+    /** Re-fetches `/api/program` for the live generation after `E_OFFLINE_RESET`. */
+    reload?(authority: Authority): Promise<void>;
+}, adjustment?: ResumeAdjustment, retry?: boolean): Promise<boolean>;

package/dist/client-outbox.d.ts

@@ -0,0 +1,58 @@
+import { type OfflineRuntime } from "./offline.js";
+import type { MutationResult, OutboxApi } from "./types.js";
+/** Records the grant a login/guest response carries; the value passes through untouched. */
+export declare function captureGrant<T>(runtime: OfflineRuntime | undefined, value: T): T;
+/**
+ * The replayed mutation's terminal object: today's committed/rejected shapes
+ * plus the trace conflict, which carries no diagnostic code of its own on the
+ * wire and is given the client-side `E_OFFLINE_CONFLICT` envelope here.
+ */
+export declare function wireReplayResponse<Result>(value: unknown): MutationResult<Result> & {
+    intent?: string;
+};
+type Transport = (path: string, init: RequestInit) => Promise<unknown>;
+type DrainResult = {
+    stopped: boolean;
+    reason?: "fence";
+};
+export interface SubmitMutationOptions {
+    runtime: OfflineRuntime | undefined;
+    /** The client's transport is cut (`client.offline()`); the owner is never tried. */
+    offline: boolean;
+    op: string;
+    args: unknown;
+    json: Transport;
+    failure(error: unknown): Error;
+    drain(): Promise<{
+        stopped: boolean;
+    }>;
+}
+/**
+ * A client with no store (no partition open) sends today's bytes. With a
+ * partition open every write carries the replay envelope, online or not: the
+ * twin runs it locally for its ids and trace, the intent is durable before the
+ * request, and the server's ledger makes the online path exactly-once too — a
+ * 503 after a commit can no longer double-send (LLP 1002 §9, LLP 1012 §7). A
+ * partition with no custody yet (no grant, or an unknown write bound) refuses
+ * `E_OFFLINE_ID_BLOCK` with no request rather than fall back to plain bytes:
+ * that window is exactly where a 503 after a commit would double-send.
+ * Offline, behind queued intents a drain could not clear, or after a transport
+ * failure, the write resolves `queued`.
+ */
+export declare function submitMutation<Result>(options: SubmitMutationOptions): Promise<MutationResult<Result>>;
+export interface DrainOptions {
+    signal?: AbortSignal;
+    runtime: OfflineRuntime;
+    json: Transport;
+    shape(message: string): Error;
+    failure(error: unknown): Error;
+}
+/**
+ * Replays queued intents in order. A transport failure leaves the intent
+ * queued and stops; a rejection, conflict, or refusal settles only that intent
+ * and the drain continues. Past the fence, replay waits for a successful
+ * resume; only the owner's `E_OFFLINE_INTENT_EXPIRED` refusal settles expired.
+ */
+export declare function drainOutbox(options: DrainOptions): Promise<DrainResult>;
+export declare function createOutboxApi(runtime: OfflineRuntime | undefined, drain: () => Promise<DrainResult>, ready?: () => Promise<void>): OutboxApi;
+export {};

package/dist/client-upload.d.ts

@@ -0,0 +1,41 @@
+import { type PreparedAssetSource } from "./assets.js";
+import { SnapbackRefusal } from "./client-wire.js";
+import type { AssetBytes, AssetFetchOptions, ByteCache } from "./store/byte-cache.js";
+import type { AssetRecord, AssetUploadOptions, AssetUploadSource, AssetUrlOptions, RefusalEnvelope } from "./types.js";
+/** The authority snapshot every request is fenced by (LLP 1002 §9). */
+export interface Authority {
+    authGeneration: number;
+    custodyGeneration: number;
+    fence: number;
+    token?: string;
+}
+export interface CarrierSession {
+    token: string;
+    expiresAt: number;
+    authGeneration: number;
+    custodyGeneration: number;
+    fence: number;
+}
+/** What the client lends the asset arm; the class satisfies it structurally. */
+export interface UploadHost {
+    readonly url: string;
+    readonly persona?: string;
+    readonly assetCache?: ByteCache;
+    readonly fetchImpl: typeof globalThis.fetch;
+    readonly customFetch: boolean;
+    carrier?: CarrierSession;
+    headers(authority: Authority, stream?: boolean, hasBody?: boolean): Headers;
+    json(path: string, init: RequestInit, authority: Authority): Promise<unknown>;
+    ensureAuthority(authority: Authority | undefined): asserts authority is Authority;
+    recordRefusal(envelope: RefusalEnvelope): void;
+    validated(authority: Authority | undefined): void;
+    networkRefusal(message: string): SnapbackRefusal;
+    transportRefusal(message: string): SnapbackRefusal;
+}
+export declare function uploadAsset(host: UploadHost, source: AssetUploadSource, options: AssetUploadOptions, authority: Authority): Promise<AssetRecord>;
+export declare function assetUrlFor(host: UploadHost, assetOrList: AssetRecord | readonly AssetRecord[] | null | undefined, options: AssetUrlOptions, authority: Authority): Promise<string | string[] | undefined>;
+export declare function assetHeadersFor(host: UploadHost, authority: Authority): Record<string, string>;
+export declare function assetBlobFor(host: UploadHost, bytes: ByteCache | undefined, offline: () => boolean, url: string, options: AssetFetchOptions, authority: Authority): Promise<Blob>;
+export declare function assetBytesFor(host: UploadHost, cache: ByteCache | undefined, offline: () => boolean, url: string, options: AssetFetchOptions, authority: Authority): Promise<AssetBytes>;
+export declare function uploadPrepared(host: UploadHost, prepared: PreparedAssetSource, options: AssetUploadOptions, authority: Authority): Promise<AssetRecord>;
+export declare function assetInput(host: UploadHost, error: unknown): SnapbackRefusal;

package/dist/client-wire.d.ts

@@ -0,0 +1,41 @@
+import type { AuthMe, AuthSession, ChannelDelivery, ChannelPublishResult, LiveQueryDelivery, Manifest, MutationResult, QueryRefusedDelivery, RefusalEnvelope, ServerQueryResult } from "./types.js";
+export declare function fallbackRefusal(code: string, message: string): RefusalEnvelope;
+declare const snapbackRefusalBrand: unique symbol;
+export declare class SnapbackRefusal extends Error {
+    readonly retryable: boolean;
+    readonly status?: number | undefined;
+    readonly [snapbackRefusalBrand] = true;
+    readonly envelope: RefusalEnvelope;
+    readonly code: string;
+    constructor(envelope: RefusalEnvelope, retryable?: boolean, status?: number | undefined);
+}
+export declare function isSnapbackRefusal(value: unknown): value is SnapbackRefusal;
+export declare function wireShape(message: string): SnapbackRefusal;
+export declare function wireObject(value: unknown, surface: string): Record<string, unknown>;
+export declare function wireRefusalEnvelope(value: unknown, surface: string): RefusalEnvelope;
+export declare function copyRefusal(envelope: RefusalEnvelope): RefusalEnvelope;
+export declare function isTerminalSession(envelope: Pick<RefusalEnvelope, "code" | "family">): boolean;
+export declare function wireQuery<Result>(value: unknown, surface?: string): ServerQueryResult<Result>;
+export declare function wireMutation<Result>(value: unknown): MutationResult<Result>;
+export declare function wireSubscription<Result>(data: string): LiveQueryDelivery<Result> | QueryRefusedDelivery;
+export declare function wireChannelDelivery<Payload>(data: string): ChannelDelivery<Payload>;
+export declare function wireChannelPublish(value: unknown): ChannelPublishResult;
+export declare function terminalSessionEnvelope(value: unknown): RefusalEnvelope | undefined;
+export declare function wireAuthSession(value: unknown, surface: string): AuthSession;
+export declare function wireAuthMe(value: unknown): AuthMe;
+export declare function wireLogout(value: unknown): {
+    ok: boolean;
+};
+export declare function wireManifest(value: unknown): Manifest;
+export declare function wireAssetSession(value: unknown): {
+    token: string;
+    expiresAt: number;
+};
+export declare function responseRefusal(response: Response): Promise<SnapbackRefusal>;
+export declare function sseObject(data: string, surface: string): Record<string, unknown>;
+/**
+ * `AbortSignal.prototype.throwIfAborted` does not exist on React Native's AbortSignal
+ * (Hermes, RN 0.81 / Expo SDK 54), so every abort check goes through this helper.
+ */
+export declare function throwIfAborted(signal?: AbortSignal | null): void;
+export {};

package/dist/client.d.ts

@@ -0,0 +1,12 @@
+import { api, type Api, type ApiProxy, type Channel as ChannelRef, type Op } from "./api.js";
+import { SnapbackRefusal, isSnapbackRefusal } from "./client-wire.js";
+import type { CreateClientOptions, SnapbackClient } from "./types.js";
+export { api };
+export { SnapbackRefusal, isSnapbackRefusal };
+export { browserTokenStore } from "./token-store.js";
+export type { Api, ApiProxy, ChannelRef as Channel, Op };
+export * from "./types.js";
+export type { Coverage, CoverageFacts, HeldAnswer, HeldOperation, HeldProgram, OutboxEntry, OutboxStore, OverlayRow, RangeStore, RangeStoreFactory, Receipt, ReceiptRange, StoreSwap, } from "./store/range-store.js";
+export type { LocalAnswer, Prediction } from "./twin.js";
+export type { PartialReason, PartialSite } from "./twin-hydrate.js";
+export declare function createClient(options: CreateClientOptions): SnapbackClient;