@xentobias/worker-rpc 1.0.1

package/dist/channel.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Worker RPC - Channel Module
+ * Direct worker-to-worker communication without routing through main thread
+ */
+import { Endpoint } from "./endpoint";
+import { type MessageTarget, type EndpointOptions, type RemoteObject } from "./types";
+/** Unique identifier for workers */
+export type WorkerId = string;
+/** Worker registry for managing direct channels */
+export interface WorkerRegistry {
+    /** Register a worker with an ID */
+    register(id: WorkerId, worker: MessageTarget): void;
+    /** Unregister a worker */
+    unregister(id: WorkerId): void;
+    /** Get a direct channel to another worker */
+    getChannel<T extends object>(targetId: WorkerId): Promise<RemoteObject<T>>;
+    /** Release all channels */
+    releaseAll(): void;
+}
+/**
+ * Create a worker registry for the main thread
+ * This allows workers to establish direct communication channels
+ */
+export declare function createRegistry(): WorkerRegistry;
+/**
+ * Create a direct channel from within a worker to another worker
+ * This bypasses the main thread for all subsequent communication
+ */
+export declare function createWorkerChannel<T extends object>(mainThreadEndpoint: Endpoint, targetWorkerId: WorkerId, options?: EndpointOptions): Promise<RemoteObject<T>>;
+/**
+ * Accept a channel connection from another worker
+ * Call this in the worker that receives the channel request
+ */
+export declare function acceptChannel<T extends object>(port: MessagePort, api: T, options?: EndpointOptions): RemoteObject<T>;
+/**
+ * Set up a worker to handle incoming channel requests
+ */
+export declare function setupChannelHandler(mainThread: MessageTarget, getApi: () => object, options?: EndpointOptions): void;
+/**
+ * Peer-to-peer channel utilities
+ */
+export declare class PeerChannel<T extends object> {
+    private endpoint;
+    private remote;
+    constructor(port: MessagePort, localApi: object, options?: EndpointOptions);
+    /** Get the remote API proxy */
+    getRemote(): RemoteObject<T>;
+    /** Release this channel */
+    release(): void;
+}
+/**
+ * Create a pair of connected peer channels for testing or in-process communication
+ */
+export declare function createPeerPair<A extends object, B extends object>(apiA: A, apiB: B, options?: EndpointOptions): [RemoteObject<B>, RemoteObject<A>];
+//# sourceMappingURL=channel.d.ts.map

package/dist/channel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"channel.d.ts","sourceRoot":"","sources":["../src/channel.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,QAAQ,EAAkB,MAAM,YAAY,CAAC;AAEtD,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,YAAY,EAClB,MAAM,SAAS,CAAC;AAEjB,oCAAoC;AACpC,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC;AAE9B,mDAAmD;AACnD,MAAM,WAAW,cAAc;IAC7B,mCAAmC;IACnC,QAAQ,CAAC,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,aAAa,GAAG,IAAI,CAAC;IACpD,0BAA0B;IAC1B,UAAU,CAAC,EAAE,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC/B,6CAA6C;IAC7C,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3E,2BAA2B;IAC3B,UAAU,IAAI,IAAI,CAAC;CACpB;AAQD;;;GAGG;AACH,wBAAgB,cAAc,IAAI,cAAc,CAyF/C;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CAAC,CAAC,SAAS,MAAM,EACxD,kBAAkB,EAAE,QAAQ,EAC5B,cAAc,EAAE,QAAQ,EACxB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAkD1B;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,EAC5C,IAAI,EAAE,WAAW,EACjB,GAAG,EAAE,CAAC,EACN,OAAO,CAAC,EAAE,eAAe,GACxB,YAAY,CAAC,CAAC,CAAC,CAKjB;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,aAAa,EACzB,MAAM,EAAE,MAAM,MAAM,EACpB,OAAO,CAAC,EAAE,eAAe,GACxB,IAAI,CAoCN;AAED;;GAEG;AACH,qBAAa,WAAW,CAAC,CAAC,SAAS,MAAM;IACvC,OAAO,CAAC,QAAQ,CAAW;IAC3B,OAAO,CAAC,MAAM,CAAkB;gBAEpB,IAAI,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe;IAO1E,+BAA+B;IAC/B,SAAS,IAAI,YAAY,CAAC,CAAC,CAAC;IAI5B,2BAA2B;IAC3B,OAAO,IAAI,IAAI;CAGhB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,EAC/D,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,CAAC,EACP,OAAO,CAAC,EAAE,eAAe,GACxB,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC,CAapC"}

package/dist/endpoint.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Worker RPC - Endpoint Module
+ * Core RPC endpoint handling message passing and method invocation
+ * Uses structured clone for data, custom handling only for callbacks
+ */
+import { type MethodPath, type MessageTarget, type EndpointOptions, type ExposeOptions } from "./types";
+/**
+ * RPC Endpoint - handles bidirectional communication with a worker
+ */
+export declare class Endpoint {
+    private target;
+    private options;
+    private exposedApi;
+    private exposeOptions;
+    /** Pending calls awaiting response */
+    private pendingCalls;
+    /** Registered callbacks (functions passed as arguments) */
+    private callbacks;
+    /** Remote callbacks (proxies for functions on the other side) */
+    private remoteCallbacks;
+    /** Message handler bound to this instance */
+    private boundMessageHandler;
+    /** Whether this endpoint has been released */
+    private released;
+    constructor(target: MessageTarget, options?: EndpointOptions);
+    /**
+     * Attach the message listener to the target
+     */
+    private attachListener;
+    /**
+     * Detach the message listener from the target
+     */
+    private detachListener;
+    /**
+     * Log a debug message
+     */
+    private debug;
+    /**
+     * Expose an API object for remote invocation
+     */
+    expose(api: object, options?: ExposeOptions): void;
+    /**
+     * Handle incoming messages
+     */
+    private handleMessage;
+    /**
+     * Handle a method call request
+     */
+    private handleCall;
+    /**
+     * Resolve a method from the exposed API by path
+     */
+    private resolveMethod;
+    /**
+     * Handle a successful result
+     */
+    private handleResult;
+    /**
+     * Handle an error result
+     */
+    private handleError;
+    /**
+     * Handle a callback invocation
+     */
+    private handleCallback;
+    /**
+     * Handle release of callbacks
+     */
+    private handleRelease;
+    /**
+     * Register a local callback function
+     */
+    private registerCallback;
+    /**
+     * Create a proxy function for a remote callback
+     */
+    private createRemoteCallback;
+    /**
+     * Invoke a remote callback
+     */
+    private invokeCallback;
+    /**
+     * Call a remote method
+     */
+    call(path: MethodPath, args: unknown[]): Promise<unknown>;
+    /**
+     * Send a message to the target
+     */
+    private send;
+    /**
+     * Release this endpoint and clean up resources
+     */
+    release(): void;
+    /**
+     * Get the underlying message target
+     */
+    getTarget(): MessageTarget;
+}
+/**
+ * Create an endpoint for a worker or message port
+ */
+export declare function createEndpoint(target: MessageTarget, options?: EndpointOptions): Endpoint;
+//# sourceMappingURL=endpoint.d.ts.map

package/dist/endpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"endpoint.d.ts","sourceRoot":"","sources":["../src/endpoint.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAUL,KAAK,UAAU,EAGf,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,aAAa,EAEnB,MAAM,SAAS,CAAC;AAejB;;GAEG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,OAAO,CAA4B;IAC3C,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,aAAa,CAAqB;IAE1C,sCAAsC;IACtC,OAAO,CAAC,YAAY,CAAkC;IAEtD,2DAA2D;IAC3D,OAAO,CAAC,SAAS,CAA+C;IAEhE,iEAAiE;IACjE,OAAO,CAAC,eAAe,CAAmC;IAE1D,6CAA6C;IAC7C,OAAO,CAAC,mBAAmB,CAAgC;IAE3D,8CAA8C;IAC9C,OAAO,CAAC,QAAQ,CAAS;gBAEb,MAAM,EAAE,aAAa,EAAE,OAAO,GAAE,eAAoB;IAYhE;;OAEG;IACH,OAAO,CAAC,cAAc;IAQtB;;OAEG;IACH,OAAO,CAAC,cAAc;IAQtB;;OAEG;IACH,OAAO,CAAC,KAAK;IAMb;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,GAAE,aAAkB,GAAG,IAAI;IAOtD;;OAEG;IACH,OAAO,CAAC,aAAa;IA6BrB;;OAEG;YACW,UAAU;IAqDxB;;OAEG;IACH,OAAO,CAAC,aAAa;IAgCrB;;OAEG;IACH,OAAO,CAAC,YAAY;IAoBpB;;OAEG;IACH,OAAO,CAAC,WAAW;IAuBnB;;OAEG;YACW,cAAc;IA8D5B;;OAEG;IACH,OAAO,CAAC,aAAa;IAMrB;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAMxB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAkB5B;;OAEG;YACW,cAAc;IA6C5B;;OAEG;IACG,IAAI,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC;IAkD/D;;OAEG;IACH,OAAO,CAAC,IAAI;IAKZ;;OAEG;IACH,OAAO,IAAI,IAAI;IAkCf;;OAEG;IACH,SAAS,IAAI,aAAa;CAG3B;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,QAAQ,CAEzF"}

package/dist/index.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Worker RPC - High-performance worker communication for Bun.js
+ *
+ * A type-safe, ergonomic library for seamless RPC between Bun workers.
+ * Supports nested methods, callback functions, and direct worker-to-worker channels.
+ *
+ * @example
+ * ```typescript
+ * // worker.ts
+ * import { expose } from "worker-rpc";
+ *
+ * const api = {
+ *   add: (a: number, b: number) => a + b,
+ *   db: {
+ *     users: {
+ *       find: async (id: string) => ({ id, name: "John" }),
+ *     },
+ *   },
+ *   processWithCallback: async (data: number[], cb: (progress: number) => void) => {
+ *     for (let i = 0; i < data.length; i++) {
+ *       await someWork(data[i]);
+ *       cb((i + 1) / data.length);
+ *     }
+ *     return "done";
+ *   },
+ * };
+ *
+ * expose(api);
+ *
+ * export type WorkerApi = typeof api;
+ *
+ * // main.ts
+ * import { wrap, createEndpoint } from "worker-rpc";
+ * import type { WorkerApi } from "./worker";
+ *
+ * const worker = new Worker("./worker.ts");
+ * const api = wrap<WorkerApi>(createEndpoint(worker));
+ *
+ * // Type-safe, async calls
+ * const sum = await api.add(1, 2);
+ * const user = await api.db.users.find("123");
+ *
+ * // Callbacks work seamlessly
+ * await api.processWithCallback([1, 2, 3], (progress) => {
+ *   console.log(`Progress: ${progress * 100}%`);
+ * });
+ * ```
+ */
+export { type CallId, type CallbackId, type MethodPath, MessageType, type RpcMessage, type EndpointOptions, type ExposeOptions, type RemoteObject, type RemoteFunction, type MessageTarget, type BunWorker, REMOTE_PROXY, ENDPOINT, RELEASE, CREATE_CHANNEL, } from "./types";
+export { Endpoint, createEndpoint } from "./endpoint";
+export { wrap, isProxy, getEndpoint, releaseProxy } from "./proxy";
+export { type WorkerId, type WorkerRegistry, createRegistry, createWorkerChannel, acceptChannel, setupChannelHandler, PeerChannel, createPeerPair, } from "./channel";
+export { serializeError, deserializeError, isFunction, isMessagePort, isTransferable, type SerializedError, } from "./serialize";
+import { Endpoint } from "./endpoint";
+import type { MessageTarget, EndpointOptions, RemoteObject } from "./types";
+/**
+ * Expose an API object for remote invocation
+ * Call this in the worker to expose methods to the parent
+ *
+ * @param api - The API object to expose
+ * @param options - Optional configuration
+ *
+ * @example
+ * ```typescript
+ * const api = {
+ *   greet: (name: string) => `Hello, ${name}!`,
+ *   math: {
+ *     add: (a: number, b: number) => a + b,
+ *   },
+ * };
+ *
+ * expose(api);
+ * ```
+ */
+export declare function expose(api: object, options?: EndpointOptions): Endpoint;
+/**
+ * Create a wrapped remote API from a worker
+ * Convenience function that combines createEndpoint and wrap
+ *
+ * @param worker - The worker or message target
+ * @param options - Optional configuration
+ * @returns A type-safe proxy for the remote API
+ *
+ * @example
+ * ```typescript
+ * const worker = new Worker("./worker.ts");
+ * const api = remote<WorkerApi>(worker);
+ *
+ * const result = await api.someMethod();
+ * ```
+ */
+export declare function remote<T extends object>(worker: MessageTarget, options?: EndpointOptions): RemoteObject<T>;
+/**
+ * Transfer a value by reference (marks it for zero-copy transfer)
+ * Currently supports ArrayBuffer and MessagePort
+ *
+ * Note: With the optimized serialization, ArrayBuffers are passed through
+ * structured clone which handles transfer automatically.
+ *
+ * @param value - The value to transfer
+ * @returns The same value
+ *
+ * @example
+ * ```typescript
+ * const buffer = new ArrayBuffer(1024);
+ * await api.processBuffer(transfer(buffer));
+ * // buffer is now unusable in this context (transferred)
+ * ```
+ */
+export declare function transfer<T extends ArrayBuffer | MessagePort>(value: T): T;
+/**
+ * Create a proxy function that can be passed to workers
+ * Useful for creating callbacks with specific invocation limits
+ *
+ * @param fn - The function to wrap
+ * @param options - Options for the callback
+ * @returns The wrapped function
+ *
+ * @example
+ * ```typescript
+ * // Single-use callback
+ * await api.onComplete(callback(() => console.log("done"), { once: true }));
+ *
+ * // Limited invocations
+ * await api.onProgress(callback((p) => console.log(p), { times: 10 }));
+ * ```
+ */
+export declare function callback<T extends (...args: any[]) => any>(fn: T, _options?: {
+    once?: boolean;
+    times?: number;
+}): T;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAGH,OAAO,EACL,KAAK,MAAM,EACX,KAAK,UAAU,EACf,KAAK,UAAU,EACf,WAAW,EACX,KAAK,UAAU,EACf,KAAK,eAAe,EACpB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,SAAS,EACd,YAAY,EACZ,QAAQ,EACR,OAAO,EACP,cAAc,GACf,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAGtD,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAGnE,OAAO,EACL,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,cAAc,EACd,mBAAmB,EACnB,aAAa,EACb,mBAAmB,EACnB,WAAW,EACX,cAAc,GACf,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,UAAU,EACV,aAAa,EACb,cAAc,EACd,KAAK,eAAe,GACrB,MAAM,aAAa,CAAC;AAErB,OAAO,EAAE,QAAQ,EAAkB,MAAM,YAAY,CAAC;AAEtD,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5E;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,QAAQ,CAMvE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,EACrC,MAAM,EAAE,aAAa,EACrB,OAAO,CAAC,EAAE,eAAe,GACxB,YAAY,CAAC,CAAC,CAAC,CAGjB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAIzE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,EACxD,EAAE,EAAE,CAAC,EACL,QAAQ,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5C,CAAC,CAIH"}

package/dist/index.js

@@ -0,0 +1,678 @@
+// @bun
+// src/types.ts
+var MessageType;
+((MessageType2) => {
+  MessageType2[MessageType2["Call"] = 0] = "Call";
+  MessageType2[MessageType2["Result"] = 1] = "Result";
+  MessageType2[MessageType2["Error"] = 2] = "Error";
+  MessageType2[MessageType2["Callback"] = 3] = "Callback";
+  MessageType2[MessageType2["Release"] = 4] = "Release";
+  MessageType2[MessageType2["Channel"] = 5] = "Channel";
+  MessageType2[MessageType2["ChannelAck"] = 6] = "ChannelAck";
+})(MessageType ||= {});
+var REMOTE_PROXY = Symbol.for("worker-rpc:remote-proxy");
+var ENDPOINT = Symbol.for("worker-rpc:endpoint");
+var RELEASE = Symbol.for("worker-rpc:release");
+var CREATE_CHANNEL = Symbol.for("worker-rpc:create-channel");
+// src/serialize.ts
+function serializeError(error) {
+  return {
+    e: error.message,
+    n: error.name,
+    s: error.stack
+  };
+}
+function deserializeError(data) {
+  const error = new Error(data.e);
+  error.name = data.n;
+  if (data.s) {
+    error.stack = data.s;
+  }
+  return error;
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isMessagePort(value) {
+  return typeof MessagePort !== "undefined" && value instanceof MessagePort;
+}
+function isTransferable(value) {
+  return value instanceof ArrayBuffer || typeof MessagePort !== "undefined" && value instanceof MessagePort;
+}
+
+// src/endpoint.ts
+var DEFAULT_TIMEOUT = 30000;
+var idCounter = 0;
+function generateId() {
+  return `${++idCounter}:${Date.now().toString(36)}`;
+}
+
+class Endpoint {
+  target;
+  options;
+  exposedApi = null;
+  exposeOptions = {};
+  pendingCalls = new Map;
+  callbacks = new Map;
+  remoteCallbacks = new Map;
+  boundMessageHandler;
+  released = false;
+  constructor(target, options = {}) {
+    this.target = target;
+    this.options = {
+      timeout: options.timeout ?? DEFAULT_TIMEOUT,
+      onError: options.onError ?? console.error,
+      debug: options.debug ?? false
+    };
+    this.boundMessageHandler = this.handleMessage.bind(this);
+    this.attachListener();
+  }
+  attachListener() {
+    if (this.target.addEventListener) {
+      this.target.addEventListener("message", this.boundMessageHandler);
+    } else if (this.target.onmessage !== undefined) {
+      this.target.onmessage = this.boundMessageHandler;
+    }
+  }
+  detachListener() {
+    if (this.target.removeEventListener) {
+      this.target.removeEventListener("message", this.boundMessageHandler);
+    } else if (this.target.onmessage !== undefined) {
+      this.target.onmessage = null;
+    }
+  }
+  debug(...args) {
+    if (this.options.debug) {
+      console.log("[worker-rpc]", ...args);
+    }
+  }
+  expose(api, options = {}) {
+    this.exposedApi = api;
+    this.exposeOptions = {
+      maxDepth: options.maxDepth ?? 10
+    };
+  }
+  handleMessage(event) {
+    const message = event.data;
+    if (typeof message !== "object" || message === null || !("t" in message)) {
+      return;
+    }
+    this.debug("received", MessageType[message.t], message);
+    switch (message.t) {
+      case 0 /* Call */:
+        this.handleCall(message);
+        break;
+      case 1 /* Result */:
+        this.handleResult(message);
+        break;
+      case 2 /* Error */:
+        this.handleError(message);
+        break;
+      case 3 /* Callback */:
+        this.handleCallback(message);
+        break;
+      case 4 /* Release */:
+        this.handleRelease(message);
+        break;
+    }
+  }
+  async handleCall(message) {
+    const { id, p: path, a: args, c: callbackMap } = message;
+    try {
+      const { method, thisArg } = this.resolveMethod(path);
+      if (typeof method !== "function") {
+        throw new Error(`Method not found: ${path.join(".")}`);
+      }
+      const resolvedArgs = args.map((arg, index) => {
+        const callbackId = callbackMap?.[index];
+        if (callbackId) {
+          return this.createRemoteCallback(callbackId);
+        }
+        return arg;
+      });
+      const result = await method.apply(thisArg, resolvedArgs);
+      if (isFunction(result)) {
+        const callbackId = this.registerCallback(result);
+        this.send({
+          t: 1 /* Result */,
+          id,
+          v: null,
+          c: callbackId
+        });
+      } else {
+        this.send({
+          t: 1 /* Result */,
+          id,
+          v: result
+        });
+      }
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.send({
+        t: 2 /* Error */,
+        id,
+        e: err.message,
+        n: err.name,
+        s: err.stack
+      });
+    }
+  }
+  resolveMethod(path) {
+    if (!this.exposedApi) {
+      throw new Error("No API exposed");
+    }
+    let current = this.exposedApi;
+    let parent = null;
+    for (let i = 0;i < path.length; i++) {
+      const key = path[i];
+      if (current === null || current === undefined) {
+        throw new Error(`Cannot access property '${key}' of ${current}`);
+      }
+      if (key === undefined) {
+        throw new Error(`Invalid path at index ${i}`);
+      }
+      parent = current;
+      current = current[key];
+      if (i >= (this.exposeOptions.maxDepth ?? 10)) {
+        throw new Error(`Maximum nesting depth exceeded`);
+      }
+    }
+    return { target: this.exposedApi, method: current, thisArg: parent };
+  }
+  handleResult(message) {
+    const pending = this.pendingCalls.get(message.id);
+    if (!pending) {
+      this.debug("Received result for unknown call:", message.id);
+      return;
+    }
+    this.pendingCalls.delete(message.id);
+    if (pending.timer) {
+      clearTimeout(pending.timer);
+    }
+    if (message.c) {
+      pending.resolve(this.createRemoteCallback(message.c));
+    } else {
+      pending.resolve(message.v);
+    }
+  }
+  handleError(message) {
+    const pending = this.pendingCalls.get(message.id);
+    if (!pending) {
+      this.debug("Received error for unknown call:", message.id);
+      return;
+    }
+    this.pendingCalls.delete(message.id);
+    if (pending.timer) {
+      clearTimeout(pending.timer);
+    }
+    const error = new Error(message.e);
+    if (message.n) {
+      error.name = message.n;
+    }
+    if (message.s) {
+      error.stack = message.s;
+    }
+    pending.reject(error);
+  }
+  async handleCallback(message) {
+    const { id, c: callbackId, a: args, cb: callbackMap } = message;
+    const registration = this.callbacks.get(callbackId);
+    if (!registration) {
+      this.send({
+        t: 2 /* Error */,
+        id,
+        e: `Callback not found: ${callbackId}`
+      });
+      return;
+    }
+    try {
+      const resolvedArgs = args.map((arg, index) => {
+        const cbId = callbackMap?.[index];
+        if (cbId) {
+          return this.createRemoteCallback(cbId);
+        }
+        return arg;
+      });
+      const result = await registration.fn(...resolvedArgs);
+      if (registration.remaining > 0) {
+        registration.remaining--;
+        if (registration.remaining === 0) {
+          this.callbacks.delete(callbackId);
+        }
+      }
+      if (isFunction(result)) {
+        const cbId = this.registerCallback(result);
+        this.send({
+          t: 1 /* Result */,
+          id,
+          v: null,
+          c: cbId
+        });
+      } else {
+        this.send({
+          t: 1 /* Result */,
+          id,
+          v: result
+        });
+      }
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      this.send({
+        t: 2 /* Error */,
+        id,
+        e: err.message,
+        n: err.name,
+        s: err.stack
+      });
+    }
+  }
+  handleRelease(message) {
+    for (const callbackId of message.c) {
+      this.callbacks.delete(callbackId);
+    }
+  }
+  registerCallback(fn, remaining = -1) {
+    const id = `cb:${generateId()}`;
+    this.callbacks.set(id, { fn, remaining });
+    return id;
+  }
+  createRemoteCallback(callbackId) {
+    let proxy = this.remoteCallbacks.get(callbackId);
+    if (proxy) {
+      return proxy;
+    }
+    proxy = async (...args) => {
+      return this.invokeCallback(callbackId, args);
+    };
+    this.remoteCallbacks.set(callbackId, proxy);
+    return proxy;
+  }
+  async invokeCallback(callbackId, args) {
+    const id = generateId();
+    const rawArgs = [];
+    const callbackMap = {};
+    const transferables = [];
+    for (let i = 0;i < args.length; i++) {
+      const arg = args[i];
+      if (isFunction(arg)) {
+        callbackMap[i] = this.registerCallback(arg);
+        rawArgs.push(null);
+      } else if (isMessagePort(arg)) {
+        transferables.push(arg);
+        rawArgs.push(arg);
+      } else {
+        rawArgs.push(arg);
+      }
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingCalls.delete(id);
+        reject(new Error(`Callback invocation timed out: ${callbackId}`));
+      }, this.options.timeout);
+      this.pendingCalls.set(id, { resolve, reject, timer });
+      const message = {
+        t: 3 /* Callback */,
+        id,
+        c: callbackId,
+        a: rawArgs,
+        ...Object.keys(callbackMap).length > 0 && { cb: callbackMap }
+      };
+      this.send(message, transferables);
+    });
+  }
+  async call(path, args) {
+    if (this.released) {
+      throw new Error("Endpoint has been released");
+    }
+    const id = generateId();
+    const rawArgs = [];
+    const callbackMap = {};
+    const transferables = [];
+    for (let i = 0;i < args.length; i++) {
+      const arg = args[i];
+      if (isFunction(arg)) {
+        callbackMap[i] = this.registerCallback(arg);
+        rawArgs.push(null);
+      } else if (isMessagePort(arg)) {
+        transferables.push(arg);
+        rawArgs.push(arg);
+      } else {
+        rawArgs.push(arg);
+      }
+    }
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingCalls.delete(id);
+        reject(new Error(`Call timed out: ${path.join(".")}`));
+      }, this.options.timeout);
+      this.pendingCalls.set(id, { resolve, reject, timer });
+      const message = {
+        t: 0 /* Call */,
+        id,
+        p: path,
+        a: rawArgs,
+        ...Object.keys(callbackMap).length > 0 && { c: callbackMap }
+      };
+      this.send(message, transferables);
+    });
+  }
+  send(message, transferables = []) {
+    this.debug("sending", MessageType[message.t], message);
+    this.target.postMessage(message, transferables);
+  }
+  release() {
+    if (this.released) {
+      return;
+    }
+    this.released = true;
+    for (const [, pending] of this.pendingCalls) {
+      if (pending.timer) {
+        clearTimeout(pending.timer);
+      }
+      pending.reject(new Error("Endpoint released"));
+    }
+    this.pendingCalls.clear();
+    if (this.remoteCallbacks.size > 0) {
+      const callbackIds = Array.from(this.remoteCallbacks.keys());
+      this.send({
+        t: 4 /* Release */,
+        id: generateId(),
+        c: callbackIds
+      });
+      this.remoteCallbacks.clear();
+    }
+    this.callbacks.clear();
+    this.detachListener();
+  }
+  getTarget() {
+    return this.target;
+  }
+}
+function createEndpoint(target, options) {
+  return new Endpoint(target, options);
+}
+// src/proxy.ts
+var PATH = Symbol("worker-rpc:path");
+var PROXY_ENDPOINT = Symbol("worker-rpc:proxy-endpoint");
+var proxyHandler = {
+  get(target, prop, receiver) {
+    if (prop === REMOTE_PROXY) {
+      return true;
+    }
+    if (prop === ENDPOINT) {
+      return target[PROXY_ENDPOINT];
+    }
+    if (prop === RELEASE) {
+      return () => {
+        const endpoint = target[PROXY_ENDPOINT];
+        endpoint.release();
+      };
+    }
+    if (prop === "then") {
+      if (target[PATH].length === 0) {
+        return;
+      }
+      const endpoint = target[PROXY_ENDPOINT];
+      const path = target[PATH];
+      const promise = endpoint.call(path, []);
+      return promise.then.bind(promise);
+    }
+    if (prop === "toJSON") {
+      return;
+    }
+    if (prop === Symbol.toStringTag || prop === Symbol.iterator || prop === Symbol.asyncIterator || prop === "constructor" || prop === "prototype") {
+      return;
+    }
+    if (typeof prop === "string") {
+      const endpoint = target[PROXY_ENDPOINT];
+      const currentPath = target[PATH];
+      const newPath = [...currentPath, prop];
+      return createProxyInternal(endpoint, newPath);
+    }
+    return;
+  },
+  apply(target, _thisArg, args) {
+    const endpoint = target[PROXY_ENDPOINT];
+    const path = target[PATH];
+    return endpoint.call(path, args);
+  },
+  set() {
+    throw new Error("Cannot set properties on a remote proxy");
+  },
+  deleteProperty() {
+    throw new Error("Cannot delete properties on a remote proxy");
+  },
+  getPrototypeOf() {
+    return Function.prototype;
+  },
+  has(_target, prop) {
+    return prop === REMOTE_PROXY || prop === ENDPOINT || prop === RELEASE;
+  }
+};
+function createProxyInternal(endpoint, path) {
+  const target = function() {};
+  target[PROXY_ENDPOINT] = endpoint;
+  target[PATH] = path;
+  return new Proxy(target, proxyHandler);
+}
+function wrap(endpoint) {
+  return createProxyInternal(endpoint, []);
+}
+function isProxy(value) {
+  if (value === null || value === undefined) {
+    return false;
+  }
+  try {
+    return value[REMOTE_PROXY] === true;
+  } catch {
+    return false;
+  }
+}
+function getEndpoint(proxy) {
+  if (isProxy(proxy)) {
+    return proxy[ENDPOINT];
+  }
+  return;
+}
+function releaseProxy(proxy) {
+  if (isProxy(proxy)) {
+    proxy[RELEASE]();
+  }
+}
+// src/channel.ts
+function createRegistry() {
+  const workers = new Map;
+  const channels = new Map;
+  const pendingChannels = new Map;
+  function handleWorkerMessage(workerId, event) {
+    const message = event.data;
+    if (typeof message !== "object" || message === null || message.t !== 5 /* Channel */) {
+      return;
+    }
+    const { target: targetId, port, id } = message;
+    const targetWorker = workers.get(targetId);
+    if (!targetWorker) {
+      const worker = workers.get(workerId);
+      if (worker) {
+        worker.postMessage({
+          t: 2 /* Error */,
+          id,
+          e: `Worker not found: ${targetId}`
+        });
+      }
+      return;
+    }
+    targetWorker.postMessage({
+      t: 5 /* Channel */,
+      id,
+      source: workerId,
+      port
+    }, [port]);
+  }
+  return {
+    register(id, worker) {
+      workers.set(id, worker);
+      const handler = (event) => handleWorkerMessage(id, event);
+      if (worker.addEventListener) {
+        worker.addEventListener("message", handler);
+      }
+    },
+    unregister(id) {
+      workers.delete(id);
+      for (const [key, state] of channels) {
+        if (key.includes(id)) {
+          state.endpoint.release();
+          state.port.close();
+          channels.delete(key);
+        }
+      }
+    },
+    async getChannel(targetId) {
+      throw new Error("getChannel should be called from within a worker using createWorkerChannel");
+    },
+    releaseAll() {
+      for (const [, state] of channels) {
+        state.endpoint.release();
+        state.port.close();
+      }
+      channels.clear();
+      workers.clear();
+    }
+  };
+}
+async function createWorkerChannel(mainThreadEndpoint, targetWorkerId, options) {
+  const channel = new MessageChannel;
+  return new Promise((resolve, reject) => {
+    const id = `channel:${Date.now()}:${Math.random().toString(36).slice(2)}`;
+    const originalHandler = mainThreadEndpoint.getTarget().onmessage;
+    const responseHandler = (event) => {
+      const message = event.data;
+      if (message?.id === id) {
+        if (mainThreadEndpoint.getTarget().onmessage === responseHandler) {
+          mainThreadEndpoint.getTarget().onmessage = originalHandler;
+        }
+        if (message.t === 2 /* Error */) {
+          reject(new Error(message.e));
+          return;
+        }
+        const endpoint = createEndpoint(channel.port1, options);
+        resolve(wrap(endpoint));
+      }
+    };
+    const target = mainThreadEndpoint.getTarget();
+    if (target.addEventListener) {
+      target.addEventListener("message", responseHandler);
+    } else {
+      target.onmessage = responseHandler;
+    }
+    target.postMessage({
+      t: 5 /* Channel */,
+      id,
+      target: targetWorkerId,
+      port: channel.port2
+    }, [channel.port2]);
+  });
+}
+function acceptChannel(port, api, options) {
+  const endpoint = createEndpoint(port, options);
+  endpoint.expose(api);
+  port.start();
+  return wrap(endpoint);
+}
+function setupChannelHandler(mainThread, getApi, options) {
+  const handler = (event) => {
+    const message = event.data;
+    if (typeof message !== "object" || message === null || message.t !== 5 /* Channel */) {
+      return;
+    }
+    const { port, source, id } = message;
+    if (!port) {
+      return;
+    }
+    const endpoint = createEndpoint(port, options);
+    endpoint.expose(getApi());
+    port.start();
+    mainThread.postMessage({
+      t: 6 /* ChannelAck */,
+      id,
+      source
+    });
+  };
+  if (mainThread.addEventListener) {
+    mainThread.addEventListener("message", handler);
+  } else {
+    mainThread.onmessage = handler;
+  }
+}
+
+class PeerChannel {
+  endpoint;
+  remote;
+  constructor(port, localApi, options) {
+    this.endpoint = createEndpoint(port, options);
+    this.endpoint.expose(localApi);
+    this.remote = wrap(this.endpoint);
+    port.start();
+  }
+  getRemote() {
+    return this.remote;
+  }
+  release() {
+    this.endpoint.release();
+  }
+}
+function createPeerPair(apiA, apiB, options) {
+  const channel = new MessageChannel;
+  const endpointA = createEndpoint(channel.port1, options);
+  endpointA.expose(apiA);
+  const endpointB = createEndpoint(channel.port2, options);
+  endpointB.expose(apiB);
+  channel.port1.start();
+  channel.port2.start();
+  return [wrap(endpointA), wrap(endpointB)];
+}
+// src/index.ts
+function expose(api, options) {
+  const self = globalThis;
+  const endpoint = createEndpoint(self, options);
+  endpoint.expose(api);
+  return endpoint;
+}
+function remote(worker, options) {
+  const endpoint = createEndpoint(worker, options);
+  return wrap(endpoint);
+}
+function transfer(value) {
+  return value;
+}
+function callback(fn, _options) {
+  return fn;
+}
+export {
+  wrap,
+  transfer,
+  setupChannelHandler,
+  serializeError,
+  remote,
+  releaseProxy,
+  isTransferable,
+  isProxy,
+  isMessagePort,
+  isFunction,
+  getEndpoint,
+  expose,
+  deserializeError,
+  createWorkerChannel,
+  createRegistry,
+  createPeerPair,
+  createEndpoint,
+  callback,
+  acceptChannel,
+  REMOTE_PROXY,
+  RELEASE,
+  PeerChannel,
+  MessageType,
+  Endpoint,
+  ENDPOINT,
+  CREATE_CHANNEL
+};

package/dist/proxy.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Worker RPC - Proxy Module
+ * Creates type-safe proxies for remote API access
+ */
+import { Endpoint } from "./endpoint";
+import { type RemoteObject } from "./types";
+/**
+ * Wrap a worker/endpoint to create a type-safe remote API proxy
+ *
+ * @example
+ * ```typescript
+ * interface WorkerApi {
+ *   add(a: number, b: number): number;
+ *   db: {
+ *     users: {
+ *       find(id: string): Promise<User>;
+ *     };
+ *   };
+ * }
+ *
+ * const worker = new Worker("./worker.ts");
+ * const api = wrap<WorkerApi>(worker);
+ *
+ * // All calls are async and type-safe
+ * const sum = await api.add(1, 2);
+ * const user = await api.db.users.find("123");
+ * ```
+ */
+export declare function wrap<T extends object>(endpoint: Endpoint): RemoteObject<T>;
+export declare function wrap<T extends object>(endpoint: Endpoint, options?: {
+    timeout?: number;
+}): RemoteObject<T>;
+/**
+ * Check if a value is a remote proxy
+ */
+export declare function isProxy(value: unknown): boolean;
+/**
+ * Get the endpoint from a proxy
+ */
+export declare function getEndpoint(proxy: unknown): Endpoint | undefined;
+/**
+ * Release a proxy and its underlying endpoint
+ */
+export declare function releaseProxy(proxy: unknown): void;
+//# sourceMappingURL=proxy.d.ts.map

package/dist/proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proxy.d.ts","sourceRoot":"","sources":["../src/proxy.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAEL,KAAK,YAAY,EAIlB,MAAM,SAAS,CAAC;AA6GjB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,EAAE,QAAQ,EAAE,QAAQ,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC;AAC5E,wBAAgB,IAAI,CAAC,CAAC,SAAS,MAAM,EACnC,QAAQ,EAAE,QAAQ,EAClB,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7B,YAAY,CAAC,CAAC,CAAC,CAAC;AAKnB;;GAEG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAU/C;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,QAAQ,GAAG,SAAS,CAKhE;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAIjD"}

package/dist/serialize.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Worker RPC - Serialization Module
+ * Minimal serialization - only handles Error objects for name/stack preservation
+ * All other data passes through structured clone directly
+ */
+/** Serialized error for transmission */
+export interface SerializedError {
+    /** Error message */
+    e: string;
+    /** Error name (e.g., "TypeError") */
+    n: string;
+    /** Error stack trace */
+    s?: string;
+}
+/**
+ * Serialize an Error object for transmission
+ * Preserves name and stack which structured clone doesn't handle well
+ */
+export declare function serializeError(error: Error): SerializedError;
+/**
+ * Deserialize an error from transmission
+ * Reconstructs the Error with proper name and stack
+ */
+export declare function deserializeError(data: SerializedError): Error;
+/**
+ * Check if a value is a function
+ */
+export declare function isFunction(value: unknown): value is Function;
+/**
+ * Check if a value is a MessagePort
+ */
+export declare function isMessagePort(value: unknown): value is MessagePort;
+/**
+ * Check if a value is transferable (ArrayBuffer or MessagePort)
+ */
+export declare function isTransferable(value: unknown): value is Transferable;
+//# sourceMappingURL=serialize.d.ts.map

package/dist/serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../src/serialize.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,wCAAwC;AACxC,MAAM,WAAW,eAAe;IAC9B,oBAAoB;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,qCAAqC;IACrC,CAAC,EAAE,MAAM,CAAC;IACV,wBAAwB;IACxB,CAAC,CAAC,EAAE,MAAM,CAAC;CACZ;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,eAAe,CAM5D;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,GAAG,KAAK,CAO7D;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,QAAQ,CAE5D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAKlE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAKpE"}

package/dist/types.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Worker RPC - Type Definitions
+ * High-performance, type-safe worker communication for Bun.js
+ */
+/** Unique identifier for tracking RPC calls */
+export type CallId = string;
+/** Unique identifier for callback functions */
+export type CallbackId = string;
+/** Path to a nested method (e.g., ['db', 'users', 'find']) */
+export type MethodPath = string[];
+/** Message types for the RPC protocol */
+export declare enum MessageType {
+    /** Request to invoke a method */
+    Call = 0,
+    /** Successful response */
+    Result = 1,
+    /** Error response */
+    Error = 2,
+    /** Callback invocation */
+    Callback = 3,
+    /** Release a callback reference */
+    Release = 4,
+    /** Establish a direct channel between workers */
+    Channel = 5,
+    /** Acknowledgment for channel establishment */
+    ChannelAck = 6
+}
+/** Base message structure */
+export interface BaseMessage {
+    /** Message type discriminator */
+    t: MessageType;
+    /** Call ID for request/response correlation */
+    id: CallId;
+}
+/** Request to invoke a remote method */
+export interface CallMessage extends BaseMessage {
+    t: MessageType.Call;
+    /** Method path (supports nested objects) */
+    p: MethodPath;
+    /** Arguments (passed raw via structured clone) */
+    a: unknown[];
+    /** Callback mappings: argIndex -> callbackId (only for function arguments) */
+    c?: Record<number, CallbackId>;
+}
+/** Successful response */
+export interface ResultMessage extends BaseMessage {
+    t: MessageType.Result;
+    /** Return value (passed raw via structured clone) */
+    v: unknown;
+    /** Callback ID if return value is a function */
+    c?: CallbackId;
+}
+/** Error response */
+export interface ErrorMessage extends BaseMessage {
+    t: MessageType.Error;
+    /** Error message */
+    e: string;
+    /** Error name (e.g., "TypeError", "RangeError") */
+    n?: string;
+    /** Error stack trace */
+    s?: string;
+}
+/** Callback invocation request */
+export interface CallbackMessage extends BaseMessage {
+    t: MessageType.Callback;
+    /** Callback ID */
+    c: CallbackId;
+    /** Arguments (passed raw via structured clone) */
+    a: unknown[];
+    /** Callback mappings for nested callbacks in args */
+    cb?: Record<number, CallbackId>;
+}
+/** Release a callback reference */
+export interface ReleaseMessage extends BaseMessage {
+    t: MessageType.Release;
+    /** Callback IDs to release */
+    c: CallbackId[];
+}
+/** Channel establishment message */
+export interface ChannelMessage extends BaseMessage {
+    t: MessageType.Channel;
+    /** Target worker identifier */
+    target: string;
+    /** MessagePort for direct communication */
+    port: MessagePort;
+}
+/** Channel acknowledgment */
+export interface ChannelAckMessage extends BaseMessage {
+    t: MessageType.ChannelAck;
+    /** Source worker identifier */
+    source: string;
+}
+/** Union of all message types */
+export type RpcMessage = CallMessage | ResultMessage | ErrorMessage | CallbackMessage | ReleaseMessage | ChannelMessage | ChannelAckMessage;
+/** Unwrap a Promise type */
+export type Unpromise<T> = T extends Promise<infer U> ? U : T;
+/** Make a function async if it isn't already */
+export type Promisify<T> = T extends (...args: infer A) => infer R ? (...args: A) => Promise<Unpromise<R>> : never;
+/** Convert a function type to its remote callable version */
+export type RemoteFunction<T> = T extends (...args: infer A) => infer R ? (...args: A) => Promise<Unpromise<R>> : never;
+/** Convert an object type to its remote callable version */
+export type RemoteObject<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? RemoteFunction<T[K]> : T[K] extends object ? RemoteObject<T[K]> : T[K];
+};
+/** Symbol to mark a proxy as a remote reference */
+export declare const REMOTE_PROXY: unique symbol;
+/** Symbol for accessing the underlying endpoint */
+export declare const ENDPOINT: unique symbol;
+/** Symbol for releasing a proxy */
+export declare const RELEASE: unique symbol;
+/** Symbol for creating a direct channel */
+export declare const CREATE_CHANNEL: unique symbol;
+/** Configuration options for the RPC endpoint */
+export interface EndpointOptions {
+    /** Timeout for RPC calls in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Custom error handler */
+    onError?: (error: Error) => void;
+    /** Enable debug logging */
+    debug?: boolean;
+}
+/** Configuration for exposing an API */
+export interface ExposeOptions {
+    /** Maximum depth for nested objects (default: 10) */
+    maxDepth?: number;
+}
+/** Pending call information */
+export interface PendingCall {
+    resolve: (value: any) => void;
+    reject: (error: Error) => void;
+    timer?: ReturnType<typeof setTimeout>;
+}
+/** Callback registration */
+export interface CallbackRegistration {
+    fn: Function;
+    /** Number of times this callback can be invoked (-1 = unlimited) */
+    remaining: number;
+}
+/** Transferable types */
+export type TransferableValue = ArrayBuffer | MessagePort;
+/** Worker-like message target */
+export interface MessageTarget {
+    postMessage(message: any, transfer?: any[]): void;
+    addEventListener?(type: string, listener: (event: any) => void): void;
+    removeEventListener?(type: string, listener: (event: any) => void): void;
+    onmessage?: ((event: any) => void) | null;
+    start?(): void;
+    close?(): void;
+}
+/** Extended Worker type with Bun-specific features */
+export interface BunWorker extends MessageTarget {
+    terminate?(): 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/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@xentobias/worker-rpc",
+  "version": "1.0.1",
+  "description": "High-performance, type-safe RPC for Bun.js Workers",
+  "module": "src/index.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun && tsc --declaration",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "example": "bun run examples/basic/main.ts",
+    "example:nested": "bun run examples/nested/main.ts",
+    "example:callbacks": "bun run examples/callbacks/main.ts",
+    "example:w2w": "bun run examples/worker-to-worker/main.ts",
+    "benchmark": "bun run benchmark/run.ts"
+  },
+  "keywords": [
+    "bun",
+    "worker",
+    "rpc",
+    "comlink",
+    "typescript",
+    "proxy",
+    "message-passing"
+  ],
+  "license": "MIT",
+  "devDependencies": {
+    "@types/bun": "latest",
+    "comlink": "^4.4.2",
+    "typescript": "^5"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  }
+}