@flaxia/node 0.3.7 → 0.5.1

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 { M as e, N as t, O as n, a as r, c as i, f as a, h as o, j as s, k as c, l, m as u, o as d, r as f, t as p, u as m, v as h, x as g, y as _ } from "./assets/webgpuProbe.js";
 //#region src/executor/throttle.ts
-function i(e) {
+function v(e) {
 	return new Promise((t) => setTimeout(t, e));
 }
-var a = 3e4, o = 3e4, s = class {
+var y = 3e4, ee = 500, b = 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";
+	}
+}, te = 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();
 	}
-	estimate() {
-		let e = performance.now() - this.windowStart;
-		return e <= 0 ? 0 : Math.min(1, Math.max(0, this.windowBusyMs / e));
+	resetDutyCycle() {
+		this.dutyStartedAt = null;
+	}
+	rollWindow(e) {
+		e - this.windowStart > 3e4 && (this.windowStart = e, this.windowBusyMs = 0, this.resetDutyCycle());
+	}
+	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 = y) {
+		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 b(this.lastLoad, this.maxLoad, n);
+			await v(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 v(n), this.estimate(this.windowBusyMs), n;
 	}
 	get lastMeasuredLoad() {
 		return this.lastLoad;
@@ -38,80 +57,760 @@ 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();
+}, x = 4096;
+function ne(e) {
+	let t = e.maxSeq;
+	return typeof t == "number" && Number.isInteger(t) && t > 0 ? t : x;
+}
+function S(e, t, n) {
+	let { pos: r, tokens: i } = e.header, a = ne(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 re(e, t, n, r) {
+	let i = _(e);
+	return i ? i.header.pos !== t || i.header.requestId !== t ? { kind: "stale" } : S(i, n, r) : {
+		kind: "corrupt",
+		reason: "malformed frame header"
+	};
+}
+async function ie(n) {
+	let { engine: r, link: i, semantics: a, promptTokens: o, chainLength: s, maxNewTokens: c } = n;
+	if (o.length === 0) throw Error("swarm host requires at least one prompt token");
+	r.reset();
+	let l = null;
+	i.onFrame((e) => {
+		if (t(e)) return;
+		let n = l;
+		if (!n) return;
+		let i = re(e, n.pos, r, a);
+		if (i.kind !== "stale") {
+			if (l = null, i.kind === "corrupt") {
+				n.reject(/* @__PURE__ */ Error(`swarm hop failed: ${i.reason}`));
+				return;
+			}
+			n.resolve(i.hidden);
+		}
+	});
+	let u = (e, t) => s <= 1 ? Promise.resolve(e) : new Promise((n, r) => {
+		l = {
+			pos: t,
+			resolve: n,
+			reject: r
+		}, i.send(h({
+			requestId: t,
+			pos: t,
+			tokens: 1
+		}, a.packHidden(e)));
+	}), d = async (e, t) => u(await r.embedRun(e, t), t), f = null;
+	for (let e = 0; e < o.length; e++) {
+		let t = await d(o[e], e);
+		e === o.length - 1 && (f = await r.headFromHidden(t));
+	}
+	if (!f) throw Error("swarm host produced no logits for the prompt");
+	let p = [], m = o.length, g = a.argmax(f);
+	for (; p.length < c && !(n.eosIds?.has(g) || (p.push(g), await n.onToken?.(g), p.length >= c));) {
+		let e = await d(g, m++);
+		f = await r.headFromHidden(e), g = a.argmax(f);
+	}
+	return s > 1 && i.send(e()), { tokens: p };
+}
+function ae(e) {
+	let { engine: n, link: r, semantics: i } = e;
+	return n.reset(), new Promise((e, a) => {
+		let o = Promise.resolve(), s = !1;
+		r.onFrame((c) => {
+			if (!s) {
+				if (t(c)) {
+					s = !0, r.send(c), o = o.then(() => e());
+					return;
+				}
+				o = o.then(async () => {
+					if (s) return;
+					let e = _(c);
+					if (!e) throw Error("swarm frame has a malformed frame header");
+					let t = S(e, n, i);
+					if (t.kind === "corrupt") throw Error(`swarm frame is unusable: ${t.reason}`);
+					let a = await n.runHidden(t.hidden, e.header.pos);
+					r.send(h({
+						requestId: e.header.requestId,
+						pos: e.header.pos,
+						tokens: e.header.tokens
+					}, i.packHidden(a)));
+				}).catch((e) => {
+					s = !0, a(e instanceof Error ? e : Error(String(e)));
+				});
+			}
+		});
+	});
+}
+//#endregion
+//#region src/swarm/controller.ts
+var oe = 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, this.flowPaused = !1, this.flowWaiters = /* @__PURE__ */ new Set();
+	}
+	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")) : e.type === "swarm-flow" && (this.flowPaused = e.paused, this.flowPaused || this.releaseFlowWaiters());
+		} 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 (!u(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, ae({
+			engine: t,
+			link: this.link(),
+			semantics: n
+		}).then(() => this.finish(se())).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 ie({
+			chainLength: this.chainLength,
+			promptTokens: r,
+			maxNewTokens: n,
+			engine: e,
+			link: this.link(),
+			semantics: t,
+			eosIds: t.eosIds,
+			onToken: async (e) => {
+				if (await this.waitForFlow(), this.settled) throw Error("swarm session stopped while generation was paused");
+				await 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.releaseFlowWaiters(), this.teardown(), this.options.onDone(e));
+	}
+	fail(e) {
+		this.settled || (this.settled = !0, this.releaseFlowWaiters(), this.teardown(), this.options.onError(e instanceof Error ? e.message : String(e)));
+	}
+	waitForFlow() {
+		return !this.flowPaused || this.settled ? Promise.resolve() : new Promise((e) => this.flowWaiters.add(e));
+	}
+	releaseFlowWaiters() {
+		for (let e of this.flowWaiters) e();
+		this.flowWaiters.clear();
+	}
+};
+function se() {
+	return {
+		output: "",
+		tokens: [],
+		nodes: [],
+		durationMs: 0
+	};
+}
+//#endregion
+//#region src/swarm/adapter.ts
+var C = class extends Error {
+	constructor(e) {
+		super(e), this.name = "SwarmEngineUnavailableError";
+	}
+};
+async function w(e, t) {
+	if (!(await p()).webgpu) throw new C("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 C(`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 C(`module at ${e} does not export Qwen35Engine.create`);
+	return r;
+}
+function ce(e, t, n, r) {
+	let i = !1, a = async (e) => {
+		r?.();
+		let t = await e();
+		return r?.(), t;
+	};
+	return {
+		get dim() {
+			return e.dims.dim;
+		},
+		get nc() {
+			return e.NC;
+		},
+		get maxSeq() {
+			return e.maxSeq;
+		},
+		reset: () => {
+			r?.(), e.reset();
+		},
+		embedRun: (t, n) => a(() => e.embedRun(t, n)),
+		runHidden: (t, n) => a(() => e.runHidden(t, n)),
+		headFromHidden: (t) => a(() => e.headFromHidden(t)),
+		setHidden: (t) => {
+			r?.(), e.setHidden(t);
+		},
+		dispose: () => {
+			if (!i) {
+				i = !0;
+				try {
+					e.dispose?.();
+				} catch {}
+				try {
+					t?.destroy?.();
+				} catch {}
+				try {
+					n?.();
+				} catch {}
+			}
+		}
+	};
+}
+//#endregion
+//#region src/swarm/runtime.ts
+var T = {
+	"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"
+}, le = "flaxia-swarm-weights-v1", ue = 12 * 1024 * 1024, E = 256 * 1024 * 1024, D = /* @__PURE__ */ new Map();
+function O(e, t) {
+	D.set(e, {
+		status: t,
+		failedExpiresAt: t.state === "failed" ? Date.now() + 3e4 : void 0
+	});
+}
+function k(e, t, n, r) {
+	let i = j(e);
+	return {
+		modelId: e,
+		revision: /\/resolve\/([^/]+)\//.exec(new URL(i).pathname)?.[1] ?? "unknown",
+		dtype: /-(q\d+_\d+)\.gguf/i.exec(i)?.[1] ?? "unknown",
+		backend: "webgpu",
+		layerRange: [t.start, t.end],
+		state: n,
+		referenceCount: r
+	};
+}
+function A(e = Date.now()) {
+	let t = [];
+	for (let [n, r] of D) {
+		if (r.failedExpiresAt !== void 0 && r.failedExpiresAt <= e) {
+			D.delete(n);
+			continue;
+		}
+		t.push(r.status);
+	}
+	return {
+		version: 1,
+		sampledAt: e,
+		expiresAt: e + s,
+		entries: t.slice(0, 8)
+	};
+}
+function j(e) {
+	let t = Object.prototype.hasOwnProperty.call(T, e) ? T[e] : void 0;
+	if (t) return t;
+	throw new C(`unknown swarm model: ${e}`);
+}
+var M = null, N = 0, P = 0;
+async function de() {
+	if (M !== null) return M;
+	try {
+		M = typeof caches < "u" ? await caches.open(le) : !1;
+	} catch {
+		M = !1;
+	}
+	return M;
+}
+function fe(e, t, n) {
+	return `https://flaxia-weights.local/${encodeURIComponent(e)}/${t}-${n}`;
+}
+async function F(e, t, n) {
+	let r = await I(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 I(e, t, n) {
+	let r = n - t + 1, i = await de(), a = fe(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 N++, 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 P++, 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 pe(e, t) {
+	let n = ue;
+	for (;;) {
+		let r = await F(t, 0, n - 1), i = r.buffer.slice(r.byteOffset, r.byteOffset + r.byteLength);
+		try {
+			return e.parseGGUFHeader(i);
+		} catch (e) {
+			if (n >= E) throw e;
+			n = Math.min(n * 2, E);
+		}
+	}
+}
+async function me() {
+	let e = navigator.gpu;
+	if (!e) throw new C("WebGPU is not available in this context");
+	let t = await e.requestAdapter({ powerPreference: "high-performance" });
+	if (!t) throw new C("no WebGPU adapter");
+	return t.requestDevice({ requiredLimits: {
+		maxBufferSize: t.limits.maxBufferSize,
+		maxStorageBufferBindingSize: t.limits.maxStorageBufferBindingSize
+	} });
+}
+function he(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 L(e) {
+	let t = null, n = null, r = () => {
+		if (!t) {
+			let n = new URL("./swarm-engine.js", "" + import.meta.url).href;
+			t = e ? e() : w(n).then((e) => e);
+		}
+		return t;
+	}, i = async (e) => {
+		let t = await r(), i = j(e);
+		(!n || n.url !== i) && (n = {
+			url: i,
+			gguf: await pe(t, i)
+		});
+		let a = Number(n.gguf.meta["qwen35.block_count"]) - Number(n.gguf.meta["qwen35.nextn_predict_layers"] || 0);
+		if (!Number.isInteger(a) || a < 1) throw new C(`model ${e} has no qwen35 trunk layers`);
+		return {
+			mod: t,
+			url: i,
+			gguf: n.gguf,
+			layers: a
+		};
+	};
+	return {
+		async plan(e, t) {
+			let { layers: n } = await i(t);
+			return g({
+				sessionId: "",
+				taskId: "",
+				model: t,
+				layers: n,
+				nodes: e.map((e) => ({
+					nodeId: e.nodeId,
+					capacity: e.capacity
+				}))
+			}).chain;
+		},
+		async load(e, t) {
+			N = 0, P = 0;
+			let n = JSON.stringify([
+				t,
+				e.start,
+				e.end
+			]);
+			O(n, k(t, e, "loading", 1));
+			let r, a = !1;
+			try {
+				let { mod: o, url: s, gguf: c } = await i(t);
+				r = await me();
+				let l = null, u = r;
+				u.addEventListener?.("uncapturederror", () => {
+					l = "swarm GPU validation failed";
+				}), u.lost?.then(() => {
+					l = "swarm GPU device lost";
+				});
+				let d = () => {
+					if (l) throw new C(l);
+				}, f = he(o, o.makeTokenizer(o.tokenizerFromGGUF(c.meta))), p = (e) => F(s, e.byteOffset, e.byteOffset + e.byteLength - 1);
+				c.streamEntry = (e) => o.streamEntryToGPU(r, e, (e) => I(s, e.byteOffset, e.byteOffset + e.byteLength - 1), { staging: 4 * 1024 * 1024 });
+				let m = await o.qwen35Weights(c, p, {
+					lo: e.start,
+					hi: e.end,
+					hasEmbed: e.hasEmbed,
+					hasHead: e.hasHead,
+					mtp: e.hasHead
+				}, void 0, (e, t) => o.gpuUploadEntry(r, e, t === o.GGML_EMBED)), h = c.tensors[o.GGML_EMBED]?.shape[0] ?? 0, g = await o.Qwen35Engine.create({
+					device: r,
+					meta: c.meta,
+					layerRange: [e.start, e.end],
+					hasEmbed: e.hasEmbed,
+					hasHead: e.hasHead,
+					vocab: h,
+					maxSeq: Math.min(x, Number(c.meta["qwen35.context_length"]) || 4096),
+					batchCols: 4,
+					weights: m
+				});
+				d();
+				let _ = ce(g, r, () => {
+					O(n, k(t, e, "evicting", 0)), queueMicrotask(() => D.delete(n));
+				}, d);
+				return a = !0, O(n, k(t, e, "ready", 1)), {
+					engine: _,
+					semantics: f,
+					warm: N > 0 && P === 0
+				};
+			} catch (i) {
+				if (O(n, k(t, e, "failed", 0)), !a) try {
+					r?.destroy?.();
+				} catch {}
+				throw i;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/swarm/messages.ts
+function ge(e) {
+	return a(e) || m(e) || o(e) || c(e) || i(e) || n(e);
+}
+function _e(e) {
+	if (!e || typeof e != "object") return !1;
+	let t = e;
+	return t.type === "swarm-control" && typeof t.id == "string" && ge(t.message);
+}
+//#endregion
+//#region src/worker/main.worker.ts
+var R = null, ve = y, ye = 1, z = 15e3, B = /* @__PURE__ */ new Map(), V = /* @__PURE__ */ new Set(), H = /* @__PURE__ */ new Map();
+function U(e) {
+	V.delete(e);
+	let t = H.get(e);
+	if (t) {
+		H.delete(e);
+		for (let e of t) e();
+	}
+}
+function be(e) {
+	return V.has(e) ? new Promise((t) => {
+		let n = H.get(e) ?? /* @__PURE__ */ new Set();
+		n.add(t), H.set(e, n);
+	}) : Promise.resolve();
 }
-var p = /* @__PURE__ */ new Map(), m = null;
-function h() {
-	for (let e of p.values()) try {
+var W = null, G = null, K = null, xe = 6e4;
+async function Se() {
+	for (let e = 0;; e++) try {
+		await R.waitForSlot(ve);
+		return;
+	} catch (t) {
+		if (!(t instanceof b)) throw t;
+		if (e >= ye) 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 ${z}ms before retrying`), await new Promise((e) => setTimeout(e, z));
+	}
+}
+function Ce(e) {
+	let t = (t) => {
+		let n = B.get(e);
+		if (n !== void 0) throw Error(n);
+		self.postMessage({
+			id: e,
+			type: "token",
+			token: t
+		});
+	};
+	return async (n) => {
+		await be(e), t(n), await R?.yieldIfOverloaded();
+	};
+}
+var q = d(), J = q >= f;
+console.log(`[flaxia-node:worker] startup memory probe wasmMemoryBytes=${q} capable=${J}`);
+function Y() {
+	return r();
+}
+var X = /* @__PURE__ */ new Map(), Z = /* @__PURE__ */ new Map();
+Z.set("swarm-inference", A);
+var Q = null;
+function we() {
+	for (let e of X.values()) try {
 		e();
 	} catch {}
-	p.clear();
+	X.clear(), Z.clear(), Z.set("swarm-inference", A);
 }
-function g() {
-	m && clearTimeout(m), m = setTimeout(() => {
-		m = null, h();
-	}, l);
+function $() {
+	let e = Date.now(), t = [...Z.values()].flatMap((e) => {
+		try {
+			return e().entries;
+		} catch {
+			return [];
+		}
+	}).slice(0, 8);
+	return {
+		version: 1,
+		sampledAt: e,
+		expiresAt: e + 6e4,
+		entries: t
+	};
 }
-async function _(e, t, n) {
+function Te() {
+	Q && clearTimeout(Q), Q = setTimeout(() => {
+		Q = null, we();
+	}, xe);
+}
+async function Ee(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 X.set(e, i.releaseCache), Z.set(e, i.getModelCacheSnapshot), 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 X.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 X.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 X.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 X.set(e, c.releaseCache), await c.handleNudeNet(t);
 		default: throw Error(`Unknown workload type: ${e}`);
 	}
 }
+function De(e, t, n) {
+	return new Promise((r, i) => {
+		let a = new oe({
+			initial: t,
+			runtime: L(),
+			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) => {
+				W === a && (W = null, G = null), r(e);
+			},
+			onError: (e) => {
+				W === a && (W = null, G = null), i(Error(e));
+			}
+		});
+		W = a, G = 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 === "token-flow") {
+		let e = typeof t.id == "string" ? t.id : "";
+		e && K === e && typeof t.paused == "boolean" && (t.paused ? V.add(e) : U(e));
+		return;
+	}
+	if (t?.type === "swarm-control") {
+		if (!_e(t)) {
+			console.warn("[flaxia-node:worker] dropped malformed swarm-control message");
+			return;
+		}
+		W && W.handleControl(t.message);
+		return;
+	}
+	if (t?.type === "swarm-frame") {
+		t.frame instanceof ArrayBuffer ? W?.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";
+		U(e), W && G === e ? W.abort(n) : K === e && B.set(e, n);
+		return;
+	}
+	let { id: n, workload: r, payload: i, config: a } = t, o = performance.now();
+	K = n, U(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 (R ||= new te(a?.maxCpuLoad), console.log(`[flaxia-node:worker] task start id=${n} workload=${r}`), !J) throw Error(`node incapable: insufficient WASM memory (${q} bytes < ${f}); rejecting all tasks`);
+		if (l.has(r) && !Y()) throw Error(`${r}: insufficient WASM memory (${q} bytes < ${f})`);
+		await Se(), R.beginWork();
 		let e = setInterval(() => {
 			self.postMessage({
-				id: t,
+				id: n,
 				type: "heartbeat",
-				cpuLoad: c?.lastMeasuredLoad ?? 0
+				cpuLoad: R?.lastMeasuredLoad ?? 0,
+				modelCache: $()
 			});
-		}, 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 = Ce(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 De(n, i, e) : await Ee(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,
+				modelCache: $()
+			}), 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();
+			K = null, B.delete(n), U(n), clearInterval(e), R.markTaskComplete(performance.now() - t), Te();
 		}
 	} 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}`), K === n && (K = null), U(n), self.postMessage({
+			id: n,
 			type: "error",
-			error: n
+			error: t,
+			modelCache: $()
 		});
 	}
 };