electron-effect-rpc 0.1.0 → 0.1.1

package/README.md

@@ -30,7 +30,21 @@ and let the workspace resolver handle the rest.
 
 ## Core Concepts
 
-### Methods and events
+### Communication directions
+
+This library provides two communication patterns for Electron IPC:
+
+| Direction | Mechanism | Pattern | Use case |
+|-----------|-----------|---------|----------|
+| **Renderer → Main** | RPC methods | Request/response | Fetching data, triggering actions, calling main process APIs |
+| **Main → Renderer** | Event bus | Push/broadcast | Progress updates, state changes, background task notifications |
+
+**RPC methods** are for when the renderer needs something from the main process. The renderer calls a method and awaits a typed response.
+
+**Events** are for when the main process needs to notify the renderer. The main process emits events whenever it wants, and the renderer subscribes to receive them.
+
+### Defining methods and events
+
 Define methods and events using schema-based helpers:
 
 ```ts

package/dist/contract.d.ts

@@ -0,0 +1,40 @@
+import * as S from "@effect/schema/Schema";
+export type SchemaNoContext = S.Schema.AnyNoContext;
+export declare const NoError: typeof S.Never;
+export type NoError = typeof NoError;
+export type ErrorSchema = SchemaNoContext | S.Schema<never, never, never>;
+export interface RpcMethod<Name extends string, Req extends SchemaNoContext, Res extends SchemaNoContext, Err extends ErrorSchema = NoError> {
+    readonly name: Name;
+    readonly req: Req;
+    readonly res: Res;
+    readonly err: Err;
+}
+export declare function rpc<const Name extends string, Req extends SchemaNoContext, Res extends SchemaNoContext, Err extends ErrorSchema>(name: Name, req: Req, res: Res, err: Err): RpcMethod<Name, Req, Res, Err>;
+export declare function rpc<const Name extends string, Req extends SchemaNoContext, Res extends SchemaNoContext>(name: Name, req: Req, res: Res): RpcMethod<Name, Req, Res, NoError>;
+export interface RpcEvent<Payload extends SchemaNoContext, Context extends SchemaNoContext | null, Name extends string = string> {
+    readonly name: Name;
+    readonly payload: Payload;
+    readonly context: Context;
+}
+export declare function event<const Name extends string, Payload extends SchemaNoContext, Context extends SchemaNoContext>(name: Name, payload: Payload, context: Context): RpcEvent<Payload, Context, Name>;
+export declare function event<const Name extends string, Payload extends SchemaNoContext>(name: Name, payload: Payload): RpcEvent<Payload, null, Name>;
+export declare const exitSchemaFor: <Name extends string, Req extends SchemaNoContext, Res extends SchemaNoContext, Err extends ErrorSchema>(method: RpcMethod<Name, Req, Res, Err>) => S.Exit<Res, Err, S.Defect>;
+export type AnyMethod = RpcMethod<string, SchemaNoContext, SchemaNoContext, ErrorSchema>;
+export type AnyEvent = RpcEvent<SchemaNoContext, SchemaNoContext | null, string>;
+export type RpcInput<M extends AnyMethod> = S.Schema.Type<M["req"]>;
+export type RpcOutput<M extends AnyMethod> = S.Schema.Type<M["res"]>;
+export type RpcError<M extends AnyMethod> = S.Schema.Type<M["err"]>;
+export type RpcEventPayload<E extends AnyEvent> = S.Schema.Type<E["payload"]>;
+/** Extract a method from a tuple by its name string literal. */
+export type ExtractMethod<Methods extends readonly AnyMethod[], Name extends string> = Extract<Methods[number], {
+    readonly name: Name;
+}>;
+export interface RpcContract<Methods extends ReadonlyArray<AnyMethod>, Events extends ReadonlyArray<AnyEvent>> {
+    readonly methods: Methods;
+    readonly events: Events;
+}
+export declare const defineContract: <const Methods extends ReadonlyArray<AnyMethod>, const Events extends ReadonlyArray<AnyEvent>>(input: {
+    readonly methods: Methods;
+    readonly events: Events;
+}) => RpcContract<Methods, Events>;
+//# sourceMappingURL=contract.d.ts.map

package/dist/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../src/contract.ts"],"names":[],"mappings":"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"}

package/dist/contract.js

@@ -0,0 +1,43 @@
+import * as S from "@effect/schema/Schema";
+export const NoError = S.Never;
+export function rpc(name, req, res, err = NoError) {
+    return { name, req, res, err };
+}
+export function event(name, payload, context) {
+    return { name, payload, context: context ?? null };
+}
+export const exitSchemaFor = (method) => S.Exit({
+    success: method.res,
+    failure: method.err,
+    defect: S.Defect,
+});
+const collectDuplicates = (names) => {
+    const counts = new Map();
+    const duplicates = [];
+    for (const name of names) {
+        const next = (counts.get(name) ?? 0) + 1;
+        counts.set(name, next);
+        if (next === 2) {
+            duplicates.push(name);
+        }
+    }
+    return duplicates;
+};
+export const defineContract = (input) => {
+    const { methods, events } = input;
+    if (!Array.isArray(methods)) {
+        throw new Error("RPC contract methods must be an array.");
+    }
+    if (!Array.isArray(events)) {
+        throw new Error("RPC contract events must be an array.");
+    }
+    const duplicateMethods = collectDuplicates(methods.map((method) => method.name));
+    if (duplicateMethods.length > 0) {
+        throw new Error(`Duplicate RPC method name(s): ${duplicateMethods.join(", ")}`);
+    }
+    const duplicateEvents = collectDuplicates(events.map((event) => event.name));
+    if (duplicateEvents.length > 0) {
+        throw new Error(`Duplicate RPC event name(s): ${duplicateEvents.join(", ")}`);
+    }
+    return input;
+};

package/dist/main.d.ts

@@ -0,0 +1,5 @@
+import { type RpcContract } from "./contract.ts";
+import { type AnyEvent, type AnyMethod, type EventBusOptions, type Implementations, type IpcMainLike, type RpcEventBus, type RpcServerOptions } from "./types.ts";
+export declare const createRpcServer: <const Methods extends ReadonlyArray<AnyMethod>, const Events extends ReadonlyArray<AnyEvent>, R = never>(contract: RpcContract<Methods, Events>, ipc: IpcMainLike, implementations: Implementations<RpcContract<Methods, Events>, R>, options?: RpcServerOptions<R>) => void;
+export declare const createEventBus: <const Methods extends ReadonlyArray<AnyMethod>, const Events extends ReadonlyArray<AnyEvent>>(_contract: RpcContract<Methods, Events>, options: EventBusOptions) => RpcEventBus<RpcContract<Methods, Events>>;
+//# sourceMappingURL=main.d.ts.map

package/dist/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../src/main.ts"],"names":[],"mappings":"AAGA,OAAO,EAEL,KAAK,WAAW,EAKjB,MAAM,eAAe,CAAC;AACvB,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,gBAAgB,EACtB,MAAM,YAAY,CAAC;AAKpB,eAAO,MAAM,eAAe,GAC1B,KAAK,CAAC,OAAO,SAAS,aAAa,CAAC,SAAS,CAAC,EAC9C,KAAK,CAAC,MAAM,SAAS,aAAa,CAAC,QAAQ,CAAC,EAC5C,CAAC,GAAG,KAAK,EAET,UAAU,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,EACtC,KAAK,WAAW,EAChB,iBAAiB,eAAe,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC,EACjE,UAAU,gBAAgB,CAAC,CAAC,CAAC,KAC5B,IA6CF,CAAC;AAqCF,eAAO,MAAM,cAAc,GACzB,KAAK,CAAC,OAAO,SAAS,aAAa,CAAC,SAAS,CAAC,EAC9C,KAAK,CAAC,MAAM,SAAS,aAAa,CAAC,QAAQ,CAAC,EAE5C,WAAW,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,EACvC,SAAS,eAAe,KACvB,WAAW,CAAC,WAAW,CAAC,OAAO,EAAE,MAAM,CAAC,CA8C1C,CAAC"}

package/dist/main.js

@@ -0,0 +1,72 @@
+import * as S from "@effect/schema/Schema";
+import { Effect, PubSub, Stream } from "effect";
+import * as Runtime from "effect/Runtime";
+import { exitSchemaFor, } from "./contract.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);
+    };
+    const implementationsByName = implementations;
+    const methodNames = new Set(contract.methods.map((method) => method.name));
+    for (const name in implementations) {
+        if (!methodNames.has(name)) {
+            throw new Error(`Implementation provided for unknown RPC method: ${name}`);
+        }
+    }
+    contract.methods.forEach((method) => {
+        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 channel = `${channelPrefix.rpc}${method.name}`;
+        ipc.handle(channel, async (_event, rawPayload) => {
+            let input;
+            try {
+                input = decodeInput(rawPayload);
+            }
+            catch (cause) {
+                const defectExit = await runPromiseExit(Effect.die(cause));
+                return encodeExit(defectExit);
+            }
+            const exit = await runPromiseExit(impl(input));
+            return encodeExit(exit);
+        });
+    });
+};
+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") {
+                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 };
+};

package/dist/preload.d.ts

@@ -0,0 +1,9 @@
+import { type ChannelPrefix } from "./types.ts";
+type BridgeOptions = {
+    readonly rpcGlobal?: string;
+    readonly eventsGlobal?: string;
+    readonly channelPrefix?: ChannelPrefix;
+};
+export declare const exposeRpcBridge: (options?: BridgeOptions) => void;
+export {};
+//# sourceMappingURL=preload.d.ts.map

package/dist/preload.d.ts.map

@@ -0,0 +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"}

package/dist/preload.js

@@ -0,0 +1,17 @@
+import { contextBridge, ipcRenderer } from "electron";
+import { defaultChannelPrefix } from "./types.js";
+export const exposeRpcBridge = (options) => {
+    const rpcGlobal = options?.rpcGlobal ?? "rpc";
+    const eventsGlobal = options?.eventsGlobal ?? "events";
+    const channelPrefix = options?.channelPrefix ?? defaultChannelPrefix;
+    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);
+        return () => {
+            ipcRenderer.removeListener(`${channelPrefix.event}${event}`, wrapped);
+        };
+    };
+    contextBridge.exposeInMainWorld(rpcGlobal, { invoke });
+    contextBridge.exposeInMainWorld(eventsGlobal, { subscribe });
+};

package/dist/renderer.d.ts

@@ -0,0 +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 { RpcDefectError } from "./types.ts";
+//# sourceMappingURL=renderer.d.ts.map

package/dist/renderer.d.ts.map

@@ -0,0 +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"}

package/dist/renderer.js

@@ -0,0 +1,93 @@
+import * as S from "@effect/schema/Schema";
+import { Cause, Exit } from "effect";
+import { exitSchemaFor, } from "./contract.js";
+import { RpcDefectError, } from "./types.js";
+const formatCause = (cause) => cause instanceof Error ? cause.message : String(cause);
+const requireInvoke = (options) => {
+    if (!options?.invoke) {
+        throw new Error("RpcClientOptions.invoke is required.");
+    }
+    return options.invoke;
+};
+const requireSubscribe = (options) => {
+    if (!options?.subscribe) {
+        throw new Error("EventSubscriberOptions.subscribe is required.");
+    }
+    return options.subscribe;
+};
+export const createRpcClient = (contract, options) => {
+    const invoke = requireInvoke(options);
+    const call = async (method, input) => {
+        let encoded;
+        try {
+            encoded = S.encodeSync(method.req)(input);
+        }
+        catch (cause) {
+            throw new Error(`RPC ${method.name} request encoding failed: ${formatCause(cause)}`);
+        }
+        const raw = await invoke(method.name, encoded);
+        const exitSchema = exitSchemaFor(method);
+        const decodeExit = S.decodeUnknownSync(exitSchema);
+        let exit;
+        try {
+            exit = decodeExit(raw);
+        }
+        catch (cause) {
+            throw new Error(`RPC ${method.name} response decoding failed: ${formatCause(cause)}`);
+        }
+        if (Exit.isSuccess(exit)) {
+            return exit.value;
+        }
+        const cause = exit.cause;
+        const failureOption = Cause.failureOption(cause);
+        if (failureOption._tag === "Some") {
+            throw failureOption.value;
+        }
+        const defectOption = Cause.dieOption(cause);
+        if (defectOption._tag === "Some") {
+            const defect = defectOption.value;
+            if (defect instanceof Error) {
+                throw new RpcDefectError(defect.message, defect);
+            }
+            throw new RpcDefectError(String(defect), defect);
+        }
+        throw new RpcDefectError("RPC call was interrupted or failed unexpectedly", cause);
+    };
+    const client = Object.create(null);
+    const clientRecord = client;
+    contract.methods.forEach((method) => {
+        const caller = (input) => {
+            const payload = input ?? S.decodeUnknownSync(method.req)({});
+            return call(method, payload);
+        };
+        clientRecord[method.name] = caller;
+    });
+    return client;
+};
+export const createEventSubscriber = (contract, options) => {
+    const subscribe = requireSubscribe(options);
+    const eventMap = new Map();
+    for (const event of contract.events) {
+        eventMap.set(event.name, event);
+    }
+    const subscribeEvent = (event, handler) => {
+        const decoder = S.decodeUnknownSync(event.payload);
+        return subscribe(event.name, (payload) => {
+            const decoded = decoder(payload);
+            handler(decoded);
+        });
+    };
+    const subscribeByName = (name, handler) => {
+        const event = eventMap.get(name);
+        if (!event) {
+            throw new Error(`Unknown event: ${name}`);
+        }
+        const decoder = S.decodeUnknownSync(event.payload);
+        return subscribe(name, (payload) => handler(decoder(payload)));
+    };
+    return {
+        subscribe: subscribeEvent,
+        subscribeByName,
+    };
+};
+export { RpcDefectError } from "./types.js";

package/dist/testing.d.ts

@@ -0,0 +1,15 @@
+import type { RpcInvoke } from "./types.ts";
+export type Invocation = {
+    readonly method: string;
+    readonly payload: unknown;
+};
+export type InvokeStub = RpcInvoke & {
+    readonly invocations: Invocation[];
+};
+export declare const createInvokeStub: (impl: RpcInvoke) => InvokeStub;
+export declare const createDeferred: <T>() => {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: unknown) => void;
+};
+//# sourceMappingURL=testing.d.ts.map

package/dist/testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAE5C,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG;IAAE,QAAQ,CAAC,WAAW,EAAE,UAAU,EAAE,CAAA;CAAE,CAAC;AAE5E,eAAO,MAAM,gBAAgB,GAAI,MAAM,SAAS,KAAG,UAYlD,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,CAAC;;qBACT,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI;sBAC1B,OAAO,KAAK,IAAI;CAOvC,CAAC"}

package/dist/testing.js

@@ -0,0 +1,17 @@
+export const createInvokeStub = (impl) => {
+    const invocations = [];
+    const wrapped = Object.assign(async (method, payload) => {
+        invocations.push({ method, payload });
+        return impl(method, payload);
+    }, { invocations });
+    return wrapped;
+};
+export const createDeferred = () => {
+    let resolve = () => { };
+    let reject = () => { };
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+};

package/dist/types.d.ts

@@ -0,0 +1,52 @@
+import type * as Effect from "effect/Effect";
+import type * as Runtime from "effect/Runtime";
+import type { BrowserWindow } from "electron";
+import type { AnyEvent, AnyMethod, ExtractMethod, RpcContract, RpcError, RpcEventPayload, RpcInput, RpcOutput } from "./contract.ts";
+export type { AnyEvent, AnyMethod, ErrorSchema, ExtractMethod, RpcContract, RpcError, RpcEvent, RpcEventPayload, RpcInput, RpcMethod, RpcOutput, SchemaNoContext, } from "./contract.ts";
+export type Implementations<C extends RpcContract<readonly AnyMethod[], readonly AnyEvent[]>, R = never> = {
+    readonly [Name in C["methods"][number]["name"]]: (input: RpcInput<ExtractMethod<C["methods"], Name>>) => Effect.Effect<RpcOutput<ExtractMethod<C["methods"], Name>>, RpcError<ExtractMethod<C["methods"], Name>>, R>;
+};
+type IsEmptyObject<T> = keyof T extends never ? true : false;
+export type RpcCaller<M extends AnyMethod> = IsEmptyObject<RpcInput<M>> extends true ? () => Promise<RpcOutput<M>> : (input: RpcInput<M>) => Promise<RpcOutput<M>>;
+export type RpcClient<C extends RpcContract<readonly AnyMethod[], readonly AnyEvent[]>> = {
+    readonly [Name in C["methods"][number]["name"]]: RpcCaller<ExtractMethod<C["methods"], Name>>;
+};
+export declare class RpcDefectError extends Error {
+    readonly cause: unknown;
+    readonly _tag = "RpcDefectError";
+    constructor(message: string, cause: unknown);
+}
+export type ChannelPrefix = {
+    readonly rpc: string;
+    readonly event: string;
+};
+export declare const defaultChannelPrefix: ChannelPrefix;
+export type IpcMainLike = {
+    readonly handle: (channel: string, listener: (event: unknown, payload: unknown) => unknown) => unknown;
+};
+export type RpcInvoke = (method: string, payload: unknown) => Promise<unknown>;
+/** Provide a Runtime when handlers require services (R). */
+export type RpcServerOptions<R = never> = {
+    readonly channelPrefix?: ChannelPrefix;
+    readonly runtime?: Runtime.Runtime<R>;
+};
+export type RpcClientOptions = {
+    readonly invoke?: RpcInvoke;
+    readonly channelPrefix?: ChannelPrefix;
+};
+export type EventBusOptions = {
+    readonly channelPrefix?: ChannelPrefix;
+    readonly getWindow: () => BrowserWindow | null;
+};
+export type EventSubscriberOptions = {
+    readonly channelPrefix?: ChannelPrefix;
+    readonly subscribe?: (name: string, handler: (payload: unknown) => void) => () => void;
+};
+export interface RpcEventBus<C extends RpcContract<readonly AnyMethod[], readonly AnyEvent[]>> {
+    readonly emit: <E extends C["events"][number]>(event: E, payload: RpcEventPayload<E>) => Effect.Effect<void, never>;
+}
+export interface EventSubscriber<C extends RpcContract<readonly AnyMethod[], readonly AnyEvent[]>> {
+    readonly subscribe: <E extends C["events"][number]>(event: E, handler: (payload: RpcEventPayload<E>) => void) => () => void;
+    readonly subscribeByName: (name: C["events"][number]["name"], handler: (payload: unknown) => void) => () => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,12 @@
+export class RpcDefectError extends Error {
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+        this._tag = "RpcDefectError";
+        this.name = "RpcDefectError";
+    }
+}
+export const defaultChannelPrefix = {
+    rpc: "rpc/",
+    event: "event/",
+};

package/package.json

@@ -1,20 +1,40 @@
 {
   "name": "electron-effect-rpc",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Typed IPC RPC for Electron, built on Effect and @effect/schema",
   "type": "module",
   "exports": {
-    "./main": "./src/main.ts",
-    "./renderer": "./src/renderer.ts",
-    "./preload": "./src/preload.ts",
-    "./contract": "./src/contract.ts",
-    "./types": "./src/types.ts",
-    "./testing": "./src/testing.ts"
+    "./main": {
+      "types": "./dist/main.d.ts",
+      "default": "./dist/main.js"
+    },
+    "./renderer": {
+      "types": "./dist/renderer.d.ts",
+      "default": "./dist/renderer.js"
+    },
+    "./preload": {
+      "types": "./dist/preload.d.ts",
+      "default": "./dist/preload.js"
+    },
+    "./contract": {
+      "types": "./dist/contract.d.ts",
+      "default": "./dist/contract.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "default": "./dist/types.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "default": "./dist/testing.js"
+    }
   },
   "files": [
-    "src"
+    "dist"
   ],
   "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "bun run build",
     "test": "bun test",
     "typecheck": "tsc --noEmit"
   },

package/src/contract.ts

@@ -1,165 +0,0 @@
-import * as S from "@effect/schema/Schema";
-
-export type SchemaNoContext = S.Schema.AnyNoContext;
-
-export const NoError = S.Never;
-export type NoError = typeof NoError;
-
-export type ErrorSchema = SchemaNoContext | S.Schema<never, never, never>;
-
-export interface RpcMethod<
-  Name extends string,
-  Req extends SchemaNoContext,
-  Res extends SchemaNoContext,
-  Err extends ErrorSchema = NoError
-> {
-  readonly name: Name;
-  readonly req: Req;
-  readonly res: Res;
-  readonly err: Err;
-}
-
-export function rpc<
-  const Name extends string,
-  Req extends SchemaNoContext,
-  Res extends SchemaNoContext,
-  Err extends ErrorSchema
->(name: Name, req: Req, res: Res, err: Err): RpcMethod<Name, Req, Res, Err>;
-
-export function rpc<
-  const Name extends string,
-  Req extends SchemaNoContext,
-  Res extends SchemaNoContext
->(name: Name, req: Req, res: Res): RpcMethod<Name, Req, Res, NoError>;
-
-export function rpc<const Name extends string>(
-  name: Name,
-  req: SchemaNoContext,
-  res: SchemaNoContext,
-  err: ErrorSchema = NoError
-): RpcMethod<Name, SchemaNoContext, SchemaNoContext, ErrorSchema> {
-  return { name, req, res, err };
-}
-
-export interface RpcEvent<
-  Payload extends SchemaNoContext,
-  Context extends SchemaNoContext | null,
-  Name extends string = string
-> {
-  readonly name: Name;
-  readonly payload: Payload;
-  readonly context: Context;
-}
-
-export function event<
-  const Name extends string,
-  Payload extends SchemaNoContext,
-  Context extends SchemaNoContext
->(name: Name, payload: Payload, context: Context): RpcEvent<Payload, Context, Name>;
-
-export function event<const Name extends string, Payload extends SchemaNoContext>(
-  name: Name,
-  payload: Payload
-): RpcEvent<Payload, null, Name>;
-
-export function event<const Name extends string>(
-  name: Name,
-  payload: SchemaNoContext,
-  context?: SchemaNoContext | null
-): RpcEvent<SchemaNoContext, SchemaNoContext | null, Name> {
-  return { name, payload, context: context ?? null };
-}
-
-export const exitSchemaFor = <
-  Name extends string,
-  Req extends SchemaNoContext,
-  Res extends SchemaNoContext,
-  Err extends ErrorSchema
->(
-  method: RpcMethod<Name, Req, Res, Err>
-) =>
-  S.Exit({
-    success: method.res,
-    failure: method.err,
-    defect: S.Defect,
-  });
-
-export type AnyMethod = RpcMethod<
-  string,
-  SchemaNoContext,
-  SchemaNoContext,
-  ErrorSchema
->;
-
-export type AnyEvent = RpcEvent<SchemaNoContext, SchemaNoContext | null, string>;
-
-export type RpcInput<M extends AnyMethod> = S.Schema.Type<M["req"]>;
-
-export type RpcOutput<M extends AnyMethod> = S.Schema.Type<M["res"]>;
-
-export type RpcError<M extends AnyMethod> = S.Schema.Type<M["err"]>;
-
-export type RpcEventPayload<E extends AnyEvent> = S.Schema.Type<E["payload"]>;
-
-/** Extract a method from a tuple by its name string literal. */
-export type ExtractMethod<
-  Methods extends readonly AnyMethod[],
-  Name extends string
-> = Extract<Methods[number], { readonly name: Name }>;
-
-export interface RpcContract<
-  Methods extends ReadonlyArray<AnyMethod>,
-  Events extends ReadonlyArray<AnyEvent>
-> {
-  readonly methods: Methods;
-  readonly events: Events;
-}
-
-const collectDuplicates = (names: ReadonlyArray<string>): Array<string> => {
-  const counts = new Map<string, number>();
-  const duplicates: string[] = [];
-
-  for (const name of names) {
-    const next = (counts.get(name) ?? 0) + 1;
-    counts.set(name, next);
-    if (next === 2) {
-      duplicates.push(name);
-    }
-  }
-
-  return duplicates;
-};
-
-export const defineContract = <
-  const Methods extends ReadonlyArray<AnyMethod>,
-  const Events extends ReadonlyArray<AnyEvent>
->(input: {
-  readonly methods: Methods;
-  readonly events: Events;
-}): RpcContract<Methods, Events> => {
-  const { methods, events } = input;
-
-  if (!Array.isArray(methods)) {
-    throw new Error("RPC contract methods must be an array.");
-  }
-
-  if (!Array.isArray(events)) {
-    throw new Error("RPC contract events must be an array.");
-  }
-
-  const duplicateMethods = collectDuplicates(methods.map((method) => method.name));
-  if (duplicateMethods.length > 0) {
-    throw new Error(
-      `Duplicate RPC method name(s): ${duplicateMethods.join(", ")}`
-    );
-  }
-
-  const duplicateEvents = collectDuplicates(events.map((event) => event.name));
-  if (duplicateEvents.length > 0) {
-    throw new Error(
-      `Duplicate RPC event name(s): ${duplicateEvents.join(", ")}`
-    );
-  }
-
-  return input;
-};

package/src/main.ts

@@ -1,169 +0,0 @@
-import * as S from "@effect/schema/Schema";
-import { Effect, PubSub, Stream } from "effect";
-import * as Runtime from "effect/Runtime";
-import {
-  exitSchemaFor,
-  type RpcContract,
-  type RpcError,
-  type RpcEventPayload,
-  type RpcInput,
-  type RpcOutput,
-} from "./contract.ts";
-import {
-  defaultChannelPrefix,
-  type AnyEvent,
-  type AnyMethod,
-  type EventBusOptions,
-  type Implementations,
-  type IpcMainLike,
-  type RpcEventBus,
-  type RpcServerOptions,
-} from "./types.ts";
-
-const resolveChannelPrefix = (prefix: EventBusOptions["channelPrefix"]) =>
-  prefix ?? defaultChannelPrefix;
-
-export const createRpcServer = <
-  const Methods extends ReadonlyArray<AnyMethod>,
-  const Events extends ReadonlyArray<AnyEvent>,
-  R = never
->(
-  contract: RpcContract<Methods, Events>,
-  ipc: IpcMainLike,
-  implementations: Implementations<RpcContract<Methods, Events>, R>,
-  options?: RpcServerOptions<R>
-): void => {
-  const channelPrefix = resolveChannelPrefix(options?.channelPrefix);
-  const runPromiseExit = <A, E>(effect: Effect.Effect<A, E, R>) => {
-    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);
-  };
-  const implementationsByName: Implementations<RpcContract<Methods, Events>, R> &
-    Record<string, unknown> = implementations;
-
-  const methodNames = new Set(contract.methods.map((method) => method.name));
-
-  for (const name in implementations) {
-    if (!methodNames.has(name)) {
-      throw new Error(`Implementation provided for unknown RPC method: ${name}`);
-    }
-  }
-
-  contract.methods.forEach((method: Methods[number]) => {
-    const impl = implementationsByName[method.name];
-    if (!isImplementation<typeof method, R>(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 channel = `${channelPrefix.rpc}${method.name}`;
-
-    ipc.handle(channel, async (_event, rawPayload) => {
-      let input: RpcInput<typeof method>;
-      try {
-        input = decodeInput(rawPayload);
-      } catch (cause) {
-        const defectExit = await runPromiseExit(Effect.die(cause));
-        return encodeExit(defectExit);
-      }
-
-      const exit = await runPromiseExit(impl(input));
-      return encodeExit(exit);
-    });
-  });
-};
-
-type Envelope<E extends AnyEvent> = {
-  readonly event: E;
-  readonly payload: RpcEventPayload<E>;
-};
-
-const isImplementation = <M extends AnyMethod, R>(
-  value: unknown
-): value is (
-  input: RpcInput<M>
-) => Effect.Effect<RpcOutput<M>, RpcError<M>, R> => typeof value === "function";
-
-const encodePayload = <E extends AnyEvent>(
-  event: E,
-  payload: RpcEventPayload<E>
-) =>
-  Effect.try({
-    try: () => S.encodeSync(event.payload)(payload),
-    catch: (cause) =>
-      cause instanceof Error ? cause : new Error(String(cause)),
-  });
-
-const dispatchToRenderer = <E extends AnyEvent>(
-  getWindow: EventBusOptions["getWindow"],
-  channelPrefix: EventBusOptions["channelPrefix"],
-  event: E,
-  encoded: unknown
-) =>
-  Effect.sync(() => {
-    const window = getWindow();
-    if (window && !window.isDestroyed()) {
-      const prefix = resolveChannelPrefix(channelPrefix);
-      window.webContents.send(`${prefix.event}${event.name}`, encoded);
-    }
-  });
-
-export const createEventBus = <
-  const Methods extends ReadonlyArray<AnyMethod>,
-  const Events extends ReadonlyArray<AnyEvent>
->(
-  _contract: RpcContract<Methods, Events>,
-  options: EventBusOptions
-): RpcEventBus<RpcContract<Methods, Events>> => {
-  const pubsub = Effect.runSync(
-    PubSub.unbounded<Envelope<Events[number]>>()
-  );
-
-  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") {
-                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 = <E extends Events[number]>(
-    event: E,
-    payload: RpcEventPayload<E>
-  ) =>
-    Effect.flatMap(PubSub.publish(pubsub, { event, payload }), () =>
-      Effect.void
-    );
-
-  return { emit };
-};

package/src/preload.ts

@@ -1,33 +0,0 @@
-import { contextBridge, ipcRenderer, type IpcRendererEvent } from "electron";
-import { defaultChannelPrefix, type ChannelPrefix } from "./types.ts";
-
-type Listener = (payload: unknown) => void;
-
-type BridgeOptions = {
-  readonly rpcGlobal?: string;
-  readonly eventsGlobal?: string;
-  readonly channelPrefix?: ChannelPrefix;
-};
-
-export const exposeRpcBridge = (options?: BridgeOptions): void => {
-  const rpcGlobal = options?.rpcGlobal ?? "rpc";
-  const eventsGlobal = options?.eventsGlobal ?? "events";
-  const channelPrefix = options?.channelPrefix ?? defaultChannelPrefix;
-
-  const invoke = (method: string, payload: unknown): Promise<unknown> =>
-    ipcRenderer.invoke(`${channelPrefix.rpc}${method}`, payload);
-
-  const subscribe = (event: string, listener: Listener): (() => void) => {
-    const wrapped = (_event: IpcRendererEvent, payload: unknown) =>
-      listener(payload);
-
-    ipcRenderer.on(`${channelPrefix.event}${event}`, wrapped);
-
-    return () => {
-      ipcRenderer.removeListener(`${channelPrefix.event}${event}`, wrapped);
-    };
-  };
-
-  contextBridge.exposeInMainWorld(rpcGlobal, { invoke });
-  contextBridge.exposeInMainWorld(eventsGlobal, { subscribe });
-};

package/src/renderer.ts

@@ -1,167 +0,0 @@
-import * as S from "@effect/schema/Schema";
-import { Cause, Exit } from "effect";
-import {
-  exitSchemaFor,
-  type RpcContract,
-  type RpcEventPayload,
-  type RpcInput,
-  type RpcOutput,
-} from "./contract.ts";
-import {
-  RpcDefectError,
-  type AnyEvent,
-  type AnyMethod,
-  type EventSubscriber,
-  type EventSubscriberOptions,
-  type RpcCaller,
-  type RpcClient,
-  type RpcClientOptions,
-} from "./types.ts";
-
-const formatCause = (cause: unknown): string =>
-  cause instanceof Error ? cause.message : String(cause);
-
-const requireInvoke = (options?: RpcClientOptions) => {
-  if (!options?.invoke) {
-    throw new Error("RpcClientOptions.invoke is required.");
-  }
-  return options.invoke;
-};
-
-const requireSubscribe = (options?: EventSubscriberOptions) => {
-  if (!options?.subscribe) {
-    throw new Error("EventSubscriberOptions.subscribe is required.");
-  }
-  return options.subscribe;
-};
-
-type MutableRpcClient<
-  C extends RpcContract<readonly AnyMethod[], readonly AnyEvent[]>
-> = {
-  -readonly [Name in keyof RpcClient<C>]: RpcClient<C>[Name];
-};
-
-export const createRpcClient = <
-  const Methods extends ReadonlyArray<AnyMethod>,
-  const Events extends ReadonlyArray<AnyEvent>
->(
-  contract: RpcContract<Methods, Events>,
-  options?: RpcClientOptions
-): RpcClient<RpcContract<Methods, Events>> => {
-  const invoke = requireInvoke(options);
-
-  const call = async <M extends Methods[number]>(
-    method: M,
-    input: RpcInput<M>
-  ): Promise<RpcOutput<M>> => {
-    let encoded: unknown;
-    try {
-      encoded = S.encodeSync(method.req)(input);
-    } catch (cause) {
-      throw new Error(
-        `RPC ${method.name} request encoding failed: ${formatCause(cause)}`
-      );
-    }
-
-    const raw = await invoke(method.name, encoded);
-
-    const exitSchema = exitSchemaFor(method);
-    const decodeExit = S.decodeUnknownSync(exitSchema);
-    let exit: ReturnType<typeof decodeExit>;
-
-    try {
-      exit = decodeExit(raw);
-    } catch (cause) {
-      throw new Error(
-        `RPC ${method.name} response decoding failed: ${formatCause(cause)}`
-      );
-    }
-
-    if (Exit.isSuccess(exit)) {
-      return exit.value;
-    }
-
-    const cause = exit.cause;
-    const failureOption = Cause.failureOption(cause);
-    if (failureOption._tag === "Some") {
-      throw failureOption.value;
-    }
-
-    const defectOption = Cause.dieOption(cause);
-    if (defectOption._tag === "Some") {
-      const defect = defectOption.value;
-      if (defect instanceof Error) {
-        throw new RpcDefectError(defect.message, defect);
-      }
-      throw new RpcDefectError(String(defect), defect);
-    }
-
-    throw new RpcDefectError(
-      "RPC call was interrupted or failed unexpectedly",
-      cause
-    );
-  };
-
-  const client: MutableRpcClient<RpcContract<Methods, Events>> =
-    Object.create(null);
-  const clientRecord: Record<string, unknown> = client;
-
-  contract.methods.forEach((method: Methods[number]) => {
-    const caller: RpcCaller<typeof method> = (
-      input?: RpcInput<typeof method>
-    ) => {
-      const payload = input ?? S.decodeUnknownSync(method.req)({});
-      return call(method, payload);
-    };
-
-    clientRecord[method.name] = caller;
-  });
-
-  return client;
-};
-
-export const createEventSubscriber = <
-  const Methods extends ReadonlyArray<AnyMethod>,
-  const Events extends ReadonlyArray<AnyEvent>
->(
-  contract: RpcContract<Methods, Events>,
-  options?: EventSubscriberOptions
-): EventSubscriber<RpcContract<Methods, Events>> => {
-  const subscribe = requireSubscribe(options);
-  const eventMap = new Map<string, Events[number]>();
-
-  for (const event of contract.events) {
-    eventMap.set(event.name, event);
-  }
-
-  const subscribeEvent = <E extends Events[number]>(
-    event: E,
-    handler: (payload: RpcEventPayload<E>) => void
-  ) => {
-    const decoder = S.decodeUnknownSync(event.payload);
-    return subscribe(event.name, (payload) => {
-      const decoded = decoder(payload);
-      handler(decoded);
-    });
-  };
-
-  const subscribeByName = (
-    name: Events[number]["name"],
-    handler: (payload: unknown) => void
-  ) => {
-    const event = eventMap.get(name);
-    if (!event) {
-      throw new Error(`Unknown event: ${name}`);
-    }
-
-    const decoder = S.decodeUnknownSync(event.payload);
-    return subscribe(name, (payload) => handler(decoder(payload)));
-  };
-
-  return {
-    subscribe: subscribeEvent,
-    subscribeByName,
-  };
-};
-
-export { RpcDefectError } from "./types.ts";

package/src/testing.ts

@@ -1,33 +0,0 @@
-import type { RpcInvoke } from "./types.ts";
-
-export type Invocation = {
-  readonly method: string;
-  readonly payload: unknown;
-};
-
-export type InvokeStub = RpcInvoke & { readonly invocations: Invocation[] };
-
-export const createInvokeStub = (impl: RpcInvoke): InvokeStub => {
-  const invocations: Invocation[] = [];
-
-  const wrapped = Object.assign(
-    async (method: string, payload: unknown) => {
-      invocations.push({ method, payload });
-      return impl(method, payload);
-    },
-    { invocations }
-  );
-
-  return wrapped;
-};
-
-export const createDeferred = <T>() => {
-  let resolve: (value: T | PromiseLike<T>) => void = () => {};
-  let reject: (reason?: unknown) => void = () => {};
-  const promise = new Promise<T>((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-
-  return { promise, resolve, reject };
-};

package/src/types.ts

@@ -1,134 +0,0 @@
-import type * as Effect from "effect/Effect";
-import type * as Runtime from "effect/Runtime";
-import type { BrowserWindow } from "electron";
-import type {
-  AnyEvent,
-  AnyMethod,
-  ErrorSchema,
-  ExtractMethod,
-  RpcContract,
-  RpcError,
-  RpcEvent,
-  RpcEventPayload,
-  RpcInput,
-  RpcMethod,
-  RpcOutput,
-  SchemaNoContext,
-} from "./contract.ts";
-
-export type {
-  AnyEvent,
-  AnyMethod,
-  ErrorSchema,
-  ExtractMethod,
-  RpcContract,
-  RpcError,
-  RpcEvent,
-  RpcEventPayload,
-  RpcInput,
-  RpcMethod,
-  RpcOutput,
-  SchemaNoContext,
-} from "./contract.ts";
-
-export type Implementations<
-  C extends RpcContract<readonly AnyMethod[], readonly AnyEvent[]>,
-  R = never
-> = {
-  readonly [Name in C["methods"][number]["name"]]: (
-    input: RpcInput<ExtractMethod<C["methods"], Name>>
-  ) => Effect.Effect<
-    RpcOutput<ExtractMethod<C["methods"], Name>>,
-    RpcError<ExtractMethod<C["methods"], Name>>,
-    R
-  >;
-};
-
-type IsEmptyObject<T> = keyof T extends never ? true : false;
-
-export type RpcCaller<M extends AnyMethod> =
-  IsEmptyObject<RpcInput<M>> extends true
-    ? () => Promise<RpcOutput<M>>
-    : (input: RpcInput<M>) => Promise<RpcOutput<M>>;
-
-export type RpcClient<
-  C extends RpcContract<readonly AnyMethod[], readonly AnyEvent[]>
-> = {
-  readonly [Name in C["methods"][number]["name"]]: RpcCaller<
-    ExtractMethod<C["methods"], Name>
-  >;
-};
-
-export class RpcDefectError extends Error {
-  readonly _tag = "RpcDefectError";
-
-  constructor(
-    message: string,
-    public readonly cause: unknown
-  ) {
-    super(message);
-    this.name = "RpcDefectError";
-  }
-}
-
-export type ChannelPrefix = {
-  readonly rpc: string;
-  readonly event: string;
-};
-
-export const defaultChannelPrefix: ChannelPrefix = {
-  rpc: "rpc/",
-  event: "event/",
-};
-
-export type IpcMainLike = {
-  readonly handle: (
-    channel: string,
-    listener: (event: unknown, payload: unknown) => unknown
-  ) => unknown;
-};
-
-export type RpcInvoke = (method: string, payload: unknown) => Promise<unknown>;
-
-/** Provide a Runtime when handlers require services (R). */
-export type RpcServerOptions<R = never> = {
-  readonly channelPrefix?: ChannelPrefix;
-  readonly runtime?: Runtime.Runtime<R>;
-};
-
-export type RpcClientOptions = {
-  readonly invoke?: RpcInvoke;
-  readonly channelPrefix?: ChannelPrefix;
-};
-
-export type EventBusOptions = {
-  readonly channelPrefix?: ChannelPrefix;
-  readonly getWindow: () => BrowserWindow | null;
-};
-
-export type EventSubscriberOptions = {
-  readonly channelPrefix?: ChannelPrefix;
-  readonly subscribe?: (name: string, handler: (payload: unknown) => void) => () => void;
-};
-
-export interface RpcEventBus<
-  C extends RpcContract<readonly AnyMethod[], readonly AnyEvent[]>
-> {
-  readonly emit: <E extends C["events"][number]>(
-    event: E,
-    payload: RpcEventPayload<E>
-  ) => Effect.Effect<void, never>;
-}
-
-export interface EventSubscriber<
-  C extends RpcContract<readonly AnyMethod[], readonly AnyEvent[]>
-> {
-  readonly subscribe: <E extends C["events"][number]>(
-    event: E,
-    handler: (payload: RpcEventPayload<E>) => void
-  ) => () => void;
-  readonly subscribeByName: (
-    name: C["events"][number]["name"],
-    handler: (payload: unknown) => void
-  ) => () => void;
-}