@flaxia/node 0.3.7 → 0.5.0

package/dist/worker.js

@@ -1,36 +1,55 @@
-import { n as e, r as t, t as n } from "./assets/memoryProbe.js";
-//#region ../sdk/dist/index.js
-var r = new Set([
-	"ai-inference",
-	"image-process",
-	"container",
-	"vector-embed",
-	"vector-query",
-	"nudenet"
-]);
-//#endregion
+import { _ as e, a as t, b as n, c as r, g as i, h as a, i as o, l as s, n as c, o as l, s as u, t as d, v as f, x as p, y as m } from "./assets/dist.js";
 //#region src/executor/throttle.ts
-function i(e) {
+function h(e) {
 	return new Promise((t) => setTimeout(t, e));
 }
-var a = 3e4, o = 3e4, s = class {
+var g = 3e4, ee = 500, _ = class extends Error {
+	constructor(e, t, n) {
+		super(`device is over its CPU budget (load ${e.toFixed(2)} > max ${t.toFixed(2)}) after waiting ${Math.round(n)}ms; task not started`), this.load = e, this.maxLoad = t, this.waitedMs = n, this.retryable = !0, this.name = "ThrottleBusyError";
+	}
+}, v = class {
 	constructor(e = .15) {
-		this.windowStart = performance.now(), this.windowBusyMs = 0, this.lastLoad = 0, this.maxLoad = Math.max(.05, Math.min(.3, e));
+		this.windowStart = performance.now(), this.windowBusyMs = 0, this.lastLoad = 0, this.dutyStartedAt = null, this.maxLoad = Math.max(.05, Math.min(.3, e));
 	}
 	markTaskComplete(e) {
-		let t = performance.now();
-		t - this.windowStart > a && (this.windowStart = t, this.windowBusyMs = 0), this.windowBusyMs += Math.max(0, e), this.lastLoad = this.estimate();
+		this.estimate(this.windowBusyMs + Math.max(0, e)), this.resetDutyCycle();
+	}
+	beginWork() {
+		this.dutyStartedAt = performance.now();
+	}
+	resetDutyCycle() {
+		this.dutyStartedAt = null;
+	}
+	rollWindow(e) {
+		e - this.windowStart > 3e4 && (this.windowStart = e, this.windowBusyMs = 0, this.resetDutyCycle());
 	}
-	estimate() {
-		let e = performance.now() - this.windowStart;
-		return e <= 0 ? 0 : Math.min(1, Math.max(0, this.windowBusyMs / e));
+	estimate(e) {
+		let t = performance.now();
+		this.rollWindow(t), this.windowBusyMs = e;
+		let n = t - this.windowStart;
+		if (n <= 0) return 0;
+		let r = e / n;
+		return this.lastLoad = Math.min(1, Math.max(0, r)), this.lastLoad;
 	}
 	async shouldPause() {
-		return this.estimate() > this.maxLoad;
+		return this.rollWindow(performance.now()), this.estimate(this.windowBusyMs) > this.maxLoad;
 	}
-	async waitForSlot(e = o) {
+	async waitForSlot(e = g) {
+		if (!Number.isFinite(e) || e < 0) throw Error(`waitForSlot: maxWaitMs must be a non-negative number, got ${String(e)}`);
 		let t = performance.now();
-		for (; await this.shouldPause() && !(performance.now() - t > e);) await i(500);
+		for (; await this.shouldPause();) {
+			let n = performance.now() - t;
+			if (n >= e) throw new _(this.lastLoad, this.maxLoad, n);
+			await h(Math.min(ee, Math.max(1, e - n)));
+		}
+	}
+	async yieldIfOverloaded() {
+		let e = performance.now();
+		this.rollWindow(e), this.dutyStartedAt === null && (this.dutyStartedAt = e);
+		let t = Math.max(0, e - this.dutyStartedAt);
+		if (t < 200) return 0;
+		let n = Math.ceil(t * (1 / this.maxLoad - 1));
+		return this.dutyStartedAt = null, n > 0 && await h(n), this.estimate(this.windowBusyMs), n;
 	}
 	get lastMeasuredLoad() {
 		return this.lastLoad;
@@ -38,80 +57,637 @@ var a = 3e4, o = 3e4, s = class {
 	get maxLoadValue() {
 		return this.maxLoad;
 	}
-}, c = null, l = 6e4, u = t(), d = u >= n;
-console.log(`[flaxia-node:worker] startup memory probe wasmMemoryBytes=${u} capable=${d}`);
-function f() {
-	return e();
+}, y = 4096;
+function b(e) {
+	let t = e.maxSeq;
+	return typeof t == "number" && Number.isInteger(t) && t > 0 ? t : y;
+}
+function x(e, t, n) {
+	let { pos: r, tokens: i } = e.header, a = b(t);
+	if (!Number.isInteger(i) || i < 1) return {
+		kind: "corrupt",
+		reason: `carried ${i} token columns`
+	};
+	if (!Number.isInteger(r) || r < 0 || r + i > a) return {
+		kind: "corrupt",
+		reason: `position ${r}+${i} is outside the ${a}-token context`
+	};
+	let o;
+	try {
+		o = n.unpackHidden(e.payload);
+	} catch (e) {
+		return {
+			kind: "corrupt",
+			reason: e instanceof Error ? e.message : String(e)
+		};
+	}
+	let s = t.dim * i;
+	if (o.length !== s) return {
+		kind: "corrupt",
+		reason: `carried ${o.length} values, expected ${s}`
+	};
+	for (let e = 0; e < o.length; e++) if (!Number.isFinite(o[e])) return {
+		kind: "corrupt",
+		reason: `carried a non-finite value at index ${e}`
+	};
+	return {
+		kind: "ok",
+		hidden: o
+	};
+}
+function te(e, t, n, r) {
+	let i = s(e);
+	return i ? i.header.pos !== t || i.header.requestId !== t ? { kind: "stale" } : x(i, n, r) : {
+		kind: "corrupt",
+		reason: "malformed frame header"
+	};
+}
+async function ne(t) {
+	let { engine: n, link: i, semantics: o, promptTokens: s, chainLength: c, maxNewTokens: l } = t;
+	if (s.length === 0) throw Error("swarm host requires at least one prompt token");
+	n.reset();
+	let u = null;
+	i.onFrame((t) => {
+		if (e(t)) return;
+		let r = u;
+		if (!r) return;
+		let i = te(t, r.pos, n, o);
+		if (i.kind !== "stale") {
+			if (u = null, i.kind === "corrupt") {
+				r.reject(/* @__PURE__ */ Error(`swarm hop failed: ${i.reason}`));
+				return;
+			}
+			r.resolve(i.hidden);
+		}
+	});
+	let d = (e, t) => c <= 1 ? Promise.resolve(e) : new Promise((n, a) => {
+		u = {
+			pos: t,
+			resolve: n,
+			reject: a
+		}, i.send(r({
+			requestId: t,
+			pos: t,
+			tokens: 1
+		}, o.packHidden(e)));
+	}), f = async (e, t) => d(await n.embedRun(e, t), t), p = null;
+	for (let e = 0; e < s.length; e++) {
+		let t = await f(s[e], e);
+		e === s.length - 1 && (p = await n.headFromHidden(t));
+	}
+	if (!p) throw Error("swarm host produced no logits for the prompt");
+	let m = [], h = s.length, g = o.argmax(p);
+	for (; m.length < l && !(t.eosIds?.has(g) || (m.push(g), await t.onToken?.(g), m.length >= l));) {
+		let e = await f(g, h++);
+		p = await n.headFromHidden(e), g = o.argmax(p);
+	}
+	return c > 1 && i.send(a()), { tokens: m };
+}
+function re(t) {
+	let { engine: n, link: i, semantics: a } = t;
+	return n.reset(), new Promise((t, o) => {
+		let c = Promise.resolve(), l = !1;
+		i.onFrame((u) => {
+			if (!l) {
+				if (e(u)) {
+					l = !0, i.send(u), c = c.then(() => t());
+					return;
+				}
+				c = c.then(async () => {
+					if (l) return;
+					let e = s(u);
+					if (!e) throw Error("swarm frame has a malformed frame header");
+					let t = x(e, n, a);
+					if (t.kind === "corrupt") throw Error(`swarm frame is unusable: ${t.reason}`);
+					let o = await n.runHidden(t.hidden, e.header.pos);
+					i.send(r({
+						requestId: e.header.requestId,
+						pos: e.header.pos,
+						tokens: e.header.tokens
+					}, a.packHidden(o)));
+				}).catch((e) => {
+					l = !0, o(e instanceof Error ? e : Error(String(e)));
+				});
+			}
+		});
+	});
+}
+//#endregion
+//#region src/swarm/controller.ts
+var S = class {
+	constructor(e) {
+		this.options = e, this.frameHandler = null, this.engine = null, this.semantics = null, this.sessionId = "", this.model = "", this.chainLength = 1, this.chain = [], this.slice = null, this.hostWarm = void 0, this.prompt = "", this.maxNewTokens = 128, this.sliceLoaded = !1, this.generationStarted = !1, this.settled = !1;
+	}
+	async start() {
+		if (this.settled) return;
+		let e = this.options.initial;
+		try {
+			if (e.type === "swarm-init") {
+				if (this.sessionId = e.sessionId, this.model = e.model, !Array.isArray(e.members) || e.members.length < 1 || e.members.length > 16) throw Error(`swarm-init has an invalid member count: ${JSON.stringify(e.members?.length)}`);
+				this.chainLength = e.members.length, this.prompt = e.prompt, e.maxNewTokens !== void 0 && (this.maxNewTokens = e.maxNewTokens);
+				let t = await this.options.runtime.plan(e.members, e.model);
+				this.chain = t, this.options.sendControl({
+					type: "swarm-plan",
+					sessionId: e.sessionId,
+					chain: t
+				});
+				return;
+			}
+			await this.loadSlice(e);
+		} catch (e) {
+			this.fail(e);
+		}
+	}
+	async handleControl(e) {
+		if (!this.settled && e.sessionId === this.sessionId) try {
+			e.type === "swarm-slice" ? await this.loadSlice(e) : e.type === "swarm-start" ? await this.startHost() : e.type === "swarm-error" && this.fail(Error(e.error || "swarm session aborted by the coordinator"));
+		} catch (e) {
+			this.fail(e);
+		}
+	}
+	handleFrame(e) {
+		this.settled || this.frameHandler?.(e);
+	}
+	abort(e) {
+		this.fail(Error(e));
+	}
+	link() {
+		return {
+			send: (e) => this.options.sendFrame(e),
+			onFrame: (e) => {
+				this.frameHandler = e;
+			}
+		};
+	}
+	validateSlice(e) {
+		if (!Number.isInteger(e.chainLength) || e.chainLength < 1 || e.chainLength > 16) throw Error(`swarm slice has an invalid chain length: ${JSON.stringify(e.chainLength)}`);
+		if (!Number.isInteger(e.index) || e.index < 0 || e.index >= e.chainLength) throw Error(`swarm slice has an invalid index: ${JSON.stringify(e.index)}`);
+		if (e.role !== (e.index === 0 ? "host" : "worker")) throw Error(`swarm slice role ${e.role} does not match index ${e.index}`);
+		if (!l(e.slice)) throw Error(`swarm slice is out of bounds: ${JSON.stringify(e.slice)}`);
+		let t = e.index === 0;
+		if (e.slice.hasEmbed !== t || e.slice.hasHead !== t) throw Error("swarm slice embed/head ownership does not match the host position");
+	}
+	async loadSlice(e) {
+		if (this.settled || this.sliceLoaded) return;
+		this.validateSlice(e), this.sessionId = e.sessionId, this.model = e.model, this.chainLength = e.chainLength, this.slice = e.slice;
+		let { engine: t, semantics: n, warm: r } = await this.options.runtime.load(e.slice, e.model);
+		if (this.settled) {
+			t.dispose();
+			return;
+		}
+		this.engine = t, this.semantics = n, this.hostWarm = r, this.sliceLoaded = !0, this.options.sendControl({
+			type: "swarm-ready",
+			sessionId: e.sessionId
+		}), e.role === "worker" && (this.generationStarted = !0, re({
+			engine: t,
+			link: this.link(),
+			semantics: n
+		}).then(() => this.finish(C())).catch((e) => this.fail(e)));
+	}
+	async startHost() {
+		if (this.generationStarted) return;
+		let e = this.engine, t = this.semantics;
+		if (!e || !t) throw Error("swarm host received start before loading its slice");
+		if (!t.encodePrompt || !t.decodeTokens) throw Error("host semantics must provide encodePrompt and decodeTokens");
+		let n = this.maxNewTokens;
+		if (!Number.isInteger(n) || n < 1) throw Error(`swarm maxNewTokens must be a positive integer, got ${JSON.stringify(n)}`);
+		let r = t.encodePrompt(this.prompt), i = e.maxSeq ?? 4096;
+		if (r.length + n > i) throw Error(`swarm request needs ${r.length + n} tokens but the model context holds ${i}`);
+		this.generationStarted = !0;
+		let a = performance.now(), { tokens: o } = await ne({
+			chainLength: this.chainLength,
+			promptTokens: r,
+			maxNewTokens: n,
+			engine: e,
+			link: this.link(),
+			semantics: t,
+			eosIds: t.eosIds,
+			onToken: (e) => this.options.emitToken(t.decodeTokens([e]))
+		}), s = t.decodeTokens;
+		this.finish({
+			output: s(o),
+			tokens: o.map((e) => s([e])),
+			nodes: this.nodeInfos(),
+			durationMs: Math.round(performance.now() - a)
+		});
+	}
+	nodeInfos() {
+		return (this.chain.length > 0 ? this.chain.map((e) => ({
+			slice: e.slice,
+			host: e.role === "host"
+		})) : this.slice ? [{
+			slice: this.slice,
+			host: !0
+		}] : []).map((e) => {
+			let t = {
+				layers: [e.slice.start, e.slice.end],
+				host: e.host
+			};
+			return e.host && this.hostWarm !== void 0 && (t.warm = this.hostWarm), t;
+		});
+	}
+	teardown() {
+		this.frameHandler = null;
+		let e = this.engine;
+		if (this.engine = null, this.semantics = null, e) try {
+			e.dispose();
+		} catch {}
+	}
+	finish(e) {
+		this.settled || (this.settled = !0, this.teardown(), this.options.onDone(e));
+	}
+	fail(e) {
+		this.settled || (this.settled = !0, this.teardown(), this.options.onError(e instanceof Error ? e.message : String(e)));
+	}
+};
+function C() {
+	return {
+		output: "",
+		tokens: [],
+		nodes: [],
+		durationMs: 0
+	};
+}
+//#endregion
+//#region src/swarm/adapter.ts
+var w = class extends Error {
+	constructor(e) {
+		super(e), this.name = "SwarmEngineUnavailableError";
+	}
+};
+async function T(e, t) {
+	if (!(await f()).webgpu) throw new w("WebGPU is not available in this context");
+	let n = t ?? ((e) => import(
+		/* @vite-ignore */
+		e
+)), r;
+	try {
+		r = await n(e);
+	} catch (e) {
+		throw new w(`failed to load swarm engine module: ${e instanceof Error ? e.message : String(e)}`);
+	}
+	let i = r?.Qwen35Engine;
+	if (!i || typeof i.create != "function") throw new w(`module at ${e} does not export Qwen35Engine.create`);
+	return r;
+}
+function E(e, t) {
+	let n = !1;
+	return {
+		get dim() {
+			return e.dims.dim;
+		},
+		get nc() {
+			return e.NC;
+		},
+		get maxSeq() {
+			return e.maxSeq;
+		},
+		reset: () => e.reset(),
+		embedRun: (t, n) => e.embedRun(t, n),
+		runHidden: (t, n) => e.runHidden(t, n),
+		headFromHidden: (t) => e.headFromHidden(t),
+		setHidden: (t) => e.setHidden(t),
+		dispose: () => {
+			if (!n) {
+				n = !0;
+				try {
+					e.dispose?.();
+				} catch {}
+				try {
+					t?.destroy?.();
+				} catch {}
+			}
+		}
+	};
+}
+//#endregion
+//#region src/swarm/runtime.ts
+var D = {
+	"qwen3.5-2b": "https://huggingface.co/unsloth/Qwen3.5-2B-GGUF/resolve/main/Qwen3.5-2B-Q4_0.gguf",
+	"qwen3.8-27b": "https://huggingface.co/unsloth/Qwen3.8-27B-GGUF/resolve/main/Qwen3.8-27B-Q4_0.gguf",
+	"qwen3.6-35b-moe": "https://huggingface.co/bartowski/Qwen_Qwen3.6-35B-A3B-GGUF/resolve/main/Qwen_Qwen3.6-35B-A3B-Q4_0.gguf"
+}, ie = "flaxia-swarm-weights-v1", ae = 12 * 1024 * 1024, O = 256 * 1024 * 1024;
+function oe(e) {
+	let t = D[e];
+	if (t) return t;
+	throw new w(`unknown swarm model: ${e}`);
+}
+var k = null, A = 0, j = 0;
+async function M() {
+	if (k !== null) return k;
+	try {
+		k = typeof caches < "u" ? await caches.open(ie) : !1;
+	} catch {
+		k = !1;
+	}
+	return k;
+}
+function N(e, t, n) {
+	return `https://flaxia-weights.local/${encodeURIComponent(e)}/${t}-${n}`;
+}
+async function P(e, t, n) {
+	let r = await F(e, t, n), i = new Uint8Array(await r.arrayBuffer()), a = n - t + 1;
+	if (i.byteLength !== a) throw Error(`short range ${i.byteLength}/${a}`);
+	return i;
+}
+async function F(e, t, n) {
+	let r = n - t + 1, i = await M(), a = N(e, t, n);
+	if (i) try {
+		let e = await i.match(a);
+		if (e) {
+			let t = new Uint8Array(await e.arrayBuffer());
+			if (t.byteLength === r) return A++, new Response(t, { status: 200 });
+			await i.delete(a).catch(() => {});
+		}
+	} catch {}
+	let o;
+	for (let s = 0; s < 4; s++) {
+		try {
+			let s = await fetch(e, { headers: { Range: `bytes=${t}-${n}` } });
+			if (s.status !== 206) o = /* @__PURE__ */ Error(`model host refused range requests (${s.status})`);
+			else return j++, i && s.clone().arrayBuffer().then((e) => {
+				if (e.byteLength === r) return i.put(a, new Response(e, {
+					status: 200,
+					headers: { "content-type": "application/octet-stream" }
+				}));
+			}).catch(() => {}), s;
+		} catch (e) {
+			o = e;
+		}
+		await new Promise((e) => setTimeout(e, 150 * (s + 1)));
+	}
+	throw Error(`range fetch ${t}-${n} failed: ${o instanceof Error ? o.message : String(o)}`);
+}
+async function I(e, t) {
+	let n = ae;
+	for (;;) {
+		let r = await P(t, 0, n - 1), i = r.buffer.slice(r.byteOffset, r.byteOffset + r.byteLength);
+		try {
+			return e.parseGGUFHeader(i);
+		} catch (e) {
+			if (n >= O) throw e;
+			n = Math.min(n * 2, O);
+		}
+	}
+}
+async function L() {
+	let e = navigator.gpu;
+	if (!e) throw new w("WebGPU is not available in this context");
+	let t = await e.requestAdapter({ powerPreference: "high-performance" });
+	if (!t) throw new w("no WebGPU adapter");
+	return t.requestDevice({ requiredLimits: {
+		maxBufferSize: t.limits.maxBufferSize,
+		maxStorageBufferBindingSize: t.limits.maxStorageBufferBindingSize
+	} });
+}
+function R(e, t) {
+	let n = t.vocab, r = n["<|im_start|>"], i = n["<|im_end|>"], a = n["<think>"], o = n["</think>"], s = (e) => [
+		r,
+		...t.encode("user\n" + e),
+		i,
+		...t.encode("\n"),
+		r,
+		...t.encode("assistant\n"),
+		a,
+		...t.encode("\n\n"),
+		o,
+		...t.encode("\n\n")
+	].filter((e) => typeof e == "number" && e >= 0), c = [i, n["<|endoftext|>"]].filter((e) => typeof e == "number");
+	return {
+		packHidden: (t) => {
+			let n = new Uint16Array(t.length);
+			for (let r = 0; r < t.length; r++) n[r] = e.f32ToF16(t[r]);
+			return new Uint8Array(n.buffer);
+		},
+		unpackHidden: (t) => {
+			let n = t.slice(), r = new Uint16Array(n.buffer), i = new Float32Array(r.length);
+			for (let t = 0; t < r.length; t++) i[t] = e.f16ToF32(r[t]);
+			return i;
+		},
+		argmax: (t) => e.argmax(t),
+		encodePrompt: (e) => s(Array.isArray(e) ? e.join("\n") : e),
+		decodeTokens: (e) => t.decode(e),
+		eosIds: new Set(c)
+	};
+}
+function z() {
+	let e = null, t = null, n = () => {
+		if (!e) {
+			let t = new URL("./swarm-engine.js", "" + import.meta.url).href;
+			e = T(t).then((e) => e);
+		}
+		return e;
+	}, r = async (e) => {
+		let r = await n(), i = oe(e);
+		(!t || t.url !== i) && (t = {
+			url: i,
+			gguf: await I(r, i)
+		});
+		let a = Number(t.gguf.meta["qwen35.block_count"]) - Number(t.gguf.meta["qwen35.nextn_predict_layers"] || 0);
+		if (!Number.isInteger(a) || a < 1) throw new w(`model ${e} has no qwen35 trunk layers`);
+		return {
+			mod: r,
+			url: i,
+			gguf: t.gguf,
+			layers: a
+		};
+	};
+	return {
+		async plan(e, t) {
+			let { layers: n } = await r(t);
+			return d({
+				sessionId: "",
+				taskId: "",
+				model: t,
+				layers: n,
+				nodes: e.map((e) => ({
+					nodeId: e.nodeId,
+					capacity: e.capacity
+				}))
+			}).chain;
+		},
+		async load(e, t) {
+			A = 0, j = 0;
+			let { mod: n, url: i, gguf: a } = await r(t), o = await L(), s = n.makeTokenizer(n.tokenizerFromGGUF(a.meta)), c = (e) => P(i, e.byteOffset, e.byteOffset + e.byteLength - 1);
+			a.streamEntry = (e) => n.streamEntryToGPU(o, e, (e) => F(i, e.byteOffset, e.byteOffset + e.byteLength - 1), { staging: 4 * 1024 * 1024 });
+			let l = await n.qwen35Weights(a, c, {
+				lo: e.start,
+				hi: e.end,
+				hasEmbed: e.hasEmbed,
+				hasHead: e.hasHead,
+				mtp: e.hasHead
+			}, void 0, (e, t) => n.gpuUploadEntry(o, e, t === n.GGML_EMBED)), u = a.tensors[n.GGML_EMBED]?.shape[0] ?? 0, d = await n.Qwen35Engine.create({
+				device: o,
+				meta: a.meta,
+				layerRange: [e.start, e.end],
+				hasEmbed: e.hasEmbed,
+				hasHead: e.hasHead,
+				vocab: u,
+				maxSeq: Math.min(y, Number(a.meta["qwen35.context_length"]) || 4096),
+				batchCols: 4,
+				weights: l
+			}), f = A > 0 && j === 0;
+			return {
+				engine: E(d, o),
+				semantics: R(n, s),
+				warm: f
+			};
+		}
+	};
+}
+//#endregion
+//#region src/swarm/messages.ts
+function B(e) {
+	return o(e) || c(e) || i(e) || t(e);
 }
-var p = /* @__PURE__ */ new Map(), m = null;
-function h() {
-	for (let e of p.values()) try {
+function V(e) {
+	if (!e || typeof e != "object") return !1;
+	let t = e;
+	return t.type === "swarm-control" && typeof t.id == "string" && B(t.message);
+}
+//#endregion
+//#region src/worker/main.worker.ts
+var H = null, U = g, W = 1, G = 15e3, K = /* @__PURE__ */ new Map(), q = null, J = null, Y = null, se = 6e4;
+async function ce() {
+	for (let e = 0;; e++) try {
+		await H.waitForSlot(U);
+		return;
+	} catch (t) {
+		if (!(t instanceof _)) throw t;
+		if (e >= W) throw Error(`device CPU busy: ${t.message}; task not started, retry on an idle node (retryable)`);
+		console.warn(`[flaxia-node:worker] ${t.message}; cooling down ${G}ms before retrying`), await new Promise((e) => setTimeout(e, G));
+	}
+}
+function le(e) {
+	let t = (t) => {
+		let n = K.get(e);
+		if (n !== void 0) throw Error(n);
+		self.postMessage({
+			id: e,
+			type: "token",
+			token: t
+		});
+	};
+	return async (e) => {
+		t(e), await H?.yieldIfOverloaded();
+	};
+}
+var X = p(), Z = X >= m;
+console.log(`[flaxia-node:worker] startup memory probe wasmMemoryBytes=${X} capable=${Z}`);
+function ue() {
+	return n();
+}
+var Q = /* @__PURE__ */ new Map(), $ = null;
+function de() {
+	for (let e of Q.values()) try {
 		e();
 	} catch {}
-	p.clear();
+	Q.clear();
 }
-function g() {
-	m && clearTimeout(m), m = setTimeout(() => {
-		m = null, h();
-	}, l);
+function fe() {
+	$ && clearTimeout($), $ = setTimeout(() => {
+		$ = null, de();
+	}, se);
 }
-async function _(e, t, n) {
+async function pe(e, t, n, r) {
 	switch (e) {
 		case "ai-inference":
-			let r = await import("./assets/ai-inference.js");
-			return p.set(e, r.releaseCache), await r.handleAiInference(t, n);
+			let i = await import("./assets/ai-inference.js");
+			return Q.set(e, i.releaseCache), await i.handleAiInference(t, n);
 		case "image-process": return await (await import("./assets/image-process.js")).handleImageProcess(t);
-		case "container": return await (await import("./assets/container.js")).handleContainer(t);
+		case "container": return await (await import("./assets/container.js")).handleContainer(t, r?.fileSourceOrigins ?? [], r?.containerImageOrigins ?? []);
 		case "vector-embed":
-			let i = await import("./assets/vector-embed.js");
-			return p.set(e, i.releaseCache), await i.handleVectorEmbed(t);
+			let a = await import("./assets/vector-embed.js");
+			return Q.set(e, a.releaseCache), await a.handleVectorEmbed(t);
 		case "vector-store":
-			let a = await import("./assets/vector-store.js");
-			return p.set(e, a.releaseCache), await a.handleVectorStore(t);
+			let o = await import("./assets/vector-store.js");
+			return Q.set(e, o.releaseCache), await o.handleVectorStore(t);
 		case "vector-query":
-			let o = await import("./assets/vector-query.js");
-			return p.set(e, o.releaseCache), await o.handleVectorQuery(t);
+			let s = await import("./assets/vector-query.js");
+			return Q.set(e, s.releaseCache), await s.handleVectorQuery(t);
 		case "nudenet":
-			let s = await import("./assets/nudenet.js");
-			return p.set(e, s.releaseCache), await s.handleNudeNet(t);
+			let c = await import("./assets/nudenet.js");
+			return Q.set(e, c.releaseCache), await c.handleNudeNet(t);
 		default: throw Error(`Unknown workload type: ${e}`);
 	}
 }
+function me(e, t, n) {
+	return new Promise((r, i) => {
+		let a = new S({
+			initial: t,
+			runtime: z(),
+			sendControl: (t) => self.postMessage({
+				id: e,
+				type: "swarm-message",
+				message: t
+			}),
+			sendFrame: (t) => self.postMessage({
+				id: e,
+				type: "swarm-frame",
+				frame: t
+			}, [t]),
+			emitToken: n,
+			onDone: (e) => {
+				q === a && (q = null, J = null), r(e);
+			},
+			onError: (e) => {
+				q === a && (q = null, J = null), i(Error(e));
+			}
+		});
+		q = a, J = e, a.start();
+	});
+}
 self.onmessage = async (e) => {
-	let { id: t, workload: i, payload: a, config: o } = e.data, l = performance.now();
+	let t = e.data;
+	if (t?.type === "swarm-control") {
+		if (!V(t)) {
+			console.warn("[flaxia-node:worker] dropped malformed swarm-control message");
+			return;
+		}
+		q && q.handleControl(t.message);
+		return;
+	}
+	if (t?.type === "swarm-frame") {
+		t.frame instanceof ArrayBuffer ? q?.handleFrame(t.frame) : console.warn("[flaxia-node:worker] dropped malformed swarm-frame message");
+		return;
+	}
+	if (t?.type === "abort") {
+		let e = t.id, n = typeof t.reason == "string" && t.reason ? t.reason : "aborted by the coordinator";
+		q && J === e ? q.abort(n) : Y === e && K.set(e, n);
+		return;
+	}
+	let { id: n, workload: r, payload: i, config: a } = t, o = performance.now();
+	Y = n;
 	try {
-		if (c ||= new s(o?.maxCpuLoad), console.log(`[flaxia-node:worker] task start id=${t} workload=${i}`), !d) throw Error(`node incapable: insufficient WASM memory (${u} bytes < ${n}); rejecting all tasks`);
-		if (r.has(i) && !f()) throw Error(`${i}: insufficient WASM memory (${u} bytes < ${n})`);
-		await c.waitForSlot();
+		if (H ||= new v(a?.maxCpuLoad), console.log(`[flaxia-node:worker] task start id=${n} workload=${r}`), !Z) throw Error(`node incapable: insufficient WASM memory (${X} bytes < ${m}); rejecting all tasks`);
+		if (u.has(r) && !ue()) throw Error(`${r}: insufficient WASM memory (${X} bytes < ${m})`);
+		await ce(), H.beginWork();
 		let e = setInterval(() => {
 			self.postMessage({
-				id: t,
+				id: n,
 				type: "heartbeat",
-				cpuLoad: c?.lastMeasuredLoad ?? 0
+				cpuLoad: H?.lastMeasuredLoad ?? 0
 			});
-		}, 1e4), p = performance.now();
+		}, 1e4), t = performance.now();
 		try {
-			let e = await _(i, a, (e) => {
-				self.postMessage({
-					id: t,
-					type: "token",
-					token: e
-				});
+			let e = le(n), t = Array.isArray(a?.fileSourceOrigins) ? a.fileSourceOrigins.filter((e) => typeof e == "string") : [], s = Array.isArray(a?.containerImageOrigins) ? a.containerImageOrigins.filter((e) => typeof e == "string") : [], c = r === "swarm-inference" ? await me(n, i, e) : await pe(r, i, e, {
+				fileSourceOrigins: t,
+				containerImageOrigins: s
 			});
 			self.postMessage({
-				id: t,
+				id: n,
 				type: "done",
-				result: e
-			}), console.log(`[flaxia-node:worker] task done id=${t} workload=${i} durationMs=${Math.round(performance.now() - l)}`);
+				result: c
+			}), console.log(`[flaxia-node:worker] task done id=${n} workload=${r} durationMs=${Math.round(performance.now() - o)}`);
 		} finally {
-			clearInterval(e), c.markTaskComplete(performance.now() - p), g();
+			Y = null, K.delete(n), clearInterval(e), H.markTaskComplete(performance.now() - t), fe();
 		}
 	} catch (e) {
-		let n = e instanceof Error ? e.message : String(e);
-		console.error(`[flaxia-node:worker] task error id=${t} workload=${i} error=${n}`), self.postMessage({
-			id: t,
+		let t = e instanceof Error ? e.message : String(e);
+		console.error(`[flaxia-node:worker] task error id=${n} workload=${r} error=${t}`), Y === n && (Y = null), self.postMessage({
+			id: n,
 			type: "error",
-			error: n
+			error: t
 		});
 	}
 };