@djodjonx/x32-simulator 0.0.1

package/dist/UdpNetworkGateway-BrroQ6-Q.mjs

@@ -0,0 +1,1189 @@
+import * as os from "os";
+import { EventEmitter } from "node:events";
+import * as dgram from "node:dgram";
+
+//#region src/application/use-cases/ProcessPacketUseCase.ts
+var ProcessPacketUseCase = class {
+	constructor(messageHandler, gateway) {
+		this.messageHandler = messageHandler;
+		this.gateway = gateway;
+	}
+	execute(packet, rinfo) {
+		if (packet.oscType === "bundle") packet.elements?.forEach((el) => this.execute(el, rinfo));
+		else if (packet.oscType === "message") {
+			const args = packet.args.map((arg) => {
+				if (typeof arg === "object" && arg !== null && "value" in arg) return arg.value;
+				return arg;
+			});
+			this.messageHandler.handle({
+				address: packet.address,
+				args
+			}, rinfo).forEach((reply) => {
+				this.gateway.send(rinfo, reply.address, reply.args);
+			});
+		}
+	}
+};
+
+//#endregion
+//#region src/domain/ports/ILogger.ts
+/**
+* Standard log categories for the domain.
+*/
+let LogCategory = /* @__PURE__ */ function(LogCategory$1) {
+	LogCategory$1["SYSTEM"] = "SYSTEM";
+	LogCategory$1["OSC_IN"] = "OSC_IN";
+	LogCategory$1["OSC_OUT"] = "OSC_OUT";
+	LogCategory$1["DISPATCH"] = "DISPATCH";
+	LogCategory$1["STATE"] = "STATE";
+	LogCategory$1["SUB"] = "SUB";
+	LogCategory$1["METER"] = "METER";
+	return LogCategory$1;
+}({});
+
+//#endregion
+//#region src/application/use-cases/BroadcastUpdatesUseCase.ts
+var BroadcastUpdatesUseCase = class {
+	constructor(subscriptionManager, state, gateway, logger, meterService, schemaRegistry) {
+		this.subscriptionManager = subscriptionManager;
+		this.state = state;
+		this.gateway = gateway;
+		this.logger = logger;
+		this.meterService = meterService;
+		this.schemaRegistry = schemaRegistry;
+	}
+	execute() {
+		this.subscriptionManager.getSubscribers().forEach((sub) => {
+			if (sub.type === "path" || !sub.alias) {
+				if (sub.type === "meter" && sub.meterPath) {
+					const meterData = this.meterService.generateMeterData(sub.meterPath, this.state);
+					this.gateway.send({
+						address: sub.address,
+						port: sub.port
+					}, sub.meterPath, [meterData.toBlob()]);
+				}
+				return;
+			}
+			const rinfo = {
+				address: sub.address,
+				port: sub.port
+			};
+			if (sub.type === "batch" && sub.paths) {
+				if (sub.paths.length === 1 && sub.paths[0].startsWith("/meters")) {
+					const meterData = this.meterService.generateMeterData(sub.paths[0], this.state);
+					this.gateway.send(rinfo, sub.alias, [meterData.toBlob()]);
+					return;
+				}
+				let stride;
+				const dataSize = sub.paths.length * 4;
+				const factor = sub.factor || 0;
+				const count = sub.count || 0;
+				if (factor > 0) stride = Math.max(factor * 4, dataSize);
+				else stride = sub.paths.length === 3 ? 16 : dataSize;
+				const blobSize = count * stride;
+				if (isNaN(blobSize) || blobSize < 0) {
+					this.logger.error(LogCategory.SYSTEM, `Invalid blob size`, {
+						alias: sub.alias,
+						blobSize,
+						count,
+						stride,
+						factor,
+						dataSize
+					});
+					return;
+				}
+				const blob = Buffer.alloc(blobSize);
+				for (let i = 0; i < count; i++) {
+					const root = this.schemaRegistry.getRootFromIndex(sub.start + i);
+					let currentOffset = i * stride;
+					if (!root) continue;
+					sub.paths.forEach((s, pIdx) => {
+						if (pIdx * 4 >= stride) return;
+						if (s.startsWith("/meters")) blob.writeFloatLE(0, currentOffset);
+						else {
+							const target = `${root}${s}`;
+							const node = this.schemaRegistry.getNode(target);
+							let val = this.state.get(target);
+							if (val === void 0) val = node ? node.default : 0;
+							if (typeof val === "number") if (node && node.type === "f") blob.writeFloatLE(val, currentOffset);
+							else blob.writeInt32LE(val, currentOffset);
+							else blob.writeInt32LE(0, currentOffset);
+						}
+						currentOffset += 4;
+					});
+				}
+				this.gateway.send(rinfo, sub.alias, [blob]);
+			} else if (sub.type === "format" && sub.pattern) {
+				const stride = sub.factor ? sub.factor * 4 : 4;
+				const start = sub.start || 0;
+				const count = sub.count || 0;
+				const totalSize = (start + count) * stride;
+				if (isNaN(totalSize) || totalSize < 0) return;
+				const blob = Buffer.alloc(totalSize);
+				let offset = start * stride;
+				for (let i = start; i < start + count; i++) {
+					const id = i.toString().padStart(2, "0");
+					const target = sub.pattern.replace(/\*\*?/, id);
+					let val = this.state.get(target);
+					if (val === void 0) val = 0;
+					if (typeof val === "number") {
+						const node = this.schemaRegistry.getNode(target);
+						if (node && node.type === "f") blob.writeFloatLE(val, offset);
+						else blob.writeInt32LE(val, offset);
+					} else blob.writeInt32LE(0, offset);
+					offset += stride;
+				}
+				this.gateway.send(rinfo, sub.alias, [blob]);
+			}
+		});
+	}
+	broadcastSingleChange(path, value) {
+		this.subscriptionManager.getSubscribers().forEach((sub) => {
+			if (path === sub.path || sub.path === "/xremote" || sub.path && sub.path.includes("*") && path.startsWith(sub.path.split("*")[0])) this.gateway.send({
+				address: sub.address,
+				port: sub.port
+			}, path, [value]);
+		});
+	}
+};
+
+//#endregion
+//#region src/application/use-cases/ManageSessionsUseCase.ts
+var ManageSessionsUseCase = class {
+	constructor(subscriptionManager) {
+		this.subscriptionManager = subscriptionManager;
+	}
+	cleanup() {
+		this.subscriptionManager.cleanup();
+	}
+};
+
+//#endregion
+//#region src/domain/entities/SubscriptionManager.ts
+/**
+* Manages OSC client subscriptions and their lifecycle.
+*/
+var SubscriptionManager = class {
+	logger;
+	subscribers = [];
+	constructor(logger) {
+		this.logger = logger;
+	}
+	/**
+	* Cleans up expired subscriptions.
+	* Standard X32 subscriptions last 10 seconds.
+	*/
+	cleanup() {
+		const now = Date.now();
+		const initialCount = this.subscribers.length;
+		this.subscribers = this.subscribers.filter((s) => {
+			const active = s.expires > now;
+			if (!active) this.logger.debug(LogCategory.SUB, `Expired subscriber`, {
+				type: s.type,
+				ip: s.address,
+				port: s.port,
+				path: "path" in s ? s.path : s.alias
+			});
+			return active;
+		});
+		if (this.subscribers.length !== initialCount) this.logger.info(LogCategory.SUB, `Cleanup finished`, {
+			removed: initialCount - this.subscribers.length,
+			remaining: this.subscribers.length
+		});
+	}
+	/**
+	* Gets all active subscribers.
+	* @returns Array of subscribers.
+	*/
+	getSubscribers() {
+		return this.subscribers;
+	}
+	/**
+	* Adds or renews a path-based subscription (e.g. /subscribe or /xremote).
+	* @param rinfo - Client remote info.
+	* @param path - Subscription path.
+	*/
+	addPathSubscriber(rinfo, path) {
+		const key = `${rinfo.address}:${rinfo.port}:${path}`;
+		const expires = Date.now() + 1e4;
+		const existing = this.subscribers.find((s) => s.type === "path" && `${s.address}:${s.port}:${s.path}` === key);
+		if (existing) {
+			existing.expires = expires;
+			this.logger.debug(LogCategory.SUB, `Renewed subscription`, {
+				ip: rinfo.address,
+				path
+			});
+		} else {
+			this.subscribers.push({
+				type: "path",
+				address: rinfo.address,
+				port: rinfo.port,
+				path,
+				expires
+			});
+			this.logger.info(LogCategory.SUB, `New subscription`, {
+				ip: rinfo.address,
+				path
+			});
+		}
+	}
+	/**
+	* Adds or renews a batch subscription.
+	* @param rinfo - Client remote info.
+	* @param alias - Response alias.
+	* @param paths - Target paths.
+	* @param start - Start index.
+	* @param count - Count.
+	* @param factor - Frequency factor.
+	* @param args - Command arguments.
+	*/
+	addBatchSubscriber(rinfo, alias, paths, start, count, factor, args) {
+		const expires = Date.now() + 1e4;
+		this.subscribers = this.subscribers.filter((s) => !(s.type === "batch" && s.alias === alias && s.address === rinfo.address));
+		this.subscribers.push({
+			type: "batch",
+			address: rinfo.address,
+			port: rinfo.port,
+			alias,
+			paths,
+			start,
+			count,
+			factor,
+			expires,
+			args
+		});
+		this.logger.info(LogCategory.SUB, `Batch subscription`, {
+			alias,
+			count: paths.length,
+			factor,
+			ip: rinfo.address,
+			args
+		});
+	}
+	/**
+	* Adds or renews a format subscription.
+	* @param rinfo - Client remote info.
+	* @param alias - Response alias.
+	* @param pattern - Path pattern.
+	* @param start - Start index.
+	* @param count - Count.
+	* @param factor - Frequency factor.
+	*/
+	addFormatSubscriber(rinfo, alias, pattern, start, count, factor) {
+		const expires = Date.now() + 1e4;
+		this.subscribers = this.subscribers.filter((s) => !(s.type === "format" && s.alias === alias && s.address === rinfo.address));
+		this.subscribers.push({
+			type: "format",
+			address: rinfo.address,
+			port: rinfo.port,
+			alias,
+			pattern,
+			start,
+			count,
+			factor,
+			expires
+		});
+		this.logger.info(LogCategory.SUB, `Format subscription`, {
+			alias,
+			pattern,
+			factor,
+			ip: rinfo.address
+		});
+	}
+	/**
+	* Adds or renews a high-frequency meter subscription.
+	* @param rinfo - Client remote info.
+	* @param meterPath - Target meter path.
+	*/
+	addMeterSubscriber(rinfo, meterPath) {
+		const expires = Date.now() + 1e4;
+		const existing = this.subscribers.find((s) => s.type === "meter" && s.meterPath === meterPath && s.address === rinfo.address);
+		this.subscribers = this.subscribers.filter((s) => !(s.type === "meter" && s.meterPath === meterPath && s.address === rinfo.address));
+		this.subscribers.push({
+			type: "meter",
+			address: rinfo.address,
+			port: rinfo.port,
+			meterPath,
+			expires
+		});
+		if (!existing) this.logger.info(LogCategory.SUB, `Meter subscription`, {
+			path: meterPath,
+			ip: rinfo.address
+		});
+		else this.logger.debug(LogCategory.SUB, `Meter renewal`, {
+			path: meterPath,
+			ip: rinfo.address
+		});
+	}
+	/**
+	* Removes a subscription.
+	* @param rinfo - Client remote info.
+	* @param path - Subscription path.
+	*/
+	removeSubscriber(rinfo, path) {
+		const initial = this.subscribers.length;
+		this.subscribers = this.subscribers.filter((s) => !(s.address === rinfo.address && s.port === rinfo.port && s.path === path));
+		if (this.subscribers.length < initial) this.logger.info(LogCategory.SUB, `Unsubscribed`, {
+			path,
+			ip: rinfo.address
+		});
+	}
+};
+
+//#endregion
+//#region src/domain/services/strategies/NodeDiscoveryStrategy.ts
+/**
+* Handles the /node command for tree traversal/discovery.
+* Returns a list of child nodes for a given path.
+*/
+var NodeDiscoveryStrategy = class {
+	constructor(schemaRegistry) {
+		this.schemaRegistry = schemaRegistry;
+	}
+	canHandle(address) {
+		return address === "/node";
+	}
+	execute(msg, _source) {
+		const queryPath = msg.args[0];
+		if (!queryPath) return [];
+		const children = /* @__PURE__ */ new Set();
+		const prefix = queryPath.endsWith("/") ? queryPath : `${queryPath}/`;
+		for (const key of this.schemaRegistry.getAllPaths()) if (key.startsWith(prefix)) {
+			const segment = key.slice(prefix.length).split("/")[0];
+			if (segment) children.add(segment);
+		}
+		return [{
+			address: "/node",
+			args: [queryPath, ...children]
+		}];
+	}
+};
+
+//#endregion
+//#region src/domain/services/strategies/StaticResponseStrategy.ts
+/**
+* Handles discovery and static information queries.
+* e.g., /status, /xinfo, /-prefs/...
+*/
+var StaticResponseStrategy = class {
+	constructor(serverIp, serverName, serverModel, staticResponseService) {
+		this.serverIp = serverIp;
+		this.serverName = serverName;
+		this.serverModel = serverModel;
+		this.staticResponseService = staticResponseService;
+	}
+	canHandle(address) {
+		return !!this.staticResponseService.getResponse(address);
+	}
+	execute(msg, _source) {
+		const rawResponse = this.staticResponseService.getResponse(msg.address);
+		if (!rawResponse) return [];
+		const args = rawResponse.map((arg) => {
+			if (typeof arg === "string") return arg.replace("{{ip}}", this.serverIp).replace("{{name}}", this.serverName).replace("{{model}}", this.serverModel);
+			return arg;
+		});
+		return [{
+			address: msg.address,
+			args
+		}];
+	}
+};
+
+//#endregion
+//#region src/domain/services/strategies/SubscriptionStrategy.ts
+var SubscriptionStrategy = class {
+	constructor(subscriptionManager, state, logger) {
+		this.subscriptionManager = subscriptionManager;
+		this.state = state;
+		this.logger = logger;
+	}
+	canHandle(address) {
+		return [
+			"/subscribe",
+			"/renew",
+			"/unsubscribe",
+			"/xremote"
+		].includes(address);
+	}
+	/**
+	* Handles Session and Subscription lifecycle.
+	*
+	* ROUTES:
+	* - /xremote: Firehose subscription (requests all console updates for 10s).
+	* - /subscribe [path]: Requests updates for a specific node path for 10s.
+	* - /renew [path]: Resets the 10s watchdog timer for a path.
+	* - /unsubscribe [path]: Stops updates for a path.
+	* @param msg - Parsed OSC message.
+	* @param source - Source address and port of the packet.
+	* @returns Returns the current value of the path upon subscription.
+	*/
+	execute(msg, source) {
+		const addr = msg.address;
+		if (addr === "/xremote") {
+			this.subscriptionManager.addPathSubscriber(source, "/xremote");
+			return [{
+				address: "/xremote",
+				args: []
+			}];
+		}
+		if (addr === "/unsubscribe") {
+			this.subscriptionManager.removeSubscriber(source, msg.args[0]);
+			this.logger.debug(LogCategory.SUB, `[UNSUB] ${msg.args[0]}`);
+			return [];
+		}
+		const target = msg.args[0];
+		this.subscriptionManager.addPathSubscriber(source, target);
+		const val = this.state.get(target);
+		if (val !== void 0) {
+			this.logger.debug(LogCategory.SUB, `[SUB] ${target} -> ${val}`);
+			return [{
+				address: target,
+				args: [val]
+			}];
+		}
+		return [];
+	}
+};
+
+//#endregion
+//#region src/domain/services/strategies/BatchStrategy.ts
+/**
+* Handles bulk data subscription requests from advanced clients like X32-Edit or Mixing Station.
+*
+* SUPPORTED COMMANDS:
+* - /formatsubscribe: Requests a range of numbered nodes (e.g. /ch/01-32/mix/fader).
+* - /batchsubscribe: Aggregates multiple parameters into a single binary blob response.
+*/
+var BatchStrategy = class {
+	/**
+	* Initializes the strategy.
+	* @param subscriptionManager - Session manager.
+	* @param logger - Logger instance.
+	*/
+	constructor(subscriptionManager, logger) {
+		this.subscriptionManager = subscriptionManager;
+		this.logger = logger;
+	}
+	/** @inheritdoc */
+	canHandle(address) {
+		return ["/batchsubscribe", "/formatsubscribe"].includes(address);
+	}
+	/** @inheritdoc */
+	execute(msg, source) {
+		const addr = msg.address;
+		if (addr === "/formatsubscribe") {
+			const alias = msg.args[0];
+			const pattern = msg.args[1];
+			const start = msg.args[2];
+			const end = msg.args[3];
+			const factor = msg.args[4];
+			const count = end - start + 1;
+			this.subscriptionManager.addFormatSubscriber(source, alias, pattern, start, count, factor);
+			this.logger.debug(LogCategory.SUB, `[FORMAT] ${alias} factor: ${factor}`);
+			return [];
+		}
+		if (addr === "/batchsubscribe") {
+			const alias = msg.args[0];
+			const firstIntIndex = msg.args.findIndex((a) => typeof a === "number");
+			if (firstIntIndex === -1) return [];
+			const paths = msg.args.slice(1, firstIntIndex);
+			const intArgs = msg.args.slice(firstIntIndex);
+			const factor = intArgs.pop();
+			const cmdArgs = intArgs;
+			this.subscriptionManager.addBatchSubscriber(source, alias, paths, 0, 1, factor, cmdArgs);
+			this.logger.debug(LogCategory.SUB, `[BATCH] ${alias} paths: ${JSON.stringify(paths)} args: ${JSON.stringify(cmdArgs)} factor: ${factor}`);
+			return [];
+		}
+		return [];
+	}
+};
+
+//#endregion
+//#region src/domain/services/strategies/MeterStrategy.ts
+/**
+* Handles high-frequency metering data requests.
+* Meters are sent as binary blobs to optimize network bandwidth.
+* Supports both direct address requests (/meters/1) and argument-based requests (/meters ,s "/meters/1").
+*/
+var MeterStrategy = class {
+	/**
+	* Initializes the strategy.
+	* @param subscriptionManager - Session manager.
+	* @param state - Current mixer state.
+	* @param meterService - Service to generate meter data.
+	*/
+	constructor(subscriptionManager, state, meterService) {
+		this.subscriptionManager = subscriptionManager;
+		this.state = state;
+		this.meterService = meterService;
+	}
+	/** @inheritdoc */
+	canHandle(address) {
+		return address.startsWith("/meters");
+	}
+	/** @inheritdoc */
+	execute(msg, source) {
+		let meterPath = msg.address;
+		if (msg.address === "/meters" && typeof msg.args[0] === "string" && msg.args[0].startsWith("/meters")) meterPath = msg.args[0];
+		this.subscriptionManager.addMeterSubscriber(source, meterPath);
+		const blob = this.meterService.generateMeterData(meterPath, this.state).toBlob();
+		return [{
+			address: meterPath,
+			args: [blob]
+		}];
+	}
+};
+
+//#endregion
+//#region src/domain/services/strategies/StateAccessStrategy.ts
+/**
+* General-purpose strategy for reading and writing console parameters.
+* acts as the fallback for any command that matches the schema.
+*
+* LOGIC:
+* - If no arguments: Treats as a QUERY (GET) and returns the current value.
+* - If arguments provided: Treats as an UPDATE (SET) and stores the new value.
+*/
+var StateAccessStrategy = class {
+	/**
+	* Initializes the strategy.
+	* @param state - Current mixer state.
+	* @param logger - Logger instance.
+	* @param schemaRegistry - Registry to validate addresses.
+	*/
+	constructor(state, logger, schemaRegistry) {
+		this.state = state;
+		this.logger = logger;
+		this.schemaRegistry = schemaRegistry;
+	}
+	/** @inheritdoc */
+	canHandle(address) {
+		return this.schemaRegistry.has(address);
+	}
+	/** @inheritdoc */
+	execute(msg, _source) {
+		const addr = msg.address;
+		const node = this.schemaRegistry.getNode(addr);
+		if (msg.args.length === 0) {
+			const val$1 = this.state.get(addr);
+			if (val$1 !== void 0) return [{
+				address: addr,
+				args: [val$1]
+			}];
+			return [];
+		}
+		const val = msg.args[0];
+		if (node) {
+			if (!node.validate(val)) {
+				this.logger.warn(LogCategory.DISPATCH, `[TYPE ERR] ${addr} expected ${node.type}, got ${typeof val}`);
+				return [];
+			}
+			this.state.set(addr, val);
+			this.logger.debug(LogCategory.STATE, `[SET] ${addr} -> ${val}`);
+			if (addr.startsWith("/config/mute/")) {
+				const groupIdx = parseInt(addr.split("/").pop(), 10);
+				if (!isNaN(groupIdx)) this.state.handleMuteGroupChange(groupIdx, val);
+			}
+		}
+		return [];
+	}
+};
+
+//#endregion
+//#region src/domain/services/OscMessageHandler.ts
+/**
+* The central dispatcher for incoming OSC messages.
+* Uses a Chain of Responsibility (Strategy pattern) to delegate handling.
+* Order of strategies is critical for correct prioritization.
+*/
+var OscMessageHandler = class {
+	/** List of active command strategies. */
+	strategies;
+	/**
+	* Initializes the handler with all available strategies.
+	* @param state - Global mixer state.
+	* @param subscriptionManager - Active client sessions.
+	* @param logger - Logger instance.
+	* @param serverIp - Host IP reported in handshakes.
+	* @param serverName - Console name reported in handshakes.
+	* @param serverModel - Console model reported in handshakes.
+	* @param meterService - Service for metering.
+	* @param schemaRegistry - Service for schema validation.
+	* @param staticResponseService - Service for static responses.
+	*/
+	constructor(state, subscriptionManager, logger, serverIp, serverName, serverModel, meterService, schemaRegistry, staticResponseService) {
+		this.logger = logger;
+		this.meterService = meterService;
+		this.schemaRegistry = schemaRegistry;
+		this.staticResponseService = staticResponseService;
+		this.strategies = [
+			new NodeDiscoveryStrategy(this.schemaRegistry),
+			new StaticResponseStrategy(serverIp, serverName, serverModel, this.staticResponseService),
+			new SubscriptionStrategy(subscriptionManager, state, logger),
+			new BatchStrategy(subscriptionManager, logger),
+			new MeterStrategy(subscriptionManager, state, this.meterService),
+			new StateAccessStrategy(state, logger, this.schemaRegistry)
+		];
+	}
+	/**
+	* Dispatches an incoming message to the first matching strategy.
+	* @param msg - Parsed OSC message.
+	* @param source - Source address and port of the packet.
+	* @returns Array of replies generated by the strategy.
+	*/
+	handle(msg, source) {
+		const addr = msg.address;
+		if (!addr.startsWith("/meters")) this.logger.debug(LogCategory.DISPATCH, `Handling`, {
+			addr,
+			args: msg.args
+		});
+		for (const strategy of this.strategies) if (strategy.canHandle(addr)) {
+			const replies = strategy.execute(msg, source);
+			if (replies.length > 0) this.logger.debug(LogCategory.DISPATCH, `Strategy ${strategy.constructor.name} replied`, { count: replies.length });
+			return replies;
+		}
+		this.logger.warn(LogCategory.DISPATCH, `Unknown Command`, {
+			addr,
+			args: msg.args,
+			ip: source.address
+		});
+		return [];
+	}
+};
+
+//#endregion
+//#region src/domain/models/MeterData.ts
+/**
+* Represents a set of meter values for a specific meter path.
+* Handles the storage of float values and serialization to X32-specific binary blobs.
+*/
+var MeterData = class {
+	_path;
+	_values;
+	/**
+	* Creates a new MeterData instance.
+	* @param path - The meter OSC path (e.g., "/meters/1").
+	* @param values - The array of float values (0.0 - 1.0 or similar).
+	*/
+	constructor(path, values) {
+		this._path = path;
+		this._values = values;
+	}
+	/**
+	* Gets the meter path.
+	*/
+	get path() {
+		return this._path;
+	}
+	/**
+	* Gets the values.
+	*/
+	get values() {
+		return [...this._values];
+	}
+	/**
+	* Generates an optimized binary blob for X32 meters (mixed endianness).
+	* Structure: [Size (Int32BE)] [Count (Int32LE)] [Float1 (LE)] [Float2 (LE)] ...
+	* @returns Buffer containing the OSC blob.
+	*/
+	toBlob() {
+		const count = this._values.length;
+		const totalSize = 8 + count * 4;
+		const blob = Buffer.alloc(totalSize);
+		blob.writeInt32BE(totalSize, 0);
+		blob.writeInt32LE(count, 4);
+		for (let i = 0; i < count; i++) blob.writeFloatLE(this._values[i], 8 + i * 4);
+		return blob;
+	}
+};
+
+//#endregion
+//#region src/domain/models/MeterConfig.ts
+/**
+* Configuration for meter counts per path.
+*/
+const METER_COUNTS = {
+	"/meters/0": 70,
+	"/meters/1": 96,
+	"/meters/2": 49,
+	"/meters/3": 22,
+	"/meters/4": 82,
+	"/meters/5": 27,
+	"/meters/6": 4,
+	"/meters/7": 16,
+	"/meters/8": 6,
+	"/meters/9": 32,
+	"/meters/10": 32,
+	"/meters/11": 5,
+	"/meters/12": 4,
+	"/meters/13": 48,
+	"/meters/14": 80,
+	"/meters/15": 50,
+	"/meters/16": 48
+};
+
+//#endregion
+//#region src/domain/services/MeterService.ts
+/**
+* Service responsible for generating meter values and data.
+* Mimics the physics/audio engine of the X32.
+*/
+var MeterService = class {
+	/**
+	* Generates a MeterData object for a given path.
+	* @param path - The meter OSC path (e.g., "/meters/1").
+	* @param state - The current X32 state (for correlating faders to meters).
+	* @returns MeterData object containing the values.
+	*/
+	generateMeterData(path, state) {
+		const count = METER_COUNTS[path];
+		if (count === void 0) return new MeterData(path, []);
+		const values = [];
+		for (let i = 0; i < count; i++) {
+			let val = Math.random() * .05;
+			if (state && path === "/meters/1") {
+				if (i < 32) {
+					const faderPath = `/ch/${(i + 1).toString().padStart(2, "0")}/mix/fader`;
+					const fader = state.get(faderPath);
+					if (typeof fader === "number") val = fader > .01 ? fader * (.9 + Math.random() * .1) : 0;
+				}
+			}
+			values.push(val);
+		}
+		return new MeterData(path, values);
+	}
+};
+
+//#endregion
+//#region src/domain/services/StaticResponseService.ts
+/**
+* Static OSC responses for X32 Discovery and System status.
+*/
+const STATIC_RESPONSES_DATA = {
+	"/xinfo": [
+		"{{ip}}",
+		"{{name}}",
+		"{{model}}",
+		"4.06"
+	],
+	"/info": [
+		"V2.05",
+		"{{name}}",
+		"{{model}}",
+		"4.06"
+	],
+	"/status": [
+		"active",
+		"{{ip}}",
+		"{{name}}"
+	],
+	"/-prefs/invertmutes": [0],
+	"/-prefs/fine": [0],
+	"/-prefs/bright": [50],
+	"/-prefs/contrast": [50],
+	"/-prefs/led_bright": [50],
+	"/-prefs/lcd_bright": [50],
+	"/-stat/userpar/1/value": [0],
+	"/-stat/userpar/2/value": [0],
+	"/-stat/tape/state": [0],
+	"/-stat/aes50/A": [0],
+	"/-stat/aes50/B": [0],
+	"/-stat/solo": [0],
+	"/-stat/rtasource": [0],
+	"/-urec/errorcode": [0],
+	"/-prefs/rta/gain": [0],
+	"/-prefs/rta/autogain": [0],
+	"/-prefs/hardmute": [0],
+	"/-prefs/dcamute": [0],
+	"/config/mono/mode": [0],
+	"/config/amixenable/X": [0],
+	"/config/amixenable/Y": [0],
+	"/-show/prepos/current": [0],
+	"/-show/showfile/current": [""],
+	"/-action/setrtasrc": [0],
+	"/-action/playtrack": [0],
+	"/-action/goscene": [0],
+	"/-action/setscene": [0]
+};
+/**
+* Service providing static system responses.
+* Mimics the fixed firmware responses of the X32.
+*/
+var StaticResponseService = class {
+	responses = STATIC_RESPONSES_DATA;
+	/**
+	* Retrieves a static response for a given path.
+	* @param path - The OSC path.
+	* @returns The response arguments or undefined.
+	*/
+	getResponse(path) {
+		return this.responses[path];
+	}
+};
+
+//#endregion
+//#region src/application/use-cases/SimulationService.ts
+/**
+* Gets the first non-internal IPv4 address found on this machine.
+* @returns Detected IP or localhost.
+*/
+function getLocalIp() {
+	const interfaces = os.networkInterfaces();
+	for (const name of Object.keys(interfaces)) for (const iface of interfaces[name]) if (iface.family === "IPv4" && !iface.internal) return iface.address;
+	return "127.0.0.1";
+}
+var SimulationService = class {
+	subscriptionManager;
+	messageHandler;
+	processPacket;
+	broadcastUpdates;
+	manageSessions;
+	meterService;
+	staticResponseService;
+	updateInterval = null;
+	cleanupInterval = null;
+	constructor(gateway, logger, stateRepo, schemaRegistry, port = 10023, ip = "0.0.0.0", name = "osc-server", model = "X32") {
+		this.gateway = gateway;
+		this.logger = logger;
+		this.stateRepo = stateRepo;
+		this.schemaRegistry = schemaRegistry;
+		this.port = port;
+		this.ip = ip;
+		const state = this.stateRepo.getState();
+		this.subscriptionManager = new SubscriptionManager(logger);
+		this.meterService = new MeterService();
+		this.staticResponseService = new StaticResponseService();
+		const reportedIp = this.ip === "0.0.0.0" ? getLocalIp() : this.ip;
+		this.messageHandler = new OscMessageHandler(state, this.subscriptionManager, logger, reportedIp, name, model, this.meterService, this.schemaRegistry, this.staticResponseService);
+		this.processPacket = new ProcessPacketUseCase(this.messageHandler, gateway);
+		this.broadcastUpdates = new BroadcastUpdatesUseCase(this.subscriptionManager, state, gateway, logger, this.meterService, this.schemaRegistry);
+		this.manageSessions = new ManageSessionsUseCase(this.subscriptionManager);
+		state.on("change", (evt) => {
+			this.logger.info(LogCategory.STATE, `State Changed`, evt);
+			this.broadcastUpdates.broadcastSingleChange(evt.address, evt.value);
+		});
+		this.gateway.onPacket((packet, source) => this.processPacket.execute(packet, source));
+	}
+	async start() {
+		await this.gateway.start(this.port, this.ip);
+		this.cleanupInterval = setInterval(() => {
+			this.manageSessions.cleanup();
+		}, 5e3);
+		this.updateInterval = setInterval(() => {
+			this.broadcastUpdates.execute();
+		}, 100);
+	}
+	async stop() {
+		if (this.updateInterval) clearInterval(this.updateInterval);
+		if (this.cleanupInterval) clearInterval(this.cleanupInterval);
+		await this.gateway.stop();
+	}
+	resetState() {
+		this.stateRepo.reset();
+	}
+};
+
+//#endregion
+//#region src/domain/entities/X32State.ts
+/**
+* Manages the internal "Digital Twin" state of the X32 console.
+* acts as a single source of truth for all parameters.
+* Emits 'change' events whenever a value is updated.
+*/
+var X32State = class extends EventEmitter {
+	/** Map storing all OSC paths and their current values. */
+	state = /* @__PURE__ */ new Map();
+	defaultState = /* @__PURE__ */ new Map();
+	/**
+	* Initializes the state with default values from the schema.
+	* @param schema - The schema definition map.
+	*/
+	constructor(schema) {
+		super();
+		for (const [addr, def] of Object.entries(schema)) this.defaultState.set(addr, def.default);
+		this.reset();
+	}
+	/**
+	* Resets all state parameters to their default values defined in the schema.
+	*/
+	reset() {
+		this.state.clear();
+		this.defaultState.forEach((val, key) => {
+			this.state.set(key, val);
+		});
+	}
+	/**
+	* Retrieves the value of a specific OSC node.
+	* @param address - The full OSC address path.
+	* @returns The stored value (number or string) or undefined if not found.
+	*/
+	get(address) {
+		return this.state.get(address);
+	}
+	/**
+	* Updates the value of a specific OSC node and notifies subscribers.
+	* @param address - The full OSC address path.
+	* @param value - The new value to store.
+	*/
+	set(address, value) {
+		this.state.set(address, value);
+		this.emit("change", {
+			address,
+			value
+		});
+	}
+	/**
+	* Specialized logic to handle X32 Mute Groups side-effects.
+	* When a mute group is toggled, it iterates through all channels
+	* assigned to that group and updates their individual mute status.
+	* @param groupIdx - The index of the mute group (1-6).
+	* @param isOn - The new state of the group master switch (0 or 1).
+	*/
+	handleMuteGroupChange(groupIdx, isOn) {
+		for (let i = 1; i <= 32; i++) {
+			const ch = i.toString().padStart(2, "0");
+			const grpVal = this.get(`/ch/${ch}/grp/mute`);
+			if (typeof grpVal === "number") {
+				if ((grpVal & 1 << groupIdx - 1) !== 0) {
+					const targetMute = isOn === 1 ? 0 : 1;
+					const muteAddr = `/ch/${ch}/mix/on`;
+					this.set(muteAddr, targetMute);
+				}
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/infrastructure/repositories/InMemoryStateRepository.ts
+var InMemoryStateRepository = class {
+	state;
+	constructor(logger, schemaRegistry) {
+		this.logger = logger;
+		this.state = new X32State(schemaRegistry.getSchema());
+	}
+	getState() {
+		return this.state;
+	}
+	reset() {
+		this.logger.info(LogCategory.SYSTEM, "Resetting state to defaults");
+		this.state.reset();
+	}
+};
+
+//#endregion
+//#region src/infrastructure/services/ConsoleLogger.ts
+/**
+* Log levels for the application.
+*/
+let LogLevel = /* @__PURE__ */ function(LogLevel$1) {
+	LogLevel$1[LogLevel$1["DEBUG"] = 0] = "DEBUG";
+	LogLevel$1[LogLevel$1["INFO"] = 1] = "INFO";
+	LogLevel$1[LogLevel$1["WARN"] = 2] = "WARN";
+	LogLevel$1[LogLevel$1["ERROR"] = 3] = "ERROR";
+	LogLevel$1[LogLevel$1["NONE"] = 4] = "NONE";
+	return LogLevel$1;
+}({});
+/**
+* Enhanced logger with category support and environment-based filtering.
+*/
+var ConsoleLogger = class ConsoleLogger {
+	static instance;
+	level = LogLevel.DEBUG;
+	hiddenPatterns = [];
+	enabledCategories = new Set([
+		LogCategory.SYSTEM,
+		LogCategory.OSC_IN,
+		LogCategory.OSC_OUT,
+		LogCategory.DISPATCH,
+		LogCategory.STATE,
+		LogCategory.SUB
+	]);
+	constructor() {
+		if (process.env.HIDDEN_LOG) this.hiddenPatterns = process.env.HIDDEN_LOG.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+	}
+	/**
+	* Gets the singleton instance.
+	* @returns ConsoleLogger instance.
+	*/
+	static getInstance() {
+		if (!ConsoleLogger.instance) ConsoleLogger.instance = new ConsoleLogger();
+		return ConsoleLogger.instance;
+	}
+	/**
+	* Sets the minimum log level.
+	* @param level - LogLevel.
+	*/
+	setLevel(level) {
+		this.level = level;
+	}
+	/**
+	* Enables a category for output.
+	* @param cat - Category name.
+	*/
+	enableCategory(cat) {
+		this.enabledCategories.add(cat);
+	}
+	/**
+	* Disables a category for output.
+	* @param cat - Category name.
+	*/
+	disableCategory(cat) {
+		this.enabledCategories.delete(cat);
+	}
+	/**
+	* Logs a debug message.
+	* @param category - Log category.
+	* @param msg - Message string.
+	* @param data - Optional metadata.
+	*/
+	debug(category, msg, data) {
+		if (this.shouldHide(msg, data)) return;
+		if (this.level <= LogLevel.DEBUG && this.enabledCategories.has(category)) console.log(this.format("DEBUG", category, msg, data));
+	}
+	/**
+	* Logs an info message.
+	* @param category - Log category.
+	* @param msg - Message string.
+	* @param data - Optional metadata.
+	*/
+	info(category, msg, data) {
+		if (this.shouldHide(msg, data)) return;
+		if (this.level <= LogLevel.INFO && this.enabledCategories.has(category)) console.log(this.format("INFO ", category, msg, data));
+	}
+	/**
+	* Logs a warning message.
+	* @param category - Log category.
+	* @param msg - Message string.
+	* @param data - Optional metadata.
+	*/
+	warn(category, msg, data) {
+		if (this.shouldHide(msg, data)) return;
+		if (this.level <= LogLevel.WARN && this.enabledCategories.has(category)) console.log(this.format("WARN ", category, msg, data));
+	}
+	/**
+	* Logs an error message.
+	* @param category - Log category.
+	* @param msg - Message string.
+	* @param err - Optional error object.
+	*/
+	error(category, msg, err) {
+		if (this.shouldHide(msg, err)) return;
+		if (this.level <= LogLevel.ERROR) console.log(this.format("ERROR", category, msg, err));
+	}
+	/**
+	* Checks if a log should be hidden based on patterns.
+	* @param msg - Message.
+	* @param data - Metadata.
+	* @returns True if log should be suppressed.
+	*/
+	shouldHide(msg, data) {
+		if (this.hiddenPatterns.length === 0) return false;
+		if (this.hiddenPatterns.some((p) => msg.includes(p))) return true;
+		if (data !== void 0) {
+			const strData = Buffer.isBuffer(data) ? data.toString("hex") : typeof data === "object" ? JSON.stringify(data) : String(data);
+			if (this.hiddenPatterns.some((p) => strData.includes(p))) return true;
+		}
+		return false;
+	}
+	/**
+	* Formats the log message.
+	* @param level - Level label.
+	* @param category - Category label.
+	* @param msg - Message.
+	* @param data - Metadata.
+	* @returns Formatted string.
+	*/
+	format(level, category, msg, data) {
+		const now = /* @__PURE__ */ new Date();
+		let out = `\x1b[90m[${`${now.getHours().toString().padStart(2, "0")}:${now.getMinutes().toString().padStart(2, "0")}:${now.getSeconds().toString().padStart(2, "0")}.${now.getMilliseconds().toString().padStart(3, "0")}`}]\x1b[0m `;
+		switch (level) {
+			case "DEBUG":
+				out += `\x1b[36m[DEBUG]\x1b[0m`;
+				break;
+			case "INFO ":
+				out += `\x1b[32m[INFO ]\x1b[0m`;
+				break;
+			case "WARN ":
+				out += `\x1b[33m[WARN ]\x1b[0m`;
+				break;
+			case "ERROR":
+				out += `\x1b[31m[ERROR]\x1b[0m`;
+				break;
+		}
+		out += ` \x1b[35m[${category.padEnd(8)}]\x1b[0m ${msg}`;
+		if (data !== void 0) try {
+			if (Buffer.isBuffer(data)) out += ` \x1b[90m<Buffer ${data.length}b>\x1b[0m`;
+			else if (typeof data === "object" && data !== null) out += ` \x1b[90m${JSON.stringify(data)}\x1b[0m`;
+			else out += ` \x1b[90m${data}\x1b[0m`;
+		} catch {
+			out += ` [Circular/Error]`;
+		}
+		return out;
+	}
+};
+
+//#endregion
+//#region src/infrastructure/services/UdpNetworkGateway.ts
+var UdpNetworkGateway = class {
+	socket;
+	isRunning = false;
+	packetCallback = null;
+	constructor(logger, codec) {
+		this.logger = logger;
+		this.codec = codec;
+		this.socket = dgram.createSocket("udp4");
+	}
+	onPacket(callback) {
+		this.packetCallback = callback;
+	}
+	start(port, ip) {
+		return new Promise((resolve, reject) => {
+			this.socket.on("error", (err) => {
+				this.logger.error(LogCategory.SYSTEM, "Socket Error", err);
+				reject(err);
+			});
+			this.socket.on("message", (msg, rinfo) => {
+				try {
+					this.logger.debug(LogCategory.OSC_IN, `Packet received ${msg.length}b`, { ip: rinfo.address });
+					const decoded = this.codec.decode(msg);
+					if (this.packetCallback) this.packetCallback(decoded, {
+						address: rinfo.address,
+						port: rinfo.port
+					});
+				} catch (err) {
+					this.logger.error(LogCategory.OSC_IN, "Decode Error", err instanceof Error ? err : new Error(String(err)));
+				}
+			});
+			this.socket.bind(port, ip, () => {
+				this.logger.info(LogCategory.SYSTEM, `Server bound to ${ip}:${port}`);
+				this.isRunning = true;
+				resolve();
+			});
+		});
+	}
+	stop() {
+		return new Promise((resolve) => {
+			if (!this.isRunning) return resolve();
+			this.socket.close(() => {
+				this.isRunning = false;
+				this.logger.info(LogCategory.SYSTEM, "Server stopped");
+				resolve();
+			});
+		});
+	}
+	send(target, address, args) {
+		const buf = this.codec.encode(address, args);
+		const cat = address.startsWith("/meters") ? LogCategory.METER : LogCategory.OSC_OUT;
+		this.logger.debug(cat, `Sending ${address}`, {
+			ip: target.address,
+			args
+		});
+		this.socket.send(buf, target.port, target.address, (err) => {
+			if (err) this.logger.error(LogCategory.OSC_OUT, "Send Error", err);
+		});
+	}
+};
+
+//#endregion
+export { SimulationService as a, InMemoryStateRepository as i, ConsoleLogger as n, STATIC_RESPONSES_DATA as o, LogLevel as r, LogCategory as s, UdpNetworkGateway as t };