@djodjonx/x32-simulator 0.0.2 → 0.0.4

package/tests/domain/services/strategies/BatchStrategy.test.ts

@@ -1,41 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { BatchStrategy } from '../../../../src/domain/services/strategies/BatchStrategy';
-import { SubscriptionManager } from '../../../../src/domain/entities/SubscriptionManager';
-
-describe('BatchStrategy', () => {
-  it('should handle /formatsubscribe', () => {
-    const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-    const manager = new SubscriptionManager(logger);
-    const strategy = new BatchStrategy(manager, logger);
-
-    // /formatsubscribe, alias, pattern, start, end, factor
-    strategy.execute({ address: '/formatsubscribe', args: ['alias', '/ch/*/mix/on', 1, 10, 5] }, { address: '1.2.3.4', port: 1234 });
-    expect(manager.getSubscribers()).toHaveLength(1);
-    expect(manager.getSubscribers()[0].type).toBe('format');
-  });
-
-  it('should handle /batchsubscribe', () => {
-    const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-    const manager = new SubscriptionManager(logger);
-    const strategy = new BatchStrategy(manager, logger);
-
-    // /batchsubscribe, alias, path1, path2, ..., int1, int2, ..., factor
-    // args: ['alias', '/mix/fader', '/mix/on', 10] (factor=10)
-    strategy.execute({ address: '/batchsubscribe', args: ['b_alias', '/mix/fader', '/mix/on', 10] }, { address: '1.2.3.4', port: 1234 });
-    
-    const subs = manager.getSubscribers();
-    expect(subs).toHaveLength(1);
-    expect(subs[0].type).toBe('batch');
-    expect(subs[0].paths).toEqual(['/mix/fader', '/mix/on']);
-    expect(subs[0].factor).toBe(10);
-  });
-
-  it('should return empty if no integer found in batchsubscribe', () => {
-    const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-    const manager = new SubscriptionManager(logger);
-    const strategy = new BatchStrategy(manager, logger);
-
-    const replies = strategy.execute({ address: '/batchsubscribe', args: ['alias', 'path'] }, { address: '1.2.3.4', port: 1234 });
-    expect(replies).toHaveLength(0);
-  });
-});

package/tests/domain/services/strategies/MeterStrategy.test.ts

@@ -1,19 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { MeterStrategy } from '../../../../src/domain/services/strategies/MeterStrategy';
-import { SubscriptionManager } from '../../../../src/domain/entities/SubscriptionManager';
-import { MeterService } from '../../../../src/domain/services/MeterService';
-import { X32State } from '../../../../src/domain/entities/X32State';
-
-describe('MeterStrategy', () => {
-  it('should handle /meters', () => {
-    const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-    const manager = new SubscriptionManager(logger);
-    const meterService = new MeterService();
-    const state = new X32State({});
-    const strategy = new MeterStrategy(manager, state, meterService);
-
-    strategy.execute({ address: '/meters', args: ['/meters/1'] }, { address: '1.2.3.4', port: 1234 });
-    expect(manager.getSubscribers()).toHaveLength(1);
-    expect(manager.getSubscribers()[0].type).toBe('meter');
-  });
-});

package/tests/domain/services/strategies/NodeDiscoveryStrategy.test.ts

@@ -1,22 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { NodeDiscoveryStrategy } from '../../../../src/domain/services/strategies/NodeDiscoveryStrategy';
-import { SchemaRegistry } from '../../../../src/domain/services/SchemaRegistry';
-
-describe('NodeDiscoveryStrategy', () => {
-  it('should list children', () => {
-    // Mock registry with getAllPaths
-    const registry = {
-        getAllPaths: () => ['/ch/01/mix', '/ch/01/config', '/bus/01']
-    } as unknown as SchemaRegistry;
-
-    const strategy = new NodeDiscoveryStrategy(registry);
-    
-    // Query /ch/01
-    const replies = strategy.execute({ address: '/node', args: ['/ch/01'] }, { address: '127.0.0.1', port: 10000 });
-    
-    expect(replies).toHaveLength(1);
-    expect(replies[0].args).toContain('mix');
-    expect(replies[0].args).toContain('config');
-    expect(replies[0].args).not.toContain('bus');
-  });
-});

package/tests/domain/services/strategies/StateAccessStrategy.test.ts

@@ -1,49 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { StateAccessStrategy } from '../../../../src/domain/services/strategies/StateAccessStrategy';
-import { X32State } from '../../../../src/domain/entities/X32State';
-import { SchemaRegistry } from '../../../../src/domain/services/SchemaRegistry';
-import { X32Node } from '../../../../src/domain/models/X32Node';
-
-describe('StateAccessStrategy', () => {
-  let strategy: StateAccessStrategy;
-  let state: X32State;
-  
-  beforeEach(() => {
-    // Mini schema for testing
-    const schema = {
-        '/test/fader': new X32Node('f', 0.0),
-        '/config/mute/1': new X32Node('i', 0),
-    };
-    
-    // Mock registry to return our mini schema nodes
-    const registry = {
-        has: (path: string) => path in schema,
-        getNode: (path: string) => schema[path as keyof typeof schema]
-    } as unknown as SchemaRegistry;
-
-    state = new X32State(schema);
-    
-    const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-    
-    strategy = new StateAccessStrategy(state, logger, registry);
-  });
-
-  it('should handle get requests', () => {
-    state.set('/test/fader', 0.5);
-    const replies = strategy.execute({ address: '/test/fader', args: [] }, { address: '127.0.0.1', port: 10000 });
-    expect(replies).toHaveLength(1);
-    expect(replies[0].args[0]).toBe(0.5);
-  });
-
-  it('should handle set requests', () => {
-    const replies = strategy.execute({ address: '/test/fader', args: [0.8] }, { address: '127.0.0.1', port: 10000 });
-    expect(state.get('/test/fader')).toBe(0.8);
-    expect(replies).toHaveLength(0);
-  });
-
-  it('should validate types', () => {
-    // Sending string to float
-    strategy.execute({ address: '/test/fader', args: ['invalid'] }, { address: '127.0.0.1', port: 10000 });
-    expect(state.get('/test/fader')).toBe(0.0); // Should not change
-  });
-});

package/tests/domain/services/strategies/StaticResponseStrategy.test.ts

@@ -1,15 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { StaticResponseStrategy } from '../../../../src/domain/services/strategies/StaticResponseStrategy';
-import { StaticResponseService } from '../../../../src/domain/services/StaticResponseService';
-
-describe('StaticResponseStrategy', () => {
-  it('should return static response with replacements', () => {
-    const service = new StaticResponseService();
-    const strategy = new StaticResponseStrategy('10.0.0.1', 'MyMixer', 'X32', service);
-    
-    // /status -> ["active", "{{ip}}", "{{name}}"]
-    const replies = strategy.execute({ address: '/status', args: [] }, { address: '127.0.0.1', port: 10000 });
-    
-    expect(replies[0].args).toEqual(['active', '10.0.0.1', 'MyMixer']);
-  });
-});

package/tests/domain/services/strategies/SubscriptionStrategy.test.ts

@@ -1,45 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { SubscriptionStrategy } from '../../../../src/domain/services/strategies/SubscriptionStrategy';
-import { SubscriptionManager } from '../../../../src/domain/entities/SubscriptionManager';
-import { X32State } from '../../../../src/domain/entities/X32State';
-import { X32Node } from '../../../../src/domain/models/X32Node';
-
-describe('SubscriptionStrategy', () => {
-  it('should handle /subscribe', () => {
-    const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-    const manager = new SubscriptionManager(logger);
-    const state = new X32State({ '/test': new X32Node('i', 123) });
-    const strategy = new SubscriptionStrategy(manager, state, logger);
-
-    const replies = strategy.execute({ address: '/subscribe', args: ['/test', 10] }, { address: '1.2.3.4', port: 1234 });
-    
-    // Should add subscriber
-    expect(manager.getSubscribers()).toHaveLength(1);
-    // Should return current value
-    expect(replies[0].args[0]).toBe(123);
-  });
-
-  it('should handle /xremote', () => {
-    const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-    const manager = new SubscriptionManager(logger);
-    const state = new X32State({});
-    const strategy = new SubscriptionStrategy(manager, state, logger);
-
-    strategy.execute({ address: '/xremote', args: [] }, { address: '1.2.3.4', port: 1234 });
-    expect(manager.getSubscribers()).toHaveLength(1);
-  });
-
-  it('should handle /unsubscribe', () => {
-    const logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-    const manager = new SubscriptionManager(logger);
-    const state = new X32State({});
-    const strategy = new SubscriptionStrategy(manager, state, logger);
-    const client = { address: '1.2.3.4', port: 1234 };
-
-    manager.addPathSubscriber(client, '/test');
-    expect(manager.getSubscribers()).toHaveLength(1);
-
-    strategy.execute({ address: '/unsubscribe', args: ['/test'] }, client);
-    expect(manager.getSubscribers()).toHaveLength(0);
-  });
-});

package/tests/infrastructure/mappers/OscCodec.test.ts

@@ -1,41 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { OscCodec } from '../../../src/infrastructure/mappers/OscCodec';
-import { SchemaRegistry } from '../../../src/domain/services/SchemaRegistry';
-import { X32Node } from '../../../src/domain/models/X32Node';
-
-describe('OscCodec', () => {
-  const registry = {
-      getNode: (path: string) => {
-          if (path === '/test/int') return new X32Node('i', 0);
-          if (path === '/test/float') return new X32Node('f', 0.0);
-          if (path === '/test/string') return new X32Node('s', '');
-          return undefined;
-      }
-  } as unknown as SchemaRegistry;
-
-  const codec = new OscCodec(registry);
-
-  it('should encode message with schema inference', () => {
-      // Int
-      const buf1 = codec.encode('/test/int', [123]);
-      expect(Buffer.isBuffer(buf1)).toBe(true);
-      
-      // Float
-      const buf2 = codec.encode('/test/float', [0.5]);
-      expect(Buffer.isBuffer(buf2)).toBe(true);
-
-      // String
-      const buf3 = codec.encode('/test/string', ['hello']);
-      expect(Buffer.isBuffer(buf3)).toBe(true);
-  });
-
-  it('should handle raw typed args in encode', () => {
-      const buf = codec.encode('/any', [{ type: 'i', value: 10 }]);
-      expect(Buffer.isBuffer(buf)).toBe(true);
-  });
-
-  it('should handle buffers in encode', () => {
-      const buf = codec.encode('/any', [Buffer.alloc(4)]);
-      expect(Buffer.isBuffer(buf)).toBe(true);
-  });
-});

package/tests/infrastructure/repositories/InMemoryStateRepository.test.ts

@@ -1,29 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { InMemoryStateRepository } from '../../../src/infrastructure/repositories/InMemoryStateRepository';
-import { SchemaRegistry } from '../../../src/domain/services/SchemaRegistry';
-import { ILogger } from '../../../src/domain/ports/ILogger';
-
-describe('InMemoryStateRepository', () => {
-  it('should initialize and provide state', () => {
-    const logger: ILogger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-    const schemaRegistry = {
-        getSchema: vi.fn().mockReturnValue({})
-    } as unknown as SchemaRegistry;
-
-    const repo = new InMemoryStateRepository(logger, schemaRegistry);
-    const state = repo.getState();
-    
-    expect(state).toBeDefined();
-    expect(repo.getState()).toBe(state); // Singleton check
-  });
-
-  it('should reset state', () => {
-    const logger: ILogger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-    const schemaRegistry = { getSchema: vi.fn().mockReturnValue({}) } as unknown as SchemaRegistry;
-    const repo = new InMemoryStateRepository(logger, schemaRegistry);
-    
-    // We can't easily see internal reset without mocking X32State, 
-    // but we can verify it doesn't throw.
-    expect(() => repo.reset()).not.toThrow();
-  });
-});

package/tests/infrastructure/services/ConsoleLogger.test.ts

@@ -1,74 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { ConsoleLogger, LogLevel } from '../../../src/infrastructure/services/ConsoleLogger';
-import { LogCategory } from '../../../src/domain/ports/ILogger';
-
-describe('ConsoleLogger', () => {
-  let logger: ConsoleLogger;
-
-  beforeEach(() => {
-    logger = new ConsoleLogger();
-    vi.spyOn(console, 'log').mockImplementation(() => {});
-    vi.clearAllMocks();
-  });
-
-  it('should log messages at all levels', () => {
-    logger.setLevel(LogLevel.DEBUG);
-    logger.debug(LogCategory.SYSTEM, 'debug');
-    logger.info(LogCategory.SYSTEM, 'info');
-    logger.warn(LogCategory.SYSTEM, 'warn');
-    logger.error(LogCategory.SYSTEM, 'error');
-    expect(console.log).toHaveBeenCalledTimes(4);
-  });
-
-  it('should not log if level is higher', () => {
-    logger.setLevel(LogLevel.ERROR);
-    logger.info(LogCategory.SYSTEM, 'test info');
-    expect(console.log).not.toHaveBeenCalled();
-  });
-
-  it('should format message with color codes', () => {
-    logger.setLevel(LogLevel.INFO);
-    logger.info(LogCategory.SYSTEM, 'hello');
-    const call = vi.mocked(console.log).mock.calls[0][0];
-    expect(call).toContain('[SYSTEM  ]');
-    expect(call).toContain('hello');
-  });
-
-  it('should handle data metadata', () => {
-    logger.info(LogCategory.SYSTEM, 'msg', { foo: 'bar' });
-    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('{"foo":"bar"}'));
-    
-    // Buffer data
-    logger.info(LogCategory.SYSTEM, 'buf', Buffer.from('abc'));
-    expect(console.log).toHaveBeenCalledWith(expect.stringContaining('<Buffer 3b>'));
-  });
-
-  it('should enable and disable categories', () => {
-    logger.disableCategory(LogCategory.SYSTEM);
-    logger.info(LogCategory.SYSTEM, 'hidden');
-    expect(console.log).not.toHaveBeenCalled();
-
-    logger.enableCategory(LogCategory.SYSTEM);
-    logger.info(LogCategory.SYSTEM, 'shown');
-    expect(console.log).toHaveBeenCalled();
-  });
-
-  it('should singleton instance', () => {
-    const instance = ConsoleLogger.getInstance();
-    expect(instance).toBeInstanceOf(ConsoleLogger);
-    expect(ConsoleLogger.getInstance()).toBe(instance);
-  });
-
-  it('should hide messages matching patterns', () => {
-    process.env.HIDDEN_LOG = 'secret,private';
-    const loggerWithEnv = new ConsoleLogger();
-    
-    loggerWithEnv.info(LogCategory.SYSTEM, 'this is secret');
-    expect(console.log).not.toHaveBeenCalled();
-
-    loggerWithEnv.info(LogCategory.SYSTEM, 'this is public');
-    expect(console.log).toHaveBeenCalled();
-    
-    delete process.env.HIDDEN_LOG;
-  });
-});

package/tests/infrastructure/services/UdpNetworkGateway.test.ts

@@ -1,61 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { UdpNetworkGateway } from '../../../src/infrastructure/services/UdpNetworkGateway';
-import { ILogger } from '../../../src/domain/ports/ILogger';
-import { OscCodec } from '../../../src/infrastructure/mappers/OscCodec';
-import * as dgram from 'dgram';
-
-let messageCallback: Function;
-
-vi.mock('dgram', () => ({
-    createSocket: vi.fn(() => ({
-        bind: vi.fn((port, ip, cb) => cb && cb()),
-        on: vi.fn((event, cb) => {
-            if (event === 'message') messageCallback = cb;
-        }),
-        send: vi.fn(),
-        close: vi.fn((cb) => cb && cb()),
-    }))
-}));
-
-describe('UdpNetworkGateway', () => {
-  let gateway: UdpNetworkGateway;
-  let logger: ILogger;
-  let codec: OscCodec;
-
-  beforeEach(() => {
-    logger = { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() };
-    codec = { 
-        encode: vi.fn().mockReturnValue(Buffer.from('encoded')),
-        decode: vi.fn().mockReturnValue({ address: '/decoded', args: [] })
-    } as unknown as OscCodec;
-    gateway = new UdpNetworkGateway(logger, codec);
-  });
-
-  it('should start and bind socket', async () => {
-    await gateway.start(10023, '0.0.0.0');
-    expect(dgram.createSocket).toHaveBeenCalledWith('udp4');
-  });
-
-  it('should send packets', async () => {
-    await gateway.start(10023, '0.0.0.0');
-    gateway.send({ address: '1.2.3.4', port: 1234 }, '/test', [1]);
-    expect(codec.encode).toHaveBeenCalledWith('/test', [1]);
-  });
-
-  it('should receive and decode packets', async () => {
-    const spy = vi.fn();
-    gateway.onPacket(spy);
-    await gateway.start(10023, '0.0.0.0');
-    
-    // Simulate incoming message
-    messageCallback(Buffer.from('raw'), { address: '5.6.7.8', port: 5678 });
-    
-    expect(codec.decode).toHaveBeenCalled();
-    expect(spy).toHaveBeenCalledWith(expect.anything(), expect.objectContaining({ address: '5.6.7.8' }));
-  });
-
-  it('should stop', async () => {
-    await gateway.start(10023, '0.0.0.0');
-    await gateway.stop();
-  });
-});

package/tests/presentation/cli/server.test.ts

@@ -1,178 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-
-const mocks = vi.hoisted(() => ({
-    serviceInstance: {
-        start: vi.fn().mockResolvedValue(undefined),
-        stop: vi.fn().mockResolvedValue(undefined),
-        resetState: vi.fn()
-    },
-    rl: {
-        on: vi.fn(),
-        close: vi.fn()
-    }
-}));
-
-// Mock fs
-vi.mock('fs', () => ({
-    existsSync: vi.fn(),
-    readFileSync: vi.fn()
-}));
-
-// Mock SimulationService
-vi.mock('../../../src/application/use-cases/SimulationService', () => {
-    const MockService = vi.fn();
-    MockService.prototype.start = mocks.serviceInstance.start;
-    MockService.prototype.stop = mocks.serviceInstance.stop;
-    MockService.prototype.resetState = mocks.serviceInstance.resetState;
-    return {
-        SimulationService: MockService
-    };
-});
-
-// Mock ConsoleLogger
-vi.mock('../../../src/infrastructure/services/ConsoleLogger', () => ({
-    ConsoleLogger: {
-        getInstance: vi.fn().mockReturnValue({ setLevel: vi.fn() })
-    },
-    LogLevel: { DEBUG: 0 }
-}));
-
-// Mock readline
-vi.mock('readline', () => ({
-    createInterface: vi.fn().mockReturnValue(mocks.rl)
-}));
-
-import * as Server from '../../../src/presentation/cli/server';
-import { SimulationService } from '../../../src/application/use-cases/SimulationService';
-
-describe('CLI Server', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        vi.spyOn(console, 'log').mockImplementation(() => {});
-        vi.spyOn(console, 'error').mockImplementation(() => {});
-        vi.spyOn(console, 'warn').mockImplementation(() => {});
-        vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
-        vi.spyOn(process, 'on').mockImplementation(() => process);
-        
-        // Reset specific mock implementations if needed
-        mocks.serviceInstance.start.mockResolvedValue(undefined);
-    });
-
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-
-    describe('parseArgs', () => {
-        it('should parse port and host flags', () => {
-            const args = ['node', 'server.ts', '--port', '1234', '--host', '1.2.3.4'];
-            const result = Server.parseArgs(args);
-            expect(result.PORT).toBe(1234);
-            expect(result.HOST).toBe('1.2.3.4');
-        });
-
-        it('should parse short flags', () => {
-            const args = ['node', 'server.ts', '-p', '1234', '-h', '1.2.3.4'];
-            const result = Server.parseArgs(args);
-            expect(result.PORT).toBe(1234);
-            expect(result.HOST).toBe('1.2.3.4');
-        });
-
-        it('should parse positional arguments', () => {
-            const args = ['node', 'server.ts', '1.2.3.4', '1234'];
-            const result = Server.parseArgs(args);
-            expect(result.PORT).toBe(1234);
-            expect(result.HOST).toBe('1.2.3.4');
-        });
-
-        it('should use defaults', () => {
-            const args = ['node', 'server.ts'];
-            const result = Server.parseArgs(args);
-            expect(result.PORT).toBe(10023);
-            expect(result.HOST).toBe('0.0.0.0');
-        });
-    });
-
-    describe('loadEnv', () => {
-        it('should load .env file', () => {
-            vi.mocked(fs.existsSync).mockReturnValue(true);
-            vi.mocked(fs.readFileSync).mockReturnValue('X32_PORT=9999\nX32_IP=10.0.0.1');
-            
-            Server.loadEnv();
-            
-            expect(process.env.X32_PORT).toBe('9999');
-            expect(process.env.X32_IP).toBe('10.0.0.1');
-            
-            delete process.env.X32_PORT;
-            delete process.env.X32_IP;
-        });
-
-        it('should handle errors gracefully', () => {
-            vi.mocked(fs.existsSync).mockReturnValue(true);
-            vi.mocked(fs.readFileSync).mockImplementation(() => { throw new Error('Fail'); });
-            
-            Server.loadEnv();
-            
-            expect(console.warn).toHaveBeenCalledWith(expect.stringContaining('Failed to load'), expect.any(String));
-        });
-    });
-
-    describe('bootstrap', () => {
-        it('should start simulation service', async () => {
-            await Server.bootstrap();
-            expect(SimulationService).toHaveBeenCalled();
-            expect(console.log).toHaveBeenCalledWith(expect.stringContaining('X32 SIMULATION SERVER ACTIVE'));
-        });
-
-        it('should handle EADDRNOTAVAIL error', async () => {
-            const error = new Error('Bind failed');
-            (error as any).code = 'EADDRNOTAVAIL';
-            mocks.serviceInstance.start.mockRejectedValueOnce(error);
-
-            // Mock platform
-            Object.defineProperty(process, 'platform', { value: 'darwin', configurable: true });
-
-            await Server.bootstrap();
-            expect(console.error).toHaveBeenCalledWith(expect.stringContaining('FAILED TO BIND'));
-            expect(process.exit).toHaveBeenCalledWith(1);
-        });
-
-        it('should handle generic startup errors', async () => {
-            mocks.serviceInstance.start.mockRejectedValueOnce(new Error('Generic fail'));
-            await Server.bootstrap();
-            expect(console.error).toHaveBeenCalledWith('Failed to start server:', expect.any(Error));
-            expect(process.exit).toHaveBeenCalledWith(1);
-        });
-
-        it('should handle CLI commands', async () => {
-            await Server.bootstrap();
-            
-            const lineHandler = mocks.rl.on.mock.calls.find(call => call[0] === 'line')?.[1];
-            expect(lineHandler).toBeDefined();
-
-            await lineHandler('reset');
-            expect(mocks.serviceInstance.resetState).toHaveBeenCalled();
-
-            await lineHandler('stop');
-            expect(mocks.serviceInstance.stop).toHaveBeenCalled();
-            expect(process.exit).toHaveBeenCalledWith(0);
-        });
-
-        it('should handle unknown CLI commands', async () => {
-            await Server.bootstrap();
-            const lineHandler = mocks.rl.on.mock.calls.find(call => call[0] === 'line')?.[1];
-            await lineHandler('unknown');
-            expect(console.log).toHaveBeenCalledWith(expect.stringContaining('Unknown command'));
-        });
-
-        it('should handle SIGINT', async () => {
-            await Server.bootstrap();
-            const sigintHandler = vi.mocked(process.on).mock.calls.find(call => call[0] === 'SIGINT')?.[1] as Function;
-            expect(sigintHandler).toBeDefined();
-            
-            await sigintHandler();
-            expect(mocks.serviceInstance.stop).toHaveBeenCalled();
-            expect(process.exit).toHaveBeenCalledWith(0);
-        });
-    });
-});

package/tests/presentation/library/library.test.ts

@@ -1,13 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import * as Lib from '../../../src/presentation/library/library';
-
-describe('Library Entry', () => {
-  it('should export all public members', () => {
-    expect(Lib.SimulationService).toBeDefined();
-    expect(Lib.ConsoleLogger).toBeDefined();
-    expect(Lib.UdpNetworkGateway).toBeDefined();
-    expect(Lib.InMemoryStateRepository).toBeDefined();
-    expect(Lib.LogCategory).toBeDefined();
-    // Types aren't runtime values, so we can't check them with toBeDefined(), but the import * works.
-  });
-});

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleResolution": "Bundler",
-    "lib": ["ESNext", "DOM"],
-    "strict": true,
-    "declaration": true,
-    "removeComments": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "outDir": "dist",
-    "baseUrl": ".",
-    "paths": {
-      "@/*": ["src/*"]
-    }
-  },
-  "include": ["src/**/*", "tests/**/*"],
-  "exclude": ["node_modules", "dist"]
-}

package/tsdown.config.ts

@@ -1,15 +0,0 @@
-import { defineConfig } from 'tsdown';
-
-export default defineConfig({
-  clean: true,
-  dts: true,
-  entry: {
-    index: 'src/presentation/library/library.ts',
-    server: 'src/presentation/cli/server.ts',
-  },
-  format: ['cjs', 'esm'],
-  platform: 'node',
-  // Bundle all dependencies
-  // @ts-ignore
-  noExternal: [/(.*)/],
-});

package/vitest.config.ts

@@ -1,9 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    environment: 'node',
-    globals: true,
-    include: ['tests/**/*.test.ts'],
-  },
-});