@flaxia/node 0.1.4 → 0.2.0

package/dist/client/SignalingClient.d.ts

@@ -4,6 +4,7 @@ export interface TaskMessage {
     taskId: string;
     workload: WorkloadType;
     payload: unknown;
+    timeoutMs?: number;
 }
 export declare const initFlaxiaNode: (config: NodeConfig) => void;
 //# sourceMappingURL=SignalingClient.d.ts.map

package/dist/client/SignalingClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SignalingClient.d.ts","sourceRoot":"","sources":["../../src/client/SignalingClient.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE5D,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,YAAY,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;CAClB;AA4GD,eAAO,MAAM,cAAc,GAAI,QAAQ,UAAU,SAehD,CAAC"}
+{"version":3,"file":"SignalingClient.d.ts","sourceRoot":"","sources":["../../src/client/SignalingClient.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE5D,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,YAAY,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AA8ND,eAAO,MAAM,cAAc,GAAI,QAAQ,UAAU,SAehD,CAAC"}

package/dist/executor/WorkerPool.d.ts

@@ -1,12 +1,33 @@
 import type { WorkloadType } from "@flaxia/sdk";
+/**
+ * Executes tasks against a single Web Worker.
+ *
+ * Design notes:
+ * - Tasks are serialized (1 node = 1 task at a time) so a worker restart on
+ *   timeout never destroys another task's execution.
+ * - Timeouts are a hard deadline from task start; heartbeats and token
+ *   messages do NOT extend them, so a stuck task cannot hold a slot forever.
+ * - terminate()/suspend() settles all pending promises and clears timers so a
+ *   stale timeout can never kill a freshly resumed worker.
+ */
 export declare class WorkerPool {
     private worker;
     private defaultTimeoutMs;
     private workerUrl;
+    private queue;
+    private active;
+    private _lastCpuLoad;
     constructor(workerUrl?: string, timeoutMs?: number);
     private initWorker;
-    run(id: string, workload: WorkloadType, payload: unknown, timeoutMs?: number, onToken?: (token: string) => void): Promise<unknown>;
+    run(id: string, workload: WorkloadType, payload: unknown, timeoutMs?: number, onToken?: (token: string) => void, config?: {
+        maxCpuLoad?: number;
+    }): Promise<unknown>;
+    private execute;
+    private handleWorkerError;
+    private dequeue;
     private cleanupWorker;
     terminate(): void;
+    resume(): void;
+    get lastCpuLoad(): number;
 }
 //# sourceMappingURL=WorkerPool.d.ts.map

package/dist/executor/WorkerPool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WorkerPool.d.ts","sourceRoot":"","sources":["../../src/executor/WorkerPool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,SAAS,CAAS;gBAEd,SAAS,CAAC,EAAE,MAAM,EAAE,SAAS,SAAS;IAMlD,OAAO,CAAC,UAAU;IAKlB,GAAG,CACD,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,YAAY,EACtB,OAAO,EAAE,OAAO,EAChB,SAAS,CAAC,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAChC,OAAO,CAAC,OAAO,CAAC;IAmDnB,OAAO,CAAC,aAAa;IAQrB,SAAS;CAMV"}
+{"version":3,"file":"WorkerPool.d.ts","sourceRoot":"","sources":["../../src/executor/WorkerPool.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAWhD;;;;;;;;;;GAUG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,gBAAgB,CAAS;IACjC,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,KAAK,CAAyB;IACtC,OAAO,CAAC,MAAM,CAA2B;IACzC,OAAO,CAAC,YAAY,CAAK;gBAEb,SAAS,CAAC,EAAE,MAAM,EAAE,SAAS,SAAS;IAMlD,OAAO,CAAC,UAAU;IAYlB,GAAG,CACD,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,YAAY,EACtB,OAAO,EAAE,OAAO,EAChB,SAAS,CAAC,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,EACjC,MAAM,CAAC,EAAE;QAAE,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,GAC/B,OAAO,CAAC,OAAO,CAAC;IAenB,OAAO,CAAC,OAAO;IA2Ef,OAAO,CAAC,iBAAiB;IAWzB,OAAO,CAAC,OAAO;IAKf,OAAO,CAAC,aAAa;IAQrB,SAAS;IAaT,MAAM;IAMN,IAAI,WAAW,IAAI,MAAM,CAExB;CACF"}

package/dist/executor/__tests__/throttle.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=throttle.test.d.ts.map

package/dist/executor/__tests__/throttle.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"throttle.test.d.ts","sourceRoot":"","sources":["../../../src/executor/__tests__/throttle.test.ts"],"names":[],"mappings":""}

package/dist/executor/throttle.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Estimates current CPU contention and throttles work accordingly.
+ *
+ * Runs inside the compute Worker (where the actual workload executes) rather
+ * than on the main thread, so the measurement reflects the thread that does
+ * the work. Load is estimated with a calibrated busy-loop: a fixed-iteration
+ * loop takes longer to finish when the system is busy, and the ratio to the
+ * idle baseline is the estimated load.
+ *
+ * There is no direct API for CPU usage in the browser, so this is a heuristic
+ * used to (a) avoid starting work while the machine is already loaded and
+ * (b) space out task starts so average CPU stays near `maxLoad`.
+ */
+export declare class CpuThrottle {
+    private baselineMs;
+    private lastLoad;
+    private readonly maxLoad;
+    private readonly loopIterations;
+    constructor(maxLoad?: number, loopIterations?: number);
+    private busyLoop;
+    private sample;
+    calibrate(): Promise<void>;
+    getCurrentLoad(): Promise<number>;
+    shouldPause(): Promise<boolean>;
+    /**
+     * Waits until the system is calm enough to run a task.
+     * Bounded by `maxWaitMs` so a persistently busy machine cannot stall
+     * the queue forever.
+     */
+    waitForSlot(maxWaitMs?: number): Promise<void>;
+    get lastMeasuredLoad(): number;
+    get maxLoadValue(): number;
+}
+//# sourceMappingURL=throttle.d.ts.map

package/dist/executor/throttle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"throttle.d.ts","sourceRoot":"","sources":["../../src/executor/throttle.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;GAYG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;gBAE5B,OAAO,SAAO,EAAE,cAAc,SAAY;IAKtD,OAAO,CAAC,QAAQ;IAQhB,OAAO,CAAC,MAAM;IAKR,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC;IAM1B,cAAc,IAAI,OAAO,CAAC,MAAM,CAAC;IAWjC,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAIrC;;;;OAIG;IACG,WAAW,CAAC,SAAS,SAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAQnD,IAAI,gBAAgB,IAAI,MAAM,CAE7B;IAED,IAAI,YAAY,IAAI,MAAM,CAEzB;CACF"}

package/dist/index.js

@@ -51,55 +51,99 @@ var e = class {
 	localStorage.setItem(t, "true"), localStorage.setItem(n, String(Date.now() + r));
 }, o = class {
 	constructor(e, t = 3e5) {
-		this.worker = null, this.workerUrl = e || "/worker.js", this.defaultTimeoutMs = t, this.initWorker();
+		this.worker = null, this.queue = [], this.active = null, this._lastCpuLoad = 0, this.workerUrl = e || "/worker.js", this.defaultTimeoutMs = t, this.initWorker();
 	}
 	initWorker() {
-		typeof Worker > "u" || (this.worker = new Worker(this.workerUrl, { type: "module" }));
+		if (typeof Worker > "u") return;
+		let e = new Worker(this.workerUrl, { type: "module" });
+		e.onerror = (e) => {
+			this.handleWorkerError(Error(e.message || "Worker error"));
+		}, e.onmessageerror = () => {
+			this.handleWorkerError(/* @__PURE__ */ Error("Worker message error"));
+		}, this.worker = e;
 	}
-	run(e, t, n, r, i) {
-		return new Promise((a, o) => {
+	run(e, t, n, r, i, a) {
+		return new Promise((o, s) => {
 			if (!this.worker) {
-				o(/* @__PURE__ */ Error("Worker not available"));
+				s(/* @__PURE__ */ Error("Worker not available"));
 				return;
 			}
-			let s = r ?? this.defaultTimeoutMs, c = setTimeout(() => {
-				this.cleanupWorker(), o(/* @__PURE__ */ Error("TIMEOUT"));
-			}, s), l = (t) => {
-				let { id: n, type: r, result: u, error: d, token: f } = t.data;
-				if (n === e) {
-					if (r === "heartbeat") {
-						clearTimeout(c), c = setTimeout(() => {
-							this.cleanupWorker(), o(/* @__PURE__ */ Error("TIMEOUT"));
-						}, s);
-						return;
-					}
-					if (r === "token") {
-						i?.(f), clearTimeout(c), c = setTimeout(() => {
-							this.cleanupWorker(), o(/* @__PURE__ */ Error("TIMEOUT"));
-						}, s);
-						return;
-					}
-					clearTimeout(c), this.worker?.removeEventListener("message", l), r === "done" ? a(u) : r === "error" && o(Error(d));
+			let c = () => this.execute(e, t, n, r, i, a, o, s);
+			this.active ? this.queue.push(c) : c();
+		});
+	}
+	execute(e, t, n, r, i, a, o, s) {
+		let c = this.worker;
+		if (!c) {
+			s(/* @__PURE__ */ Error("Worker not available")), this.dequeue();
+			return;
+		}
+		let l = r ?? this.defaultTimeoutMs, u = !1, d = (e) => {
+			if (u) return;
+			u = !0;
+			let t = this.active;
+			t && (clearTimeout(t.timer), t.removeListener()), this.active = null, e(), this.dequeue();
+		}, f = (t) => {
+			let { id: n, type: r, result: a, error: c, token: l, cpuLoad: u } = t.data;
+			if (n === e) {
+				if (r === "token") {
+					i?.(l);
+					return;
 				}
-			};
-			this.worker.addEventListener("message", l), this.worker.postMessage({
+				if (r === "heartbeat") {
+					typeof u == "number" && Number.isFinite(u) && (this._lastCpuLoad = Math.min(1, Math.max(0, u)));
+					return;
+				}
+				d(r === "done" ? () => o(a) : r === "error" ? () => s(Error(c)) : () => s(/* @__PURE__ */ Error(`Unknown message type: ${String(r)}`)));
+			}
+		}, p = () => c.removeEventListener("message", f), m = setTimeout(() => {
+			this.cleanupWorker(), d(() => s(/* @__PURE__ */ Error("TIMEOUT")));
+		}, l);
+		this.active = {
+			id: e,
+			resolve: o,
+			reject: s,
+			timer: m,
+			worker: c,
+			removeListener: p
+		}, c.addEventListener("message", f);
+		try {
+			c.postMessage({
 				id: e,
 				workload: t,
-				payload: n
+				payload: n,
+				timeoutMs: l,
+				config: a
 			});
-		});
+		} catch (e) {
+			d(() => s(e instanceof Error ? e : Error(String(e))));
+		}
+	}
+	handleWorkerError(e) {
+		let t = this.active;
+		this.cleanupWorker(), t && (clearTimeout(t.timer), this.active = null, t.reject(e), this.dequeue());
+	}
+	dequeue() {
+		let e = this.queue.shift();
+		e && e();
 	}
 	cleanupWorker() {
 		this.worker &&= (this.worker.terminate(), null), this.initWorker();
 	}
 	terminate() {
-		this.worker &&= (this.worker.terminate(), null);
+		this.queue = [], this.active &&= (clearTimeout(this.active.timer), this.active.reject(/* @__PURE__ */ Error("TERMINATED")), null), this.worker &&= (this.worker.terminate(), null);
+	}
+	resume() {
+		this.worker || this.initWorker();
+	}
+	get lastCpuLoad() {
+		return this._lastCpuLoad;
 	}
-}, s = class {
+}, s = "flaxia_node_id", c = "flaxia_node_token", l = class {
 	constructor(e, t, n) {
-		this.config = e, this.workerPool = t, this.nodeId = n, this.ws = null, this.reconnectAttempts = 0, this.MAX_RECONNECT_DELAY = 3e4, this.destroyed = !1;
+		this.config = e, this.workerPool = t, this.nodeId = n, this.ws = null, this.reconnectAttempts = 0, this.MAX_RECONNECT_DELAY = 3e4, this.destroyed = !1, this.suspended = !1, this.visibilityHandler = null;
 	}
-	connect() {
+	async connect() {
 		if (this.destroyed) return;
 		if (this.ws) {
 			let e = this.ws;
@@ -109,74 +153,141 @@ var e = class {
 			} catch {}
 			this.ws = null;
 		}
-		let e = this.config.capabilities ?? ["ai-inference", "image-process"], t = new URL(`${this.config.orchestratorUrl.replace("http", "ws")}/crowd/signal`);
-		t.searchParams.set("nodeId", this.nodeId), t.searchParams.set("capabilities", e.join(","));
-		let n = new WebSocket(t.toString());
-		this.ws = n, n.onopen = () => {
+		this.setupVisibilityHandler();
+		let e = await this.obtainToken();
+		if (!e) {
+			this.scheduleReconnect();
+			return;
+		}
+		let t = this.config.orchestratorUrl.replace(/\/+$/, "").replace(/^http/, "ws"), n = new URL(`${t}/crowd/signal`);
+		n.searchParams.set("token", e.token);
+		let r = new WebSocket(n.toString());
+		this.ws = r, r.onopen = () => {
 			this.reconnectAttempts = 0;
-		}, n.onmessage = async (e) => {
-			let t = JSON.parse(e.data);
+		}, r.onmessage = async (e) => {
+			let t;
+			try {
+				t = JSON.parse(e.data);
+			} catch {
+				return;
+			}
 			if (t.type === "ping") {
-				n.send(JSON.stringify({
+				this.send({
 					type: "pong",
-					cpuLoad: .1
-				}));
+					cpuLoad: this.workerPool.lastCpuLoad
+				});
 				return;
 			}
-			t.type === "task" && this.handleTask(t);
-		}, n.onclose = () => {
-			if (n.onclose = null, this.ws !== n || (this.ws = null, this.destroyed)) return;
-			let e = Math.min(1e3 * 2 ** this.reconnectAttempts, this.MAX_RECONNECT_DELAY);
-			setTimeout(() => {
-				this.reconnectAttempts++, this.connect();
-			}, e);
+			if (t.type === "task") try {
+				await this.handleTask(t);
+			} catch (e) {
+				this.send({
+					type: "error",
+					taskId: String(t.taskId ?? ""),
+					error: e instanceof Error ? e.message : String(e)
+				});
+			}
+		}, r.onclose = () => {
+			r.onclose = null, this.ws === r && (this.ws = null, !this.destroyed && this.scheduleReconnect());
 		};
 	}
+	scheduleReconnect() {
+		let e = Math.min(1e3 * 2 ** this.reconnectAttempts, this.MAX_RECONNECT_DELAY);
+		setTimeout(() => {
+			this.destroyed || this.suspended || (this.reconnectAttempts++, this.connect());
+		}, e);
+	}
 	disconnect() {
-		this.destroyed = !0;
+		this.destroyed = !0, this.suspended = !1, this.removeVisibilityHandler();
 		try {
 			this.ws?.close();
 		} catch {}
 		this.ws = null;
 	}
-	async handleTask(e) {
+	suspend() {
+		if (!(this.suspended || this.destroyed)) {
+			if (this.suspended = !0, this.ws) {
+				let e = this.ws;
+				e.onclose = null;
+				try {
+					e.close();
+				} catch {}
+				this.ws = null;
+			}
+			this.workerPool.terminate();
+		}
+	}
+	resume() {
+		!this.suspended || this.destroyed || (this.suspended = !1, this.workerPool.resume(), this.connect());
+	}
+	async obtainToken() {
 		try {
-			let t = await this.workerPool.run(e.taskId, e.workload, e.payload, void 0, (t) => {
-				this.ws?.send(JSON.stringify({
-					type: "progress",
-					taskId: e.taskId,
-					token: t
-				}));
+			let e = localStorage.getItem(c);
+			if (e) try {
+				let t = JSON.parse(e);
+				if (t.token && t.nodeId && t.expiresAt > Date.now() + 6e4) return t;
+			} catch {}
+			let t = this.config.orchestratorUrl.replace(/\/+$/, ""), n = await fetch(`${t}/crowd/nodes/register`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					siteId: this.config.siteId,
+					nodeId: this.nodeId,
+					capabilities: this.config.capabilities ?? ["ai-inference", "image-process"]
+				})
 			});
-			this.ws?.send(JSON.stringify({
-				type: "result",
-				taskId: e.taskId,
-				payload: t
-			}));
-		} catch (t) {
-			this.ws?.send(JSON.stringify({
-				type: "error",
-				taskId: e.taskId,
-				error: t instanceof Error ? t.message : String(t)
-			}));
+			if (!n.ok) return null;
+			let r = await n.json();
+			if (!r.token) return null;
+			try {
+				localStorage.setItem(c, JSON.stringify(r));
+			} catch {}
+			return r;
+		} catch {
+			return null;
 		}
 	}
-}, c = "__flaxia_node_signal_client", l = (e) => {
-	let t = window[c];
+	send(e) {
+		this.ws && this.ws.readyState === WebSocket.OPEN && this.ws.send(JSON.stringify(e));
+	}
+	async handleTask(e) {
+		let t = e.timeoutMs ? e.timeoutMs + 3e4 : void 0, n = await this.workerPool.run(e.taskId, e.workload, e.payload, t, (t) => {
+			this.send({
+				type: "progress",
+				taskId: e.taskId,
+				token: t
+			});
+		}, { maxCpuLoad: this.config.maxCpuLoad });
+		this.send({
+			type: "result",
+			taskId: e.taskId,
+			payload: n
+		});
+	}
+	setupVisibilityHandler() {
+		this.removeVisibilityHandler(), this.visibilityHandler = () => {
+			document.hidden ? this.suspend() : this.suspended && this.resume();
+		}, document.addEventListener("visibilitychange", this.visibilityHandler);
+	}
+	removeVisibilityHandler() {
+		this.visibilityHandler &&= (document.removeEventListener("visibilitychange", this.visibilityHandler), null);
+	}
+}, u = "__flaxia_node_signal_client", d = (e) => {
+	let t = window[u];
 	t && t.disconnect();
-	let n = new URL("./worker.js", "" + import.meta.url).href, r = new o(n), i = localStorage.getItem("flaxia_node_id");
-	i || (i = crypto.randomUUID(), localStorage.setItem("flaxia_node_id", i));
-	let a = new s(e, r, i);
-	window[c] = a, a.connect();
-}, u = (t) => {
+	let n = new URL("./worker.js", "" + import.meta.url).href, r = new o(n), i = localStorage.getItem(s);
+	i || (i = crypto.randomUUID(), localStorage.setItem(s, i));
+	let a = new l(e, r, i);
+	window[u] = a, a.connect();
+}, f = (t) => {
 	if (i()) {
-		l(t);
+		d(t);
 		return;
 	}
 	let n = document.createElement("div");
 	n.id = "flaxia-consent-container", document.body.appendChild(n), new e(n, t.consent, () => {
-		a(), n.remove(), l(t);
+		a(), n.remove(), d(t);
 	});
 };
 //#endregion
-export { u as initFlaxiaNode };
+export { f as initFlaxiaNode };

package/dist/worker.js

@@ -1,54 +1,102 @@
-//#region src/worker/main.worker.ts
+//#region src/executor/throttle.ts
+function e(e) {
+	return new Promise((t) => setTimeout(t, e));
+}
+var t = class {
+	constructor(e = .15, t = 2e6) {
+		this.baselineMs = null, this.lastLoad = 0, this.maxLoad = Math.max(.05, Math.min(.3, e)), this.loopIterations = t;
+	}
+	busyLoop() {
+		let e = this.loopIterations, t = performance.now(), n = 0;
+		for (; n < e;) n++;
+		return performance.now() - t;
+	}
+	sample() {
+		return [
+			this.busyLoop(),
+			this.busyLoop(),
+			this.busyLoop()
+		].sort((e, t) => e - t)[1];
+	}
+	async calibrate() {
+		this.busyLoop(), this.baselineMs = this.sample(), this.lastLoad = 0;
+	}
+	async getCurrentLoad() {
+		if (this.baselineMs === null) return await this.calibrate(), 0;
+		let e = this.sample(), t = Math.min(1, Math.max(0, e / this.baselineMs - 1));
+		return this.lastLoad = t, t;
+	}
+	async shouldPause() {
+		return await this.getCurrentLoad() > this.maxLoad;
+	}
+	async waitForSlot(t = 3e4) {
+		let n = performance.now();
+		for (; await this.shouldPause() && !(performance.now() - n > t);) await e(500);
+	}
+	get lastMeasuredLoad() {
+		return this.lastLoad;
+	}
+	get maxLoadValue() {
+		return this.maxLoad;
+	}
+}, n = null;
 self.onmessage = async (e) => {
-	let { id: t, workload: n, payload: r } = e.data, i = setInterval(() => {
-		self.postMessage({
-			id: t,
-			type: "heartbeat"
-		});
-	}, 1e4);
+	let { id: r, workload: i, payload: a, config: o } = e.data;
 	try {
-		let e, a = (e) => {
+		n ||= new t(o?.maxCpuLoad), await n.waitForSlot();
+		let e = setInterval(() => {
 			self.postMessage({
-				id: t,
-				type: "token",
-				token: e
+				id: r,
+				type: "heartbeat",
+				cpuLoad: n?.lastMeasuredLoad ?? 0
 			});
-		};
-		switch (n) {
-			case "ai-inference":
-				let { handleAiInference: t } = await import("./assets/ai-inference.js");
-				e = await t(r, a);
-				break;
-			case "image-process":
-				let { handleImageProcess: i } = await import("./assets/image-process.js");
-				e = await i(r);
-				break;
-			case "container":
-				let { handleContainer: o } = await import("./assets/container.js");
-				e = await o(r);
-				break;
-			case "vector-embed":
-				let { handleVectorEmbed: s } = await import("./assets/vector-embed.js");
-				e = await s(r);
-				break;
-			case "vector-store":
-				let { handleVectorStore: c } = await import("./assets/vector-store.js");
-				e = await c(r);
-				break;
-			case "vector-query":
-				let { handleVectorQuery: l } = await import("./assets/vector-query.js");
-				e = await l(r);
-				break;
-			default: throw Error(`Unknown workload type: ${n}`);
+		}, 1e4);
+		try {
+			let e, t = (e) => {
+				self.postMessage({
+					id: r,
+					type: "token",
+					token: e
+				});
+			};
+			switch (i) {
+				case "ai-inference":
+					let { handleAiInference: n } = await import("./assets/ai-inference.js");
+					e = await n(a, t);
+					break;
+				case "image-process":
+					let { handleImageProcess: r } = await import("./assets/image-process.js");
+					e = await r(a);
+					break;
+				case "container":
+					let { handleContainer: o } = await import("./assets/container.js");
+					e = await o(a);
+					break;
+				case "vector-embed":
+					let { handleVectorEmbed: s } = await import("./assets/vector-embed.js");
+					e = await s(a);
+					break;
+				case "vector-store":
+					let { handleVectorStore: c } = await import("./assets/vector-store.js");
+					e = await c(a);
+					break;
+				case "vector-query":
+					let { handleVectorQuery: l } = await import("./assets/vector-query.js");
+					e = await l(a);
+					break;
+				default: throw Error(`Unknown workload type: ${i}`);
+			}
+			self.postMessage({
+				id: r,
+				type: "done",
+				result: e
+			});
+		} finally {
+			clearInterval(e);
 		}
-		clearInterval(i), self.postMessage({
-			id: t,
-			type: "done",
-			result: e
-		});
 	} catch (e) {
-		clearInterval(i), self.postMessage({
-			id: t,
+		self.postMessage({
+			id: r,
 			type: "error",
 			error: e instanceof Error ? e.message : String(e)
 		});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flaxia/node",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "private": false,
   "main": "dist/index.js",
   "types": "./dist/index.d.ts",
@@ -12,7 +12,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/RemydreScarlet/flaxia-crowd.git"
+    "url": "https://github.com/TeamFlaxia/flaxia-crowd.git"
   },
   "scripts": {
     "build": "rm -f tsconfig.tsbuildinfo && vite build && tsc -b",
@@ -21,7 +21,7 @@
   },
   "dependencies": {
     "@bjorn3/browser_wasi_shim": "^0.4.2",
-    "@flaxia/sdk": "^0.1.0",
+    "@flaxia/sdk": "^0.2.0",
     "@huggingface/transformers": "^4.2.0",
     "rollup": "^4.61.0"
   },

package/dist/worker/main.worker.js

@@ -1,29 +0,0 @@
-import type { WorkloadType } from '@flaxia/sdk';
-
-self.onmessage = async (e: MessageEvent) => {
-  const { id, workload, payload } = e.data;
-
-  try {
-    let result;
-    switch (workload as WorkloadType) {
-      case 'ai-inference':
-        const { handleAiInference } = await import('../workloads/ai-inference');
-        result = await handleAiInference(payload);
-        break;
-      case 'image-process':
-        const { handleImageProcess } = await import('../workloads/image-process');
-        result = await handleImageProcess(payload);
-        break;
-      case 'container':
-        const { handleContainer } = await import('../workloads/container');
-        result = await handleContainer(payload);
-        break;
-      default:
-        throw new Error(`Unknown workload type: ${workload}`);
-    }
-
-    self.postMessage({ id, type: 'done', result });
-  } catch (err) {
-    self.postMessage({ id, type: 'error', error: err instanceof Error ? err.message : String(err) });
-  }
-};