electron-effect-rpc 0.1.1 → 0.3.0

package/dist/main.js

@@ -1,18 +1,19 @@
 import * as S from "@effect/schema/Schema";
-import { Effect, PubSub, Stream } from "effect";
+import { Cause, Effect, Exit } from "effect";
 import * as Runtime from "effect/Runtime";
-import { exitSchemaFor, } from "./contract.js";
+import { isNoErrorSchema } from "./contract.js";
+import { extractErrorTag, safelyCall, toDefectEnvelope, } from "./protocol.js";
 import { defaultChannelPrefix, } from "./types.js";
-const resolveChannelPrefix = (prefix) => prefix ?? defaultChannelPrefix;
-export const createRpcServer = (contract, ipc, implementations, options) => {
-    const channelPrefix = resolveChannelPrefix(options?.channelPrefix);
-    const runPromiseExit = (effect) => {
-        if (options?.runtime) {
-            return Runtime.runPromiseExit(options.runtime)(effect);
-        }
-        // @ts-expect-error -- default runtime only supports R=never when no runtime is provided
-        return Effect.runPromiseExit(effect);
-    };
+function resolveChannelPrefix(prefix) {
+    return prefix ?? defaultChannelPrefix;
+}
+function isImplementation(value) {
+    return typeof value === "function";
+}
+export function createRpcEndpoint(contract, ipc, implementations, options) {
+    const channelPrefix = resolveChannelPrefix(options.channelPrefix);
+    const diagnostics = options.diagnostics;
+    const runPromiseExit = Runtime.runPromiseExit(options.runtime);
     const implementationsByName = implementations;
     const methodNames = new Set(contract.methods.map((method) => method.name));
     for (const name in implementations) {
@@ -20,53 +21,325 @@ export const createRpcServer = (contract, ipc, implementations, options) => {
             throw new Error(`Implementation provided for unknown RPC method: ${name}`);
         }
     }
-    contract.methods.forEach((method) => {
+    function reportProtocolError(method, response, cause) {
+        safelyCall(diagnostics?.onProtocolError, {
+            method,
+            response,
+            cause,
+        });
+    }
+    const listeners = new Map();
+    for (const method of contract.methods) {
         const impl = implementationsByName[method.name];
         if (!isImplementation(impl)) {
             throw new Error(`Missing implementation for RPC method: ${method.name}`);
         }
-        const exitSchema = exitSchemaFor(method);
-        const encodeExit = S.encodeUnknownSync(exitSchema);
         const decodeInput = S.decodeUnknownSync(method.req);
+        const encodeSuccess = S.encodeSync(method.res);
+        const encodeFailure = isNoErrorSchema(method.err)
+            ? null
+            : S.encodeSync(method.err);
         const channel = `${channelPrefix.rpc}${method.name}`;
-        ipc.handle(channel, async (_event, rawPayload) => {
+        listeners.set(channel, async function handleRpcRequest(_event, rawPayload) {
             let input;
             try {
                 input = decodeInput(rawPayload);
             }
             catch (cause) {
-                const defectExit = await runPromiseExit(Effect.die(cause));
-                return encodeExit(defectExit);
+                safelyCall(diagnostics?.onDecodeFailure, {
+                    scope: "rpc-request",
+                    name: method.name,
+                    payload: rawPayload,
+                    cause,
+                });
+                return toDefectEnvelope(cause, `RPC ${method.name} request decode failed`);
+            }
+            let effect;
+            try {
+                effect = impl(input);
+            }
+            catch (cause) {
+                return toDefectEnvelope(cause, `RPC ${method.name} implementation threw`);
+            }
+            const exit = await runPromiseExit(effect);
+            if (Exit.isSuccess(exit)) {
+                try {
+                    return {
+                        type: "success",
+                        data: encodeSuccess(exit.value),
+                    };
+                }
+                catch (cause) {
+                    reportProtocolError(method.name, exit.value, cause);
+                    return toDefectEnvelope(cause, `RPC ${method.name} success encoding failed`);
+                }
+            }
+            const failure = Cause.failureOption(exit.cause);
+            if (failure._tag === "Some") {
+                if (!encodeFailure) {
+                    return toDefectEnvelope(failure.value, `RPC ${method.name} returned a typed failure, but method declares NoError`);
+                }
+                try {
+                    return {
+                        type: "failure",
+                        error: {
+                            tag: extractErrorTag(failure.value),
+                            data: encodeFailure(failure.value),
+                        },
+                    };
+                }
+                catch (cause) {
+                    reportProtocolError(method.name, failure.value, cause);
+                    return toDefectEnvelope(cause, `RPC ${method.name} failure encoding failed`);
+                }
             }
-            const exit = await runPromiseExit(impl(input));
-            return encodeExit(exit);
+            const defect = Cause.dieOption(exit.cause);
+            if (defect._tag === "Some") {
+                return toDefectEnvelope(defect.value, `RPC ${method.name} defect`);
+            }
+            return toDefectEnvelope(exit.cause, `RPC ${method.name} interrupted`);
         });
-    });
-};
-const isImplementation = (value) => typeof value === "function";
-const encodePayload = (event, payload) => Effect.try({
-    try: () => S.encodeSync(event.payload)(payload),
-    catch: (cause) => cause instanceof Error ? cause : new Error(String(cause)),
-});
-const dispatchToRenderer = (getWindow, channelPrefix, event, encoded) => Effect.sync(() => {
-    const window = getWindow();
-    if (window && !window.isDestroyed()) {
-        const prefix = resolveChannelPrefix(channelPrefix);
-        window.webContents.send(`${prefix.event}${event.name}`, encoded);
-    }
-});
-export const createEventBus = (_contract, options) => {
-    const pubsub = Effect.runSync(PubSub.unbounded());
-    Effect.runFork(Effect.scoped(Effect.gen(function* () {
-        const dequeue = yield* PubSub.subscribe(pubsub);
-        yield* Stream.fromQueue(dequeue, { shutdown: true }).pipe(Stream.runForEach(({ event, payload }) => Effect.gen(function* () {
-            const encodeResult = yield* Effect.either(encodePayload(event, payload));
-            if (encodeResult._tag === "Left") {
+    }
+    let running = false;
+    let disposed = false;
+    function start() {
+        if (disposed) {
+            throw new Error("RPC endpoint has already been disposed.");
+        }
+        if (running) {
+            return;
+        }
+        const registeredChannels = [];
+        try {
+            for (const [channel, listener] of listeners) {
+                ipc.handle(channel, listener);
+                registeredChannels.push(channel);
+            }
+        }
+        catch (cause) {
+            for (const channel of registeredChannels) {
+                try {
+                    ipc.removeHandler(channel);
+                }
+                catch {
+                    // Best-effort rollback: avoid leaving partial registration behind.
+                }
+            }
+            throw cause;
+        }
+        running = true;
+    }
+    function stop() {
+        if (!running) {
+            return;
+        }
+        let firstError;
+        for (const channel of listeners.keys()) {
+            try {
+                ipc.removeHandler(channel);
+            }
+            catch (cause) {
+                firstError ??= cause;
+            }
+        }
+        running = false;
+        if (firstError !== undefined) {
+            throw firstError;
+        }
+    }
+    function dispose() {
+        if (disposed) {
+            return;
+        }
+        let stopError;
+        try {
+            stop();
+        }
+        catch (cause) {
+            stopError = cause;
+        }
+        disposed = true;
+        if (stopError !== undefined) {
+            throw stopError;
+        }
+    }
+    function isRunning() {
+        return running;
+    }
+    return {
+        start,
+        stop,
+        dispose,
+        isRunning,
+    };
+}
+function clampQueueSize(maxQueueSize) {
+    if (maxQueueSize === undefined) {
+        return 1000;
+    }
+    if (!Number.isFinite(maxQueueSize) || maxQueueSize < 1) {
+        throw new Error("Event publisher maxQueueSize must be a positive finite number.");
+    }
+    return Math.floor(maxQueueSize);
+}
+export function createEventPublisher(_contract, options) {
+    const channelPrefix = resolveChannelPrefix(options.channelPrefix);
+    const diagnostics = options.diagnostics;
+    const maxQueueSize = clampQueueSize(options.maxQueueSize);
+    const queue = [];
+    let dropped = 0;
+    let running = false;
+    let disposed = false;
+    let draining = false;
+    let drainScheduled = false;
+    function scheduleDrain() {
+        if (!running || disposed || draining || drainScheduled) {
+            return;
+        }
+        drainScheduled = true;
+        queueMicrotask(() => {
+            drainScheduled = false;
+            drain();
+        });
+    }
+    function dispatch(item) {
+        let encoded;
+        try {
+            encoded = S.encodeSync(item.event.payload)(item.payload);
+        }
+        catch (cause) {
+            dropped += 1;
+            safelyCall(diagnostics?.onDecodeFailure, {
+                scope: "event-payload",
+                name: item.event.name,
+                payload: item.payload,
+                cause,
+            });
+            safelyCall(diagnostics?.onDroppedEvent, {
+                event: item.event.name,
+                payload: item.payload,
+                reason: "encoding_failed",
+                queued: queue.length,
+                dropped,
+            });
+            return;
+        }
+        const window = options.getWindow();
+        if (!window || window.isDestroyed()) {
+            dropped += 1;
+            safelyCall(diagnostics?.onDroppedEvent, {
+                event: item.event.name,
+                payload: item.payload,
+                reason: "window_unavailable",
+                queued: queue.length,
+                dropped,
+            });
+            return;
+        }
+        try {
+            window.webContents.send(`${channelPrefix.event}${item.event.name}`, encoded);
+        }
+        catch (cause) {
+            dropped += 1;
+            safelyCall(diagnostics?.onDispatchFailure, {
+                event: item.event.name,
+                payload: item.payload,
+                cause,
+            });
+            safelyCall(diagnostics?.onDroppedEvent, {
+                event: item.event.name,
+                payload: item.payload,
+                reason: "dispatch_failed",
+                queued: queue.length,
+                dropped,
+            });
+        }
+    }
+    function drain() {
+        if (!running || disposed || draining) {
+            return;
+        }
+        draining = true;
+        try {
+            while (running && !disposed && queue.length > 0) {
+                const next = queue.shift();
+                if (!next) {
+                    continue;
+                }
+                dispatch(next);
+            }
+        }
+        finally {
+            draining = false;
+            if (running && !disposed && queue.length > 0) {
+                scheduleDrain();
+            }
+        }
+    }
+    function enqueue(item) {
+        if (queue.length >= maxQueueSize) {
+            const evicted = queue.shift();
+            dropped += 1;
+            if (evicted) {
+                safelyCall(diagnostics?.onDroppedEvent, {
+                    event: evicted.event.name,
+                    payload: evicted.payload,
+                    reason: "queue_full",
+                    queued: queue.length,
+                    dropped,
+                });
+            }
+        }
+        queue.push(item);
+        scheduleDrain();
+    }
+    function publish(event, payload) {
+        return Effect.sync(() => {
+            if (disposed) {
                 return;
             }
-            yield* dispatchToRenderer(options.getWindow, options.channelPrefix, event, encodeResult.right);
-        })));
-    })).pipe(Effect.catchAllCause(() => Effect.void), Effect.retry({ times: 3 }), Effect.catchAll(() => Effect.void)));
-    const emit = (event, payload) => Effect.flatMap(PubSub.publish(pubsub, { event, payload }), () => Effect.void);
-    return { emit };
-};
+            enqueue({ event, payload });
+        });
+    }
+    function start() {
+        if (disposed) {
+            throw new Error("Event publisher has already been disposed.");
+        }
+        if (running) {
+            return;
+        }
+        running = true;
+        scheduleDrain();
+    }
+    function stop() {
+        if (!running) {
+            return;
+        }
+        running = false;
+    }
+    function dispose() {
+        if (disposed) {
+            return;
+        }
+        stop();
+        queue.length = 0;
+        disposed = true;
+    }
+    function isRunning() {
+        return running;
+    }
+    function stats() {
+        return {
+            queued: queue.length,
+            dropped,
+        };
+    }
+    return {
+        publish,
+        start,
+        stop,
+        dispose,
+        isRunning,
+        stats,
+    };
+}

package/dist/preload.d.ts

@@ -1,9 +1,19 @@
-import { type ChannelPrefix } from "./types.ts";
-type BridgeOptions = {
+import { type ChannelPrefix, type EventSubscribe, type RpcInvoke } from "./types.ts";
+export type BridgeAdapters = {
+    readonly invoke: RpcInvoke;
+    readonly subscribe: EventSubscribe;
+};
+export type BridgeAdaptersOptions = {
+    readonly channelPrefix?: ChannelPrefix;
+};
+export type BridgeExposureOptions = BridgeAdaptersOptions & {
     readonly rpcGlobal?: string;
     readonly eventsGlobal?: string;
-    readonly channelPrefix?: ChannelPrefix;
 };
-export declare const exposeRpcBridge: (options?: BridgeOptions) => void;
-export {};
+export type IpcBridgeExposureOptions = BridgeAdaptersOptions & {
+    readonly global?: string;
+};
+export declare function createBridgeAdapters(options?: BridgeAdaptersOptions): BridgeAdapters;
+export declare function exposeRpcBridge(options?: BridgeExposureOptions): void;
+export declare function exposeIpcBridge(options?: IpcBridgeExposureOptions): void;
 //# sourceMappingURL=preload.d.ts.map

package/dist/preload.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preload.d.ts","sourceRoot":"","sources":["../src/preload.ts"],"names":[],"mappings":"AACA,OAAO,EAAwB,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAItE,KAAK,aAAa,GAAG;IACnB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,aAAa,CAAC,EAAE,aAAa,CAAC;CACxC,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,UAAU,aAAa,KAAG,IAqBzD,CAAC"}
+{"version":3,"file":"preload.d.ts","sourceRoot":"","sources":["../src/preload.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,SAAS,EACf,MAAM,YAAY,CAAC;AAEpB,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,CAAC,aAAa,CAAC,EAAE,aAAa,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG,qBAAqB,GAAG;IAC1D,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG,qBAAqB,GAAG;IAC7D,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAwCF,wBAAgB,oBAAoB,CAClC,OAAO,CAAC,EAAE,qBAAqB,GAC9B,cAAc,CAuBhB;AAED,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,qBAAqB,GAAG,IAAI,CAgBrE;AAED,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,wBAAwB,GAAG,IAAI,CAYxE"}

package/dist/preload.js

@@ -1,17 +1,56 @@
-import { contextBridge, ipcRenderer } from "electron";
-import { defaultChannelPrefix } from "./types.js";
-export const exposeRpcBridge = (options) => {
-    const rpcGlobal = options?.rpcGlobal ?? "rpc";
-    const eventsGlobal = options?.eventsGlobal ?? "events";
+import * as electronModule from "electron";
+import { defaultChannelPrefix, } from "./types.js";
+function resolveElectronRendererBindings() {
+    const moduleDefault = electronModule.default;
+    const source = moduleDefault && typeof moduleDefault === "object"
+        ? moduleDefault
+        : electronModule;
+    const contextBridge = source.contextBridge;
+    const ipcRenderer = source.ipcRenderer;
+    if (!contextBridge || !ipcRenderer) {
+        throw new Error("electron-effect-rpc/preload requires Electron preload runtime bindings.");
+    }
+    return { contextBridge, ipcRenderer };
+}
+export function createBridgeAdapters(options) {
     const channelPrefix = options?.channelPrefix ?? defaultChannelPrefix;
+    const { ipcRenderer } = resolveElectronRendererBindings();
     const invoke = (method, payload) => ipcRenderer.invoke(`${channelPrefix.rpc}${method}`, payload);
     const subscribe = (event, listener) => {
         const wrapped = (_event, payload) => listener(payload);
-        ipcRenderer.on(`${channelPrefix.event}${event}`, wrapped);
+        const channel = `${channelPrefix.event}${event}`;
+        ipcRenderer.on(channel, wrapped);
         return () => {
-            ipcRenderer.removeListener(`${channelPrefix.event}${event}`, wrapped);
+            ipcRenderer.removeListener(channel, wrapped);
         };
     };
-    contextBridge.exposeInMainWorld(rpcGlobal, { invoke });
-    contextBridge.exposeInMainWorld(eventsGlobal, { subscribe });
-};
+    return {
+        invoke,
+        subscribe,
+    };
+}
+export function exposeRpcBridge(options) {
+    const rpcGlobal = options?.rpcGlobal ?? "rpc";
+    const eventsGlobal = options?.eventsGlobal ?? "events";
+    const { contextBridge } = resolveElectronRendererBindings();
+    const adapters = createBridgeAdapters({
+        channelPrefix: options?.channelPrefix,
+    });
+    contextBridge.exposeInMainWorld(rpcGlobal, {
+        invoke: adapters.invoke,
+    });
+    contextBridge.exposeInMainWorld(eventsGlobal, {
+        subscribe: adapters.subscribe,
+    });
+}
+export function exposeIpcBridge(options) {
+    const global = options?.global ?? "api";
+    const { contextBridge } = resolveElectronRendererBindings();
+    const adapters = createBridgeAdapters({
+        channelPrefix: options?.channelPrefix,
+    });
+    contextBridge.exposeInMainWorld(global, {
+        invoke: adapters.invoke,
+        subscribe: adapters.subscribe,
+    });
+}

package/dist/protocol.d.ts

@@ -0,0 +1,23 @@
+export type RpcSuccessEnvelope = {
+    readonly type: "success";
+    readonly data: unknown;
+};
+export type RpcFailureEnvelope = {
+    readonly type: "failure";
+    readonly error: {
+        readonly tag: string;
+        readonly data: unknown;
+    };
+};
+export type RpcDefectEnvelope = {
+    readonly type: "defect";
+    readonly message: string;
+    readonly cause?: unknown;
+};
+export type RpcResponseEnvelope = RpcSuccessEnvelope | RpcFailureEnvelope | RpcDefectEnvelope;
+export declare function formatUnknown(value: unknown): string;
+export declare function extractErrorTag(error: unknown): string;
+export declare function toDefectEnvelope(cause: unknown, prefix?: string): RpcDefectEnvelope;
+export declare function safelyCall<T>(callback: ((context: T) => void) | undefined, context: T): void;
+export declare function parseRpcResponseEnvelope(value: unknown): RpcResponseEnvelope | null;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../src/protocol.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE;QACd,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;QACrB,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;KACxB,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAC3B,kBAAkB,GAClB,kBAAkB,GAClB,iBAAiB,CAAC;AAUtB,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEpD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAUtD;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,OAAO,EACd,MAAM,CAAC,EAAE,MAAM,GACd,iBAAiB,CAOnB;AAED,wBAAgB,UAAU,CAAC,CAAC,EAC1B,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,CAAC,GAAG,SAAS,EAC5C,OAAO,EAAE,CAAC,GACT,IAAI,CAUN;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,OAAO,GACb,mBAAmB,GAAG,IAAI,CA+C5B"}

package/dist/protocol.js

@@ -0,0 +1,77 @@
+function hasOwn(record, key) {
+    return Object.prototype.hasOwnProperty.call(record, key);
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+export function formatUnknown(value) {
+    return value instanceof Error ? value.message : String(value);
+}
+export function extractErrorTag(error) {
+    if (isRecord(error) && typeof error._tag === "string") {
+        return error._tag;
+    }
+    if (error instanceof Error && error.name.length > 0) {
+        return error.name;
+    }
+    return "RpcError";
+}
+export function toDefectEnvelope(cause, prefix) {
+    const causeText = formatUnknown(cause);
+    return {
+        type: "defect",
+        message: prefix ? `${prefix}: ${causeText}` : causeText,
+        cause: causeText,
+    };
+}
+export function safelyCall(callback, context) {
+    if (!callback) {
+        return;
+    }
+    try {
+        callback(context);
+    }
+    catch {
+        // Diagnostics hooks must never crash transport internals.
+    }
+}
+export function parseRpcResponseEnvelope(value) {
+    if (!isRecord(value) || typeof value.type !== "string") {
+        return null;
+    }
+    switch (value.type) {
+        case "success":
+            if (!hasOwn(value, "data")) {
+                return null;
+            }
+            return {
+                type: "success",
+                data: value.data,
+            };
+        case "failure":
+            if (!isRecord(value.error) || typeof value.error.tag !== "string") {
+                return null;
+            }
+            if (!hasOwn(value.error, "data")) {
+                return null;
+            }
+            return {
+                type: "failure",
+                error: {
+                    tag: value.error.tag,
+                    data: value.error.data,
+                },
+            };
+        case "defect":
+            if (typeof value.message !== "string") {
+                return null;
+            }
+            return {
+                type: "defect",
+                message: value.message,
+                cause: value.cause,
+            };
+        default:
+            return null;
+    }
+}

package/dist/renderer.d.ts

@@ -1,6 +1,6 @@
 import { type RpcContract } from "./contract.ts";
 import { type AnyEvent, type AnyMethod, type EventSubscriber, type EventSubscriberOptions, type RpcClient, type RpcClientOptions } from "./types.ts";
-export declare const createRpcClient: <const Methods extends ReadonlyArray<AnyMethod>, const Events extends ReadonlyArray<AnyEvent>>(contract: RpcContract<Methods, Events>, options?: RpcClientOptions) => RpcClient<RpcContract<Methods, Events>>;
-export declare const createEventSubscriber: <const Methods extends ReadonlyArray<AnyMethod>, const Events extends ReadonlyArray<AnyEvent>>(contract: RpcContract<Methods, Events>, options?: EventSubscriberOptions) => EventSubscriber<RpcContract<Methods, Events>>;
+export declare function createRpcClient<const Methods extends ReadonlyArray<AnyMethod>, const Events extends ReadonlyArray<AnyEvent>>(contract: RpcContract<Methods, Events>, options: RpcClientOptions): RpcClient<RpcContract<Methods, Events>>;
+export declare function createEventSubscriber<const Methods extends ReadonlyArray<AnyMethod>, const Events extends ReadonlyArray<AnyEvent>>(contract: RpcContract<Methods, Events>, options: EventSubscriberOptions): EventSubscriber<RpcContract<Methods, Events>>;
 export { RpcDefectError } from "./types.ts";
 //# sourceMappingURL=renderer.d.ts.map

package/dist/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../src/renderer.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,WAAW,EAIjB,MAAM,eAAe,CAAC;AACvB,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAE3B,KAAK,SAAS,EACd,KAAK,gBAAgB,EACtB,MAAM,YAAY,CAAC;AAyBpB,eAAO,MAAM,eAAe,GAC1B,KAAK,CAAC,OAAO,SAAS,aAAa,CAAC,SAAS,CAAC,EAC9C,KAAK,CAAC,MAAM,SAAS,aAAa,CAAC,QAAQ,CAAC,EAE5C,UAAU,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,EACtC,UAAU,gBAAgB,KACzB,SAAS,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAuExC,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,KAAK,CAAC,OAAO,SAAS,aAAa,CAAC,SAAS,CAAC,EAC9C,KAAK,CAAC,MAAM,SAAS,aAAa,CAAC,QAAQ,CAAC,EAE5C,UAAU,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,EACtC,UAAU,sBAAsB,KAC/B,eAAe,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAoC9C,CAAC;AAEF,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../src/renderer.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,WAAW,EAIjB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,SAAS,EAGd,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAE3B,KAAK,SAAS,EACd,KAAK,gBAAgB,EAEtB,MAAM,YAAY,CAAC;AAuDpB,wBAAgB,eAAe,CAC7B,KAAK,CAAC,OAAO,SAAS,aAAa,CAAC,SAAS,CAAC,EAC9C,KAAK,CAAC,MAAM,SAAS,aAAa,CAAC,QAAQ,CAAC,EAE5C,QAAQ,EAAE,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,EACtC,OAAO,EAAE,gBAAgB,GACxB,SAAS,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAwIzC;AAqBD,wBAAgB,qBAAqB,CACnC,KAAK,CAAC,OAAO,SAAS,aAAa,CAAC,SAAS,CAAC,EAC9C,KAAK,CAAC,MAAM,SAAS,aAAa,CAAC,QAAQ,CAAC,EAE5C,QAAQ,EAAE,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,EACtC,OAAO,EAAE,sBAAsB,GAC9B,eAAe,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC,CAyF/C;AAED,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC"}