@djodjonx/x32-simulator 0.0.2 → 0.0.3

package/dist/{UdpNetworkGateway-Ccdd7Us5.cjs → SchemaRegistry-CfDtw84j.cjs}

@@ -30,6 +30,7 @@ os = __toESM(os);
 let node_events = require("node:events");
 let node_dgram = require("node:dgram");
 node_dgram = __toESM(node_dgram);
+let node_buffer = require("node:buffer");
 
 //#region src/application/use-cases/ProcessPacketUseCase.ts
 var ProcessPacketUseCase = class {
@@ -861,6 +862,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;
@@ -871,6 +876,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;
@@ -893,6 +909,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(() => {
@@ -902,11 +921,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();
 	}
@@ -916,7 +941,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 node_events.EventEmitter {
@@ -983,17 +1008,76 @@ var X32State = class extends node_events.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();
@@ -1154,18 +1238,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 = node_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) => {
@@ -1191,6 +1294,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();
@@ -1201,6 +1308,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;
@@ -1214,6 +1327,881 @@ var UdpNetworkGateway = class {
 	}
 };
 
+//#endregion
+//#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 - node_buffer.Buffer.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 = node_buffer.Buffer.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 = node_buffer.Buffer.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 = node_buffer.Buffer.alloc(padding === 4 ? 0 : padding);
+	return node_buffer.Buffer.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 = node_buffer.Buffer.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 = node_buffer.Buffer.alloc(4);
+	if (node_buffer.Buffer.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: node_buffer.Buffer.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: node_buffer.Buffer.alloc(0)
+		};
+		case "F": return {
+			tag: "F",
+			data: node_buffer.Buffer.alloc(0)
+		};
+		case "boolean": return arg.value ? {
+			tag: "T",
+			data: node_buffer.Buffer.alloc(0)
+		} : {
+			tag: "F",
+			data: node_buffer.Buffer.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: node_buffer.Buffer.from(padString(arg))
+		};
+		case "boolean": return arg ? {
+			tag: "T",
+			data: node_buffer.Buffer.alloc(0)
+		} : {
+			tag: "F",
+			data: node_buffer.Buffer.alloc(0)
+		};
+		default:
+			if (node_buffer.Buffer.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 = node_buffer.Buffer.from(address);
+	const encodedArgs = message.args.map(encodeArgument);
+	const typeTags$1 = "," + encodedArgs.map((arg) => arg.tag).join("");
+	const typeTagsBuffer = node_buffer.Buffer.from(padString(typeTags$1));
+	const argumentBuffers = encodedArgs.map((arg) => arg.data);
+	return node_buffer.Buffer.concat([
+		addressBuffer,
+		typeTagsBuffer,
+		...argumentBuffers
+	]);
+}
+function encodeBundleToBuffer(bundle) {
+	const bundleString = padString("#bundle");
+	const bundleStringBuffer = node_buffer.Buffer.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 node_buffer.Buffer.concat([sizeBuffer, elementBuffer]);
+	});
+	return node_buffer.Buffer.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
 Object.defineProperty(exports, 'ConsoleLogger', {
   enumerable: true,
@@ -1239,10 +2227,34 @@ Object.defineProperty(exports, 'LogLevel', {
     return LogLevel;
   }
 });
-Object.defineProperty(exports, 'STATIC_RESPONSES_DATA', {
+Object.defineProperty(exports, 'METER_COUNTS', {
+  enumerable: true,
+  get: function () {
+    return METER_COUNTS;
+  }
+});
+Object.defineProperty(exports, 'MeterData', {
+  enumerable: true,
+  get: function () {
+    return MeterData;
+  }
+});
+Object.defineProperty(exports, 'OscCodec', {
+  enumerable: true,
+  get: function () {
+    return OscCodec;
+  }
+});
+Object.defineProperty(exports, 'SchemaFactory', {
+  enumerable: true,
+  get: function () {
+    return SchemaFactory;
+  }
+});
+Object.defineProperty(exports, 'SchemaRegistry', {
   enumerable: true,
   get: function () {
-    return STATIC_RESPONSES_DATA;
+    return SchemaRegistry;
   }
 });
 Object.defineProperty(exports, 'SimulationService', {
@@ -1251,12 +2263,30 @@ Object.defineProperty(exports, 'SimulationService', {
     return SimulationService;
   }
 });
+Object.defineProperty(exports, 'SubscriptionManager', {
+  enumerable: true,
+  get: function () {
+    return SubscriptionManager;
+  }
+});
 Object.defineProperty(exports, 'UdpNetworkGateway', {
   enumerable: true,
   get: function () {
     return UdpNetworkGateway;
   }
 });
+Object.defineProperty(exports, 'X32Node', {
+  enumerable: true,
+  get: function () {
+    return X32Node;
+  }
+});
+Object.defineProperty(exports, 'X32State', {
+  enumerable: true,
+  get: function () {
+    return X32State;
+  }
+});
 Object.defineProperty(exports, '__toESM', {
   enumerable: true,
   get: function () {