@fungi.computer/agar 0.0.0-stage → 0.0.1

package/dist/internal/git-edit-tree.js

@@ -0,0 +1,46 @@
+import * as git from "isomorphic-git";
+const DIR = "/repository";
+/** Apply changes under one tree; null means the tree became empty. */
+export async function editTree(fs, oid, changes) {
+    if (changes.length === 0)
+        return oid;
+    const entries = new Map(oid === null
+        ? []
+        : (await git.readTree({ fs, dir: DIR, oid })).tree.map((entry) => [
+            entry.path,
+            entry,
+        ]));
+    const nested = new Map();
+    for (const change of changes) {
+        const [name = "", ...rest] = change.parts;
+        if (rest.length > 0) {
+            nested.set(name, [
+                ...(nested.get(name) ?? []),
+                { ...change, parts: rest },
+            ]);
+            continue;
+        }
+        if (change.content === null) {
+            entries.delete(name);
+            continue;
+        }
+        const existing = entries.get(name);
+        entries.set(name, {
+            path: name,
+            type: "blob",
+            mode: change.mode ?? (existing?.type === "blob" ? existing.mode : "100644"),
+            oid: await git.writeBlob({ fs, dir: DIR, blob: change.content }),
+        });
+    }
+    for (const [name, children] of nested) {
+        const existing = entries.get(name);
+        const sub = await editTree(fs, existing?.type === "tree" ? existing.oid : null, children);
+        if (sub === null)
+            entries.delete(name);
+        else
+            entries.set(name, { path: name, type: "tree", mode: "040000", oid: sub });
+    }
+    if (entries.size === 0)
+        return null;
+    return git.writeTree({ fs, dir: DIR, tree: [...entries.values()] });
+}

package/dist/internal/memory-fs.d.ts

@@ -0,0 +1,39 @@
+/**
+ * A minimal in-memory filesystem with the promise API isomorphic-git uses,
+ * so a merge runs inside an App backend with no Node built-ins. One instance
+ * lives for one merge.
+ */
+/** File metadata in the subset of `fs.Stats` isomorphic-git reads. */
+export type MemoryStats = Readonly<{
+    type: "file" | "dir";
+    mode: number;
+    size: number;
+    ino: number;
+    mtimeMs: number;
+    ctimeMs: number;
+    uid: number;
+    gid: number;
+    dev: number;
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isSymbolicLink(): boolean;
+}>;
+/** The `{ promises }` filesystem isomorphic-git accepts as `fs`. */
+export type MemoryFs = Readonly<{
+    promises: Readonly<{
+        readFile(path: string, options?: {
+            encoding?: string;
+        } | string): Promise<Uint8Array | string>;
+        writeFile(path: string, data: Uint8Array | string): Promise<void>;
+        unlink(path: string): Promise<void>;
+        readdir(path: string): Promise<string[]>;
+        mkdir(path: string): Promise<void>;
+        rmdir(path: string): Promise<void>;
+        stat(path: string): Promise<MemoryStats>;
+        lstat(path: string): Promise<MemoryStats>;
+        readlink(path: string): Promise<string>;
+        symlink(target: string, path: string): Promise<void>;
+        chmod(path: string): Promise<void>;
+    }>;
+}>;
+export declare function memoryFs(): MemoryFs;

package/dist/internal/memory-fs.js

@@ -0,0 +1,154 @@
+/**
+ * A minimal in-memory filesystem with the promise API isomorphic-git uses,
+ * so a merge runs inside an App backend with no Node built-ins. One instance
+ * lives for one merge.
+ */
+/** The error shape isomorphic-git checks (`code`). */
+class FsError extends Error {
+    code;
+    constructor(code, path) {
+        super(`${code}: ${path}`);
+        this.code = code;
+    }
+}
+function normalize(path) {
+    const parts = [];
+    for (const part of path.split("/")) {
+        if (part === "" || part === ".")
+            continue;
+        if (part === "..")
+            parts.pop();
+        else
+            parts.push(part);
+    }
+    return `/${parts.join("/")}`;
+}
+function parentOf(path) {
+    const index = path.lastIndexOf("/");
+    return index <= 0 ? "/" : path.slice(0, index);
+}
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+export function memoryFs() {
+    const entries = new Map([
+        ["/", { kind: "dir", mtimeMs: Date.now() }],
+    ]);
+    const inodes = new Map();
+    const inode = (path) => {
+        let value = inodes.get(path);
+        if (value === undefined) {
+            value = inodes.size + 1;
+            inodes.set(path, value);
+        }
+        return value;
+    };
+    const stats = (path) => {
+        const entry = entries.get(path);
+        if (entry === undefined)
+            throw new FsError("ENOENT", path);
+        const file = entry.kind === "file";
+        return {
+            type: entry.kind,
+            mode: file ? 0o100644 : 0o40000,
+            size: file ? entry.data.length : 0,
+            ino: inode(path),
+            mtimeMs: entry.mtimeMs,
+            ctimeMs: entry.mtimeMs,
+            uid: 1,
+            gid: 1,
+            dev: 1,
+            isFile: () => file,
+            isDirectory: () => !file,
+            isSymbolicLink: () => false,
+        };
+    };
+    const requireDir = (path) => {
+        const entry = entries.get(path);
+        if (entry === undefined)
+            throw new FsError("ENOENT", path);
+        if (entry.kind !== "dir")
+            throw new FsError("ENOTDIR", path);
+    };
+    const sync = {
+        readFile: (raw, options) => {
+            const path = normalize(raw);
+            const entry = entries.get(path);
+            if (entry === undefined)
+                throw new FsError("ENOENT", path);
+            if (entry.kind !== "file")
+                throw new FsError("EISDIR", path);
+            const utf8 = options === "utf8" ||
+                (options instanceof Object && options.encoding === "utf8");
+            return utf8 ? decoder.decode(entry.data) : entry.data;
+        },
+        writeFile: (raw, data) => {
+            const path = normalize(raw);
+            requireDir(parentOf(path));
+            entries.set(path, {
+                kind: "file",
+                data: data instanceof Uint8Array
+                    ? new Uint8Array(data)
+                    : encoder.encode(data),
+                mtimeMs: Date.now(),
+            });
+        },
+        unlink: (raw) => {
+            const path = normalize(raw);
+            if (entries.get(path)?.kind !== "file")
+                throw new FsError("ENOENT", path);
+            entries.delete(path);
+        },
+        readdir: (raw) => {
+            const path = normalize(raw);
+            requireDir(path);
+            const prefix = path === "/" ? "/" : `${path}/`;
+            return [...entries.keys()]
+                .filter((key) => key !== path &&
+                key.startsWith(prefix) &&
+                !key.slice(prefix.length).includes("/"))
+                .map((key) => key.slice(prefix.length));
+        },
+        mkdir: (raw) => {
+            const path = normalize(raw);
+            if (entries.has(path))
+                throw new FsError("EEXIST", path);
+            requireDir(parentOf(path));
+            entries.set(path, { kind: "dir", mtimeMs: Date.now() });
+        },
+        rmdir: (raw) => {
+            const path = normalize(raw);
+            const prefix = `${path}/`;
+            if ([...entries.keys()].some((key) => key.startsWith(prefix)))
+                throw new FsError("ENOTEMPTY", path);
+            entries.delete(path);
+        },
+        stat: (raw) => {
+            return stats(normalize(raw));
+        },
+        lstat: (raw) => {
+            return stats(normalize(raw));
+        },
+        readlink: (raw) => {
+            throw new FsError("ENOENT", normalize(raw));
+        },
+        symlink: (_target, raw) => {
+            throw new FsError("EEXIST", normalize(raw));
+        },
+        chmod: () => undefined,
+    };
+    const lift = (run) => async (...args) => await run(...args);
+    const promises = {
+        readFile: lift(sync.readFile),
+        writeFile: lift(sync.writeFile),
+        unlink: lift(sync.unlink),
+        readdir: lift(sync.readdir),
+        mkdir: lift(sync.mkdir),
+        rmdir: lift(sync.rmdir),
+        stat: lift(sync.stat),
+        lstat: lift(sync.lstat),
+        readlink: lift(sync.readlink),
+        symlink: lift(sync.symlink),
+        chmod: lift(sync.chmod),
+    };
+    return { promises };
+}

package/dist/internal/protocol.d.ts

@@ -0,0 +1,116 @@
+import type { AppCommand } from "../commands.js";
+import type { WhistleExecutionOrigin, WhistleJsonValue } from "@fungi.computer/whistle";
+import type { AppContext, AppIdentity, AppLifecycle, FocusState } from "../lifecycle.js";
+import type { AppBrowserAction, AppBrowserActionOutcome, AgentSessionSelection, AppPermissionOutcome, AppPermissionRequest, AppStatusAction, AppStatusItem, FileNavigationInput, ToastInput } from "../ui.js";
+import type { APP_NAVIGATION_CONTRACT_VERSION } from "../window.js";
+import type { AppErrorData } from "./app-error.js";
+import type { RpcResult } from "./result.js";
+import type { WhistleFailure } from "@fungi.computer/whistle";
+/** The iframe handshake version both App and host must speak. */
+export declare const APP_PROTOCOL_VERSION: 2;
+/** Message type the App iframe posts to announce it is ready to connect. */
+export declare const APP_READY_TYPE: "fungi.app.ready";
+/** Message type the host posts to hand the App its RPC MessagePort. */
+export declare const APP_CONNECT_TYPE: "fungi.app.connect";
+export type AppClientRpc = {
+    disconnect(error?: AppErrorData): Promise<RpcResult<void>>;
+    requestClose(): Promise<RpcResult<boolean>>;
+    /** Ask the App to go back one step in its own history; `true` when it did. */
+    requestBack(): Promise<RpcResult<boolean>>;
+    /** The person used one of the App's status items; `true` when it acted. */
+    activateStatus(action: AppStatusAction): Promise<RpcResult<boolean>>;
+    updateContext(context: VersionedFact<AppContext>): Promise<RpcResult<void>>;
+    reconfigure(value: AppHostReconfigurationWire): Promise<RpcResult<void>>;
+    updateLifecycle(lifecycle: VersionedFact<AppLifecycle>): Promise<RpcResult<void>>;
+    updateReservedChords(chords: VersionedFact<readonly ReservedChord[]>): Promise<RpcResult<void>>;
+    updateTheme(theme: VersionedFact<string>): Promise<RpcResult<void>>;
+};
+/** The host's handshake message that hands the App its RPC MessagePort. */
+export type AppConnectMessage = {
+    readonly epoch: string;
+    readonly protocolVersion: typeof APP_PROTOCOL_VERSION;
+    readonly type: typeof APP_CONNECT_TYPE;
+};
+export type AppHostRpc = {
+    requestComputerChoice(): Promise<RpcResult<void>>;
+    requestBrowserAction(input: AppBrowserAction): Promise<RpcResult<AppBrowserActionOutcome>>;
+    connect(request: ConnectRequestWire): Promise<RpcResult<HostBootstrapWire>>;
+    invokeReservedChord(id: string, repeat: boolean): Promise<RpcResult<void>>;
+    openNavigation(input: FileNavigationInput): Promise<RpcResult<void>>;
+    openTeamBilling(): Promise<RpcResult<void>>;
+    openDesktopSettings(): Promise<RpcResult<void>>;
+    requestAppPermissions(input: AppPermissionRequest): Promise<RpcResult<AppPermissionOutcome>>;
+    registerCommand(command: AppCommand, handler: CommandHandlerRpc): Promise<RpcResult<RegisteredCommandWire>>;
+    reportFocus(focus: FocusState): Promise<RpcResult<void>>;
+    reportNavigation(state: NavigationStateWire): Promise<RpcResult<void>>;
+    reportStatus(items: readonly AppStatusItem[]): Promise<RpcResult<void>>;
+    reportAgentSessionSelection(selection: AgentSessionSelection | null): Promise<RpcResult<void>>;
+    showToast(input: ToastInput): Promise<RpcResult<void>>;
+    unregisterCommand(commandId: string): Promise<RpcResult<void>>;
+};
+/** The versioned navigation contract an App reports to its host. */
+export type NavigationStateWire = Readonly<{
+    contractVersion: typeof APP_NAVIGATION_CONTRACT_VERSION;
+    canGoBack: boolean;
+    title?: string;
+}>;
+/** The App iframe's handshake message announcing it is ready to connect. */
+export type AppReadyMessage = {
+    readonly protocolVersion: typeof APP_PROTOCOL_VERSION;
+    readonly type: typeof APP_READY_TYPE;
+};
+/** The handle is deliberately opaque: capability owners define its methods. */
+export type CapabilityGrantWire = {
+    readonly handle: object;
+    readonly id: string;
+    readonly version: number;
+};
+export type CommandHandlerRpc = {
+    cancel(requestId: string): Promise<RpcResult<void>>;
+    invoke(invocation: CommandInvocationWire): Promise<RpcResult<CommandInvocationResultWire>>;
+};
+/** Data-only command outcome crossing the App boundary. */
+export type CommandInvocationResultWire = Readonly<{
+    readonly status: "handled";
+    readonly result?: WhistleJsonValue;
+}> | Readonly<{
+    readonly status: "failed";
+    readonly error: WhistleFailure;
+}>;
+export type CommandInvocationWire = {
+    readonly arguments?: WhistleJsonValue;
+    readonly commandId: string;
+    readonly origin: WhistleExecutionOrigin;
+    readonly requestId: string;
+};
+export type ConnectRequestWire = {
+    readonly epoch: string;
+    readonly protocolVersion: typeof APP_PROTOCOL_VERSION;
+};
+export type HostBootstrapWire = {
+    readonly capabilities: readonly CapabilityGrantWire[];
+    readonly context: VersionedFact<AppContext>;
+    readonly identity: AppIdentity;
+    readonly lifecycle: VersionedFact<AppLifecycle>;
+    readonly reservedChords: VersionedFact<readonly ReservedChord[]>;
+    readonly theme: VersionedFact<string>;
+};
+export type AppHostReconfigurationWire = {
+    readonly capabilities: readonly CapabilityGrantWire[];
+    readonly context: VersionedFact<AppContext>;
+};
+export type RegisteredCommandWire = {
+    readonly commandId: string;
+};
+export type ReservedChord = {
+    readonly altKey: boolean;
+    readonly ctrlKey: boolean;
+    readonly id: string;
+    readonly key: string;
+    readonly metaKey: boolean;
+    readonly shiftKey: boolean;
+};
+export type VersionedFact<T> = {
+    readonly value: T;
+    readonly version: number;
+};

package/dist/internal/protocol.js

@@ -0,0 +1,6 @@
+/** The iframe handshake version both App and host must speak. */
+export const APP_PROTOCOL_VERSION = 2;
+/** Message type the App iframe posts to announce it is ready to connect. */
+export const APP_READY_TYPE = "fungi.app.ready";
+/** Message type the host posts to hand the App its RPC MessagePort. */
+export const APP_CONNECT_TYPE = "fungi.app.connect";

package/dist/internal/query-feed.d.ts

@@ -0,0 +1,23 @@
+import { type QueryKey, type QueryMeta } from "@tanstack/react-query";
+import { AppError } from "../errors.js";
+import { type MemberInboxItem } from "../inbox.js";
+import type { AppRoot } from "../root.js";
+import type { Disposer } from "../store.js";
+/** A feed can lose its connection without losing its last owner snapshot. */
+export type FeedSnapshot<T> = Readonly<{
+    status: "live";
+    data: T;
+}> | Readonly<{
+    status: "loading" | "error";
+    data?: T;
+}>;
+/** Start a live feed, calling `onChange` with each snapshot until
+ * `signal` aborts; the returned (or resolved) Disposer tears it down. */
+export type FeedWatch<T> = (onChange: (snapshot: FeedSnapshot<T>) => void, signal: AbortSignal) => Disposer | Promise<Disposer>;
+/** Query owns sharing and teardown; Effect supplies a bounded latest-snapshot queue. */
+export declare function useFeedQuery<T>(queryKey: QueryKey, watch: FeedWatch<T>, options?: {
+    enabled?: boolean;
+    meta?: QueryMeta;
+}): import("@tanstack/react-query").UseQueryResult<FeedSnapshot<T>, AppError>;
+export declare function watchInbox(app: Pick<AppRoot, "capabilities"> | null, onChange: (snapshot: FeedSnapshot<readonly MemberInboxItem[]>) => void, signal: AbortSignal): Promise<Disposer>;
+export declare function queryError(cause: unknown): AppError;

package/dist/internal/query-feed.js

@@ -0,0 +1,111 @@
+import { experimental_streamedQuery, useQuery, } from "@tanstack/react-query";
+import * as Effect from "effect/Effect";
+import * as Queue from "effect/Queue";
+import * as Stream from "effect/Stream";
+import { EventSource } from "eventsource";
+import * as z from "zod";
+import { openAppInbox } from "../agents.js";
+import { AppError } from "../errors.js";
+import { reportCatchFailure } from "../failure.js";
+import { watchMemberInbox } from "../inbox.js";
+function retain(previous, next) {
+    return next.status === "live"
+        ? next
+        : { ...next, data: next.data ?? previous.data };
+}
+/** Query owns sharing and teardown; Effect supplies a bounded latest-snapshot queue. */
+export function useFeedQuery(queryKey, watch, options = {}) {
+    return useQuery({
+        queryKey,
+        ...options,
+        retry: false,
+        staleTime: Infinity,
+        refetchOnMount: "always",
+        queryFn: experimental_streamedQuery({
+            initialValue: { status: "loading" },
+            refetchMode: "append",
+            reducer: retain,
+            streamFn: ({ signal }) => Stream.toAsyncIterable(Stream.callback((queue) => Effect.gen(function* () {
+                let latest = { status: "loading" };
+                const end = () => {
+                    Queue.endUnsafe(queue);
+                };
+                yield* Effect.acquireRelease(Effect.sync(() => {
+                    signal.addEventListener("abort", end, { once: true });
+                }), () => Effect.sync(() => {
+                    signal.removeEventListener("abort", end);
+                }));
+                if (signal.aborted) {
+                    end();
+                    return;
+                }
+                yield* Effect.acquireRelease(Effect.tryPromise({
+                    try: () => Promise.resolve(watch((snapshot) => {
+                        latest = retain(latest, snapshot);
+                        Queue.offerUnsafe(queue, latest);
+                    }, signal)),
+                    catch: queryError,
+                }), (release) => Effect.sync(release));
+            }).pipe(Effect.catch((error) => Queue.fail(queue, error))), { bufferSize: 1, strategy: "sliding" })),
+        }),
+    });
+}
+export async function watchInbox(app, onChange, signal) {
+    if (!app)
+        throw new AppError("No App connection", {
+            code: "DISCONNECTED",
+            retryable: true,
+        });
+    const transport = await openAppInbox(app.capabilities);
+    const close = () => {
+        void transport.close().catch((cause) => {
+            reportCatchFailure("inbox.query-close", cause);
+        });
+    };
+    if (signal.aborted) {
+        close();
+        return () => undefined;
+    }
+    const feed = watchMemberInbox({
+        baseUrl: transport.baseUrl,
+        fetch: transport.fetch,
+        openEvents: (url) => {
+            const source = new EventSource(url, {
+                fetch: (input, init) => transport.fetch(input, init),
+            });
+            return {
+                addEventListener: (type, listener) => {
+                    source.addEventListener(type, (event) => {
+                        if (type === "open" || type === "error")
+                            listener(new MessageEvent(type));
+                        else if (event instanceof MessageEvent)
+                            listener(new MessageEvent(type, {
+                                data: z.string().parse(event.data),
+                            }));
+                    });
+                },
+                close: () => {
+                    source.close();
+                },
+            };
+        },
+        onChange: (snapshot) => {
+            onChange(snapshot.status === "live"
+                ? { status: "live", data: snapshot.items }
+                : { status: snapshot.status });
+        },
+    });
+    return () => {
+        feed.close();
+        close();
+    };
+}
+export function queryError(cause) {
+    return cause instanceof AppError
+        ? cause
+        : new AppError("App operation failed", {
+            cause,
+            code: "HOST_FAILURE",
+            retryable: false,
+        });
+}

package/dist/internal/result.d.ts

@@ -0,0 +1,22 @@
+import type * as Schema from "effect/Schema";
+import { type AppErrorData } from "./app-error.js";
+export type RpcResult<T> = {
+    readonly error: AppErrorData;
+    readonly ok: false;
+} | {
+    readonly ok: true;
+    readonly value: T;
+};
+export declare const rpcSuccess: <T>(value: T) => RpcResult<T>;
+export declare const rpcFailure: <T = never>(cause: unknown) => RpcResult<T>;
+/**
+ * Decodes one ordinary RPC response and releases its Cap'n Web result owner.
+ * The bootstrap response is intentionally not passed here: it owns the live
+ * capability handles retained by the published app root.
+ */
+export declare function callRpc<T>(operation: PromiseLike<unknown>, parse: ReturnType<typeof Schema.decodeUnknownSync<Schema.Decoder<RpcResult<T>>>>): Promise<T>;
+/**
+ * Callers must first decode an unknown transport envelope with an
+ * operation-specific schema. This function only exposes that trusted result.
+ */
+export declare function unwrapRpcResult<T>(result: RpcResult<T>): T;

package/dist/internal/result.js

@@ -0,0 +1,61 @@
+import * as Predicate from "effect/Predicate";
+import { AppError } from "../errors.js";
+import { appErrorData, appErrorFromData, } from "./app-error.js";
+export const rpcSuccess = (value) => ({ ok: true, value });
+export const rpcFailure = (cause) => ({
+    error: appErrorData(cause),
+    ok: false,
+});
+/**
+ * Decodes one ordinary RPC response and releases its Cap'n Web result owner.
+ * The bootstrap response is intentionally not passed here: it owns the live
+ * capability handles retained by the published app root.
+ */
+export async function callRpc(operation, parse) {
+    let result;
+    const disposed = new Set();
+    try {
+        result = await operation;
+        return unwrapRpcResult(parse(result));
+    }
+    catch (cause) {
+        if (isRpcResultOwner(cause))
+            disposeRpcResult(cause, disposed);
+        if (cause instanceof AppError)
+            throw cause;
+        throw new AppError("The remote operation failed", {
+            cause,
+            code: "HOST_FAILURE",
+            retryable: true,
+        });
+    }
+    finally {
+        if (result !== operation && isRpcResultOwner(result))
+            disposeRpcResult(result, disposed);
+    }
+}
+/**
+ * Callers must first decode an unknown transport envelope with an
+ * operation-specific schema. This function only exposes that trusted result.
+ */
+export function unwrapRpcResult(result) {
+    if (result.ok)
+        return result.value;
+    throw appErrorFromData(result.error);
+}
+function isRpcResultOwner(value) {
+    return (Predicate.isObject(value) &&
+        Symbol.dispose in value &&
+        Predicate.isFunction(value[Symbol.dispose]));
+}
+function disposeRpcResult(value, disposed) {
+    if (disposed.has(value))
+        return;
+    disposed.add(value);
+    try {
+        value[Symbol.dispose]();
+    }
+    catch (cause) {
+        console.warn("RPC result disposal failed", cause);
+    }
+}

package/dist/internal/rpc-contract.d.ts

@@ -0,0 +1,24 @@
+import * as z from "zod";
+/** Cap'n Web stubs are callable proxies, not records. Select only owner methods
+ * and bind their receiver before the maintained function schemas wrap them. */
+export declare function rpcHandleSchema<S extends z.ZodRawShape>(methods: S): z.ZodPipe<z.ZodUnknown, z.ZodTransform<Awaited<z.core.$InferObjectOutput<{ -readonly [P in keyof S]: S[P]; }, {}> & {
+    /** Release the underlying RPC stub; call once the handle is done with. */
+    [Symbol.dispose](): void;
+}>, unknown>>;
+/** Copy an owned data result through its domain decoder, then release the RPC
+ * envelope. Live resources use their own handle schemas instead. */
+export declare function rpcDataSchema<T>(result: z.ZodType<T>): z.ZodPipe<z.ZodUnknown, z.ZodTransform<Awaited<T>, unknown>>;
+/** Wrap an RPC method's result schema into a Zod function schema: the
+ * decoded value resolves on success, and a malformed result is rethrown
+ * as a PROTOCOL AppError after releasing the raw RPC envelope. */
+export declare function rpcMethod<T>(result: z.ZodType<T>): z.ZodFunction<z.core.$ZodFunctionArgs, z.ZodPromise<z.ZodPipe<z.ZodUnknown, z.ZodTransform<Awaited<T>, unknown>>>>;
+/** A method that decodes and releases an empty RPC result. */
+export declare const rpcVoid: z.ZodFunction<z.core.$ZodFunctionArgs, z.ZodPromise<z.ZodPipe<z.ZodUnknown, z.ZodTransform<void, unknown>>>>;
+/** A per-request Fetch capability keeps Response bodies live until consumed. */
+export declare const rpcFetchHandleSchema: z.ZodPipe<z.ZodUnknown, z.ZodTransform<{
+    fetch: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.ZodPromise<z.ZodPipe<z.ZodUnknown, z.ZodTransform<Response, unknown>>>>;
+    close: z.core.$InferOuterFunctionType<z.core.$ZodFunctionArgs, z.ZodPromise<z.ZodPipe<z.ZodUnknown, z.ZodTransform<void, unknown>>>>;
+} & {
+    /** Release the underlying RPC stub; call once the handle is done with. */
+    [Symbol.dispose](): void;
+}, unknown>>;