@djodjonx/x32-simulator 0.0.1

package/src/infrastructure/services/UdpNetworkGateway.ts

@@ -0,0 +1,71 @@
+import * as dgram from 'node:dgram';
+import { INetworkGateway } from '../../domain/ports/INetworkGateway';
+import { OscPacket, RemoteClient } from '../../domain/models/types';
+import { OscCodec } from '../mappers/OscCodec';
+import { ILogger, LogCategory } from '../../domain/ports/ILogger';
+
+export class UdpNetworkGateway implements INetworkGateway {
+    private socket: dgram.Socket;
+    private isRunning = false;
+    private packetCallback: ((packet: OscPacket, source: RemoteClient) => void) | null = null;
+
+    constructor(private logger: ILogger, private codec: OscCodec) {
+        this.socket = dgram.createSocket('udp4');
+    }
+
+    public onPacket(callback: (packet: OscPacket, source: RemoteClient) => void): void {
+        this.packetCallback = callback;
+    }
+
+    public start(port: number, ip: string): Promise<void> {
+        return new Promise((resolve, reject) => {
+            this.socket.on('error', (err) => {
+                this.logger.error(LogCategory.SYSTEM, 'Socket Error', err);
+                reject(err);
+            });
+
+            this.socket.on('message', (msg, rinfo) => {
+                try {
+                    this.logger.debug(LogCategory.OSC_IN, `Packet received ${msg.length}b`, { ip: rinfo.address });
+                    const decoded = this.codec.decode(msg);
+                    if (this.packetCallback) {
+                        this.packetCallback(decoded, { address: rinfo.address, port: rinfo.port });
+                    }
+                } catch (err) {
+                    this.logger.error(LogCategory.OSC_IN, 'Decode Error', err instanceof Error ? err : new Error(String(err)));
+                }
+            });
+
+            this.socket.bind(port, ip, () => {
+                this.logger.info(LogCategory.SYSTEM, `Server bound to ${ip}:${port}`);
+                this.isRunning = true;
+                resolve();
+            });
+        });
+    }
+
+    public stop(): Promise<void> {
+        return new Promise((resolve) => {
+            if (!this.isRunning) return resolve();
+            this.socket.close(() => {
+                this.isRunning = false;
+                this.logger.info(LogCategory.SYSTEM, 'Server stopped');
+                resolve();
+            });
+        });
+    }
+
+    public send(target: RemoteClient, address: string, args: any[]): void {
+        const buf = this.codec.encode(address, args);
+        const cat = address.startsWith('/meters') ? LogCategory.METER : LogCategory.OSC_OUT;
+
+        // Skip noisy meter logging if needed, or rely on logger level
+        this.logger.debug(cat, `Sending ${address}`, { ip: target.address, args });
+
+        this.socket.send(buf, target.port, target.address, (err) => {
+            if (err) {
+                this.logger.error(LogCategory.OSC_OUT, 'Send Error', err);
+            }
+        });
+    }
+}

package/src/presentation/cli/server.ts

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+import * as readline from 'node:readline';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { SimulationService } from '../../application/use-cases/SimulationService';
+import { ConsoleLogger, LogLevel } from '../../infrastructure/services/ConsoleLogger';
+import { UdpNetworkGateway } from '../../infrastructure/services/UdpNetworkGateway';
+import { InMemoryStateRepository } from '../../infrastructure/repositories/InMemoryStateRepository';
+import { SchemaRegistry } from '../../domain/services/SchemaRegistry';
+import { SchemaFactory } from '../../domain/services/SchemaFactory';
+import { OscCodec } from '../../infrastructure/mappers/OscCodec';
+
+// Basic .env loader
+export const loadEnv = () => {
+  try {
+    const envPath = path.resolve(process.cwd(), '.env');
+    if (fs.existsSync(envPath)) {
+      const content = fs.readFileSync(envPath, 'utf8');
+      content.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);
+  }
+};
+
+export const parseArgs = (argv: string[]) => {
+    const args = argv.slice(2);
+    let cliPort: number | undefined;
+    let cliHost: string | undefined;
+
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+
+        // Handle flags
+        if (arg === '--port' || arg === '-p') {
+            const next = args[i + 1];
+            if (next && /^\d+$/.test(next)) {
+            cliPort = parseInt(next, 10);
+            i++; // Skip next
+            continue;
+            }
+        }
+        if (arg === '--ip' || arg === '-h' || arg === '--host') {
+            const next = args[i + 1];
+            if (next) {
+            cliHost = next;
+            i++; // Skip next
+            continue;
+            }
+        }
+
+        // Handle positional arguments (simple heuristic)
+        // If it looks like an IP (x.x.x.x), treat as Host
+        if (!cliHost && /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(arg)) {
+            cliHost = arg;
+            continue;
+        }
+
+        // If it looks like a port number (and we haven't set port yet), treat as Port
+        if (!cliPort && /^\d+$/.test(arg)) {
+            cliPort = parseInt(arg, 10);
+            continue;
+        }
+    }
+
+    const PORT = cliPort || parseInt(process.env.X32_PORT || '10023', 10);
+    const HOST = cliHost || process.env.X32_IP || '0.0.0.0';
+
+    return { PORT, HOST };
+};
+
+export const bootstrap = async () => {
+    loadEnv();
+    const { PORT, HOST } = parseArgs(process.argv);
+
+    // 0. Configure Logging
+    const logger = ConsoleLogger.getInstance();
+    logger.setLevel(LogLevel.DEBUG);
+
+    // 1. Initialize Domain Services (Registry) & Mappers
+    const schemaFactory = new SchemaFactory();
+    const schemaRegistry = new SchemaRegistry(schemaFactory);
+    const oscCodec = new OscCodec(schemaRegistry);
+
+    // 2. Initialize Infrastructure
+    const gateway = new UdpNetworkGateway(logger, oscCodec);
+    const stateRepo = new InMemoryStateRepository(logger, schemaRegistry);
+
+    // 3. Initialize Application Service
+    const service = new SimulationService(
+        gateway,
+        logger,
+        stateRepo,
+        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: any) {
+        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);
+    }
+
+    // 3. Setup CLI Input
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+
+    rl.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;
+        }
+    });
+
+    // Handle Ctrl+C
+    process.on('SIGINT', async () => {
+        console.log('\n(SIGINT received)');
+        await service.stop();
+        process.exit(0);
+    });
+};
+
+// Check if main module
+const isMainModule = process.argv[1] === fileURLToPath(import.meta.url);
+if (isMainModule) {
+    bootstrap();
+}

package/src/presentation/library/library.ts

@@ -0,0 +1,9 @@
+export { SimulationService } from '../../application/use-cases/SimulationService';
+export type { INetworkGateway } from '../../domain/ports/INetworkGateway';
+export type { ILogger, LogData } from '../../domain/ports/ILogger';
+export { LogCategory } from '../../domain/ports/ILogger';
+export type { IStateRepository } from '../../domain/ports/IStateRepository';
+export { InMemoryStateRepository } from '../../infrastructure/repositories/InMemoryStateRepository';
+export { ConsoleLogger } from '../../infrastructure/services/ConsoleLogger';
+export { UdpNetworkGateway } from '../../infrastructure/services/UdpNetworkGateway';
+export * from '../../domain/models/types';

package/tests/application/use-cases/BroadcastUpdatesUseCase.test.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect, vi } from 'vitest';
+import { BroadcastUpdatesUseCase } from '../../../src/application/use-cases/BroadcastUpdatesUseCase';
+import { SubscriptionManager } from '../../../src/domain/entities/SubscriptionManager';
+import { X32State } from '../../../src/domain/entities/X32State';
+import { INetworkGateway } from '../../../src/domain/ports/INetworkGateway';
+import { MeterService } from '../../../src/domain/services/MeterService';
+import { SchemaRegistry } from '../../../src/domain/services/SchemaRegistry';
+import { X32Node } from '../../../src/domain/models/X32Node';
+
+describe('BroadcastUpdatesUseCase', () => {
+  it('should broadcast single change to xremote', () => {
+    const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    const manager = new SubscriptionManager(logger);
+    manager.addPathSubscriber({ address: '1.2.3.4', port: 1234 }, '/xremote');
+
+    const state = new X32State({});
+    const gateway = { send: vi.fn() } as unknown as INetworkGateway;
+    const meterService = new MeterService();
+    const registry = {} as unknown as SchemaRegistry;
+
+    const useCase = new BroadcastUpdatesUseCase(manager, state, gateway, logger as any, meterService, registry);
+    useCase.broadcastSingleChange('/ch/01/mix/on', 1);
+
+    expect(gateway.send).toHaveBeenCalledWith(
+        expect.objectContaining({ address: '1.2.3.4' }),
+        '/ch/01/mix/on',
+        [1]
+    );
+  });
+
+  it('should execute batch updates', () => {
+    const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    const manager = new SubscriptionManager(logger);
+    const client = { address: '1.2.3.4', port: 1234 };
+    
+    // Add a batch subscriber
+    manager.addBatchSubscriber(client, '/batch/alias', ['/mix/fader'], 0, 1, 0);
+
+    const state = new X32State({ '/ch/01/mix/fader': new X32Node('f', 0.5) });
+    const gateway = { send: vi.fn() } as unknown as INetworkGateway;
+    const meterService = new MeterService();
+    const registry = {
+        getRootFromIndex: vi.fn().mockReturnValue('/ch/01'),
+        getNode: vi.fn().mockReturnValue(new X32Node('f', 0.0))
+    } as unknown as SchemaRegistry;
+
+    const useCase = new BroadcastUpdatesUseCase(manager, state, gateway, logger as any, meterService, registry);
+    useCase.execute();
+
+    expect(gateway.send).toHaveBeenCalledWith(
+        expect.objectContaining({ address: '1.2.3.4' }),
+        '/batch/alias',
+        [expect.any(Buffer)]
+    );
+  });
+
+  it('should execute format updates', () => {
+    const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    const manager = new SubscriptionManager(logger);
+    const client = { address: '1.2.3.4', port: 1234 };
+    
+    // Add a format subscriber: alias, pattern, start, count, factor
+    manager.addFormatSubscriber(client, '/format/alias', '/ch/*/mix/fader', 1, 2, 1);
+
+    const state = new X32State({ 
+        '/ch/01/mix/fader': new X32Node('f', 0.5),
+        '/ch/02/mix/fader': new X32Node('f', 0.6)
+    });
+    const gateway = { send: vi.fn() } as unknown as INetworkGateway;
+    const meterService = new MeterService();
+    const registry = {
+        getNode: vi.fn().mockReturnValue(new X32Node('f', 0.0))
+    } as unknown as SchemaRegistry;
+
+    const useCase = new BroadcastUpdatesUseCase(manager, state, gateway, logger as any, meterService, registry);
+    useCase.execute();
+
+    expect(gateway.send).toHaveBeenCalledWith(
+        expect.objectContaining({ address: '1.2.3.4' }),
+        '/format/alias',
+        [expect.any(Buffer)]
+    );
+  });
+
+  it('should broadcast meter updates', () => {
+    const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    const manager = new SubscriptionManager(logger);
+    manager.addMeterSubscriber({ address: '1.2.3.4', port: 1234 }, '/meters/1');
+
+    const state = new X32State({});
+    const gateway = { send: vi.fn() } as unknown as INetworkGateway;
+    const meterService = new MeterService();
+    const registry = {} as unknown as SchemaRegistry;
+
+    const useCase = new BroadcastUpdatesUseCase(manager, state, gateway, logger as any, meterService, registry);
+    useCase.execute();
+
+    expect(gateway.send).toHaveBeenCalledWith(
+        expect.objectContaining({ address: '1.2.3.4' }),
+        '/meters/1',
+        [expect.any(Buffer)]
+    );
+  });
+});

package/tests/application/use-cases/ManageSessionsUseCase.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect, vi } from 'vitest';
+import { ManageSessionsUseCase } from '../../../src/application/use-cases/ManageSessionsUseCase';
+import { SubscriptionManager } from '../../../src/domain/entities/SubscriptionManager';
+
+describe('ManageSessionsUseCase', () => {
+  it('should cleanup sessions', () => {
+    const manager = { cleanup: vi.fn() } as unknown as SubscriptionManager;
+    const useCase = new ManageSessionsUseCase(manager);
+    useCase.cleanup();
+    expect(manager.cleanup).toHaveBeenCalled();
+  });
+});

package/tests/application/use-cases/ProcessPacketUseCase.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect, vi } from 'vitest';
+import { ProcessPacketUseCase } from '../../../src/application/use-cases/ProcessPacketUseCase';
+import { OscMessageHandler } from '../../../src/domain/services/OscMessageHandler';
+import { INetworkGateway } from '../../../src/domain/ports/INetworkGateway';
+
+describe('ProcessPacketUseCase', () => {
+  it('should process message and send replies', () => {
+    const handler = {
+        handle: vi.fn().mockReturnValue([{ address: '/reply', args: [1] }])
+    } as unknown as OscMessageHandler;
+
+    const gateway = {
+        send: vi.fn()
+    } as unknown as INetworkGateway;
+
+    const useCase = new ProcessPacketUseCase(handler, gateway);
+    
+    useCase.execute(
+        { oscType: 'message', address: '/test', args: [123] },
+        { address: '1.2.3.4', port: 1234 }
+    );
+
+    expect(handler.handle).toHaveBeenCalled();
+    expect(gateway.send).toHaveBeenCalledWith({ address: '1.2.3.4', port: 1234 }, '/reply', [1]);
+  });
+
+  it('should process bundles', () => {
+    const handler = {
+        handle: vi.fn().mockReturnValue([])
+    } as unknown as OscMessageHandler;
+    const gateway = { send: vi.fn() } as unknown as INetworkGateway;
+    const useCase = new ProcessPacketUseCase(handler, gateway);
+
+    useCase.execute(
+        { 
+            oscType: 'bundle', 
+            address: '', // Bundles don't have address
+            args: [],
+            elements: [
+                { oscType: 'message', address: '/msg1', args: [] },
+                { oscType: 'message', address: '/msg2', args: [] }
+            ]
+        },
+        { address: '1.2.3.4', port: 1234 }
+    );
+
+    expect(handler.handle).toHaveBeenCalledTimes(2);
+  });
+});

package/tests/application/use-cases/SimulationService.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { SimulationService } from '../../../src/application/use-cases/SimulationService';
+import { INetworkGateway } from '../../../src/domain/ports/INetworkGateway';
+import { ILogger } from '../../../src/domain/ports/ILogger';
+import { IStateRepository } from '../../../src/domain/ports/IStateRepository';
+import { SchemaRegistry } from '../../../src/domain/services/SchemaRegistry';
+import { X32State } from '../../../src/domain/entities/X32State';
+import * as os from 'os';
+
+vi.mock('os', () => ({
+    networkInterfaces: vi.fn().mockReturnValue({
+        eth0: [{ family: 'IPv4', internal: false, address: '192.168.1.1' }]
+    })
+}));
+
+describe('SimulationService', () => {
+  let service: SimulationService;
+  let gateway: INetworkGateway;
+  let logger: ILogger;
+  let stateRepo: IStateRepository;
+  let schemaRegistry: SchemaRegistry;
+  let state: X32State;
+
+  beforeEach(() => {
+    gateway = {
+        start: vi.fn().mockResolvedValue(undefined),
+        stop: vi.fn().mockResolvedValue(undefined),
+        send: vi.fn(),
+        onPacket: vi.fn()
+    };
+    logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
+    state = new X32State({});
+    stateRepo = {
+        getState: vi.fn().mockReturnValue(state),
+        reset: vi.fn()
+    };
+    schemaRegistry = {
+        getSchema: vi.fn().mockReturnValue({}),
+        getNode: vi.fn(),
+        getAllPaths: vi.fn().mockReturnValue([])
+    } as unknown as SchemaRegistry;
+
+    // Use 0.0.0.0 to trigger getLocalIp
+    service = new SimulationService(
+        gateway,
+        logger as any,
+        stateRepo,
+        schemaRegistry,
+        10023,
+        '0.0.0.0'
+    );
+  });
+
+  it('should start the service and detect local IP', async () => {
+    await service.start();
+    expect(gateway.start).toHaveBeenCalledWith(10023, '0.0.0.0');
+    expect(os.networkInterfaces).toHaveBeenCalled();
+  });
+
+  it('should stop the service', async () => {
+    await service.start();
+    await service.stop();
+    expect(gateway.stop).toHaveBeenCalled();
+  });
+
+  it('should handle state change events', () => {
+    // Trigger change on the state
+    state.emit('change', { address: '/test', value: 1 });
+    // Should log and broadcast (indirectly verified by coverage)
+    expect(logger.info).toHaveBeenCalled();
+  });
+
+  it('should reset state', () => {
+    service.resetState();
+    expect(stateRepo.reset).toHaveBeenCalled();
+  });
+});

package/tests/domain/entities/SubscriptionManager.test.ts

@@ -0,0 +1,50 @@
+import { describe, it, expect, vi } from 'vitest';
+import { SubscriptionManager } from '../../../src/domain/entities/SubscriptionManager';
+import { ILogger } from '../../../src/domain/ports/ILogger';
+
+describe('SubscriptionManager', () => {
+  const logger: ILogger = {
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn()
+  };
+
+  it('should add a path subscriber', () => {
+    const manager = new SubscriptionManager(logger);
+    const client = { address: '127.0.0.1', port: 10000 };
+    
+    manager.addPathSubscriber(client, '/ch/01/mix/fader');
+    const subs = manager.getSubscribers();
+    
+    expect(subs).toHaveLength(1);
+    expect(subs[0].type).toBe('path');
+    expect(subs[0].path).toBe('/ch/01/mix/fader');
+  });
+
+  it('should remove subscriber', () => {
+    const manager = new SubscriptionManager(logger);
+    const client = { address: '127.0.0.1', port: 10000 };
+    
+    manager.addPathSubscriber(client, '/test');
+    manager.removeSubscriber(client, '/test');
+    
+    expect(manager.getSubscribers()).toHaveLength(0);
+  });
+
+  it('should cleanup expired subscribers', () => {
+    const manager = new SubscriptionManager(logger);
+    const client = { address: '127.0.0.1', port: 10000 };
+    
+    manager.addPathSubscriber(client, '/test');
+    
+    // Mock Date.now to fast forward
+    const originalNow = Date.now;
+    Date.now = vi.fn(() => originalNow() + 20000); // +20s
+    
+    manager.cleanup();
+    expect(manager.getSubscribers()).toHaveLength(0);
+    
+    Date.now = originalNow;
+  });
+});

package/tests/domain/entities/X32State.test.ts

@@ -0,0 +1,52 @@
+import { describe, it, expect, vi } from 'vitest';
+import { X32State } from '../../../src/domain/entities/X32State';
+import { X32Node } from '../../../src/domain/models/X32Node';
+
+describe('X32State', () => {
+  const schema = {
+    '/ch/01/mix/fader': new X32Node('f', 0.0),
+    '/ch/01/mix/on': new X32Node('i', 0),
+    '/ch/01/grp/mute': new X32Node('i', 0), // needed for mute group logic
+  };
+
+  it('should initialize with default values', () => {
+    const state = new X32State(schema);
+    expect(state.get('/ch/01/mix/fader')).toBe(0.0);
+  });
+
+  it('should update values and emit events', () => {
+    const state = new X32State(schema);
+    const spy = vi.fn();
+    state.on('change', spy);
+
+    state.set('/ch/01/mix/fader', 0.5);
+    expect(state.get('/ch/01/mix/fader')).toBe(0.5);
+    expect(spy).toHaveBeenCalledWith({ address: '/ch/01/mix/fader', value: 0.5 });
+  });
+
+  it('should reset to defaults', () => {
+    const state = new X32State(schema);
+    state.set('/ch/01/mix/fader', 0.8);
+    state.reset();
+    expect(state.get('/ch/01/mix/fader')).toBe(0.0);
+  });
+
+  // Mute Group Logic Test
+  it('should handle mute group side effects', () => {
+    const state = new X32State(schema);
+    // Assign CH 01 to Mute Group 1 (Bit 0)
+    state.set('/ch/01/grp/mute', 1); // 1 << 0
+
+    const spy = vi.fn();
+    state.on('change', spy);
+
+    // Turn Mute Group 1 ON (1)
+    state.handleMuteGroupChange(1, 1);
+    
+    // Expect CH 01 Mute to be 0 (Muted? Logic: isOn=1 -> target=0? Check code: isOn=1 -> target=0. Wait, 0 usually means OFF/Muted or ON/Active? In X32 'on' means passing audio. So Mute Group ON means 'on' parameter becomes 0)
+    // Code: const targetMute = isOn === 1 ? 0 : 1;
+    // So if MG is ON, channel.on = 0 (Muted). Correct.
+    expect(state.get('/ch/01/mix/on')).toBe(0);
+    expect(spy).toHaveBeenCalledWith({ address: '/ch/01/mix/on', value: 0 });
+  });
+});

package/tests/domain/models/MeterData.test.ts

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import { MeterData } from '../../../src/domain/models/MeterData';
+
+describe('MeterData', () => {
+  it('should create and store values', () => {
+    const data = new MeterData('/meters/1', [0.1, 0.2]);
+    expect(data.path).toBe('/meters/1');
+    expect(data.values).toEqual([0.1, 0.2]);
+  });
+
+  it('should encode to binary blob', () => {
+    const data = new MeterData('/meters/1', [0.5]);
+    const blob = data.toBlob();
+    
+    // Size = 4 (total size) + 4 (count) + 4 (float) = 12 bytes body + header?
+    // Implementation: 4 byte size + 4 byte count + floats
+    // totalSize = 4 + 4 + (1 * 4) = 12
+    
+    expect(blob.readInt32BE(0)).toBe(12); // Header Size
+    expect(blob.readInt32LE(4)).toBe(1);  // Count
+    expect(blob.readFloatLE(8)).toBeCloseTo(0.5); // Value
+  });
+});