Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
10 changes: 9 additions & 1 deletion packages/utils/src/worker_helper.ts
Original file line number Diff line number Diff line change
Expand Up @@ -88,10 +88,18 @@ export interface WorkerConnection {
* @returns A promise that resolves to a {@link WorkerConnection} once the handshake completes.
*/
export function connectWorker(worker: Worker): Promise<WorkerConnection> {
return new Promise((resolve) => {
return new Promise((resolve, reject) => {
const pending = new Map<string, { resolve(v: any): void; reject(e: Error): void }>();
const callbacks = new Map<string, (...args: any[]) => any>();

worker.onerror = (event: ErrorEvent) => {
const failure = event.error instanceof Error ? event.error : new Error(event.message || "Worker failed");
reject(failure);
for (const call of pending.values()) call.reject(failure);
pending.clear();
callbacks.clear();
};

function send(msg: Record<string, any>, callArgs?: any[]): Promise<any> {
return new Promise((res, rej) => {
const id = nextId();
Expand Down
86 changes: 86 additions & 0 deletions packages/utils/test/worker_helper.test.js
Original file line number Diff line number Diff line change
@@ -0,0 +1,86 @@
// Copyright (c) 2026 Apple Inc. Licensed under MIT License.

import { Worker } from "node:worker_threads";

import { connectWorker } from "@embedding-atlas/utils";
import { afterEach, describe, expect, it } from "vitest";

const runtimeUrl = new URL("../dist/worker_helper.js", import.meta.url).href;
const threads = [];

function startWorker(body) {
const thread = new Worker(
`
const { parentPort } = require("node:worker_threads");
globalThis.postMessage = (message, options) => parentPort.postMessage(message, options?.transfer);
parentPort.on("message", (data) => globalThis.onmessage?.({ data }));
(async () => {
const { createWorkerRuntime } = await import(${JSON.stringify(runtimeUrl)});
${body}
})().catch((error) => { setImmediate(() => { throw error; }); });
`,
{ eval: true },
);
threads.push(thread);

// Adapt Node's real worker events to the browser Worker interface.
const worker = {
onmessage: null,
onerror: null,
postMessage(message, options) {
thread.postMessage(message, options?.transfer);
},
};
thread.on("message", (data) => worker.onmessage?.({ data }));
thread.on("error", (error) => worker.onerror?.({ error, message: error.message }));
return worker;
}

afterEach(async () => {
await Promise.all(threads.splice(0).map((thread) => thread.terminate()));
});

describe("connectWorker", () => {
it("completes the handshake and forwards RPC results", async () => {
const worker = startWorker(`
const runtime = createWorkerRuntime();
globalThis.onmessage = runtime.handler;
runtime.registerFunction("sum", (a, b) => a + b);
`);
const connection = await connectWorker(worker);
await expect(connection.call("sum", 2, 3)).resolves.toBe(5);
});

it("rejects the handshake when the worker fails to start", async () => {
const worker = startWorker(`throw new Error("startup failed");`);
await expect(connectWorker(worker)).rejects.toThrow("startup failed");
});

it("rejects pending calls when the worker crashes", async () => {
const worker = startWorker(`
const runtime = createWorkerRuntime();
globalThis.onmessage = runtime.handler;
runtime.registerFunction("wait", () => new Promise(() => {}));
runtime.registerFunction("crash", () => new Promise(() => {
setImmediate(() => { throw new Error("runtime failed"); });
}));
`);
const connection = await connectWorker(worker);
await Promise.all([
expect(connection.call("wait")).rejects.toThrow("runtime failed"),
expect(connection.call("crash")).rejects.toThrow("runtime failed"),
]);
});

it("still accepts calls after an error the worker survives", async () => {
const worker = startWorker(`
const runtime = createWorkerRuntime();
globalThis.onmessage = runtime.handler;
runtime.registerFunction("sum", (a, b) => a + b);
`);
const connection = await connectWorker(worker);
// A Node thread dies on an uncaught error, while a browser worker can survive it.
worker.onerror({ message: "stray error" });
await expect(connection.call("sum", 2, 3)).resolves.toBe(5);
});
});