capnweb 0.6.1 → 0.7.0

package/dist/index-bun.d.cts

@@ -0,0 +1,125 @@
+import { _ as __RPC_TARGET_BRAND, R as RpcTransport, a as RpcTargetBranded, b as RpcSessionOptions, c as RpcCompatible, d as RpcStub$1 } from './index-workers-C1na2_sM.cjs';
+export { e as RpcPromise, f as RpcSession, g as RpcTarget, h as deserialize, n as newHttpBatchRpcResponse, i as newHttpBatchRpcSession, j as newMessagePortRpcSession, k as newWebSocketRpcSession, l as newWorkersRpcResponse, m as newWorkersWebSocketRpcResponse, o as nodeHttpBatchRpcResponse, s as serialize } from './index-workers-C1na2_sM.cjs';
+import { ServerWebSocket } from 'bun';
+import 'node:http';
+
+interface RpcTarget {
+    [__RPC_TARGET_BRAND]: never;
+}
+declare let RpcTarget: any;
+type PropertyPath = (string | number)[];
+declare abstract class StubHook {
+    abstract call(path: PropertyPath, args: RpcPayload): StubHook;
+    stream(path: PropertyPath, args: RpcPayload): {
+        promise: Promise<void>;
+        size?: number;
+    };
+    abstract map(path: PropertyPath, captures: StubHook[], instructions: unknown[]): StubHook;
+    abstract get(path: PropertyPath): StubHook;
+    abstract dup(): StubHook;
+    abstract pull(): RpcPayload | Promise<RpcPayload>;
+    abstract ignoreUnhandledRejections(): void;
+    abstract dispose(): void;
+    abstract onBroken(callback: (error: any) => void): void;
+}
+declare let RAW_STUB: symbol;
+interface RpcStub extends Disposable {
+}
+declare class RpcStub extends RpcTarget {
+    [RAW_STUB]: this;
+    constructor(hook: StubHook, pathIfPromise?: PropertyPath);
+    hook: StubHook;
+    pathIfPromise?: PropertyPath;
+    dup(): RpcStub;
+    onRpcBroken(callback: (error: any) => void): void;
+    map(func: (value: RpcPromise) => unknown): RpcPromise;
+    toString(): string;
+}
+declare class RpcPromise extends RpcStub {
+    constructor(hook: StubHook, pathIfPromise: PropertyPath);
+    then(onfulfilled?: ((value: unknown) => unknown) | undefined | null, onrejected?: ((reason: any) => unknown) | undefined | null): Promise<unknown>;
+    catch(onrejected?: ((reason: any) => unknown) | undefined | null): Promise<unknown>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<unknown>;
+    toString(): string;
+}
+type LocatedPromise = {
+    parent: object;
+    property: string | number;
+    promise: RpcPromise;
+};
+declare class RpcPayload {
+    value: unknown;
+    private source;
+    private hooks?;
+    private promises?;
+    static fromAppParams(value: unknown): RpcPayload;
+    static fromAppReturn(value: unknown): RpcPayload;
+    static fromArray(array: RpcPayload[]): RpcPayload;
+    static forEvaluate(hooks: StubHook[], promises: LocatedPromise[]): RpcPayload;
+    static deepCopyFrom(value: unknown, oldParent: object | undefined, owner: RpcPayload | null): RpcPayload;
+    private constructor();
+    private rpcTargets?;
+    getHookForRpcTarget(target: RpcTarget | Function, parent: object | undefined, dupStubs?: boolean): StubHook;
+    getHookForWritableStream(stream: WritableStream, parent: object | undefined, dupStubs?: boolean): StubHook;
+    getHookForReadableStream(stream: ReadableStream, parent: object | undefined, dupStubs?: boolean): StubHook;
+    private deepCopy;
+    ensureDeepCopied(): void;
+    private deliverTo;
+    private static deliverRpcPromiseTo;
+    deliverCall(func: Function, thisArg: object | undefined): Promise<RpcPayload>;
+    deliverResolve(): Promise<unknown>;
+    dispose(): void;
+    private disposeImpl;
+    ignoreUnhandledRejections(): void;
+    private ignoreUnhandledRejectionsImpl;
+}
+
+type WsData = {
+    __capnwebTransport: BunWebSocketTransport<WsData>;
+    __capnwebStub: RpcStub;
+};
+/**
+ * Create a Bun `WebSocketHandler` object that manages RPC sessions automatically.
+ *
+ * The returned object can be passed directly as the `websocket` option to `Bun.serve()`.
+ * A fresh `localMain` is created for each connection via the `createMain` callback.
+ * The transport is stored on `ws.data.__capnwebTransport`.
+ *
+ * @param createMain Called once per connection to create the main RPC interface for that client.
+ * @param options Optional RPC session options applied to every connection.
+ */
+declare function newBunWebSocketRpcHandler(createMain: () => RpcTargetBranded, options?: RpcSessionOptions): {
+    open(ws: ServerWebSocket<WsData>): void;
+    message(ws: ServerWebSocket<WsData>, message: string | Buffer): void;
+    close(ws: ServerWebSocket<WsData>, code: number, reason: string): void;
+    error(ws: ServerWebSocket<WsData>, error: Error): void;
+};
+declare class BunWebSocketTransport<T = undefined> implements RpcTransport {
+    #private;
+    constructor(ws: ServerWebSocket<T>);
+    send(message: string): Promise<void>;
+    receive(): Promise<string>;
+    abort?(reason: any): void;
+    dispatchMessage(data: string | Buffer): void;
+    dispatchClose(code: number, reason: string): void;
+    dispatchError(error: Error): void;
+}
+
+interface Empty {
+}
+/**
+ * Start an RPC session over a Bun ServerWebSocket.
+ *
+ * Returns both the RPC stub and the transport. The transport exposes `dispatchMessage`,
+ * `dispatchClose`, and `dispatchError` methods that must be wired to Bun's `WebSocketHandler`
+ * callbacks. For a zero-wiring alternative, use `newBunWebSocketRpcHandler` instead.
+ *
+ * @param ws The Bun ServerWebSocket from the `open` callback.
+ * @param localMain The main RPC interface to expose to the peer.
+ */
+declare let newBunWebSocketRpcSession: <T extends RpcCompatible<T> = Empty, D = undefined>(ws: ServerWebSocket<D>, localMain?: any, options?: RpcSessionOptions) => {
+    stub: RpcStub$1<T>;
+    transport: BunWebSocketTransport<D>;
+};
+
+export { BunWebSocketTransport, RpcCompatible, RpcSessionOptions, RpcStub$1 as RpcStub, RpcTransport, newBunWebSocketRpcHandler, newBunWebSocketRpcSession };

package/dist/index-bun.d.ts

@@ -0,0 +1,125 @@
+import { _ as __RPC_TARGET_BRAND, R as RpcTransport, a as RpcTargetBranded, b as RpcSessionOptions, c as RpcCompatible, d as RpcStub$1 } from './index-workers-C1na2_sM.js';
+export { e as RpcPromise, f as RpcSession, g as RpcTarget, h as deserialize, n as newHttpBatchRpcResponse, i as newHttpBatchRpcSession, j as newMessagePortRpcSession, k as newWebSocketRpcSession, l as newWorkersRpcResponse, m as newWorkersWebSocketRpcResponse, o as nodeHttpBatchRpcResponse, s as serialize } from './index-workers-C1na2_sM.js';
+import { ServerWebSocket } from 'bun';
+import 'node:http';
+
+interface RpcTarget {
+    [__RPC_TARGET_BRAND]: never;
+}
+declare let RpcTarget: any;
+type PropertyPath = (string | number)[];
+declare abstract class StubHook {
+    abstract call(path: PropertyPath, args: RpcPayload): StubHook;
+    stream(path: PropertyPath, args: RpcPayload): {
+        promise: Promise<void>;
+        size?: number;
+    };
+    abstract map(path: PropertyPath, captures: StubHook[], instructions: unknown[]): StubHook;
+    abstract get(path: PropertyPath): StubHook;
+    abstract dup(): StubHook;
+    abstract pull(): RpcPayload | Promise<RpcPayload>;
+    abstract ignoreUnhandledRejections(): void;
+    abstract dispose(): void;
+    abstract onBroken(callback: (error: any) => void): void;
+}
+declare let RAW_STUB: symbol;
+interface RpcStub extends Disposable {
+}
+declare class RpcStub extends RpcTarget {
+    [RAW_STUB]: this;
+    constructor(hook: StubHook, pathIfPromise?: PropertyPath);
+    hook: StubHook;
+    pathIfPromise?: PropertyPath;
+    dup(): RpcStub;
+    onRpcBroken(callback: (error: any) => void): void;
+    map(func: (value: RpcPromise) => unknown): RpcPromise;
+    toString(): string;
+}
+declare class RpcPromise extends RpcStub {
+    constructor(hook: StubHook, pathIfPromise: PropertyPath);
+    then(onfulfilled?: ((value: unknown) => unknown) | undefined | null, onrejected?: ((reason: any) => unknown) | undefined | null): Promise<unknown>;
+    catch(onrejected?: ((reason: any) => unknown) | undefined | null): Promise<unknown>;
+    finally(onfinally?: (() => void) | undefined | null): Promise<unknown>;
+    toString(): string;
+}
+type LocatedPromise = {
+    parent: object;
+    property: string | number;
+    promise: RpcPromise;
+};
+declare class RpcPayload {
+    value: unknown;
+    private source;
+    private hooks?;
+    private promises?;
+    static fromAppParams(value: unknown): RpcPayload;
+    static fromAppReturn(value: unknown): RpcPayload;
+    static fromArray(array: RpcPayload[]): RpcPayload;
+    static forEvaluate(hooks: StubHook[], promises: LocatedPromise[]): RpcPayload;
+    static deepCopyFrom(value: unknown, oldParent: object | undefined, owner: RpcPayload | null): RpcPayload;
+    private constructor();
+    private rpcTargets?;
+    getHookForRpcTarget(target: RpcTarget | Function, parent: object | undefined, dupStubs?: boolean): StubHook;
+    getHookForWritableStream(stream: WritableStream, parent: object | undefined, dupStubs?: boolean): StubHook;
+    getHookForReadableStream(stream: ReadableStream, parent: object | undefined, dupStubs?: boolean): StubHook;
+    private deepCopy;
+    ensureDeepCopied(): void;
+    private deliverTo;
+    private static deliverRpcPromiseTo;
+    deliverCall(func: Function, thisArg: object | undefined): Promise<RpcPayload>;
+    deliverResolve(): Promise<unknown>;
+    dispose(): void;
+    private disposeImpl;
+    ignoreUnhandledRejections(): void;
+    private ignoreUnhandledRejectionsImpl;
+}
+
+type WsData = {
+    __capnwebTransport: BunWebSocketTransport<WsData>;
+    __capnwebStub: RpcStub;
+};
+/**
+ * Create a Bun `WebSocketHandler` object that manages RPC sessions automatically.
+ *
+ * The returned object can be passed directly as the `websocket` option to `Bun.serve()`.
+ * A fresh `localMain` is created for each connection via the `createMain` callback.
+ * The transport is stored on `ws.data.__capnwebTransport`.
+ *
+ * @param createMain Called once per connection to create the main RPC interface for that client.
+ * @param options Optional RPC session options applied to every connection.
+ */
+declare function newBunWebSocketRpcHandler(createMain: () => RpcTargetBranded, options?: RpcSessionOptions): {
+    open(ws: ServerWebSocket<WsData>): void;
+    message(ws: ServerWebSocket<WsData>, message: string | Buffer): void;
+    close(ws: ServerWebSocket<WsData>, code: number, reason: string): void;
+    error(ws: ServerWebSocket<WsData>, error: Error): void;
+};
+declare class BunWebSocketTransport<T = undefined> implements RpcTransport {
+    #private;
+    constructor(ws: ServerWebSocket<T>);
+    send(message: string): Promise<void>;
+    receive(): Promise<string>;
+    abort?(reason: any): void;
+    dispatchMessage(data: string | Buffer): void;
+    dispatchClose(code: number, reason: string): void;
+    dispatchError(error: Error): void;
+}
+
+interface Empty {
+}
+/**
+ * Start an RPC session over a Bun ServerWebSocket.
+ *
+ * Returns both the RPC stub and the transport. The transport exposes `dispatchMessage`,
+ * `dispatchClose`, and `dispatchError` methods that must be wired to Bun's `WebSocketHandler`
+ * callbacks. For a zero-wiring alternative, use `newBunWebSocketRpcHandler` instead.
+ *
+ * @param ws The Bun ServerWebSocket from the `open` callback.
+ * @param localMain The main RPC interface to expose to the peer.
+ */
+declare let newBunWebSocketRpcSession: <T extends RpcCompatible<T> = Empty, D = undefined>(ws: ServerWebSocket<D>, localMain?: any, options?: RpcSessionOptions) => {
+    stub: RpcStub$1<T>;
+    transport: BunWebSocketTransport<D>;
+};
+
+export { BunWebSocketTransport, RpcCompatible, RpcSessionOptions, RpcStub$1 as RpcStub, RpcTransport, newBunWebSocketRpcHandler, newBunWebSocketRpcSession };