@spatius/avatarkit 1.3.1-beta.2 → 1.3.1-beta.4

package/dist/OpusDecoderProxy-BTWRku-I.js

@@ -0,0 +1,129 @@
+import { t as logger } from "./logger-C3fw-NWP.js";
+//#region audio/OpusDecoderProxy.ts
+var OpusDecoderProxy = class OpusDecoderProxy {
+	worker = null;
+	fallbackDecoder = null;
+	pending = /* @__PURE__ */ new Map();
+	seq = 0;
+	backend = "main-thread";
+	constructor() {}
+	/**
+	* Create the decoder, selecting the best backend. Never rejects: it degrades
+	* through worker → main-thread so a connection always gets a working decoder.
+	* Resolves once the chosen backend is ready.
+	*/
+	static async create() {
+		const proxy = new OpusDecoderProxy();
+		try {
+			await proxy.startWorker();
+			proxy.backend = "worker";
+			return proxy;
+		} catch (err) {
+			logger.warn("[Opus][DecoderProxy] Worker unavailable, falling back to main-thread decode:", err instanceof Error ? err.message : String(err));
+		}
+		const { OggOpusDecoder } = await import("./OpusCodec-Bv4kzdt8.js").then((n) => n.n);
+		proxy.fallbackDecoder = new OggOpusDecoder();
+		proxy.backend = "main-thread";
+		return proxy;
+	}
+	startWorker() {
+		return new Promise((resolve, reject) => {
+			let worker;
+			try {
+				worker = new Worker(new URL(
+					/* @vite-ignore */
+					"/assets/OpusDecoderWorker.worker-Bd4svkEs.js",
+					"" + import.meta.url
+				), { type: "module" });
+			} catch (err) {
+				reject(err instanceof Error ? err : new Error(String(err)));
+				return;
+			}
+			let ready = false;
+			const initTimeout = setTimeout(() => {
+				if (!ready) {
+					worker.terminate();
+					reject(/* @__PURE__ */ new Error("worker init timeout"));
+				}
+			}, 3e3);
+			worker.onmessage = (e) => {
+				const d = e.data;
+				if (d.type === "ready") {
+					ready = true;
+					clearTimeout(initTimeout);
+					this.worker = worker;
+					resolve();
+					return;
+				}
+				if (d.type === "pcm") {
+					this.pending.get(d.seq)?.resolve(new Uint8Array(d.pcm));
+					this.pending.delete(d.seq);
+					return;
+				}
+				if (d.type === "error") {
+					this.pending.get(d.seq)?.reject(new Error(d.message));
+					this.pending.delete(d.seq);
+				}
+			};
+			worker.onerror = (e) => {
+				clearTimeout(initTimeout);
+				const err = new Error(e.message || "worker error");
+				if (!ready) {
+					reject(err);
+					return;
+				}
+				for (const p of this.pending.values()) p.reject(err);
+				this.pending.clear();
+			};
+			worker.postMessage({ type: "init" });
+		});
+	}
+	/**
+	* Decode one slice of an Ogg Opus stream, resolving with the PCM16 (mono LE)
+	* decoded so far (possibly empty for header-only slices). On the worker path the
+	* main thread stays free while decoding runs; on the fallback path this blocks
+	* the main thread (same as the legacy synchronous behavior).
+	*
+	* The caller (AvatarController) must serialize these in feed order — the decoder
+	* is stateful. See its inputDecodeChain.
+	*/
+	decode(ogg) {
+		if (this.worker) {
+			const seq = this.seq++;
+			return new Promise((resolve, reject) => {
+				this.pending.set(seq, {
+					resolve,
+					reject
+				});
+				this.worker.postMessage({
+					type: "decode",
+					ogg,
+					seq
+				});
+			});
+		}
+		if (this.fallbackDecoder) try {
+			const pcm = this.fallbackDecoder.decode(ogg);
+			return Promise.resolve(pcm);
+		} catch (err) {
+			return Promise.reject(err instanceof Error ? err : new Error(String(err)));
+		}
+		return Promise.reject(/* @__PURE__ */ new Error("OpusDecoderProxy not initialized"));
+	}
+	/** Tear down whichever backend is active. Call once on disconnect. */
+	destroy() {
+		for (const p of this.pending.values()) p.reject(/* @__PURE__ */ new Error("decoder destroyed"));
+		this.pending.clear();
+		if (this.worker) {
+			this.worker.postMessage({ type: "destroy" });
+			this.worker.terminate();
+			this.worker = null;
+		}
+		if (this.fallbackDecoder) {
+			this.fallbackDecoder.destroy();
+			this.fallbackDecoder = null;
+		}
+	}
+};
+//#endregion
+export { OpusDecoderProxy };

package/dist/OpusEncoderProxy-_AWpY7N6.js

@@ -0,0 +1,135 @@
+import { t as logger } from "./logger-C3fw-NWP.js";
+//#region audio/OpusEncoderProxy.ts
+var OpusEncoderProxy = class OpusEncoderProxy {
+	worker = null;
+	fallbackEncoder = null;
+	pending = /* @__PURE__ */ new Map();
+	seq = 0;
+	sampleRate;
+	bitrate;
+	backend = "main-thread";
+	constructor(sampleRate, bitrate) {
+		this.sampleRate = sampleRate;
+		this.bitrate = bitrate;
+	}
+	/**
+	* Create the encoder, selecting the best backend. Never rejects: it degrades
+	* through worker → main-thread so a connection always gets a working encoder.
+	* Resolves once the chosen backend is ready.
+	*/
+	static async create(sampleRate, bitrate) {
+		const proxy = new OpusEncoderProxy(sampleRate, bitrate);
+		try {
+			await proxy.startWorker();
+			proxy.backend = "worker";
+			return proxy;
+		} catch (err) {
+			logger.warn("[Opus][Proxy] Worker unavailable, falling back to main-thread encode:", err instanceof Error ? err.message : String(err));
+		}
+		const { OggOpusEncoder } = await import("./OpusCodec-Bv4kzdt8.js").then((n) => n.n);
+		proxy.fallbackEncoder = new OggOpusEncoder(sampleRate, bitrate);
+		proxy.backend = "main-thread";
+		return proxy;
+	}
+	startWorker() {
+		return new Promise((resolve, reject) => {
+			let worker;
+			try {
+				worker = new Worker(new URL(
+					/* @vite-ignore */
+					"/assets/OpusEncoderWorker.worker-BdxYhZZ9.js",
+					"" + import.meta.url
+				), { type: "module" });
+			} catch (err) {
+				reject(err instanceof Error ? err : new Error(String(err)));
+				return;
+			}
+			let ready = false;
+			const initTimeout = setTimeout(() => {
+				if (!ready) {
+					worker.terminate();
+					reject(/* @__PURE__ */ new Error("worker init timeout"));
+				}
+			}, 3e3);
+			worker.onmessage = (e) => {
+				const d = e.data;
+				if (d.type === "ready") {
+					ready = true;
+					clearTimeout(initTimeout);
+					this.worker = worker;
+					resolve();
+					return;
+				}
+				if (d.type === "pages") {
+					this.pending.get(d.seq)?.resolve(d.pages);
+					this.pending.delete(d.seq);
+					return;
+				}
+				if (d.type === "error") {
+					this.pending.get(d.seq)?.reject(new Error(d.message));
+					this.pending.delete(d.seq);
+				}
+			};
+			worker.onerror = (e) => {
+				clearTimeout(initTimeout);
+				const err = new Error(e.message || "worker error");
+				if (!ready) {
+					reject(err);
+					return;
+				}
+				for (const p of this.pending.values()) p.reject(err);
+				this.pending.clear();
+			};
+			worker.postMessage({
+				type: "init",
+				sampleRate: this.sampleRate,
+				bitrate: this.bitrate
+			});
+		});
+	}
+	/**
+	* Encode one PCM chunk, resolving with the Ogg pages to send (in order). On the
+	* worker path the main thread stays free while encoding runs; on the fallback
+	* path this blocks the main thread (same as the legacy behavior).
+	*/
+	encode(reqId, pcm, end) {
+		if (this.worker) {
+			const seq = this.seq++;
+			return new Promise((resolve, reject) => {
+				this.pending.set(seq, {
+					resolve,
+					reject
+				});
+				this.worker.postMessage({
+					type: "encode",
+					reqId,
+					pcm,
+					end,
+					seq
+				});
+			});
+		}
+		if (this.fallbackEncoder) try {
+			return Promise.resolve(this.fallbackEncoder.encode(reqId, pcm, end));
+		} catch (err) {
+			return Promise.reject(err instanceof Error ? err : new Error(String(err)));
+		}
+		return Promise.reject(/* @__PURE__ */ new Error("OpusEncoderProxy not initialized"));
+	}
+	/** Tear down whichever backend is active. Call once on disconnect. */
+	destroy() {
+		for (const p of this.pending.values()) p.reject(/* @__PURE__ */ new Error("encoder destroyed"));
+		this.pending.clear();
+		if (this.worker) {
+			this.worker.postMessage({ type: "destroy" });
+			this.worker.terminate();
+			this.worker = null;
+		}
+		if (this.fallbackEncoder) {
+			this.fallbackEncoder.destroy();
+			this.fallbackEncoder = null;
+		}
+	}
+};
+//#endregion
+export { OpusEncoderProxy };