@djodjonx/x32-simulator 0.0.2 → 0.0.3

package/dist/{UdpNetworkGateway-BrroQ6-Q.mjs → SchemaRegistry-BRVgnyaA.mjs}

@@ -1,6 +1,7 @@
 import * as os from "os";
 import { EventEmitter } from "node:events";
 import * as dgram from "node:dgram";
+import { Buffer as Buffer$1 } from "node:buffer";
 
 //#region src/application/use-cases/ProcessPacketUseCase.ts
 var ProcessPacketUseCase = class {
@@ -832,6 +833,10 @@ function getLocalIp() {
 	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";
 }
+/**
+* The core service that manages the X32 simulation, including networking, 
+* state management, and OSC message handling.
+*/
 var SimulationService = class {
 	subscriptionManager;
 	messageHandler;
@@ -842,6 +847,17 @@ var SimulationService = class {
 	staticResponseService;
 	updateInterval = null;
 	cleanupInterval = null;
+	/**
+	* Creates a new SimulationService instance.
+	* @param gateway - The network gateway for OSC communication.
+	* @param logger - The logger service.
+	* @param stateRepo - The repository managing the mixer state.
+	* @param schemaRegistry - The registry for X32 OSC schema.
+	* @param port - UDP port to listen on (default 10023).
+	* @param ip - IP address to bind to (default '0.0.0.0').
+	* @param name - Reported console name.
+	* @param model - Reported console model.
+	*/
 	constructor(gateway, logger, stateRepo, schemaRegistry, port = 10023, ip = "0.0.0.0", name = "osc-server", model = "X32") {
 		this.gateway = gateway;
 		this.logger = logger;
@@ -864,6 +880,9 @@ var SimulationService = class {
 		});
 		this.gateway.onPacket((packet, source) => this.processPacket.execute(packet, source));
 	}
+	/**
+	* Starts the simulator server and internal loops.
+	*/
 	async start() {
 		await this.gateway.start(this.port, this.ip);
 		this.cleanupInterval = setInterval(() => {
@@ -873,11 +892,17 @@ var SimulationService = class {
 			this.broadcastUpdates.execute();
 		}, 100);
 	}
+	/**
+	* Stops the simulator server and stops all internal loops.
+	*/
 	async stop() {
 		if (this.updateInterval) clearInterval(this.updateInterval);
 		if (this.cleanupInterval) clearInterval(this.cleanupInterval);
 		await this.gateway.stop();
 	}
+	/**
+	* Resets the mixer state to default values.
+	*/
 	resetState() {
 		this.stateRepo.reset();
 	}
@@ -887,7 +912,7 @@ var SimulationService = class {
 //#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.
+* It acts as a single source of truth for all parameters.
 * Emits 'change' events whenever a value is updated.
 */
 var X32State = class extends EventEmitter {
@@ -954,17 +979,76 @@ var X32State = class extends EventEmitter {
 	}
 };
 
+//#endregion
+//#region src/domain/models/X32Node.ts
+/**
+* Metadata for a single state node in the X32 schema.
+* Represents a "Knob" or "Variable" on the console.
+*/
+var X32Node = class X32Node {
+	/** Value type (f=float, i=int, s=string). */
+	type;
+	/** Default value for reset. */
+	default;
+	/**
+	* Creates a new X32Node.
+	* @param type - The OSC data type ('f', 'i', 's').
+	* @param defaultValue - The default value.
+	*/
+	constructor(type, defaultValue) {
+		this.type = type;
+		this.default = defaultValue;
+	}
+	/**
+	* Validates if a value is compatible with this node's type.
+	* @param value - The value to check.
+	* @returns True if valid.
+	*/
+	validate(value) {
+		if (this.type === "f") return typeof value === "number";
+		if (this.type === "i") return typeof value === "number";
+		if (this.type === "s") return typeof value === "string";
+		return false;
+	}
+	/**
+	* Factory method to create from a plain object (for compatibility/migration).
+	* @param obj - Plain object.
+	* @param obj.type - OSC data type.
+	* @param obj.default - Default value.
+	* @returns A new X32Node instance.
+	*/
+	static from(obj) {
+		return new X32Node(obj.type, obj.default);
+	}
+};
+
 //#endregion
 //#region src/infrastructure/repositories/InMemoryStateRepository.ts
+/**
+* In-memory implementation of the state repository.
+* Stores the mixer state in volatile memory during the simulator's execution.
+*/
 var InMemoryStateRepository = class {
 	state;
+	/**
+	* Creates a new InMemoryStateRepository.
+	* @param logger - Logger service.
+	* @param schemaRegistry - Registry providing the initial state schema.
+	*/
 	constructor(logger, schemaRegistry) {
 		this.logger = logger;
 		this.state = new X32State(schemaRegistry.getSchema());
 	}
+	/**
+	* Returns the current mixer state instance.
+	* @returns The X32State entity.
+	*/
 	getState() {
 		return this.state;
 	}
+	/**
+	* Resets the entire state to its default values.
+	*/
 	reset() {
 		this.logger.info(LogCategory.SYSTEM, "Resetting state to defaults");
 		this.state.reset();
@@ -1125,18 +1209,37 @@ var ConsoleLogger = class ConsoleLogger {
 
 //#endregion
 //#region src/infrastructure/services/UdpNetworkGateway.ts
+/**
+* Node.js UDP implementation of the network gateway.
+* Handles the low-level socket communication and OSC packet routing.
+*/
 var UdpNetworkGateway = class {
 	socket;
 	isRunning = false;
 	packetCallback = null;
+	/**
+	* Creates a new UdpNetworkGateway.
+	* @param logger - Logger service.
+	* @param codec - OSC codec for encoding/decoding.
+	*/
 	constructor(logger, codec) {
 		this.logger = logger;
 		this.codec = codec;
 		this.socket = dgram.createSocket("udp4");
 	}
+	/**
+	* Registers a callback to be executed whenever a new OSC packet arrives.
+	* @param callback - Function called with decoded packet and source info.
+	*/
 	onPacket(callback) {
 		this.packetCallback = callback;
 	}
+	/**
+	* Starts the UDP server on the specified port and IP.
+	* @param port - UDP port.
+	* @param ip - IP address to bind to.
+	* @returns Promise resolving when the socket is bound.
+	*/
 	start(port, ip) {
 		return new Promise((resolve, reject) => {
 			this.socket.on("error", (err) => {
@@ -1162,6 +1265,10 @@ var UdpNetworkGateway = class {
 			});
 		});
 	}
+	/**
+	* Shuts down the UDP server.
+	* @returns Promise resolving when the socket is closed.
+	*/
 	stop() {
 		return new Promise((resolve) => {
 			if (!this.isRunning) return resolve();
@@ -1172,6 +1279,12 @@ var UdpNetworkGateway = class {
 			});
 		});
 	}
+	/**
+	* Sends an OSC message to a specific remote client.
+	* @param target - Target client info (IP/port).
+	* @param address - OSC address pattern.
+	* @param args - Array of arguments.
+	*/
 	send(target, address, args) {
 		const buf = this.codec.encode(address, args);
 		const cat = address.startsWith("/meters") ? LogCategory.METER : LogCategory.OSC_OUT;
@@ -1186,4 +1299,879 @@ var UdpNetworkGateway = class {
 };
 
 //#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 };
+//#region node_modules/node-osc/lib/Message.mjs
+const typeTags = {
+	s: "string",
+	f: "float",
+	i: "integer",
+	b: "blob",
+	m: "midi"
+};
+/**
+* Represents a typed argument for an OSC message.
+* 
+* @class
+* @private
+*/
+var Argument = class {
+	/**
+	* @param {string} type - The type of the argument (string, float, integer, blob, boolean).
+	* @param {*} value - The value of the argument.
+	*/
+	constructor(type, value) {
+		this.type = type;
+		this.value = value;
+	}
+};
+/**
+* Represents an OSC message with an address and arguments.
+* 
+* OSC messages consist of an address pattern (string starting with '/')
+* and zero or more arguments of various types.
+* 
+* @class
+* 
+* @example
+* // Create a message with constructor arguments
+* const msg = new Message('/test', 1, 2, 'hello');
+* 
+* @example
+* // Create a message and append arguments
+* const msg = new Message('/test');
+* msg.append(1);
+* msg.append('hello');
+* msg.append(3.14);
+*/
+var Message = class {
+	/**
+	* Create an OSC Message.
+	* 
+	* @param {string} address - The OSC address pattern (e.g., '/oscillator/frequency').
+	* @param {...*} args - Optional arguments to include in the message.
+	* 
+	* @example
+	* const msg = new Message('/test');
+	* 
+	* @example
+	* const msg = new Message('/test', 1, 2, 3);
+	* 
+	* @example
+	* const msg = new Message('/synth', 'note', 60, 0.5);
+	*/
+	constructor(address, ...args) {
+		this.oscType = "message";
+		this.address = address;
+		this.args = args;
+	}
+	/**
+	* Append an argument to the message.
+	* 
+	* Automatically detects the type based on the JavaScript type:
+	* - Integers are encoded as OSC integers
+	* - Floats are encoded as OSC floats
+	* - Strings are encoded as OSC strings
+	* - Booleans are encoded as OSC booleans
+	* - Buffers are encoded as OSC blobs
+	* - Arrays are recursively appended
+	* - Objects with a 'type' property are used as-is
+	* 
+	* @param {*} arg - The argument to append. Can be:
+	*   - A primitive value (number, string, boolean)
+	*   - A Buffer (encoded as blob)
+	*   - An array of values (will be recursively appended)
+	*   - An object with 'type' and 'value' properties for explicit type control
+	* 
+	* @throws {Error} If the argument type cannot be encoded.
+	* 
+	* @example
+	* const msg = new Message('/test');
+	* msg.append(42);           // Integer
+	* msg.append(3.14);         // Float
+	* msg.append('hello');      // String
+	* msg.append(true);         // Boolean
+	* 
+	* @example
+	* // Append multiple values at once
+	* msg.append([1, 2, 3]);
+	* 
+	* @example
+	* // Explicitly specify type
+	* msg.append({ type: 'float', value: 42 });
+	* msg.append({ type: 'blob', value: Buffer.from('data') });
+	* 
+	* @example
+	* // MIDI messages (4 bytes: port, status, data1, data2)
+	* msg.append({ type: 'midi', value: { port: 0, status: 144, data1: 60, data2: 127 } });
+	* msg.append({ type: 'm', value: Buffer.from([0, 144, 60, 127]) });
+	*/
+	append(arg) {
+		let argOut;
+		switch (typeof arg) {
+			case "object":
+				if (Buffer.isBuffer(arg)) this.args.push(arg);
+				else if (arg instanceof Array) arg.forEach((a) => this.append(a));
+				else if (arg.type) {
+					if (typeTags[arg.type]) arg.type = typeTags[arg.type];
+					this.args.push(arg);
+				} else throw new Error(`don't know how to encode object ${arg}`);
+				break;
+			case "number":
+				if (Math.floor(arg) === arg) argOut = new Argument("integer", arg);
+				else argOut = new Argument("float", arg);
+				break;
+			case "string":
+				argOut = new Argument("string", arg);
+				break;
+			case "boolean":
+				argOut = new Argument("boolean", arg);
+				break;
+			default: throw new Error(`don't know how to encode ${arg}`);
+		}
+		if (argOut) this.args.push(argOut);
+	}
+};
+var Message_default = Message;
+
+//#endregion
+//#region node_modules/node-osc/lib/osc.mjs
+function padString(str) {
+	const nullTerminated = str + "\0";
+	const padding = (4 - Buffer$1.byteLength(nullTerminated) % 4) % 4;
+	return nullTerminated + "\0".repeat(padding);
+}
+function readString(buffer, offset) {
+	let end = offset;
+	while (end < buffer.length && buffer[end] !== 0) end++;
+	if (end >= buffer.length) throw new Error("Malformed Packet: Missing null terminator for string");
+	return {
+		value: buffer.subarray(offset, end).toString("utf8"),
+		offset: offset + Math.ceil((end - offset + 1) / 4) * 4
+	};
+}
+function writeInt32(value) {
+	const buffer = Buffer$1.alloc(4);
+	buffer.writeInt32BE(value, 0);
+	return buffer;
+}
+function readInt32(buffer, offset) {
+	if (offset + 4 > buffer.length) throw new Error("Malformed Packet: Not enough bytes for int32");
+	return {
+		value: buffer.readInt32BE(offset),
+		offset: offset + 4
+	};
+}
+function writeFloat32(value) {
+	const buffer = Buffer$1.alloc(4);
+	buffer.writeFloatBE(value, 0);
+	return buffer;
+}
+function readFloat32(buffer, offset) {
+	if (offset + 4 > buffer.length) throw new Error("Malformed Packet: Not enough bytes for float32");
+	return {
+		value: buffer.readFloatBE(offset),
+		offset: offset + 4
+	};
+}
+function writeBlob(value) {
+	const length = value.length;
+	const lengthBuffer = writeInt32(length);
+	const padding = 4 - length % 4;
+	const paddingBuffer = Buffer$1.alloc(padding === 4 ? 0 : padding);
+	return Buffer$1.concat([
+		lengthBuffer,
+		value,
+		paddingBuffer
+	]);
+}
+function readBlob(buffer, offset) {
+	const lengthResult = readInt32(buffer, offset);
+	const length = lengthResult.value;
+	if (length < 0) throw new Error("Malformed Packet: Invalid blob length");
+	if (lengthResult.offset + length > buffer.length) throw new Error("Malformed Packet: Not enough bytes for blob");
+	const data = buffer.subarray(lengthResult.offset, lengthResult.offset + length);
+	const padding = 4 - length % 4;
+	const nextOffset = lengthResult.offset + length + (padding === 4 ? 0 : padding);
+	if (nextOffset > buffer.length) throw new Error("Malformed Packet: Not enough bytes for blob padding");
+	return {
+		value: data,
+		offset: nextOffset
+	};
+}
+function writeTimeTag(value) {
+	const buffer = Buffer$1.alloc(8);
+	if (value === 0 || value === null || value === void 0) {
+		buffer.writeUInt32BE(0, 0);
+		buffer.writeUInt32BE(1, 4);
+	} else if (typeof value === "number") {
+		const seconds = Math.floor(value);
+		const fraction = Math.floor((value - seconds) * 4294967296);
+		buffer.writeUInt32BE(seconds + 2208988800, 0);
+		buffer.writeUInt32BE(fraction, 4);
+	} else {
+		buffer.writeUInt32BE(0, 0);
+		buffer.writeUInt32BE(1, 4);
+	}
+	return buffer;
+}
+function readTimeTag(buffer, offset) {
+	if (offset + 8 > buffer.length) throw new Error("Malformed Packet: Not enough bytes for timetag");
+	const seconds = buffer.readUInt32BE(offset);
+	const fraction = buffer.readUInt32BE(offset + 4);
+	let value;
+	if (seconds === 0 && fraction === 1) value = 0;
+	else value = seconds - 2208988800 + fraction / 4294967296;
+	return {
+		value,
+		offset: offset + 8
+	};
+}
+function writeMidi(value) {
+	const buffer = Buffer$1.alloc(4);
+	if (Buffer$1.isBuffer(value)) {
+		if (value.length !== 4) throw new Error("MIDI message must be exactly 4 bytes");
+		value.copy(buffer);
+	} else if (typeof value === "object" && value !== null) {
+		buffer.writeUInt8(value.port || 0, 0);
+		buffer.writeUInt8(value.status || 0, 1);
+		buffer.writeUInt8(value.data1 || 0, 2);
+		buffer.writeUInt8(value.data2 || 0, 3);
+	} else throw new Error("MIDI value must be a 4-byte Buffer or object with port, status, data1, data2 properties");
+	return buffer;
+}
+function readMidi(buffer, offset) {
+	if (offset + 4 > buffer.length) throw new Error("Not enough bytes for MIDI message");
+	return {
+		value: buffer.subarray(offset, offset + 4),
+		offset: offset + 4
+	};
+}
+function encodeArgument(arg) {
+	if (typeof arg === "object" && arg.type && arg.value !== void 0) switch (arg.type) {
+		case "i":
+		case "integer": return {
+			tag: "i",
+			data: writeInt32(arg.value)
+		};
+		case "f":
+		case "float": return {
+			tag: "f",
+			data: writeFloat32(arg.value)
+		};
+		case "s":
+		case "string": return {
+			tag: "s",
+			data: Buffer$1.from(padString(arg.value))
+		};
+		case "b":
+		case "blob": return {
+			tag: "b",
+			data: writeBlob(arg.value)
+		};
+		case "d":
+		case "double": return {
+			tag: "f",
+			data: writeFloat32(arg.value)
+		};
+		case "T": return {
+			tag: "T",
+			data: Buffer$1.alloc(0)
+		};
+		case "F": return {
+			tag: "F",
+			data: Buffer$1.alloc(0)
+		};
+		case "boolean": return arg.value ? {
+			tag: "T",
+			data: Buffer$1.alloc(0)
+		} : {
+			tag: "F",
+			data: Buffer$1.alloc(0)
+		};
+		case "m":
+		case "midi": return {
+			tag: "m",
+			data: writeMidi(arg.value)
+		};
+		default: throw new Error(`Unknown argument type: ${arg.type}`);
+	}
+	switch (typeof arg) {
+		case "number": if (Number.isInteger(arg)) return {
+			tag: "i",
+			data: writeInt32(arg)
+		};
+		else return {
+			tag: "f",
+			data: writeFloat32(arg)
+		};
+		case "string": return {
+			tag: "s",
+			data: Buffer$1.from(padString(arg))
+		};
+		case "boolean": return arg ? {
+			tag: "T",
+			data: Buffer$1.alloc(0)
+		} : {
+			tag: "F",
+			data: Buffer$1.alloc(0)
+		};
+		default:
+			if (Buffer$1.isBuffer(arg)) return {
+				tag: "b",
+				data: writeBlob(arg)
+			};
+			throw new Error(`Don't know how to encode argument: ${arg}`);
+	}
+}
+function decodeArgument(tag, buffer, offset) {
+	switch (tag) {
+		case "i": return readInt32(buffer, offset);
+		case "f": return readFloat32(buffer, offset);
+		case "s": return readString(buffer, offset);
+		case "b": return readBlob(buffer, offset);
+		case "T": return {
+			value: true,
+			offset
+		};
+		case "F": return {
+			value: false,
+			offset
+		};
+		case "N": return {
+			value: null,
+			offset
+		};
+		case "m": return readMidi(buffer, offset);
+		default: throw new Error(`I don't understand the argument code ${tag}`);
+	}
+}
+/**
+* Encode an OSC message or bundle to a Buffer.
+* 
+* This low-level function converts OSC messages and bundles into binary format
+* for transmission or storage. Useful for sending OSC over custom transports
+* (WebSocket, TCP, HTTP), storing to files, or implementing custom OSC routers.
+* 
+* @param {Object} message - OSC message or bundle object with oscType property
+* @returns {Buffer} The encoded OSC data ready for transmission
+* 
+* @example
+* // Encode a message
+* import { Message, encode } from 'node-osc';
+* 
+* const message = new Message('/oscillator/frequency', 440);
+* const buffer = encode(message);
+* console.log('Encoded bytes:', buffer.length);
+* 
+* @example
+* // Encode a bundle
+* import { Bundle, encode } from 'node-osc';
+* 
+* const bundle = new Bundle(['/one', 1], ['/two', 2]);
+* const buffer = encode(bundle);
+* 
+* @example
+* // Send over WebSocket
+* const buffer = encode(message);
+* websocket.send(buffer);
+*/
+function encode(message) {
+	if (message.oscType === "bundle") return encodeBundleToBuffer(message);
+	else return encodeMessageToBuffer(message);
+}
+function encodeMessageToBuffer(message) {
+	const address = padString(message.address);
+	const addressBuffer = Buffer$1.from(address);
+	const encodedArgs = message.args.map(encodeArgument);
+	const typeTags$1 = "," + encodedArgs.map((arg) => arg.tag).join("");
+	const typeTagsBuffer = Buffer$1.from(padString(typeTags$1));
+	const argumentBuffers = encodedArgs.map((arg) => arg.data);
+	return Buffer$1.concat([
+		addressBuffer,
+		typeTagsBuffer,
+		...argumentBuffers
+	]);
+}
+function encodeBundleToBuffer(bundle) {
+	const bundleString = padString("#bundle");
+	const bundleStringBuffer = Buffer$1.from(bundleString);
+	const timetagBuffer = writeTimeTag(bundle.timetag);
+	const elementBuffers = bundle.elements.map((element) => {
+		let elementBuffer;
+		if (element.oscType === "bundle") elementBuffer = encodeBundleToBuffer(element);
+		else elementBuffer = encodeMessageToBuffer(element);
+		const sizeBuffer = writeInt32(elementBuffer.length);
+		return Buffer$1.concat([sizeBuffer, elementBuffer]);
+	});
+	return Buffer$1.concat([
+		bundleStringBuffer,
+		timetagBuffer,
+		...elementBuffers
+	]);
+}
+/**
+* Decode a Buffer containing OSC data into a message or bundle object.
+* 
+* This low-level function parses binary OSC data back into JavaScript objects.
+* Useful for receiving OSC over custom transports, reading from files,
+* or implementing custom OSC routers.
+* 
+* @param {Buffer} buffer - The Buffer containing OSC data
+* @returns {Object} The decoded OSC message or bundle. Messages have
+*   {oscType: 'message', address: string, args: Array}, bundles have
+*   {oscType: 'bundle', timetag: number, elements: Array}
+* @throws {Error} If the buffer contains malformed OSC data
+* 
+* @example
+* // Decode received data
+* import { decode } from 'node-osc';
+* 
+* const decoded = decode(buffer);
+* if (decoded.oscType === 'message') {
+*   console.log('Address:', decoded.address);
+*   console.log('Arguments:', decoded.args);
+* }
+* 
+* @example
+* // Round-trip encode/decode
+* import { Message, encode, decode } from 'node-osc';
+* 
+* const original = new Message('/test', 42, 'hello');
+* const buffer = encode(original);
+* const decoded = decode(buffer);
+* console.log(decoded.address); // '/test'
+*/
+function decode(buffer) {
+	if (buffer.length >= 8 && buffer.subarray(0, 8).toString() === "#bundle\0") return decodeBundleFromBuffer(buffer);
+	else return decodeMessageFromBuffer(buffer);
+}
+function decodeMessageFromBuffer(buffer) {
+	let offset = 0;
+	const addressResult = readString(buffer, offset);
+	const address = addressResult.value;
+	offset = addressResult.offset;
+	const typeTagsResult = readString(buffer, offset);
+	const typeTags$1 = typeTagsResult.value;
+	offset = typeTagsResult.offset;
+	if (!typeTags$1.startsWith(",")) throw new Error("Malformed Packet");
+	const tags = typeTags$1.slice(1);
+	const args = [];
+	for (const tag of tags) {
+		const argResult = decodeArgument(tag, buffer, offset);
+		args.push({ value: argResult.value });
+		offset = argResult.offset;
+	}
+	return {
+		oscType: "message",
+		address,
+		args
+	};
+}
+function decodeBundleFromBuffer(buffer) {
+	let offset = 8;
+	const timetagResult = readTimeTag(buffer, offset);
+	const timetag = timetagResult.value;
+	offset = timetagResult.offset;
+	const elements = [];
+	while (offset < buffer.length) {
+		const sizeResult = readInt32(buffer, offset);
+		const size = sizeResult.value;
+		offset = sizeResult.offset;
+		if (size <= 0 || offset + size > buffer.length) throw new Error("Malformed Packet");
+		const element = decode(buffer.subarray(offset, offset + size));
+		elements.push(element);
+		offset += size;
+	}
+	return {
+		oscType: "bundle",
+		timetag,
+		elements
+	};
+}
+
+//#endregion
+//#region src/infrastructure/mappers/OscCodec.ts
+/**
+* Handles encoding and decoding of X32 OSC messages.
+*/
+var OscCodec = class {
+	constructor(schemaRegistry) {
+		this.schemaRegistry = schemaRegistry;
+	}
+	/**
+	* Decodes a binary OSC message into a packet object.
+	* @param msg - Raw UDP buffer.
+	* @returns Decoded OscPacket.
+	*/
+	decode(msg) {
+		return decode(msg);
+	}
+	/**
+	* Encodes an address and arguments into a binary OSC message.
+	* @param address - OSC address pattern.
+	* @param args - Array of arguments.
+	* @returns Binary buffer.
+	*/
+	encode(address, args) {
+		return encode(this.createMessage(address, args));
+	}
+	/**
+	* Creates a typed node-osc Message based on X32 schema.
+	* @param address - Target address.
+	* @param args - Untyped arguments.
+	* @returns Typed Message.
+	*/
+	createMessage(address, args) {
+		return new Message_default(address, ...args.map((arg) => {
+			if (typeof arg === "object" && arg !== null && "type" in arg && "value" in arg) return arg;
+			if (Buffer.isBuffer(arg)) return arg;
+			const node = this.schemaRegistry.getNode(address);
+			if (node) {
+				if (node.type === "f" && typeof arg === "number") return {
+					type: "f",
+					value: arg
+				};
+				if (node.type === "i" && typeof arg === "number") return {
+					type: "i",
+					value: Math.round(arg)
+				};
+				if (node.type === "s" && typeof arg === "string") return {
+					type: "s",
+					value: arg
+				};
+			}
+			return arg;
+		}));
+	}
+};
+
+//#endregion
+//#region src/domain/services/SchemaFactory.ts
+/**
+* Factory service responsible for constructing the X32 OSC Schema.
+* Encapsulates all the logic for generating channel strips, routing blocks, etc.
+*/
+var SchemaFactory = class {
+	/**
+	* Builds the complete X32 OSC Schema.
+	* @returns The constructed schema map.
+	*/
+	createSchema() {
+		const schema = {
+			...this.generateNodes(32, "ch"),
+			...this.generateNodes(16, "bus"),
+			...this.generateNodes(8, "dca"),
+			...this.generateNodes(8, "auxin"),
+			...this.generateNodes(8, "fxrtn"),
+			...this.generateNodes(6, "mtx"),
+			...Object.fromEntries(Array.from({ length: 8 }, (_, i) => [`/fx/${i + 1}/type`, this.node("i", 0)])),
+			...this.generateRange(8, "/fx", "/type", "i", 0),
+			...this.generateRange(8, "/fx", "/source/l", "i", 0),
+			...this.generateRange(8, "/fx", "/source/r", "i", 0),
+			...Object.fromEntries(Array.from({ length: 8 }, (_, slot) => Object.entries(this.generateRange(64, `/fx/${slot + 1}/par`, "", "f", 0, 2, 1))).flat()),
+			...this.generateRange(128, "/headamp", "/gain", "f", 0, 3, 0),
+			...this.generateRange(128, "/headamp", "/phantom", "i", 0, 3, 0),
+			...this.generateRange(6, "/config/mute", "", "i", 0),
+			...this.generateRange(80, "/-stat/solosw", "", "i", 0),
+			"/-stat/selidx": this.node("i", 0),
+			"/-stat/sendsonfader": this.node("i", 0),
+			"/-stat/bussendbank": this.node("i", 0),
+			"/-stat/keysolo": this.node("i", 0),
+			"/-stat/screen/screen": this.node("i", 0),
+			"/-stat/screen/CHAN/page": this.node("i", 0),
+			"/-stat/screen/METER/page": this.node("i", 0),
+			"/-stat/screen/ROUTE/page": this.node("i", 0),
+			"/-stat/screen/SETUP/page": this.node("i", 0),
+			"/-stat/screen/LIBRARY/page": this.node("i", 0),
+			"/-stat/screen/FX/page": this.node("i", 0),
+			"/-stat/screen/MON/page": this.node("i", 0),
+			"/-stat/screen/USB/page": this.node("i", 0),
+			"/-stat/screen/SCENE/page": this.node("i", 0),
+			"/-stat/screen/ASSIGN/page": this.node("i", 0),
+			"/-stat/talk/A": this.node("i", 0),
+			"/-stat/talk/B": this.node("i", 0),
+			"/-stat/osc/on": this.node("i", 0),
+			"/-prefs/autosel": this.node("i", 1),
+			"/-action/setrtasrc": this.node("i", 0),
+			"/-action/playtrack": this.node("i", 0),
+			"/-action/goscene": this.node("i", 0),
+			"/-action/setscene": this.node("i", 0),
+			"/config/routing/AES50A/1-8": this.node("i", 0),
+			"/config/routing/AES50B/1-8": this.node("i", 0),
+			"/config/routing/CARD/1-8": this.node("i", 0),
+			"/config/routing/OUT/1-4": this.node("i", 0),
+			"/-prefs/invertmutes": this.node("i", 0),
+			...this.generateChannelStrip("/main/st", 6, false),
+			...this.generateChannelStrip("/main/m", 6, false),
+			...Object.fromEntries(Array.from({ length: 16 }, (_, i) => [`/config/chlink/${i * 2 + 1}-${i * 2 + 2}`, this.node("i", 0)])),
+			...Object.fromEntries(Array.from({ length: 8 }, (_, i) => [`/config/buslink/${i * 2 + 1}-${i * 2 + 2}`, this.node("i", 0)])),
+			...Object.fromEntries(Array.from({ length: 4 }, (_, i) => [`/config/auxlink/${i * 2 + 1}-${i * 2 + 2}`, this.node("i", 0)])),
+			...Object.fromEntries(Array.from({ length: 4 }, (_, i) => [`/config/fxlink/${i * 2 + 1}-${i * 2 + 2}`, this.node("i", 0)])),
+			...this.generateRange(32, "/config/userrout/in", "", "i", 0),
+			...this.generateRange(48, "/config/userrout/out", "", "i", 0),
+			"/config/solo/level": this.node("f", 0),
+			"/config/solo/source": this.node("i", 0),
+			"/config/solo/sourcetrim": this.node("f", 0),
+			"/config/solo/exclusive": this.node("i", 0),
+			"/config/solo/dim": this.node("i", 0),
+			"/config/solo/dimpfl": this.node("i", 0),
+			"/config/solo/dimatt": this.node("f", 0),
+			"/config/solo/mono": this.node("i", 0),
+			"/config/solo/chmode": this.node("i", 0),
+			"/config/solo/busmode": this.node("i", 0),
+			"/config/solo/dcamode": this.node("i", 0),
+			"/config/solo/masterctrl": this.node("i", 0),
+			"/config/solo/delay": this.node("i", 0),
+			"/config/solo/delaytime": this.node("f", 0),
+			"/config/solo/followsel": this.node("i", 0),
+			"/config/solo/followsolo": this.node("i", 0),
+			"/config/talk/enable": this.node("i", 0),
+			"/config/talk/source": this.node("i", 0),
+			"/config/talk/A/level": this.node("f", 0),
+			"/config/talk/B/level": this.node("f", 0),
+			"/config/talk/A/dim": this.node("i", 0),
+			"/config/talk/B/dim": this.node("i", 0),
+			"/config/talk/A/latch": this.node("i", 0),
+			"/config/talk/B/latch": this.node("i", 0),
+			"/config/talk/A/destmap": this.node("i", 0),
+			"/config/talk/B/destmap": this.node("i", 0),
+			"/config/osc/on": this.node("i", 0),
+			"/config/osc/type": this.node("i", 0),
+			"/config/osc/fsel": this.node("i", 0),
+			"/config/osc/f1": this.node("f", .5),
+			"/config/osc/f2": this.node("f", .5),
+			"/config/osc/level": this.node("f", 0),
+			"/config/osc/dest": this.node("i", 0),
+			...this.generateOutputs("main", 16),
+			...this.generateOutputs("aux", 6),
+			...this.generateOutputs("p16", 16),
+			...this.generateOutputs("aes", 2),
+			...this.generateOutputs("rec", 2)
+		};
+		Object.keys(STATIC_RESPONSES_DATA).forEach((key) => {
+			if (key.startsWith("/-") || key.startsWith("/stat")) schema[key] = this.node("i", 0);
+		});
+		[
+			"/config/routing/IN/1-8",
+			"/config/routing/IN/9-16",
+			"/config/routing/IN/17-24",
+			"/config/routing/IN/25-32",
+			"/config/routing/AUX/1-4",
+			"/config/routing/OUT/1-4",
+			"/config/routing/OUT/5-8",
+			"/config/routing/OUT/9-12",
+			"/config/routing/OUT/13-16",
+			"/config/routing/P16/1-8",
+			"/config/routing/P16/9-16",
+			"/config/routing/CARD/1-8",
+			"/config/routing/CARD/9-16",
+			"/config/routing/CARD/17-24",
+			"/config/routing/CARD/25-32",
+			"/config/routing/AES50A/1-8",
+			"/config/routing/AES50A/9-16",
+			"/config/routing/AES50A/17-24",
+			"/config/routing/AES50A/25-32",
+			"/config/routing/AES50A/33-40",
+			"/config/routing/AES50A/41-48",
+			"/config/routing/AES50B/1-8",
+			"/config/routing/AES50B/9-16",
+			"/config/routing/AES50B/17-24",
+			"/config/routing/AES50B/25-32",
+			"/config/routing/AES50B/33-40",
+			"/config/routing/AES50B/41-48",
+			"/config/routing/PLAY/1-8",
+			"/config/routing/PLAY/9-16",
+			"/config/routing/PLAY/17-24",
+			"/config/routing/PLAY/25-32"
+		].forEach((path) => {
+			schema[path] = this.node("i", 0);
+		});
+		return schema;
+	}
+	node(type, def) {
+		return new X32Node(type, def);
+	}
+	generateChannelStrip(base, eqBands = 4, hasPreamp = false) {
+		const nodes = {};
+		nodes[`${base}/config/name`] = this.node("s", base.split("/").pop()?.toUpperCase() || "");
+		nodes[`${base}/config/icon`] = this.node("i", 1);
+		nodes[`${base}/config/color`] = this.node("i", 1);
+		nodes[`${base}/config/source`] = this.node("i", 1);
+		nodes[`${base}/mix/fader`] = this.node("f", .75);
+		nodes[`${base}/mix/on`] = this.node("i", 0);
+		nodes[`${base}/mix/pan`] = this.node("f", .5);
+		nodes[`${base}/mix/mono`] = this.node("i", 0);
+		nodes[`${base}/mix/mlevel`] = this.node("f", 0);
+		nodes[`${base}/mix/st`] = this.node("i", 1);
+		if (hasPreamp) {
+			nodes[`${base}/preamp/trim`] = this.node("f", .5);
+			nodes[`${base}/preamp/hpon`] = this.node("i", 0);
+			nodes[`${base}/preamp/hpf`] = this.node("f", 0);
+			nodes[`${base}/preamp/phantom`] = this.node("i", 0);
+			nodes[`${base}/preamp/rtnsw`] = this.node("i", 0);
+			nodes[`${base}/preamp/invert`] = this.node("i", 0);
+		}
+		nodes[`${base}/delay/on`] = this.node("i", 0);
+		nodes[`${base}/delay/time`] = this.node("f", 0);
+		nodes[`${base}/insert/on`] = this.node("i", 0);
+		nodes[`${base}/insert/pos`] = this.node("i", 0);
+		nodes[`${base}/insert/sel`] = this.node("i", 0);
+		nodes[`${base}/gate/on`] = this.node("i", 0);
+		nodes[`${base}/gate/mode`] = this.node("i", 0);
+		nodes[`${base}/gate/thr`] = this.node("f", 0);
+		nodes[`${base}/gate/range`] = this.node("f", 0);
+		nodes[`${base}/gate/attack`] = this.node("f", 0);
+		nodes[`${base}/gate/hold`] = this.node("f", 0);
+		nodes[`${base}/gate/release`] = this.node("f", 0);
+		nodes[`${base}/gate/keysrc`] = this.node("i", 0);
+		nodes[`${base}/gate/filter/on`] = this.node("i", 0);
+		nodes[`${base}/gate/filter/type`] = this.node("i", 0);
+		nodes[`${base}/gate/filter/f`] = this.node("f", .5);
+		nodes[`${base}/dyn/on`] = this.node("i", 0);
+		nodes[`${base}/dyn/mode`] = this.node("i", 0);
+		nodes[`${base}/dyn/pos`] = this.node("i", 0);
+		nodes[`${base}/dyn/det`] = this.node("i", 0);
+		nodes[`${base}/dyn/env`] = this.node("i", 0);
+		nodes[`${base}/dyn/thr`] = this.node("f", 0);
+		nodes[`${base}/dyn/ratio`] = this.node("i", 0);
+		nodes[`${base}/dyn/knee`] = this.node("f", 0);
+		nodes[`${base}/dyn/mgain`] = this.node("f", 0);
+		nodes[`${base}/dyn/attack`] = this.node("f", 0);
+		nodes[`${base}/dyn/hold`] = this.node("f", 0);
+		nodes[`${base}/dyn/release`] = this.node("f", 0);
+		nodes[`${base}/dyn/mix`] = this.node("f", 1);
+		nodes[`${base}/dyn/auto`] = this.node("i", 0);
+		nodes[`${base}/dyn/keysrc`] = this.node("i", 0);
+		nodes[`${base}/dyn/filter/on`] = this.node("i", 0);
+		nodes[`${base}/dyn/filter/type`] = this.node("i", 0);
+		nodes[`${base}/dyn/filter/f`] = this.node("f", .5);
+		nodes[`${base}/eq/on`] = this.node("i", 0);
+		nodes[`${base}/eq/mode`] = this.node("i", 0);
+		for (let b = 1; b <= eqBands; b++) {
+			nodes[`${base}/eq/${b}/type`] = this.node("i", 0);
+			nodes[`${base}/eq/${b}/f`] = this.node("f", .5);
+			nodes[`${base}/eq/${b}/g`] = this.node("f", .5);
+			nodes[`${base}/eq/${b}/q`] = this.node("f", .5);
+		}
+		nodes[`${base}/grp/dca`] = this.node("i", 0);
+		nodes[`${base}/grp/mute`] = this.node("i", 0);
+		return nodes;
+	}
+	generateNodes(count, prefix) {
+		const nodes = {};
+		const isChannelOrAux = prefix === "ch" || prefix === "auxin";
+		const eqBands = prefix === "bus" || prefix === "mtx" ? 6 : 4;
+		for (let i = 1; i <= count; i++) {
+			const padId = i.toString().padStart(2, "0");
+			[i.toString(), padId].forEach((id) => {
+				const base = `/${prefix}/${id}`;
+				if (prefix === "dca") {
+					nodes[`${base}/config/name`] = this.node("s", `DCA ${id}`);
+					nodes[`${base}/config/color`] = this.node("i", 1);
+					nodes[`${base}/fader`] = this.node("f", .75);
+					nodes[`${base}/on`] = this.node("i", 0);
+				} else {
+					Object.assign(nodes, this.generateChannelStrip(base, eqBands, isChannelOrAux));
+					if (prefix === "ch" || prefix === "auxin" || prefix === "fxrtn" || prefix === "bus") for (let b = 1; b <= 16; b++) {
+						const busId = b.toString().padStart(2, "0");
+						nodes[`${base}/mix/${busId}/level`] = this.node("f", 0);
+						nodes[`${base}/mix/${busId}/on`] = this.node("i", 0);
+						nodes[`${base}/mix/${busId}/pan`] = this.node("f", .5);
+						nodes[`${base}/mix/${busId}/type`] = this.node("i", 0);
+					}
+				}
+			});
+		}
+		return nodes;
+	}
+	generateRange(count, prefix, suffix, type, def, pad = 2, start = 1) {
+		const nodes = {};
+		for (let i = start; i < start + count; i++) {
+			const id = i.toString().padStart(pad, "0");
+			nodes[`${prefix}/${i}${suffix}`] = this.node(type, def);
+			nodes[`${prefix}/${id}${suffix}`] = this.node(type, def);
+		}
+		return nodes;
+	}
+	generateOutputs(prefix, count) {
+		const nodes = {};
+		for (let i = 1; i <= count; i++) {
+			const base = `/outputs/${prefix}/${i.toString().padStart(2, "0")}`;
+			nodes[`${base}/src`] = this.node("i", 0);
+			nodes[`${base}/pos`] = this.node("i", 0);
+			nodes[`${base}/invert`] = this.node("i", 0);
+			nodes[`${base}/delay/on`] = this.node("i", 0);
+			nodes[`${base}/delay/time`] = this.node("f", 0);
+			if (prefix === "p16") {
+				nodes[`${base}/iQ/group`] = this.node("i", 0);
+				nodes[`${base}/iQ/model`] = this.node("i", 0);
+				nodes[`${base}/iQ/eq`] = this.node("i", 0);
+				nodes[`${base}/iQ/speaker`] = this.node("i", 0);
+			}
+		}
+		return nodes;
+	}
+};
+
+//#endregion
+//#region src/domain/services/SchemaRegistry.ts
+/**
+* Service providing access to the X32 OSC Schema.
+* Acts as the "Registry" of all available console parameters.
+*/
+var SchemaRegistry = class {
+	_schema;
+	constructor(schemaFactory) {
+		this.schemaFactory = schemaFactory;
+		this._schema = this.schemaFactory.createSchema();
+	}
+	/**
+	* Retrieves the entire schema map.
+	* @returns The internal schema definition record.
+	*/
+	getSchema() {
+		return this._schema;
+	}
+	/**
+	* Retrieves the node definition for a given path.
+	* @param path - The OSC path.
+	* @returns The X32Node definition or undefined if not found.
+	*/
+	getNode(path) {
+		return this._schema[path];
+	}
+	/**
+	* Checks if a path exists in the schema.
+	* @param path - The path to check.
+	* @returns True if the path is registered.
+	*/
+	has(path) {
+		return path in this._schema;
+	}
+	/**
+	* Returns all paths in the schema.
+	* @returns Array of all registered OSC paths.
+	*/
+	getAllPaths() {
+		return Object.keys(this._schema);
+	}
+	/**
+	* Maps an absolute X32 global index to its specific OSC root path.
+	* Used for batch subscriptions where clients request ranges of channels.
+	* @param index - The absolute integer index.
+	* @returns The root path string or null if index is out of bounds.
+	*/
+	getRootFromIndex(index) {
+		if (index >= 0 && index <= 31) return `/ch/${(index + 1).toString().padStart(2, "0")}`;
+		if (index >= 32 && index <= 39) return `/auxin/${(index - 31).toString().padStart(2, "0")}`;
+		if (index >= 40 && index <= 47) return `/fxrtn/${(index - 39).toString().padStart(2, "0")}`;
+		if (index >= 48 && index <= 63) return `/bus/${(index - 47).toString().padStart(2, "0")}`;
+		if (index >= 64 && index <= 69) return `/mtx/${(index - 63).toString().padStart(2, "0")}`;
+		if (index === 70) return "/main/st";
+		if (index === 71) return "/main/m";
+		if (index >= 72 && index <= 79) return `/dca/${(index - 71).toString().padStart(2, "0")}`;
+		return null;
+	}
+};
+
+//#endregion
+export { ConsoleLogger as a, X32Node as c, METER_COUNTS as d, MeterData as f, UdpNetworkGateway as i, X32State as l, LogCategory as m, SchemaFactory as n, LogLevel as o, SubscriptionManager as p, OscCodec as r, InMemoryStateRepository as s, SchemaRegistry as t, SimulationService as u };