@helioslx/core 0.2.0

package/dist/source-DB1oq2GT.js

@@ -0,0 +1,884 @@
+import { _ as validateChannelWrites, c as assertCid, f as assertSourceName, g as toValidatedFrame, h as normalizeAddress, i as SacnLifecycleError, l as assertFade, m as channelValuesToWrites, n as PersistenceError, o as TransportError, p as assertTimeout, s as TransportTimeoutError, u as assertFps, v as validateTransitionWrites } from "./validation-BdsVeyAE.js";
+//#region src/memory-store.ts
+const keyOf = ({ universe, priority }) => `${universe}:${priority}`;
+const cloneRecord = (record) => Object.freeze({
+	...record,
+	target: Object.freeze([...record.target])
+});
+var MemoryOutputStore = class {
+	#records = /* @__PURE__ */ new Map();
+	async get(address) {
+		const record = this.#records.get(keyOf(address));
+		return record ? cloneRecord(record) : null;
+	}
+	async list() {
+		return Object.freeze([...this.#records.values()].sort((left, right) => left.universe - right.universe || left.priority - right.priority).map(cloneRecord));
+	}
+	async remove(address) {
+		this.#records.delete(keyOf(address));
+	}
+	async save(record) {
+		this.#records.set(keyOf({
+			universe: record.universe,
+			priority: record.priority
+		}), cloneRecord(record));
+	}
+};
+//#endregion
+//#region src/output-engine.ts
+const framesEqual = (left, right) => {
+	for (let index = 0; index < 512; index += 1) if (left[index] !== right[index]) return false;
+	return true;
+};
+const frozenFrame = (frame) => Object.freeze(Array.from(frame));
+const errorMessage = (error) => error instanceof Error ? error.message : String(error);
+var SystemClock = class {
+	now() {
+		return performance.now();
+	}
+	wallNow() {
+		return Date.now();
+	}
+	sleep(delayMs, signal) {
+		return new Promise((resolve, reject) => {
+			if (signal.aborted) {
+				reject(signal.reason ?? /* @__PURE__ */ new Error("Operation aborted."));
+				return;
+			}
+			const handle = setTimeout(resolve, delayMs);
+			signal.addEventListener("abort", () => {
+				clearTimeout(handle);
+				reject(signal.reason ?? /* @__PURE__ */ new Error("Operation aborted."));
+			}, { once: true });
+		});
+	}
+};
+var OutputEngine = class {
+	#outputs = /* @__PURE__ */ new Map();
+	#pendingMutations = /* @__PURE__ */ new Set();
+	#transport;
+	#clock;
+	#logger;
+	#activeIntervalMs;
+	#defaultIdleFps;
+	#sendTimeoutMs;
+	#shutdownTimeoutMs;
+	#maxOutputs;
+	#closeTransport;
+	#createId;
+	#lifecycle = new AbortController();
+	#running = false;
+	#closed = false;
+	#loopPromise = null;
+	#wake = null;
+	#loopIterations = 0;
+	#lastLoopStartedAt = null;
+	#lastLoopCompletedAt = null;
+	#transportTelemetry = {
+		sendAttempts: 0,
+		sendFailures: 0,
+		sendRetries: 0,
+		sendSuccesses: 0,
+		sendTimeouts: 0
+	};
+	constructor(options) {
+		const activeFps = options.activeFps ?? 44;
+		const idleFps = options.idleFps ?? 2;
+		const sendTimeoutMs = options.sendTimeoutMs ?? 1e3;
+		const shutdownTimeoutMs = options.shutdownTimeoutMs ?? 2e3;
+		const maxOutputs = options.maxOutputs ?? 1024;
+		assertFps(activeFps, "Active FPS");
+		assertFps(idleFps, "Idle FPS");
+		assertTimeout(sendTimeoutMs);
+		assertTimeout(shutdownTimeoutMs);
+		if (!Number.isInteger(maxOutputs) || maxOutputs < 1) throw new SacnLifecycleError("Maximum outputs must be a positive integer.");
+		this.#transport = options.transport;
+		this.#clock = options.clock;
+		this.#logger = options.logger;
+		this.#activeIntervalMs = 1e3 / activeFps;
+		this.#defaultIdleFps = idleFps;
+		this.#sendTimeoutMs = sendTimeoutMs;
+		this.#shutdownTimeoutMs = shutdownTimeoutMs;
+		this.#maxOutputs = maxOutputs;
+		this.#closeTransport = options.closeTransport ?? true;
+		this.#createId = options.createId;
+	}
+	restore(record) {
+		this.#assertOpen();
+		const address = normalizeAddress(record);
+		assertFps(record.idleFps, "Idle FPS");
+		if (this.#outputs.has(this.#key(address))) return;
+		if (this.#outputs.size >= this.#maxOutputs) throw new SacnLifecycleError(`Output limit of ${this.#maxOutputs} has been reached while restoring state.`);
+		const state = this.#createState(record, toValidatedFrame(record.target));
+		this.#outputs.set(this.#key(address), state);
+	}
+	async beginMutation(addressInput) {
+		this.#assertOpen();
+		const address = normalizeAddress(addressInput);
+		const key = this.#key(address);
+		if (this.#pendingMutations.has(key)) throw new SacnLifecycleError(`Output ${key} already has a pending mutation.`);
+		const output = this.#outputs.get(key);
+		if (output?.sending) await output.sending;
+		if (output?.transportPending) await output.transportPending;
+		this.#pendingMutations.add(key);
+		return {
+			key,
+			state: output ? this.#cloneState(output) : null
+		};
+	}
+	commitMutation(checkpoint) {
+		this.#pendingMutations.delete(checkpoint.key);
+		this.#wakeLoop();
+	}
+	rollbackMutation(checkpoint) {
+		if (checkpoint.state) this.#outputs.set(checkpoint.key, checkpoint.state);
+		else this.#outputs.delete(checkpoint.key);
+		this.#pendingMutations.delete(checkpoint.key);
+		this.#wakeLoop();
+	}
+	start() {
+		this.#assertOpen();
+		if (this.#running) return;
+		this.#running = true;
+		this.#loopPromise = this.#loop();
+		this.#logger.info?.("Output engine started.", {
+			activeFrameIntervalMs: this.#activeIntervalMs,
+			idleFps: this.#defaultIdleFps
+		});
+	}
+	/**
+	* Pauses the scheduler without tearing down outputs or the transport.
+	* `start()` can resume the loop afterward.
+	*/
+	async stop() {
+		this.#assertOpen();
+		if (!this.#running) return;
+		this.#running = false;
+		this.#wakeLoop();
+		if (this.#loopPromise) {
+			await this.#loopPromise;
+			this.#loopPromise = null;
+		}
+		this.#logger.info?.("Output engine stopped.");
+	}
+	writeFrame(options, frame, durationMs) {
+		this.#assertOpen();
+		assertFade(durationMs);
+		const output = this.#getOrCreate(options);
+		const now = this.#clock.now();
+		this.#updateTransitions(output, now);
+		if (durationMs === 0) {
+			output.current.set(frame);
+			output.target.set(frame);
+			output.transitions.clear();
+		} else for (let index = 0; index < 512; index += 1) {
+			const target = frame[index] ?? 0;
+			if (target === output.current[index]) {
+				output.target[index] = target;
+				output.transitions.delete(index);
+			} else {
+				output.target[index] = target;
+				output.transitions.set(index, {
+					from: output.current[index] ?? 0,
+					to: target,
+					startedAt: now,
+					durationMs
+				});
+			}
+		}
+		this.#markChanged(output, now);
+		return this.#snapshot(output);
+	}
+	writeChannels(options, writes) {
+		this.#assertOpen();
+		validateChannelWrites(writes);
+		const output = this.#getOrCreate(options);
+		const now = this.#clock.now();
+		this.#updateTransitions(output, now);
+		for (const write of writes) {
+			const index = write.channel - 1;
+			const durationMs = write.durationMs ?? 0;
+			const from = output.current[index] ?? 0;
+			output.target[index] = write.value;
+			if (durationMs === 0 || from === write.value) {
+				output.current[index] = write.value;
+				output.transitions.delete(index);
+			} else output.transitions.set(index, {
+				from,
+				to: write.value,
+				startedAt: now,
+				durationMs
+			});
+		}
+		this.#markChanged(output, now);
+		return this.#snapshot(output);
+	}
+	getOutput(addressInput) {
+		this.#assertOpen();
+		const address = normalizeAddress(addressInput);
+		const output = this.#outputs.get(this.#key(address));
+		if (!output) return null;
+		this.#updateTransitions(output, this.#clock.now());
+		return this.#snapshot(output);
+	}
+	listOutputs() {
+		this.#assertOpen();
+		const now = this.#clock.now();
+		return Object.freeze([...this.#outputs.values()].sort((left, right) => left.address.universe - right.address.universe || left.address.priority - right.address.priority).map((output) => {
+			this.#updateTransitions(output, now);
+			return this.#snapshot(output);
+		}));
+	}
+	async clearOutput(addressInput) {
+		this.#assertOpen();
+		const address = normalizeAddress(addressInput);
+		const output = this.#outputs.get(this.#key(address));
+		if (!output) return false;
+		if (output.sending) await output.sending;
+		if (output.transportPending) await output.transportPending;
+		const now = this.#clock.now();
+		output.current.fill(0);
+		output.target.fill(0);
+		output.transitions.clear();
+		this.#markChanged(output, now);
+		if (!await this.#beginSend(output, now)) throw new TransportError(`Failed to send blackout frame for ${this.#key(address)}.`);
+		this.#outputs.delete(this.#key(address));
+		try {
+			await this.#transport.closeOutput?.(address);
+		} catch (error) {
+			throw new TransportError(`Failed to close output ${this.#key(address)}.`, error);
+		}
+		this.#wakeLoop();
+		return true;
+	}
+	getTelemetry() {
+		const outputs = this.#closed ? Object.freeze([]) : this.listOutputs();
+		return Object.freeze({
+			closed: this.#closed,
+			running: this.#running,
+			outputCount: outputs.length,
+			outputs,
+			loopIterations: this.#loopIterations,
+			lastLoopStartedAt: this.#lastLoopStartedAt,
+			lastLoopCompletedAt: this.#lastLoopCompletedAt,
+			lastLoopDurationMs: this.#lastLoopStartedAt !== null && this.#lastLoopCompletedAt !== null ? Math.max(0, this.#lastLoopCompletedAt - this.#lastLoopStartedAt) : null,
+			transport: Object.freeze({ ...this.#transportTelemetry })
+		});
+	}
+	async close() {
+		if (this.#closed) return;
+		this.#closed = true;
+		this.#running = false;
+		this.#lifecycle.abort(new SacnLifecycleError("Output engine closed."));
+		this.#wakeLoop();
+		if (this.#loopPromise) {
+			await this.#loopPromise;
+			this.#loopPromise = null;
+		}
+		await Promise.allSettled([...this.#outputs.values()].map((output) => output.sending).filter((send) => send !== null));
+		if (this.#closeTransport) {
+			let timeoutHandle;
+			try {
+				await Promise.race([this.#transport.close(), new Promise((_resolve, reject) => {
+					timeoutHandle = setTimeout(() => reject(new TransportError(`Transport close timed out after ${this.#shutdownTimeoutMs}ms.`)), this.#shutdownTimeoutMs);
+				})]);
+			} finally {
+				if (timeoutHandle !== void 0) clearTimeout(timeoutHandle);
+			}
+		}
+		this.#outputs.clear();
+		this.#logger.info?.("Output engine closed.");
+	}
+	#getOrCreate(options) {
+		const address = normalizeAddress(options);
+		const key = this.#key(address);
+		const existing = this.#outputs.get(key);
+		if (existing) {
+			this.#applyOptions(existing, options);
+			return existing;
+		}
+		if (this.#outputs.size >= this.#maxOutputs) throw new SacnLifecycleError(`Output limit of ${this.#maxOutputs} has been reached.`);
+		this.#clock.now();
+		const state = this.#createState({
+			...address,
+			cid: options.cid ?? this.#createId(),
+			idleFps: options.idleFps ?? this.#defaultIdleFps,
+			sourceName: options.sourceName ?? null,
+			target: Array.from({ length: 512 }, () => 0),
+			updatedAt: this.#wallNow()
+		}, /* @__PURE__ */ new Uint8Array(512));
+		this.#applyOptions(state, options);
+		this.#outputs.set(key, state);
+		return state;
+	}
+	#createState(record, frame) {
+		if (frame.length !== 512) throw new Error(`Stored frame must contain exactly 512 values.`);
+		return {
+			address: normalizeAddress(record),
+			cid: assertCid(record.cid),
+			idleFps: record.idleFps,
+			sourceName: record.sourceName === null ? null : assertSourceName(record.sourceName),
+			current: frame.slice(),
+			target: frame.slice(),
+			lastSent: /* @__PURE__ */ new Uint8Array(512),
+			transitions: /* @__PURE__ */ new Map(),
+			sequence: 0,
+			lastSentAt: null,
+			nextDueAt: this.#clock.now(),
+			dirty: true,
+			lastError: null,
+			consecutiveFailures: 0,
+			updatedAt: record.updatedAt,
+			revision: 0,
+			sending: null,
+			transportPending: null
+		};
+	}
+	#applyOptions(output, options) {
+		const cid = options.cid === void 0 ? output.cid : assertCid(options.cid);
+		const idleFps = options.idleFps ?? output.idleFps;
+		if (options.idleFps !== void 0) assertFps(options.idleFps, "Idle FPS");
+		const sourceName = options.sourceName === void 0 ? output.sourceName : assertSourceName(options.sourceName);
+		output.cid = cid;
+		output.idleFps = idleFps;
+		output.sourceName = sourceName;
+	}
+	#markChanged(output, now) {
+		output.dirty = true;
+		output.lastError = null;
+		output.nextDueAt = now;
+		output.updatedAt = this.#wallNow();
+		output.revision += 1;
+		this.#wakeLoop();
+	}
+	#updateTransitions(output, now) {
+		let active = false;
+		for (const [index, transition] of output.transitions) {
+			const elapsed = now - transition.startedAt;
+			if (elapsed >= transition.durationMs) {
+				output.current[index] = transition.to;
+				output.transitions.delete(index);
+				continue;
+			}
+			const progress = Math.max(0, elapsed / transition.durationMs);
+			output.current[index] = Math.round(transition.from + (transition.to - transition.from) * progress);
+			active = true;
+		}
+		return active;
+	}
+	#mode(output) {
+		return output.dirty || output.transitions.size > 0 || !framesEqual(output.current, output.lastSent) ? "active" : "idle";
+	}
+	#interval(output) {
+		return this.#mode(output) === "active" ? this.#activeIntervalMs : 1e3 / output.idleFps;
+	}
+	#snapshot(output) {
+		return Object.freeze({
+			universe: output.address.universe,
+			priority: output.address.priority,
+			cid: output.cid,
+			sourceName: output.sourceName,
+			idleFps: output.idleFps,
+			current: frozenFrame(output.current),
+			target: frozenFrame(output.target),
+			lastSent: frozenFrame(output.lastSent),
+			activeTransitions: output.transitions.size,
+			frameMode: this.#mode(output),
+			dirty: output.dirty,
+			sequence: output.sequence,
+			lastSentAt: output.lastSentAt,
+			nextDueAt: output.nextDueAt,
+			lastError: output.lastError,
+			updatedAt: output.updatedAt
+		});
+	}
+	async #loop() {
+		while (this.#running && !this.#lifecycle.signal.aborted) {
+			const now = this.#clock.now();
+			this.#lastLoopStartedAt = now;
+			this.#loopIterations += 1;
+			const sends = [];
+			for (const output of this.#outputs.values()) {
+				if (this.#pendingMutations.has(this.#key(output.address))) continue;
+				this.#updateTransitions(output, now);
+				if (!output.sending && !output.transportPending && (output.dirty || now >= output.nextDueAt)) sends.push(this.#beginSend(output, now));
+			}
+			await Promise.allSettled(sends);
+			this.#lastLoopCompletedAt = this.#clock.now();
+			if (!this.#running) break;
+			let nextDueAt = Number.POSITIVE_INFINITY;
+			for (const output of this.#outputs.values()) {
+				if (this.#pendingMutations.has(this.#key(output.address))) continue;
+				nextDueAt = Math.min(nextDueAt, output.nextDueAt);
+			}
+			const delay = Number.isFinite(nextDueAt) ? Math.max(1, nextDueAt - this.#clock.now()) : 1e3;
+			await this.#wait(delay);
+		}
+	}
+	#beginSend(output, now) {
+		const send = this.#send(output, now);
+		output.sending = send;
+		send.finally(() => {
+			if (output.sending === send) output.sending = null;
+		});
+		return send;
+	}
+	async #send(output, now) {
+		const revision = output.revision;
+		const wasTransitioning = output.transitions.size > 0;
+		const sentFrame = output.current.slice();
+		const packet = Object.freeze({
+			cid: output.cid,
+			universe: output.address.universe,
+			priority: output.address.priority,
+			sequence: output.sequence,
+			sourceName: output.sourceName,
+			data: sentFrame.slice()
+		});
+		if (output.consecutiveFailures > 0) this.#transportTelemetry.sendRetries += 1;
+		this.#transportTelemetry.sendAttempts += 1;
+		try {
+			await this.#sendWithTimeout(packet, output);
+			output.lastSent.set(sentFrame);
+			output.lastSentAt = now;
+			output.sequence = output.sequence + 1 & 255;
+			output.dirty = output.revision !== revision;
+			output.lastError = null;
+			output.consecutiveFailures = 0;
+			output.nextDueAt = now + (wasTransitioning ? this.#activeIntervalMs : this.#interval(output));
+			this.#transportTelemetry.sendSuccesses += 1;
+			return true;
+		} catch (error) {
+			if (this.#closed) return false;
+			output.lastError = errorMessage(error);
+			output.dirty = true;
+			output.consecutiveFailures += 1;
+			output.nextDueAt = now + Math.min(5e3, this.#activeIntervalMs * 2 ** Math.min(output.consecutiveFailures - 1, 8));
+			this.#transportTelemetry.sendFailures += 1;
+			if (error instanceof TransportTimeoutError) this.#transportTelemetry.sendTimeouts += 1;
+			this.#logger.error?.("Output transport send failed.", {
+				universe: output.address.universe,
+				priority: output.address.priority,
+				error: output.lastError
+			});
+			return false;
+		}
+	}
+	async #sendWithTimeout(packet, output) {
+		const sendController = new AbortController();
+		const timeoutController = new AbortController();
+		let rejectOnClose;
+		const closed = new Promise((_resolve, reject) => {
+			rejectOnClose = reject;
+		});
+		const onClose = () => {
+			const reason = this.#lifecycle.signal.reason ?? new SacnLifecycleError("Output engine closed.");
+			sendController.abort(reason);
+			rejectOnClose?.(reason);
+		};
+		this.#lifecycle.signal.addEventListener("abort", onClose, { once: true });
+		const timeoutError = new TransportTimeoutError(this.#sendTimeoutMs, packet.universe, packet.priority);
+		const timeout = this.#clock.sleep(this.#sendTimeoutMs, timeoutController.signal).then(() => {
+			sendController.abort(timeoutError);
+			throw timeoutError;
+		});
+		const transportSend = Promise.resolve().then(() => this.#transport.send(packet, sendController.signal)).catch((error) => {
+			if (error instanceof TransportTimeoutError) throw error;
+			if (this.#lifecycle.signal.aborted) throw error;
+			throw new TransportError(`Transport send failed for output ${packet.universe}:${packet.priority}.`, error);
+		});
+		const settlement = transportSend.then(() => void 0, () => void 0);
+		output.transportPending = settlement;
+		settlement.finally(() => {
+			if (output.transportPending === settlement) {
+				output.transportPending = null;
+				this.#wakeLoop();
+			}
+		});
+		try {
+			await Promise.race([
+				transportSend,
+				timeout,
+				closed
+			]);
+		} finally {
+			timeoutController.abort();
+			this.#lifecycle.signal.removeEventListener("abort", onClose);
+		}
+	}
+	async #wait(delayMs) {
+		const controller = new AbortController();
+		const onClose = () => controller.abort(this.#lifecycle.signal.reason);
+		this.#lifecycle.signal.addEventListener("abort", onClose, { once: true });
+		const wake = new Promise((resolve) => {
+			this.#wake = resolve;
+		});
+		try {
+			await Promise.race([this.#clock.sleep(delayMs, controller.signal), wake]);
+		} catch {} finally {
+			this.#wake = null;
+			controller.abort();
+			this.#lifecycle.signal.removeEventListener("abort", onClose);
+		}
+	}
+	#wakeLoop() {
+		this.#wake?.();
+	}
+	#key(address) {
+		return `${address.universe}:${address.priority}`;
+	}
+	#cloneState(output) {
+		return {
+			...output,
+			address: Object.freeze({ ...output.address }),
+			current: output.current.slice(),
+			target: output.target.slice(),
+			lastSent: output.lastSent.slice(),
+			transitions: new Map([...output.transitions].map(([index, transition]) => [index, { ...transition }])),
+			sending: null,
+			transportPending: null
+		};
+	}
+	#wallNow() {
+		return this.#clock.wallNow?.() ?? Date.now();
+	}
+	#assertOpen() {
+		if (this.#closed) throw new SacnLifecycleError("Output engine is closed.");
+	}
+};
+//#endregion
+//#region src/source.ts
+const noopLogger = Object.freeze({});
+const defaultCreateId = () => {
+	if (typeof globalThis.crypto?.randomUUID !== "function") throw new SacnLifecycleError("No UUID generator is available; inject createId in source options.");
+	return globalThis.crypto.randomUUID();
+};
+const toRecord = (snapshot) => Object.freeze({
+	universe: snapshot.universe,
+	priority: snapshot.priority,
+	cid: snapshot.cid,
+	sourceName: snapshot.sourceName,
+	idleFps: snapshot.idleFps,
+	target: Object.freeze([...snapshot.target]),
+	updatedAt: snapshot.updatedAt
+});
+const outputOptionsFrom = (universe, priority, defaults) => ({
+	universe,
+	priority,
+	...defaults.cid === void 0 ? {} : { cid: defaults.cid },
+	...defaults.idleFps === void 0 ? {} : { idleFps: defaults.idleFps },
+	...defaults.sourceName === void 0 ? {} : { sourceName: defaults.sourceName }
+});
+/**
+* Thin handle for a single `(universe, priority)` output address.
+*/
+var Universe = class {
+	#source;
+	#defaults;
+	universe;
+	priority;
+	constructor(source, universe, priority, defaults) {
+		this.#source = source;
+		this.universe = universe;
+		this.priority = priority;
+		this.#defaults = defaults;
+	}
+	setChannels(values, options = {}) {
+		return this.#source.writeChannels(outputOptionsFrom(this.universe, this.priority, this.#defaults), () => channelValuesToWrites(values), options.signal);
+	}
+	fadeChannels(values, options) {
+		return this.#source.writeChannels(outputOptionsFrom(this.universe, this.priority, this.#defaults), () => {
+			assertFade(options.durationMs);
+			return channelValuesToWrites(values, options.durationMs);
+		}, options.signal);
+	}
+	transition(writes, options = {}) {
+		return this.#source.writeChannels(outputOptionsFrom(this.universe, this.priority, this.#defaults), () => {
+			validateTransitionWrites(writes);
+			return writes.map((write) => ({
+				channel: write.channel,
+				value: write.value,
+				durationMs: write.durationMs
+			}));
+		}, options.signal);
+	}
+	write(values, options = {}) {
+		return this.#source.writeFrame(outputOptionsFrom(this.universe, this.priority, this.#defaults), values, options.durationMs ?? 0, options.signal);
+	}
+	get() {
+		return this.#source.getUniverse(this.universe, this.priority);
+	}
+	clear(options = {}) {
+		return this.#source.clearUniverse(this.universe, this.priority, options.signal);
+	}
+};
+/**
+* Runtime-neutral sACN output source over scheduling and storage.
+* Mutating requests are serialized so their returned and persisted snapshots
+* represent the same operation order.
+*/
+var SacnSource = class {
+	#store;
+	#engine;
+	#ownsStore;
+	#logger;
+	#onStart;
+	#onStop;
+	#onClose;
+	#listeners = /* @__PURE__ */ new Set();
+	#universes = /* @__PURE__ */ new Map();
+	#queue = Promise.resolve();
+	#running = false;
+	#restored = false;
+	#closing = false;
+	#closed = false;
+	#closePromise = null;
+	constructor(options) {
+		this.#store = options.store ?? new MemoryOutputStore();
+		this.#ownsStore = options.ownsStore ?? options.store === void 0;
+		this.#logger = options.logger ?? noopLogger;
+		if (options.onStart !== void 0) this.#onStart = options.onStart;
+		if (options.onStop !== void 0) this.#onStop = options.onStop;
+		if (options.onClose !== void 0) this.#onClose = options.onClose;
+		this.#engine = new OutputEngine({
+			transport: options.transport,
+			clock: options.clock ?? new SystemClock(),
+			logger: this.#logger,
+			createId: options.createId ?? defaultCreateId,
+			...options.activeFps === void 0 ? {} : { activeFps: options.activeFps },
+			...options.idleFps === void 0 ? {} : { idleFps: options.idleFps },
+			...options.sendTimeoutMs === void 0 ? {} : { sendTimeoutMs: options.sendTimeoutMs },
+			...options.shutdownTimeoutMs === void 0 ? {} : { shutdownTimeoutMs: options.shutdownTimeoutMs },
+			...options.maxOutputs === void 0 ? {} : { maxOutputs: options.maxOutputs },
+			closeTransport: options.ownsTransport ?? false
+		});
+	}
+	universe(universe, options = {}) {
+		if (this.#closing || this.#closed) throw new SacnLifecycleError("Source is closed.");
+		const address = normalizeAddress({
+			universe,
+			priority: options.priority ?? 100
+		});
+		const key = `${address.universe}:${address.priority}`;
+		const existing = this.#universes.get(key);
+		if (existing) return existing;
+		const handle = new Universe(this, address.universe, address.priority, {
+			...options.cid === void 0 ? {} : { cid: options.cid },
+			...options.idleFps === void 0 ? {} : { idleFps: options.idleFps },
+			...options.sourceName === void 0 ? {} : { sourceName: options.sourceName }
+		});
+		this.#universes.set(key, handle);
+		return handle;
+	}
+	start() {
+		return this.#enqueue(async () => {
+			await this.#startLocked();
+		});
+	}
+	stop() {
+		return this.#enqueue(async () => {
+			if (this.#closed) throw new SacnLifecycleError("Source is closed.");
+			if (!this.#running) return;
+			await this.#engine.stop();
+			this.#running = false;
+			await this.#runHook(this.#onStop);
+			this.#emit({ type: "stopped" });
+		});
+	}
+	/** @internal Used by Universe handles. */
+	writeFrame(options, values, durationMs, signal) {
+		return this.#enqueue(async () => {
+			await this.#ensureStartedLocked();
+			const frame = toValidatedFrame(values);
+			assertFade(durationMs);
+			const checkpoint = await this.#engine.beginMutation(options);
+			try {
+				const snapshot = this.#engine.writeFrame(options, frame, durationMs);
+				await this.#persist("save output", () => this.#store.save(toRecord(snapshot)));
+				this.#engine.commitMutation(checkpoint);
+				this.#emit({
+					type: "output-updated",
+					output: snapshot
+				});
+				return snapshot;
+			} catch (error) {
+				this.#engine.rollbackMutation(checkpoint);
+				throw error;
+			}
+		}, signal);
+	}
+	/** @internal Used by Universe handles. */
+	writeChannels(options, resolveChannels, signal) {
+		return this.#enqueue(async () => {
+			await this.#ensureStartedLocked();
+			const channels = resolveChannels();
+			const checkpoint = await this.#engine.beginMutation(options);
+			try {
+				const snapshot = this.#engine.writeChannels(options, channels);
+				await this.#persist("save output", () => this.#store.save(toRecord(snapshot)));
+				this.#engine.commitMutation(checkpoint);
+				this.#emit({
+					type: "output-updated",
+					output: snapshot
+				});
+				return snapshot;
+			} catch (error) {
+				this.#engine.rollbackMutation(checkpoint);
+				throw error;
+			}
+		}, signal);
+	}
+	/** @internal Used by Universe handles. */
+	getUniverse(universe, priority) {
+		return this.#enqueue(() => Promise.resolve(this.#engine.getOutput(normalizeAddress({
+			universe,
+			priority
+		}))));
+	}
+	listUniverses() {
+		return this.#enqueue(() => Promise.resolve(this.#engine.listOutputs()));
+	}
+	/** @internal Used by Universe handles. */
+	clearUniverse(universe, priority, signal) {
+		return this.#enqueue(async () => {
+			await this.#ensureStartedLocked();
+			const address = normalizeAddress({
+				universe,
+				priority
+			});
+			const checkpoint = await this.#engine.beginMutation(address);
+			const previous = this.#engine.getOutput(address);
+			if (!previous) {
+				this.#engine.commitMutation(checkpoint);
+				return false;
+			}
+			let persistenceRemoved = false;
+			try {
+				await this.#persist("remove output", () => this.#store.remove(address));
+				persistenceRemoved = true;
+				const removed = await this.#engine.clearOutput(address);
+				this.#engine.commitMutation(checkpoint);
+				this.#emit({
+					type: "output-cleared",
+					address: Object.freeze({ ...address })
+				});
+				return removed;
+			} catch (error) {
+				this.#engine.rollbackMutation(checkpoint);
+				if (persistenceRemoved) try {
+					await this.#persist("restore output after failed clear", () => this.#store.save(toRecord(previous)));
+				} catch (rollbackError) {
+					throw new AggregateError([error, rollbackError], "Output clear and persistence rollback failed.");
+				}
+				throw error;
+			}
+		}, signal);
+	}
+	getTelemetry() {
+		return this.#engine.getTelemetry();
+	}
+	subscribe(listener) {
+		if (this.#closing || this.#closed) throw new SacnLifecycleError("Source is closed.");
+		this.#listeners.add(listener);
+		return () => this.#listeners.delete(listener);
+	}
+	close() {
+		if (this.#closePromise) return this.#closePromise;
+		this.#closing = true;
+		const closing = this.#queue.then(async () => {
+			const errors = [];
+			try {
+				try {
+					await this.#engine.close();
+				} catch (error) {
+					errors.push(error);
+				}
+				if (this.#ownsStore) try {
+					await this.#persist("close output store", async () => {
+						await this.#store.close?.();
+					});
+				} catch (error) {
+					errors.push(error);
+				}
+				try {
+					await this.#runHook(this.#onClose);
+				} catch (error) {
+					errors.push(error);
+				}
+				if (errors.length === 1) throw errors[0];
+				if (errors.length > 1) throw new AggregateError(errors, "Source shutdown failed.");
+			} finally {
+				this.#running = false;
+				this.#closed = true;
+				this.#closing = false;
+				this.#universes.clear();
+				this.#emit({ type: "closed" });
+				this.#listeners.clear();
+			}
+		});
+		this.#queue = closing.then(() => void 0, () => void 0);
+		this.#closePromise = closing;
+		return closing;
+	}
+	async #startLocked() {
+		if (this.#closed) throw new SacnLifecycleError("Source is closed.");
+		if (this.#running) return;
+		if (!this.#restored) {
+			const records = await this.#persist("load outputs", () => this.#store.list());
+			const checkpoints = [];
+			try {
+				for (const record of records) {
+					const checkpoint = await this.#engine.beginMutation(record);
+					checkpoints.push(checkpoint);
+					this.#engine.restore(record);
+					this.#engine.commitMutation(checkpoint);
+				}
+				this.#restored = true;
+			} catch (error) {
+				for (const checkpoint of checkpoints.reverse()) this.#engine.rollbackMutation(checkpoint);
+				throw error;
+			}
+		}
+		this.#engine.start();
+		this.#running = true;
+		await this.#runHook(this.#onStart);
+		this.#emit({ type: "started" });
+	}
+	async #ensureStartedLocked() {
+		if (!this.#running) await this.#startLocked();
+	}
+	async #runHook(hook) {
+		if (!hook) return;
+		await hook();
+	}
+	#enqueue(operation, signal) {
+		if (this.#closing || this.#closed) return Promise.reject(new SacnLifecycleError("Source is closed."));
+		const result = this.#queue.then(() => {
+			signal?.throwIfAborted();
+			return operation();
+		});
+		this.#queue = result.then(() => void 0, () => void 0);
+		return result;
+	}
+	async #persist(action, operation) {
+		try {
+			return await operation();
+		} catch (error) {
+			if (error instanceof PersistenceError) throw error;
+			throw new PersistenceError(`Failed to ${action}.`, error);
+		}
+	}
+	#emit(event) {
+		const frozenEvent = Object.freeze(event);
+		for (const listener of this.#listeners) try {
+			listener(frozenEvent);
+		} catch (error) {
+			this.#logger.warn?.("Source event listener failed.", { error });
+		}
+	}
+};
+const createSacnSource = (options) => new SacnSource(options);
+//#endregion
+export { MemoryOutputStore as a, SystemClock as i, Universe as n, createSacnSource as r, SacnSource as t };
+
+//# sourceMappingURL=source-DB1oq2GT.js.map