@djodjonx/x32-simulator 0.0.1

package/src/domain/models/types.ts

@@ -0,0 +1,96 @@
+/**
+ * Represents a basic OSC argument value.
+ */
+export type OscArgumentValue = Buffer | boolean | number | string;
+
+/**
+ * Represents an OSC argument, which can be a primitive value or a typed object.
+ */
+export type OscArgument = OscArgumentValue | { type: string; value: OscArgumentValue };
+
+/**
+ * Represents a decoded OSC packet (bundle or message) as returned by the codec.
+ */
+export interface OscPacket {
+  /** The type of OSC packet. */
+  oscType: 'bundle' | 'message';
+  /** The address pattern. */
+  address: string;
+  /** The arguments of the message or elements of the bundle. */
+  args: OscArgument[];
+  /** Elements if this is a bundle. */
+  elements?: OscPacket[];
+}
+
+/**
+ * Represents a remote OSC client's connection info.
+ */
+export interface RemoteClient {
+  /** Target IP address. */
+  address: string;
+  /** Target port. */
+  port: number;
+}
+
+/**
+ * Represents a parsed OSC message ready for handling.
+ * Arguments are already unwrapped from their {type, value} containers.
+ */
+export interface OscMsg {
+  /** The OSC address. */
+  address: string;
+  /** The message arguments. */
+  args: OscArgumentValue[];
+}
+
+/**
+ * Metadata for a single state node.
+ */
+export interface X32Node {
+  /** Value type (float, int, or string). */
+  type: 'f' | 'i' | 's';
+  /** Default value for reset. */
+  default: number | string;
+}
+
+/**
+ * Represents an active subscription from a client.
+ */
+export interface Subscriber {
+    /** Target IP address. */
+    address: string;
+    /** Target port. */
+    port: number;
+    /** Expiry timestamp. */
+    expires: number;
+    /** Subscription type. */
+    type: 'batch' | 'format' | 'meter' | 'path';
+    /** Optional exact path for 'path' type. */
+    path?: string;
+    /** Target meter path for 'meter' type. */
+    meterPath?: string;
+    /** Alias for batch/format responses. */
+    alias?: string;
+    /** Glob/Wildcard pattern for 'format' type. */
+    pattern?: string;
+    /** List of paths for 'batch' type. */
+    paths?: string[];
+    /** Start index for ranges. */
+    start?: number;
+    /** Number of items in range. */
+    count?: number;
+    /** Frequency reduction factor. */
+    factor?: number;
+    /** Parameter arguments for the command. */
+    args?: number[];
+}
+
+/**
+ * Structure representing a reply to be sent back to an OSC client.
+ */
+export interface OscReply {
+    /** The target OSC address. */
+    address: string;
+    /** The response arguments. */
+    args: OscArgument[];
+}

package/src/domain/ports/ILogger.ts

@@ -0,0 +1,27 @@
+/**
+ * Represents data that can be logged.
+ */
+export type LogData = Buffer | Error | LogData[] | boolean | number | string | { [key: string]: LogData } | null | undefined;
+
+/**
+ * Standard log categories for the domain.
+ */
+export enum LogCategory {
+    SYSTEM = 'SYSTEM',
+    OSC_IN = 'OSC_IN',
+    OSC_OUT = 'OSC_OUT',
+    DISPATCH = 'DISPATCH',
+    STATE = 'STATE',
+    SUB = 'SUB',
+    METER = 'METER'
+}
+
+/**
+ * Interface for the logging port.
+ */
+export interface ILogger {
+    debug(category: string, msg: string, data?: LogData): void;
+    info(category: string, msg: string, data?: LogData): void;
+    warn(category: string, msg: string, data?: LogData): void;
+    error(category: string, msg: string, err?: LogData): void;
+}

package/src/domain/ports/INetworkGateway.ts

@@ -0,0 +1,8 @@
+import { OscPacket, RemoteClient } from '../models/types';
+
+export interface INetworkGateway {
+    start(port: number, ip: string): Promise<void>;
+    stop(): Promise<void>;
+    send(target: RemoteClient, address: string, args: any[]): void;
+    onPacket(callback: (packet: OscPacket, source: RemoteClient) => void): void;
+}

package/src/domain/ports/IStateRepository.ts

@@ -0,0 +1,16 @@
+import { X32State } from '../entities/X32State';
+
+/**
+ * Interface for accessing the mixer state.
+ */
+export interface IStateRepository {
+    /**
+     * Retrieves the single instance of the mixer state (Singleton in this context).
+     */
+    getState(): X32State;
+
+    /**
+     * Resets the state to defaults.
+     */
+    reset(): void;
+}

package/src/domain/services/MeterService.ts

@@ -0,0 +1,46 @@
+import { X32State } from '../entities/X32State';
+import { MeterData } from '../models/MeterData';
+import { METER_COUNTS } from '../models/MeterConfig';
+
+/**
+ * Service responsible for generating meter values and data.
+ * Mimics the physics/audio engine of the X32.
+ */
+export class MeterService {
+
+    /**
+     * Generates a MeterData object for a given path.
+     * @param path - The meter OSC path (e.g., "/meters/1").
+     * @param state - The current X32 state (for correlating faders to meters).
+     * @returns MeterData object containing the values.
+     */
+    public generateMeterData(path: string, state?: X32State): MeterData {
+        const count = METER_COUNTS[path];
+        if (count === undefined) {
+            return new MeterData(path, []);
+        }
+
+        const values: number[] = [];
+        for (let i = 0; i < count; i++) {
+            let val = Math.random() * 0.05; // Noise floor
+
+            // Simulation logic: Link meters 1-32 to Channel Faders 1-32
+            if (state && path === '/meters/1') {
+                if (i < 32) {
+                    const ch = (i + 1).toString().padStart(2, '0');
+                    // We should use X32Address logic here ideally, but string construction is fast
+                    const faderPath = `/ch/${ch}/mix/fader`;
+                    const fader = state.get(faderPath);
+
+                    if (typeof fader === 'number') {
+                        // If fader is up, show signal (simulated with random variation)
+                        val = fader > 0.01 ? fader * (0.9 + Math.random() * 0.1) : 0;
+                    }
+                }
+            }
+            values.push(val);
+        }
+
+        return new MeterData(path, values);
+    }
+}

package/src/domain/services/OscMessageHandler.ts

@@ -0,0 +1,88 @@
+import { OscMsg, RemoteClient, OscReply } from '../models/types';
+import { X32State } from '../entities/X32State';
+import { SubscriptionManager } from '../entities/SubscriptionManager';
+import { OscCommandStrategy } from './strategies/OscCommandStrategy';
+import { NodeDiscoveryStrategy } from './strategies/NodeDiscoveryStrategy';
+import { StaticResponseStrategy } from './strategies/StaticResponseStrategy';
+import { SubscriptionStrategy } from './strategies/SubscriptionStrategy';
+import { BatchStrategy } from './strategies/BatchStrategy';
+import { MeterStrategy } from './strategies/MeterStrategy';
+import { StateAccessStrategy } from './strategies/StateAccessStrategy';
+import { ILogger, LogCategory } from '../ports/ILogger';
+import { MeterService } from './MeterService';
+import { SchemaRegistry } from './SchemaRegistry';
+import { StaticResponseService } from './StaticResponseService';
+
+/**
+ * The central dispatcher for incoming OSC messages.
+ * Uses a Chain of Responsibility (Strategy pattern) to delegate handling.
+ * Order of strategies is critical for correct prioritization.
+ */
+export class OscMessageHandler {
+    /** List of active command strategies. */
+    private strategies: OscCommandStrategy[];
+
+    /**
+     * Initializes the handler with all available strategies.
+     * @param state - Global mixer state.
+     * @param subscriptionManager - Active client sessions.
+     * @param logger - Logger instance.
+     * @param serverIp - Host IP reported in handshakes.
+     * @param serverName - Console name reported in handshakes.
+     * @param serverModel - Console model reported in handshakes.
+     * @param meterService - Service for metering.
+     * @param schemaRegistry - Service for schema validation.
+     * @param staticResponseService - Service for static responses.
+     */
+    constructor(
+        state: X32State,
+        subscriptionManager: SubscriptionManager,
+        private logger: ILogger,
+        serverIp: string,
+        serverName: string,
+        serverModel: string,
+        private meterService: MeterService,
+        private schemaRegistry: SchemaRegistry,
+        private staticResponseService: StaticResponseService
+    ) {
+        // Order matters! Specific strategies (Discovery, Handshake) first, generic (State Access) last.
+        this.strategies = [
+            new NodeDiscoveryStrategy(this.schemaRegistry),
+            new StaticResponseStrategy(serverIp, serverName, serverModel, this.staticResponseService),
+            new SubscriptionStrategy(subscriptionManager, state, logger),
+            new BatchStrategy(subscriptionManager, logger),
+            new MeterStrategy(subscriptionManager, state, this.meterService),
+            new StateAccessStrategy(state, logger, this.schemaRegistry)
+        ];
+    }
+
+    /**
+     * Dispatches an incoming message to the first matching strategy.
+     * @param msg - Parsed OSC message.
+     * @param source - Source address and port of the packet.
+     * @returns Array of replies generated by the strategy.
+     */
+    public handle(msg: OscMsg, source: RemoteClient): OscReply[] {
+        const addr = msg.address;
+
+        // Skip noisy subscriptions in high-level logging
+        if (!addr.startsWith('/meters')) {
+             this.logger.debug(LogCategory.DISPATCH, `Handling`, { addr, args: msg.args });
+        }
+
+        // Delegate to first matching Strategy
+        for (const strategy of this.strategies) {
+            if (strategy.canHandle(addr)) {
+                const replies = strategy.execute(msg, source);
+                if (replies.length > 0) {
+                     this.logger.debug(LogCategory.DISPATCH, `Strategy ${strategy.constructor.name} replied`, { count: replies.length });
+                }
+                return replies;
+            }
+        }
+
+        // Mimic physical hardware: ignore unknown commands
+        this.logger.warn(LogCategory.DISPATCH, `Unknown Command`, { addr, args: msg.args, ip: source.address });
+        return [];
+    }
+}

package/src/domain/services/SchemaFactory.ts

@@ -0,0 +1,308 @@
+import { X32Node } from '../models/X32Node';
+import { STATIC_RESPONSES_DATA } from './StaticResponseService';
+
+/**
+ * Factory service responsible for constructing the X32 OSC Schema.
+ * Encapsulates all the logic for generating channel strips, routing blocks, etc.
+ */
+export class SchemaFactory {
+
+    /**
+     * Builds the complete X32 OSC Schema.
+     * @returns The constructed schema map.
+     */
+    public createSchema(): Record<string, X32Node> {
+        const schema: Record<string, X32Node> = {
+            ...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.0, 2, 1))
+                ).flat()
+            ),
+            ...this.generateRange(128, '/headamp', '/gain', 'f', 0.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),
+
+            // Global Status
+            '/-stat/selidx': this.node('i', 0),
+            '/-stat/sendsonfader': this.node('i', 0),
+            '/-stat/bussendbank': this.node('i', 0),
+            '/-stat/keysolo': this.node('i', 0),
+
+            // Screens
+            '/-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),
+
+            // Telemetry
+            '/-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),
+
+            // Actions
+            '/-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),
+
+            // Links
+            ...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),
+
+            // Solo Config
+            '/config/solo/level': this.node('f', 0.0),
+            '/config/solo/source': this.node('i', 0),
+            '/config/solo/sourcetrim': this.node('f', 0.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.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.0),
+            '/config/solo/followsel': this.node('i', 0),
+            '/config/solo/followsolo': this.node('i', 0),
+
+            // Talkback Config
+            '/config/talk/enable': this.node('i', 0),
+            '/config/talk/source': this.node('i', 0),
+            '/config/talk/A/level': this.node('f', 0.0),
+            '/config/talk/B/level': this.node('f', 0.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),
+
+            // Oscillator
+            '/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', 0.5),
+            '/config/osc/f2': this.node('f', 0.5),
+            '/config/osc/level': this.node('f', 0.0),
+            '/config/osc/dest': this.node('i', 0),
+
+            // Outputs
+            ...this.generateOutputs('main', 16),
+            ...this.generateOutputs('aux', 6),
+            ...this.generateOutputs('p16', 16),
+            ...this.generateOutputs('aes', 2),
+            ...this.generateOutputs('rec', 2)
+        };
+
+        // Static Responses Integration
+        Object.keys(STATIC_RESPONSES_DATA).forEach(key => {
+            if (key.startsWith('/-') || key.startsWith('/stat')) {
+            schema[key] = this.node('i', 0);
+            }
+        });
+
+        // Routing Blocks
+        const routingBlocks = [
+            '/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'
+        ];
+
+        routingBlocks.forEach(path => {
+            schema[path] = this.node('i', 0);
+        });
+
+        return schema;
+    }
+
+    private node(type: 'f' | 'i' | 's', def: number | string): X32Node {
+        return new X32Node(type, def);
+    }
+
+    private generateChannelStrip(base: string, eqBands: number = 4, hasPreamp: boolean = false): Record<string, X32Node> {
+        const nodes: Record<string, X32Node> = {};
+
+        // Config
+        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);
+
+        // Mix
+        nodes[`${base}/mix/fader`] = this.node('f', 0.75);
+        nodes[`${base}/mix/on`]    = this.node('i', 0);
+        nodes[`${base}/mix/pan`]   = this.node('f', 0.5);
+        nodes[`${base}/mix/mono`]  = this.node('i', 0);
+        nodes[`${base}/mix/mlevel`] = this.node('f', 0.0);
+        nodes[`${base}/mix/st`]    = this.node('i', 1);
+
+        if (hasPreamp) {
+            nodes[`${base}/preamp/trim`]    = this.node('f', 0.5);
+            nodes[`${base}/preamp/hpon`]    = this.node('i', 0);
+            nodes[`${base}/preamp/hpf`]     = this.node('f', 0.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);
+        }
+
+        // Delay
+        nodes[`${base}/delay/on`]       = this.node('i', 0);
+        nodes[`${base}/delay/time`]     = this.node('f', 0.0);
+
+        // Insert
+        nodes[`${base}/insert/on`]      = this.node('i', 0);
+        nodes[`${base}/insert/pos`]     = this.node('i', 0);
+        nodes[`${base}/insert/sel`]     = this.node('i', 0);
+
+        // Gate
+        nodes[`${base}/gate/on`]   = this.node('i', 0);
+        nodes[`${base}/gate/mode`] = this.node('i', 0);
+        nodes[`${base}/gate/thr`]  = this.node('f', 0.0);
+        nodes[`${base}/gate/range`]  = this.node('f', 0.0);
+        nodes[`${base}/gate/attack`] = this.node('f', 0.0);
+        nodes[`${base}/gate/hold`]   = this.node('f', 0.0);
+        nodes[`${base}/gate/release`] = this.node('f', 0.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', 0.5);
+
+        // Dynamics
+        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.0);
+        nodes[`${base}/dyn/ratio`] = this.node('i', 0);
+        nodes[`${base}/dyn/knee`]  = this.node('f', 0.0);
+        nodes[`${base}/dyn/mgain`] = this.node('f', 0.0);
+        nodes[`${base}/dyn/attack`] = this.node('f', 0.0);
+        nodes[`${base}/dyn/hold`]   = this.node('f', 0.0);
+        nodes[`${base}/dyn/release`] = this.node('f', 0.0);
+        nodes[`${base}/dyn/mix`]    = this.node('f', 1.0);
+        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', 0.5);
+
+        // EQ
+        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', 0.5);
+            nodes[`${base}/eq/${b}/g`]    = this.node('f', 0.5);
+            nodes[`${base}/eq/${b}/q`]    = this.node('f', 0.5);
+        }
+
+        // Groups
+        nodes[`${base}/grp/dca`]  = this.node('i', 0);
+        nodes[`${base}/grp/mute`] = this.node('i', 0);
+
+        return nodes;
+    }
+
+    private generateNodes(count: number, prefix: string): Record<string, X32Node> {
+        const nodes: Record<string, X32Node> = {};
+        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');
+            const ids = [i.toString(), padId];
+
+            ids.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', 0.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.0);
+                            nodes[`${base}/mix/${busId}/on`]    = this.node('i', 0);
+                            nodes[`${base}/mix/${busId}/pan`]   = this.node('f', 0.5);
+                            nodes[`${base}/mix/${busId}/type`]  = this.node('i', 0);
+                        }
+                    }
+                }
+            });
+        }
+        return nodes;
+    }
+
+    private generateRange(count: number, prefix: string, suffix: string, type: 'f'|'i'|'s', def: number|string, pad: number = 2, start: number = 1): Record<string, X32Node> {
+        const nodes: Record<string, X32Node> = {};
+        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;
+    }
+
+    private generateOutputs(prefix: string, count: number): Record<string, X32Node> {
+        const nodes: Record<string, X32Node> = {};
+        for (let i = 1; i <= count; i++) {
+            const id = i.toString().padStart(2, '0');
+            const base = `/outputs/${prefix}/${id}`;
+            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.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;
+    }
+}

package/src/domain/services/SchemaRegistry.ts

@@ -0,0 +1,67 @@
+import { X32Node } from '../models/X32Node';
+import { SchemaFactory } from './SchemaFactory';
+
+/**
+ * Service providing access to the X32 OSC Schema.
+ * Acts as the "Registry" of all available console parameters.
+ */
+export class SchemaRegistry {
+    private readonly _schema: Record<string, X32Node>;
+
+    constructor(private schemaFactory: SchemaFactory) {
+        this._schema = this.schemaFactory.createSchema();
+    }
+
+
+    /**
+     * Retrieves the entire schema map.
+     * @returns The internal schema definition record.
+     */
+    public getSchema(): Record<string, X32Node> {
+        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.
+     */
+    public getNode(path: string): X32Node | undefined {
+        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.
+     */
+    public has(path: string): boolean {
+        return path in this._schema;
+    }
+
+    /**
+     * Returns all paths in the schema.
+     * @returns Array of all registered OSC paths.
+     */
+    public getAllPaths(): string[] {
+        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.
+     */
+    public getRootFromIndex(index: number): string | null {
+        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;
+    }
+}