electron-effect-rpc 0.5.0 → 0.6.0

package/dist/main.js

@@ -1,15 +1,30 @@
 import * as S from "@effect/schema/Schema";
-import { Cause, Effect, Exit } from "effect";
+import { Cause, Effect, Exit, FiberId, Stream } from "effect";
 import * as Runtime from "effect/Runtime";
 import { isNoErrorSchema } from "./contract.js";
-import { extractErrorTag, safelyCall, toDefectEnvelope, } from "./protocol.js";
+import { extractErrorTag, formatUnknown, isRecord, safelyCall, toDefectEnvelope, } from "./protocol.js";
 import { defaultChannelPrefix, } from "./types.js";
 function resolveChannelPrefix(prefix) {
     return prefix ?? defaultChannelPrefix;
 }
+function isWebContentsLike(value) {
+    if (!isRecord(value))
+        return false;
+    return (typeof value.id === "number" &&
+        typeof value.isDestroyed === "function" &&
+        typeof value.send === "function");
+}
+function extractSender(event) {
+    if (!isRecord(event))
+        return null;
+    return isWebContentsLike(event.sender) ? event.sender : null;
+}
 function isImplementation(value) {
     return typeof value === "function";
 }
+function isStreamImplementation(value) {
+    return typeof value === "function";
+}
 export function createRpcEndpoint(contract, ipc, implementations, options) {
     const channelPrefix = resolveChannelPrefix(options.channelPrefix);
     const diagnostics = options.diagnostics;
@@ -36,9 +51,7 @@ export function createRpcEndpoint(contract, ipc, implementations, options) {
         }
         const decodeInput = S.decodeUnknownSync(method.req);
         const encodeSuccess = S.encodeSync(method.res);
-        const encodeFailure = isNoErrorSchema(method.err)
-            ? null
-            : S.encodeSync(method.err);
+        const encodeFailure = isNoErrorSchema(method.err) ? null : S.encodeSync(method.err);
         const channel = `${channelPrefix.rpc}${method.name}`;
         listeners.set(channel, async function handleRpcRequest(_event, rawPayload) {
             let input;
@@ -100,6 +113,133 @@ export function createRpcEndpoint(contract, ipc, implementations, options) {
             return toDefectEnvelope(exit.cause, `RPC ${method.name} interrupted`);
         });
     }
+    const activeStreams = new Map();
+    const streamListeners = new Map();
+    const streamMethods = contract.streamMethods ?? [];
+    const streamHandlerImpls = options.streamHandlers;
+    const cancelChannel = `${channelPrefix.rpc}stream-cancel`;
+    if (streamMethods.length > 0 && !streamHandlerImpls) {
+        throw new Error("Contract defines stream methods but no streamHandlers were provided.");
+    }
+    if (streamMethods.length > 0 && streamHandlerImpls) {
+        const streamMethodNames = new Set(streamMethods.map((m) => m.name));
+        for (const name in streamHandlerImpls) {
+            if (!streamMethodNames.has(name)) {
+                throw new Error(`Stream implementation provided for unknown stream method: ${name}`);
+            }
+        }
+        const runFork = Runtime.runFork(options.runtime);
+        for (const method of streamMethods) {
+            const impl = streamHandlerImpls[method.name];
+            if (!isStreamImplementation(impl)) {
+                throw new Error(`Missing implementation for stream method: ${method.name}`);
+            }
+            const decodeInput = S.decodeUnknownSync(method.req);
+            const encodeChunk = S.encodeSync(method.chunk);
+            const encodeFailure = isNoErrorSchema(method.err) ? null : S.encodeSync(method.err);
+            const channel = `${channelPrefix.rpc}stream/${method.name}`;
+            streamListeners.set(channel, async function handleStreamRequest(event, rawPayload) {
+                if (!isRecord(rawPayload)) {
+                    return toDefectEnvelope("Stream request payload must be an object");
+                }
+                const streamId = rawPayload.streamId;
+                const rawData = rawPayload.data;
+                if (typeof streamId !== "string" || streamId.length === 0) {
+                    return toDefectEnvelope("Invalid streamId");
+                }
+                if (activeStreams.has(streamId)) {
+                    return toDefectEnvelope("Duplicate streamId");
+                }
+                const sender = extractSender(event);
+                if (!sender) {
+                    return toDefectEnvelope("Stream handler requires sender with webContents");
+                }
+                let input;
+                try {
+                    input = decodeInput(rawData);
+                }
+                catch (cause) {
+                    const decodeCtx = {
+                        scope: "stream-request",
+                        name: method.name,
+                        payload: rawData,
+                        cause,
+                    };
+                    safelyCall(diagnostics?.onDecodeFailure, decodeCtx);
+                    return toDefectEnvelope(cause, `Stream ${method.name} request decode failed`);
+                }
+                const sfChannel = `${channelPrefix.rpc}sf`;
+                const trySend = (frame) => Effect.try({
+                    try: () => {
+                        if (!sender.isDestroyed()) {
+                            sender.send(sfChannel, frame);
+                        }
+                    },
+                    catch: () => undefined,
+                }).pipe(Effect.ignore);
+                let handlerStream;
+                try {
+                    handlerStream = impl(input);
+                }
+                catch (cause) {
+                    return toDefectEnvelope(cause, `Stream ${method.name} implementation threw`);
+                }
+                const buildTerminalFrame = (cause) => {
+                    const failure = Cause.failureOption(cause);
+                    if (failure._tag === "Some") {
+                        if (encodeFailure) {
+                            try {
+                                return {
+                                    type: "error",
+                                    streamId,
+                                    error: {
+                                        tag: extractErrorTag(failure.value),
+                                        data: encodeFailure(failure.value),
+                                    },
+                                };
+                            }
+                            catch {
+                                // encoding failed, fall through to defect
+                            }
+                        }
+                        return { type: "defect", streamId, message: formatUnknown(failure.value) };
+                    }
+                    if (Cause.isInterruptedOnly(cause)) {
+                        return { type: "end", streamId };
+                    }
+                    const defect = Cause.dieOption(cause);
+                    return {
+                        type: "defect",
+                        streamId,
+                        message: defect._tag === "Some" ? formatUnknown(defect.value) : "Stream failed unexpectedly",
+                    };
+                };
+                const streamEffect = handlerStream.pipe(Stream.mapEffect((chunk) => Effect.try({
+                    try: () => {
+                        if (sender.isDestroyed())
+                            return;
+                        sender.send(sfChannel, { type: "data", streamId, payload: encodeChunk(chunk) });
+                    },
+                    catch: () => undefined,
+                }).pipe(Effect.ignore)), Stream.runDrain, Effect.andThen(() => trySend({ type: "end", streamId })), Effect.catchAllCause((cause) => sender.isDestroyed() ? Effect.void : trySend(buildTerminalFrame(cause))), Effect.ensuring(Effect.sync(() => {
+                    activeStreams.delete(streamId);
+                })));
+                // Reserve entry BEFORE forking
+                const entry = {
+                    fiber: null,
+                    senderId: sender.id,
+                };
+                activeStreams.set(streamId, entry);
+                const fiber = runFork(streamEffect);
+                entry.fiber = fiber;
+                const response = {
+                    type: "success",
+                    data: { type: "stream_started" },
+                };
+                return response;
+            });
+        }
+    }
     let running = false;
     let disposed = false;
     function start() {
@@ -115,6 +255,35 @@ export function createRpcEndpoint(contract, ipc, implementations, options) {
                 ipc.handle(channel, listener);
                 registeredChannels.push(channel);
             }
+            // Register stream handlers
+            for (const [channel, listener] of streamListeners) {
+                ipc.handle(channel, listener);
+                registeredChannels.push(channel);
+            }
+            // Register cancel handler if we have stream methods
+            if (streamMethods.length > 0) {
+                ipc.handle(cancelChannel, (event, rawPayload) => {
+                    if (!isRecord(rawPayload)) {
+                        return { cancelled: false };
+                    }
+                    const streamId = rawPayload.streamId;
+                    if (typeof streamId !== "string")
+                        return { cancelled: false };
+                    const entry = activeStreams.get(streamId);
+                    if (!entry)
+                        return { cancelled: false };
+                    // Validate sender identity
+                    const sender = extractSender(event);
+                    if (!sender || sender.id !== entry.senderId)
+                        return { cancelled: false };
+                    // Interrupt the fiber
+                    if (entry.fiber) {
+                        entry.fiber.unsafeInterruptAsFork(FiberId.none);
+                    }
+                    return { cancelled: true };
+                });
+                registeredChannels.push(cancelChannel);
+            }
         }
         catch (cause) {
             for (const channel of registeredChannels) {
@@ -133,6 +302,13 @@ export function createRpcEndpoint(contract, ipc, implementations, options) {
         if (!running) {
             return;
         }
+        // Interrupt all active stream fibers first
+        for (const entry of activeStreams.values()) {
+            if (entry.fiber) {
+                entry.fiber.unsafeInterruptAsFork(FiberId.none);
+            }
+        }
+        activeStreams.clear();
         let firstError;
         for (const channel of listeners.keys()) {
             try {
@@ -142,6 +318,22 @@ export function createRpcEndpoint(contract, ipc, implementations, options) {
                 firstError ??= cause;
             }
         }
+        for (const channel of streamListeners.keys()) {
+            try {
+                ipc.removeHandler(channel);
+            }
+            catch (cause) {
+                firstError ??= cause;
+            }
+        }
+        if (streamMethods.length > 0) {
+            try {
+                ipc.removeHandler(cancelChannel);
+            }
+            catch (cause) {
+                firstError ??= cause;
+            }
+        }
         running = false;
         if (firstError !== undefined) {
             throw firstError;

package/dist/preload.d.ts

@@ -2,6 +2,7 @@ import { type ChannelPrefix, type EventSubscribe, type RpcInvoke } from "./types
 export type BridgeAdapters = {
     readonly invoke: RpcInvoke;
     readonly subscribe: EventSubscribe;
+    readonly onStreamFrame: (listener: (frame: unknown) => void) => () => void;
 };
 export type BridgeAdaptersOptions = {
     readonly channelPrefix?: ChannelPrefix;

package/dist/preload.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"preload.d.ts","sourceRoot":"","sources":["../src/preload.ts"],"names":[],"mappings":"AAGA,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;IACnC,QAAQ,CAAC,aAAa,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,KAAK,MAAM,IAAI,CAAC;CAC5E,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;AAoDF,wBAAgB,oBAAoB,CAAC,OAAO,CAAC,EAAE,qBAAqB,GAAG,cAAc,CAgCpF;AAED,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,qBAAqB,GAAG,IAAI,CAiBrE;AAED,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,wBAAwB,GAAG,IAAI,CAaxE"}

package/dist/preload.js

@@ -1,13 +1,24 @@
 import * as electronModule from "electron";
+import { isRecord } from "./protocol.js";
 import { defaultChannelPrefix, } from "./types.js";
+function isContextBridgeLike(value) {
+    return isRecord(value) && typeof value.exposeInMainWorld === "function";
+}
+function isIpcRendererLike(value) {
+    return (isRecord(value) &&
+        typeof value.invoke === "function" &&
+        typeof value.on === "function" &&
+        typeof value.removeListener === "function");
+}
 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) {
+    const mod = electronModule;
+    const moduleDefault = isRecord(mod) ? mod.default : undefined;
+    const source = isRecord(moduleDefault) ? moduleDefault : isRecord(mod) ? mod : undefined;
+    if (!source) {
+        throw new Error("electron-effect-rpc/preload requires Electron preload runtime bindings.");
+    }
+    const { contextBridge, ipcRenderer } = source;
+    if (!isContextBridgeLike(contextBridge) || !isIpcRendererLike(ipcRenderer)) {
         throw new Error("electron-effect-rpc/preload requires Electron preload runtime bindings.");
     }
     return { contextBridge, ipcRenderer };
@@ -24,9 +35,18 @@ export function createBridgeAdapters(options) {
             ipcRenderer.removeListener(channel, wrapped);
         };
     };
+    const onStreamFrame = (listener) => {
+        const channel = `${channelPrefix.rpc}sf`;
+        const wrapped = (_event, frame) => listener(frame);
+        ipcRenderer.on(channel, wrapped);
+        return () => {
+            ipcRenderer.removeListener(channel, wrapped);
+        };
+    };
     return {
         invoke,
         subscribe,
+        onStreamFrame,
     };
 }
 export function exposeRpcBridge(options) {
@@ -38,6 +58,7 @@ export function exposeRpcBridge(options) {
     });
     contextBridge.exposeInMainWorld(rpcGlobal, {
         invoke: adapters.invoke,
+        onStreamFrame: adapters.onStreamFrame,
     });
     contextBridge.exposeInMainWorld(eventsGlobal, {
         subscribe: adapters.subscribe,
@@ -52,5 +73,6 @@ export function exposeIpcBridge(options) {
     contextBridge.exposeInMainWorld(global, {
         invoke: adapters.invoke,
         subscribe: adapters.subscribe,
+        onStreamFrame: adapters.onStreamFrame,
     });
 }

package/dist/protocol.d.ts

@@ -15,9 +15,35 @@ export type RpcDefectEnvelope = {
     readonly cause?: unknown;
 };
 export type RpcResponseEnvelope = RpcSuccessEnvelope | RpcFailureEnvelope | RpcDefectEnvelope;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
 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 type StreamDataFrame = {
+    readonly type: "data";
+    readonly streamId: string;
+    readonly payload: unknown;
+};
+export type StreamEndFrame = {
+    readonly type: "end";
+    readonly streamId: string;
+};
+export type StreamErrorFrame = {
+    readonly type: "error";
+    readonly streamId: string;
+    readonly error: {
+        readonly tag: string;
+        readonly data: unknown;
+    };
+};
+export type StreamDefectFrame = {
+    readonly type: "defect";
+    readonly streamId: string;
+    readonly message: string;
+};
+export type StreamFrame = StreamDataFrame | StreamEndFrame | StreamErrorFrame | StreamDefectFrame;
+export declare function extractStreamIdFromRaw(value: unknown): string | null;
+export declare function parseStreamFrame(value: unknown): StreamFrame | null;
 export declare function parseRpcResponseEnvelope(value: unknown): RpcResponseEnvelope | null;
 //# sourceMappingURL=protocol.d.ts.map

package/dist/protocol.d.ts.map

@@ -1 +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"}
+{"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,GAAG,kBAAkB,GAAG,kBAAkB,GAAG,iBAAiB,CAAC;AAM9F,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAEzE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEpD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAUtD;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,iBAAiB,CAOnF;AAED,wBAAgB,UAAU,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,KAAK,IAAI,CAAC,GAAG,SAAS,EAAE,OAAO,EAAE,CAAC,GAAG,IAAI,CAU5F;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,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,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,eAAe,GAAG,cAAc,GAAG,gBAAgB,GAAG,iBAAiB,CAAC;AAElG,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAKpE;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,WAAW,GAAG,IAAI,CA4CnE;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,OAAO,GAAG,mBAAmB,GAAG,IAAI,CA+CnF"}

package/dist/protocol.js

@@ -1,7 +1,7 @@
 function hasOwn(record, key) {
     return Object.prototype.hasOwnProperty.call(record, key);
 }
-function isRecord(value) {
+export function isRecord(value) {
     return typeof value === "object" && value !== null;
 }
 export function formatUnknown(value) {
@@ -35,6 +35,48 @@ export function safelyCall(callback, context) {
         // Diagnostics hooks must never crash transport internals.
     }
 }
+export function extractStreamIdFromRaw(value) {
+    if (!isRecord(value) || typeof value.streamId !== "string") {
+        return null;
+    }
+    return value.streamId;
+}
+export function parseStreamFrame(value) {
+    if (!isRecord(value) || typeof value.type !== "string") {
+        return null;
+    }
+    if (typeof value.streamId !== "string") {
+        return null;
+    }
+    const streamId = value.streamId;
+    switch (value.type) {
+        case "data":
+            if (!hasOwn(value, "payload")) {
+                return null;
+            }
+            return { type: "data", streamId, payload: value.payload };
+        case "end":
+            return { type: "end", streamId };
+        case "error":
+            if (!isRecord(value.error) ||
+                typeof value.error.tag !== "string" ||
+                !hasOwn(value.error, "data")) {
+                return null;
+            }
+            return {
+                type: "error",
+                streamId,
+                error: { tag: value.error.tag, data: value.error.data },
+            };
+        case "defect":
+            if (typeof value.message !== "string") {
+                return null;
+            }
+            return { type: "defect", streamId, message: value.message };
+        default:
+            return null;
+    }
+}
 export function parseRpcResponseEnvelope(value) {
     if (!isRecord(value) || typeof value.type !== "string") {
         return null;

package/dist/renderer.d.ts

@@ -1,6 +1,7 @@
-import { type RpcContract } from "./contract.ts";
-import { type AnyEvent, type AnyMethod, type EventSubscriber, type EventSubscriberOptions, type RpcClient, type RpcClientOptions } from "./types.ts";
-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>>;
+import { type AnyStreamMethod, type RpcContract } from "./contract.ts";
+import { type AnyEvent, type AnyMethod, type EventSubscriber, type EventSubscriberOptions, type RpcClient, type RpcClientOptions, type StreamRpcClientHandle, type StreamRpcClientOptions } from "./types.ts";
+export declare function createRpcClient<const Methods extends ReadonlyArray<AnyMethod>, const Events extends ReadonlyArray<AnyEvent>, const StreamMethods extends ReadonlyArray<AnyStreamMethod> = readonly []>(contract: RpcContract<Methods, Events, StreamMethods>, options: RpcClientOptions): RpcClient<RpcContract<Methods, Events, StreamMethods>>;
+export declare function createEventSubscriber<const Methods extends ReadonlyArray<AnyMethod>, const Events extends ReadonlyArray<AnyEvent>, const StreamMethods extends ReadonlyArray<AnyStreamMethod> = readonly []>(contract: RpcContract<Methods, Events, StreamMethods>, options: EventSubscriberOptions): EventSubscriber<RpcContract<Methods, Events, StreamMethods>>;
+export declare function createStreamRpcClient<const Methods extends ReadonlyArray<AnyMethod>, const Events extends ReadonlyArray<AnyEvent>, const StreamMethods extends ReadonlyArray<AnyStreamMethod>>(contract: RpcContract<Methods, Events, StreamMethods>, options: StreamRpcClientOptions): StreamRpcClientHandle<RpcContract<Methods, Events, StreamMethods>>;
 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,EAGL,KAAK,WAAW,EAIjB,MAAM,eAAe,CAAC;AAOvB,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,SAAS,EAGd,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAE3B,KAAK,SAAS,EACd,KAAK,gBAAgB,EAGtB,MAAM,YAAY,CAAC;AAuEpB,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,CA0KzC;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"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../src/renderer.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,eAAe,EACpB,KAAK,WAAW,EAMjB,MAAM,eAAe,CAAC;AAUvB,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,SAAS,EAGd,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAE3B,KAAK,SAAS,EACd,KAAK,gBAAgB,EAMrB,KAAK,qBAAqB,EAC1B,KAAK,sBAAsB,EAC5B,MAAM,YAAY,CAAC;AAsEpB,wBAAgB,eAAe,CAC7B,KAAK,CAAC,OAAO,SAAS,aAAa,CAAC,SAAS,CAAC,EAC9C,KAAK,CAAC,MAAM,SAAS,aAAa,CAAC,QAAQ,CAAC,EAC5C,KAAK,CAAC,aAAa,SAAS,aAAa,CAAC,eAAe,CAAC,GAAG,SAAS,EAAE,EAExE,QAAQ,EAAE,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,CAAC,EACrD,OAAO,EAAE,gBAAgB,GACxB,SAAS,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,CA0JxD;AAqBD,wBAAgB,qBAAqB,CACnC,KAAK,CAAC,OAAO,SAAS,aAAa,CAAC,SAAS,CAAC,EAC9C,KAAK,CAAC,MAAM,SAAS,aAAa,CAAC,QAAQ,CAAC,EAC5C,KAAK,CAAC,aAAa,SAAS,aAAa,CAAC,eAAe,CAAC,GAAG,SAAS,EAAE,EAExE,QAAQ,EAAE,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,CAAC,EACrD,OAAO,EAAE,sBAAsB,GAC9B,eAAe,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,CAsF9D;AAUD,wBAAgB,qBAAqB,CACnC,KAAK,CAAC,OAAO,SAAS,aAAa,CAAC,SAAS,CAAC,EAC9C,KAAK,CAAC,MAAM,SAAS,aAAa,CAAC,QAAQ,CAAC,EAC5C,KAAK,CAAC,aAAa,SAAS,aAAa,CAAC,eAAe,CAAC,EAE1D,QAAQ,EAAE,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,CAAC,EACrD,OAAO,EAAE,sBAAsB,GAC9B,qBAAqB,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,aAAa,CAAC,CAAC,CA2NpE;AAED,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC"}

package/dist/renderer.js

@@ -1,7 +1,7 @@
 import * as S from "@effect/schema/Schema";
-import { Cause, Effect, Exit } from "effect";
+import { Cause, Effect, Exit, Stream } from "effect";
 import { exitSchemaFor, isNoErrorSchema, } from "./contract.js";
-import { formatUnknown, parseRpcResponseEnvelope, safelyCall, } from "./protocol.js";
+import { extractStreamIdFromRaw, formatUnknown, isRecord, parseRpcResponseEnvelope, parseStreamFrame, safelyCall, } from "./protocol.js";
 import { RpcDefectError, } from "./types.js";
 function requireInvoke(options) {
     if (!options?.invoke) {
@@ -18,6 +18,12 @@ function requireSubscribe(options) {
 function rpcDefect(code, message, cause) {
     return new RpcDefectError(code, message, cause);
 }
+function decodeNonEmptyError(schema, data) {
+    if (isNoErrorSchema(schema)) {
+        throw new Error("unreachable: caller must check isNoErrorSchema first");
+    }
+    return S.decodeUnknownSync(schema)(data);
+}
 function decodeLegacyExit(method, raw) {
     return Effect.try({
         try: () => S.decodeUnknownSync(exitSchemaFor(method))(raw),
@@ -62,9 +68,8 @@ export function createRpcClient(contract, options) {
                 if (isNoErrorSchema(method.err)) {
                     return Effect.fail(rpcDefect("noerror_contract_violation", `RPC ${method.name} received a failure for a method that declares NoError`, envelope.error));
                 }
-                const errorSchema = method.err;
                 return Effect.try({
-                    try: () => S.decodeUnknownSync(errorSchema)(envelope.error.data),
+                    try: () => decodeNonEmptyError(method.err, envelope.error.data),
                     catch: (cause) => {
                         safelyCall(diagnostics?.onDecodeFailure, {
                             scope: "rpc-response",
@@ -107,8 +112,7 @@ export function createRpcClient(contract, options) {
         }
         if (decodeMode === "dual") {
             return decodeLegacyExit(method, raw).pipe(Effect.tapError((cause) => {
-                if (cause instanceof RpcDefectError &&
-                    cause.code === "legacy_decode_failed") {
+                if (cause instanceof RpcDefectError && cause.code === "legacy_decode_failed") {
                     return Effect.sync(() => safelyCall(diagnostics?.onProtocolError, {
                         method: method.name,
                         response: raw,
@@ -130,9 +134,7 @@ export function createRpcClient(contract, options) {
     const clientRecord = client;
     for (const method of contract.methods) {
         const caller = (...args) => {
-            const payload = args.length === 0
-                ? {}
-                : args[0];
+            const payload = args.length === 0 ? {} : args[0];
             return call(method, payload);
         };
         clientRecord[method.name] = caller;
@@ -221,4 +223,154 @@ export function createEventSubscriber(contract, options) {
         dispose,
     };
 }
+function isStreamStartedResponse(value) {
+    if (!isRecord(value))
+        return false;
+    if (value.type === "success" && isRecord(value.data)) {
+        return value.data.type === "stream_started";
+    }
+    return false;
+}
+export function createStreamRpcClient(contract, options) {
+    const invoke = options.invoke;
+    const onStreamFrame = options.onStreamFrame;
+    const diagnostics = options.diagnostics;
+    const frameDispatcher = new Map();
+    // Set up central frame listener
+    const centralCleanup = onStreamFrame((raw) => {
+        const frame = parseStreamFrame(raw);
+        if (!frame) {
+            // Best-effort: extract streamId from malformed frame to fail the active stream
+            const rawStreamId = extractStreamIdFromRaw(raw);
+            if (rawStreamId) {
+                const handler = frameDispatcher.get(rawStreamId);
+                if (handler) {
+                    handler.defect("Malformed stream frame received");
+                    frameDispatcher.delete(rawStreamId);
+                }
+            }
+            safelyCall(diagnostics?.onProtocolError, {
+                method: "stream-frame",
+                response: raw,
+                cause: null,
+            });
+            return;
+        }
+        const handler = frameDispatcher.get(frame.streamId);
+        if (!handler)
+            return; // stale frame for completed/cancelled stream
+        switch (frame.type) {
+            case "data":
+                handler.data(frame.payload);
+                break;
+            case "end":
+                handler.end();
+                frameDispatcher.delete(frame.streamId);
+                break;
+            case "error":
+                handler.error(frame.error);
+                frameDispatcher.delete(frame.streamId);
+                break;
+            case "defect":
+                handler.defect(frame.message);
+                frameDispatcher.delete(frame.streamId);
+                break;
+        }
+    });
+    const streamMethods = contract.streamMethods ?? [];
+    const client = Object.create(null);
+    const clientRecord = client;
+    for (const method of streamMethods) {
+        const decodeChunk = S.decodeUnknownSync(method.chunk);
+        const encodeInput = S.encodeSync(method.req);
+        const decodeTypedError = isNoErrorSchema(method.err) ? null : S.decodeUnknownSync(method.err);
+        const caller = (...args) => {
+            const payload = args.length === 0 ? {} : args[0];
+            return Stream.asyncPush((emit) => Effect.gen(function* () {
+                const streamId = crypto.randomUUID();
+                // 1. Register in dispatch map BEFORE calling invoke
+                frameDispatcher.set(streamId, {
+                    data: (rawPayload) => {
+                        let decoded;
+                        try {
+                            decoded = decodeChunk(rawPayload);
+                        }
+                        catch (cause) {
+                            const context = {
+                                scope: "stream-chunk",
+                                name: method.name,
+                                payload: rawPayload,
+                                cause,
+                            };
+                            safelyCall(diagnostics?.onDecodeFailure, context);
+                            emit.fail(rpcDefect("stream_chunk_decode_failed", `Stream ${method.name} chunk decode failed: ${formatUnknown(cause)}`, cause));
+                            return;
+                        }
+                        emit.single(decoded);
+                    },
+                    end: () => emit.end(),
+                    error: (err) => {
+                        if (!decodeTypedError) {
+                            emit.fail(rpcDefect("stream_error_decode_failed", `Stream ${method.name} received typed error but declares NoError`, err));
+                            return;
+                        }
+                        try {
+                            const decoded = decodeNonEmptyError(method.err, err.data);
+                            emit.fail(decoded);
+                        }
+                        catch (cause) {
+                            const errContext = {
+                                scope: "stream-error",
+                                name: method.name,
+                                payload: err,
+                                cause,
+                            };
+                            safelyCall(diagnostics?.onDecodeFailure, errContext);
+                            emit.fail(rpcDefect("stream_error_decode_failed", `Stream ${method.name} error decode failed: ${formatUnknown(cause)}`, cause));
+                        }
+                    },
+                    defect: (message) => emit.fail(rpcDefect("remote_defect", message, undefined)),
+                });
+                // 2. Register cleanup finalizer
+                yield* Effect.addFinalizer(() => Effect.sync(() => {
+                    frameDispatcher.delete(streamId);
+                }).pipe(Effect.andThen(Effect.tryPromise(() => invoke(`stream-cancel`, { streamId })).pipe(Effect.ignore))));
+                // 3. Encode input
+                const encodedInput = yield* Effect.try({
+                    try: () => encodeInput(payload),
+                    catch: (cause) => rpcDefect("request_encoding_failed", `Stream ${method.name} request encoding failed: ${formatUnknown(cause)}`, cause),
+                });
+                // 4. Initiate the stream on main
+                const response = yield* Effect.tryPromise({
+                    try: () => invoke(`stream/${method.name}`, {
+                        data: encodedInput,
+                        streamId,
+                    }),
+                    catch: (cause) => rpcDefect("stream_invoke_failed", `Stream ${method.name} invoke failed: ${formatUnknown(cause)}`, cause),
+                });
+                // 5. Validate handshake response
+                const envelope = parseRpcResponseEnvelope(response);
+                if (envelope?.type === "defect") {
+                    return yield* Effect.fail(rpcDefect("remote_defect", envelope.message, envelope.cause));
+                }
+                if (!isStreamStartedResponse(response)) {
+                    return yield* Effect.fail(rpcDefect("stream_handshake_invalid", `Stream ${method.name} unexpected handshake response`, response));
+                }
+            }), { bufferSize: 16, strategy: "dropping" });
+        };
+        clientRecord[method.name] = caller;
+    }
+    function dispose() {
+        // Fail all active streams so consumers don't hang
+        for (const [streamId, handler] of frameDispatcher) {
+            handler.defect("Stream client disposed");
+            frameDispatcher.delete(streamId);
+        }
+        centralCleanup();
+    }
+    return {
+        client,
+        dispose,
+    };
+}
 export { RpcDefectError } from "./types.js";