@djodjonx/x32-simulator 0.0.1

package/dist/server.mjs

@@ -0,0 +1,1055 @@
+#!/usr/bin/env node
+import { a as SimulationService, i as InMemoryStateRepository, n as ConsoleLogger, o as STATIC_RESPONSES_DATA, r as LogLevel, t as UdpNetworkGateway } from "./UdpNetworkGateway-BrroQ6-Q.mjs";
+import * as readline from "node:readline";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Buffer as Buffer$1 } from "node:buffer";
+
+//#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$1) {
+		return this._schema[path$1];
+	}
+	/**
+	* Checks if a path exists in the schema.
+	* @param path - The path to check.
+	* @returns True if the path is registered.
+	*/
+	has(path$1) {
+		return path$1 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
+//#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/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$1) => {
+			schema[path$1] = 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 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/presentation/cli/server.ts
+const loadEnv = () => {
+	try {
+		const envPath = path.resolve(process.cwd(), ".env");
+		if (fs.existsSync(envPath)) fs.readFileSync(envPath, "utf8").split("\n").forEach((line) => {
+			const match = line.match(/^([^=]+)=(.*)$/);
+			if (match) {
+				const key = match[1].trim();
+				const value = match[2].trim();
+				if (!process.env[key]) process.env[key] = value;
+			}
+		});
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		console.warn("Failed to load .env file", message);
+	}
+};
+const parseArgs = (argv) => {
+	const args = argv.slice(2);
+	let cliPort;
+	let cliHost;
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === "--port" || arg === "-p") {
+			const next = args[i + 1];
+			if (next && /^\d+$/.test(next)) {
+				cliPort = parseInt(next, 10);
+				i++;
+				continue;
+			}
+		}
+		if (arg === "--ip" || arg === "-h" || arg === "--host") {
+			const next = args[i + 1];
+			if (next) {
+				cliHost = next;
+				i++;
+				continue;
+			}
+		}
+		if (!cliHost && /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(arg)) {
+			cliHost = arg;
+			continue;
+		}
+		if (!cliPort && /^\d+$/.test(arg)) {
+			cliPort = parseInt(arg, 10);
+			continue;
+		}
+	}
+	return {
+		PORT: cliPort || parseInt(process.env.X32_PORT || "10023", 10),
+		HOST: cliHost || process.env.X32_IP || "0.0.0.0"
+	};
+};
+const bootstrap = async () => {
+	loadEnv();
+	const { PORT, HOST } = parseArgs(process.argv);
+	const logger = ConsoleLogger.getInstance();
+	logger.setLevel(LogLevel.DEBUG);
+	const schemaRegistry = new SchemaRegistry(new SchemaFactory());
+	const service = new SimulationService(new UdpNetworkGateway(logger, new OscCodec(schemaRegistry)), logger, new InMemoryStateRepository(logger, schemaRegistry), schemaRegistry, PORT, HOST);
+	try {
+		await service.start();
+		console.log(`
+╔════════════════════════════════════════╗
+║    🚀 X32 SIMULATION SERVER ACTIVE     ║
+╚════════════════════════════════════════╝
+• IP: ${HOST}
+• Port: ${PORT}
+• Protocol: UDP (Strict X32 Schema)
+• Logging: ENHANCED (DEBUG)
+
+👉 Type "exit" or "stop" to shut down.
+👉 Type "reset" to reset faders to default.
+            `);
+	} catch (err) {
+		if (err.code === "EADDRNOTAVAIL") {
+			console.error(`\n\x1b[31m❌ FAILED TO BIND TO IP: ${HOST}\x1b[0m`);
+			console.error(`\nThe IP address you requested does not exist on this machine.`);
+			console.error(`You likely need to create a network alias (Loopback) for it.\n`);
+			const isMac = process.platform === "darwin";
+			const isLinux = process.platform === "linux";
+			const isWin = process.platform === "win32";
+			if (isMac || isLinux || isWin) {
+				console.error(`To fix this, try running the following command:\n`);
+				if (isMac) console.error(`  \x1b[36msudo ifconfig lo0 alias ${HOST}\x1b[0m`);
+				else if (isLinux) console.error(`  \x1b[36msudo ip addr add ${HOST}/32 dev lo\x1b[0m`);
+				else if (isWin) {
+					console.error(`  \x1b[36mnetsh interface ip add address "Loopback" ${HOST} 255.255.255.255\x1b[0m`);
+					console.error(`  (Note: Requires 'Microsoft Loopback Adapter' installed and named "Loopback")`);
+				}
+			}
+			console.error(`\nAlternatively, remove the IP argument to listen on all interfaces (0.0.0.0).`);
+			process.exit(1);
+		}
+		console.error("Failed to start server:", err);
+		process.exit(1);
+	}
+	readline.createInterface({
+		input: process.stdin,
+		output: process.stdout
+	}).on("line", async (input) => {
+		const command = input.trim().toLowerCase();
+		switch (command) {
+			case "exit":
+			case "stop":
+			case "quit":
+				console.log("Shutting down...");
+				await service.stop();
+				process.exit(0);
+				break;
+			case "reset":
+				service.resetState();
+				console.log("✨ Console state reset to defaults.");
+				break;
+			default:
+				if (command) console.log(`Unknown command: "${command}"`);
+				break;
+		}
+	});
+	process.on("SIGINT", async () => {
+		console.log("\n(SIGINT received)");
+		await service.stop();
+		process.exit(0);
+	});
+};
+if (process.argv[1] === fileURLToPath(import.meta.url)) bootstrap();
+
+//#endregion
+export { bootstrap, loadEnv, parseArgs };