@loop_ouroboros/mcp-hub-lite 1.0.2 → 1.1.1

package/dist/server/tests/unit/utils/json-utils.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeEach } from 'vitest';
-import { stringifyForLogging, stringifyForLoggingWithReplacer, setJsonPrettyConfigGetter, rawHeadersToObject, stringifyRawHeadersForLogging, getJsonPrettySetting, getMcpCommDebugSetting, getSessionDebugSetting } from '../../../src/utils/json-utils.js';
+import { stringifyForLogging, stringifyForLoggingWithReplacer, setJsonPrettyConfigGetter, rawHeadersToObject, stringifyRawHeadersForLogging, getJsonPrettySetting, getMcpCommDebugSetting, getApiDebugSetting } from '../../../src/utils/json-utils.js';
 describe('json-utils', () => {
     beforeEach(() => {
         // Reset config getter
@@ -13,7 +13,7 @@ describe('json-utils', () => {
                     logging: {
                         jsonPretty: true,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 }
             }));
@@ -35,7 +35,7 @@ describe('json-utils', () => {
                     logging: {
                         jsonPretty: true,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 }
             }));
@@ -53,7 +53,7 @@ describe('json-utils', () => {
                     logging: {
                         jsonPretty: true,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 }
             }));
@@ -72,7 +72,7 @@ describe('json-utils', () => {
                     logging: {
                         jsonPretty: true,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 }
             }));
@@ -102,7 +102,7 @@ describe('json-utils', () => {
                     logging: {
                         jsonPretty: false,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 }
             }));
@@ -182,7 +182,7 @@ describe('json-utils', () => {
                     logging: {
                         jsonPretty: false,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 }
             }));
@@ -192,7 +192,7 @@ describe('json-utils', () => {
                     logging: {
                         jsonPretty: true,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 }
             }));
@@ -212,7 +212,7 @@ describe('json-utils', () => {
                         logging: {
                             jsonPretty: false, // Config says false, but env should override
                             mcpCommDebug: false,
-                            sessionDebug: false
+                            apiDebug: false
                         }
                     }
                 }));
@@ -231,7 +231,7 @@ describe('json-utils', () => {
                         logging: {
                             jsonPretty: false, // Config says false, but env should override
                             mcpCommDebug: false,
-                            sessionDebug: false
+                            apiDebug: false
                         }
                     }
                 }));
@@ -250,7 +250,7 @@ describe('json-utils', () => {
                         logging: {
                             jsonPretty: true, // Config says true, but env should override
                             mcpCommDebug: false,
-                            sessionDebug: false
+                            apiDebug: false
                         }
                     }
                 }));
@@ -269,7 +269,7 @@ describe('json-utils', () => {
                         logging: {
                             jsonPretty: true, // Config says true, but env should override
                             mcpCommDebug: false,
-                            sessionDebug: false
+                            apiDebug: false
                         }
                     }
                 }));
@@ -288,7 +288,7 @@ describe('json-utils', () => {
                         logging: {
                             jsonPretty: false,
                             mcpCommDebug: false,
-                            sessionDebug: false
+                            apiDebug: false
                         }
                     }
                 }));
@@ -303,7 +303,7 @@ describe('json-utils', () => {
         it('should return correct defaults when no config getter is set', () => {
             expect(getJsonPrettySetting()).toBe(true);
             expect(getMcpCommDebugSetting()).toBe(false);
-            expect(getSessionDebugSetting()).toBe(false);
+            expect(getApiDebugSetting()).toBe(false);
         });
         it('should return values from config getter when available', () => {
             setJsonPrettyConfigGetter(() => ({
@@ -311,13 +311,13 @@ describe('json-utils', () => {
                     logging: {
                         jsonPretty: false,
                         mcpCommDebug: true,
-                        sessionDebug: true
+                        apiDebug: true
                     }
                 }
             }));
             expect(getJsonPrettySetting()).toBe(false);
             expect(getMcpCommDebugSetting()).toBe(true);
-            expect(getSessionDebugSetting()).toBe(true);
+            expect(getApiDebugSetting()).toBe(true);
         });
         it('should fall back to defaults when config getter fails', () => {
             setJsonPrettyConfigGetter(() => {
@@ -325,7 +325,7 @@ describe('json-utils', () => {
             });
             expect(getJsonPrettySetting()).toBe(true);
             expect(getMcpCommDebugSetting()).toBe(false);
-            expect(getSessionDebugSetting()).toBe(false);
+            expect(getApiDebugSetting()).toBe(false);
         });
     });
     describe('rawHeadersToObject', () => {
@@ -364,7 +364,7 @@ describe('json-utils', () => {
                     logging: {
                         jsonPretty: true,
                         mcpCommDebug: false,
-                        sessionDebug: false
+                        apiDebug: false
                     }
                 }
             }));

package/dist/server/tests/unit/utils/logger-formatter.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=logger-formatter.test.d.ts.map

package/dist/server/tests/unit/utils/logger-formatter.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger-formatter.test.d.ts","sourceRoot":"","sources":["../../../../../tests/unit/utils/logger-formatter.test.ts"],"names":[],"mappings":""}

package/dist/server/tests/unit/utils/logger-formatter.test.js

@@ -0,0 +1,66 @@
+import { describe, it, expect } from 'vitest';
+import { formatError } from '../../../src/utils/logger/log-formatter.js';
+describe('Logger Formatter - formatError', () => {
+    it('should return empty string for array containing exactly one empty object ([{}])', () => {
+        const error = [{}];
+        const result = formatError(error);
+        expect(result).toBe('');
+    });
+    it('should return formatted string for array containing multiple empty objects ([{}, {}, {}])', () => {
+        const error = [{}, {}, {}];
+        const result = formatError(error);
+        expect(result).toContain('{}');
+    });
+    it('should return formatted string for array containing non-empty objects', () => {
+        const error = [{ message: 'test' }];
+        const result = formatError(error);
+        expect(result).toContain('message');
+        expect(result).toContain('test');
+    });
+    it('should return formatted string for array containing mixed objects (empty and non-empty)', () => {
+        const error = [{}, { message: 'test' }, {}];
+        const result = formatError(error);
+        expect(result).toContain('message');
+        expect(result).toContain('test');
+    });
+    it('should return empty string for empty array', () => {
+        const error = [];
+        const result = formatError(error);
+        expect(result).toBe('');
+    });
+    it('should handle Error objects with message correctly', () => {
+        const error = new Error('Test error');
+        const result = formatError(error);
+        expect(result).toContain('Test error');
+    });
+    it('should handle Error objects without message correctly', () => {
+        const error = new Error();
+        const result = formatError(error);
+        expect(result).toContain('Error');
+    });
+    it('should handle Error objects with custom name correctly', () => {
+        const error = Object.assign(new Error(), { name: 'NetworkError' });
+        const result = formatError(error);
+        expect(result).toContain('NetworkError');
+    });
+    it('should handle string errors correctly', () => {
+        const error = 'string error';
+        const result = formatError(error);
+        expect(result).toBe('string error');
+    });
+    it('should handle empty objects correctly', () => {
+        const error = {};
+        const result = formatError(error);
+        expect(result).toBe('{}');
+    });
+    it('should handle null values correctly', () => {
+        const error = null;
+        const result = formatError(error);
+        expect(result).toBe('null');
+    });
+    it('should handle undefined values correctly', () => {
+        const error = undefined;
+        const result = formatError(error);
+        expect(result).toBe('undefined');
+    });
+});

package/dist/server/tests/unit/utils/parameter-validator.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parameter-validator.test.d.ts.map

package/dist/server/tests/unit/utils/parameter-validator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameter-validator.test.d.ts","sourceRoot":"","sources":["../../../../../tests/unit/utils/parameter-validator.test.ts"],"names":[],"mappings":""}

package/dist/server/tests/unit/utils/parameter-validator.test.js

@@ -0,0 +1,63 @@
+import { describe, it, expect } from 'vitest';
+import { validateParameters } from '../../../src/utils/parameter-validator.js';
+describe('Parameter Validator', () => {
+    it('should return null for valid parameters', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                name: { type: 'string' },
+                age: { type: 'number' }
+            },
+            required: ['name']
+        };
+        const args = { name: 'test', age: 25 };
+        const result = validateParameters(args, schema);
+        expect(result).toBeNull();
+    });
+    it('should return error for missing required parameter', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                name: { type: 'string' },
+                age: { type: 'number' }
+            },
+            required: ['name', 'age']
+        };
+        const args = { name: 'test' };
+        const result = validateParameters(args, schema);
+        expect(result).toContain('Missing required parameter');
+        expect(result).toContain('age');
+    });
+    it('should return error for invalid parameter type', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                name: { type: 'string' },
+                age: { type: 'number' }
+            }
+        };
+        const args = { name: 'test', age: '25' }; // age should be number, not string
+        const result = validateParameters(args, schema);
+        expect(result).toContain('Invalid type for parameter');
+        expect(result).toContain('Expected: number');
+    });
+    it('should handle schema without required fields', () => {
+        const schema = {
+            type: 'object',
+            properties: {
+                optionalField: { type: 'string' }
+            }
+        };
+        const args = {};
+        const result = validateParameters(args, schema);
+        expect(result).toBeNull();
+    });
+    it('should handle schema without properties', () => {
+        const schema = {
+            type: 'object'
+        };
+        const args = { any: 'value' };
+        const result = validateParameters(args, schema);
+        expect(result).toBeNull();
+    });
+});

package/dist/server/tests/unit/utils/process-tree.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=process-tree.test.d.ts.map

package/dist/server/tests/unit/utils/process-tree.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-tree.test.d.ts","sourceRoot":"","sources":["../../../../../tests/unit/utils/process-tree.test.ts"],"names":[],"mappings":""}

package/dist/server/tests/unit/utils/process-tree.test.js

@@ -0,0 +1,129 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { getChildren, getProcessTree, isAnyInTreeRunning, getWorkingProcessPid, killProcessTree } from '../../../src/utils/process-tree.js';
+// Mock child_process module
+vi.mock('child_process', () => ({
+    spawn: vi.fn()
+}));
+describe('process-tree (non-Windows platform)', () => {
+    // Save original platform
+    const originalPlatform = process.platform;
+    beforeEach(() => {
+        // Mock non-Windows platform
+        Object.defineProperty(process, 'platform', {
+            value: 'linux',
+            configurable: true
+        });
+        vi.clearAllMocks();
+    });
+    describe('getChildren', () => {
+        it('should return empty array on non-Windows platform', async () => {
+            const result = await getChildren(1234);
+            expect(result).toEqual([]);
+        });
+    });
+    describe('getProcessTree', () => {
+        it('should return array with just the original PID on non-Windows platform', async () => {
+            const result = await getProcessTree(1234);
+            expect(result).toEqual([1234]);
+        });
+    });
+    describe('getWorkingProcessPid', () => {
+        it('should return the original PID on non-Windows platform', async () => {
+            const result = await getWorkingProcessPid(1234);
+            expect(result).toEqual(1234);
+        });
+    });
+    describe('isAnyInTreeRunning', () => {
+        it('should check just the single process on non-Windows platform', async () => {
+            // Mock process.kill to return true (process running)
+            const originalKill = process.kill;
+            process.kill = vi.fn();
+            const result = await isAnyInTreeRunning(1234);
+            expect(result).toBeDefined();
+            // Restore original
+            process.kill = originalKill;
+        });
+    });
+    describe('killProcessTree', () => {
+        it('should just kill the single process on non-Windows platform', async () => {
+            // Mock process.kill
+            const originalKill = process.kill;
+            process.kill = vi.fn();
+            await killProcessTree(1234);
+            // Restore original
+            process.kill = originalKill;
+        });
+    });
+    // Restore original platform after all tests
+    afterAll(() => {
+        Object.defineProperty(process, 'platform', {
+            value: originalPlatform,
+            configurable: true
+        });
+    });
+});
+describe('process-tree (Windows platform)', () => {
+    // Save original platform
+    const originalPlatform = process.platform;
+    beforeEach(() => {
+        // Mock Windows platform
+        Object.defineProperty(process, 'platform', {
+            value: 'win32',
+            configurable: true
+        });
+        vi.clearAllMocks();
+    });
+    describe('isProcessRunning (internal helper behavior)', () => {
+        it('should handle process.kill correctly', async () => {
+            const originalKill = process.kill;
+            // isAnyInTreeRunning will call our mocked kill
+            // We'll test this indirectly
+            const pidToCheck = 99999; // A PID that doesn't exist
+            process.kill = vi.fn((checkPid, signal) => {
+                if (checkPid === pidToCheck && signal === 0) {
+                    throw new Error('ESRCH');
+                }
+                return true;
+            });
+            const result = await isAnyInTreeRunning(pidToCheck);
+            expect(result !== undefined).toBe(true);
+            // Restore original
+            process.kill = originalKill;
+        });
+    });
+    describe('edge cases and error handling', () => {
+        it('should handle invalid PID gracefully', async () => {
+            const result = await getChildren(0);
+            expect(Array.isArray(result)).toBe(true);
+        });
+        it('should handle negative PID gracefully', async () => {
+            const result = await getProcessTree(-1);
+            expect(Array.isArray(result)).toBe(true);
+        });
+        it('should handle errors in getWorkingProcessPid gracefully', async () => {
+            const pid = 12345;
+            const result = await getWorkingProcessPid(pid);
+            // When PowerShell fails, it should fall back to returning the original PID
+            expect(result).toEqual(pid);
+        });
+    });
+    describe('killProcessTree error handling', () => {
+        it('should handle errors in killProcessTree gracefully', async () => {
+            const originalKill = process.kill;
+            process.kill = vi.fn(() => {
+                throw new Error('Access denied');
+            });
+            // This should not throw, errors should be caught
+            await expect(killProcessTree(1234)).resolves.not.toThrow();
+            // Restore original
+            process.kill = originalKill;
+        });
+    });
+    // Restore original platform after all tests
+    afterAll(() => {
+        Object.defineProperty(process, 'platform', {
+            value: originalPlatform,
+            configurable: true
+        });
+    });
+});

package/dist/server/tests/unit/utils/sort-utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sort-utils.test.d.ts.map

package/dist/server/tests/unit/utils/sort-utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-utils.test.d.ts","sourceRoot":"","sources":["../../../../../tests/unit/utils/sort-utils.test.ts"],"names":[],"mappings":""}

package/dist/server/tests/unit/utils/sort-utils.test.js

@@ -0,0 +1,220 @@
+import { describe, it, expect } from 'vitest';
+import { sortObjectKeys, sortObjectKeysCaseInsensitive, sortObjectKeysDeep, sortServerConfigEnvHeaders } from '../../../src/utils/sort-utils.js';
+describe('sort-utils', () => {
+    describe('sortObjectKeys', () => {
+        it('should sort object keys alphabetically using localeCompare', () => {
+            const obj = {
+                zebra: 'value3',
+                apple: 'value1',
+                banana: 'value2'
+            };
+            const result = sortObjectKeys(obj);
+            expect(Object.keys(result)).toEqual(['apple', 'banana', 'zebra']);
+            expect(result).toEqual({
+                apple: 'value1',
+                banana: 'value2',
+                zebra: 'value3'
+            });
+        });
+        it('should return the same object if input is null or undefined', () => {
+            expect(sortObjectKeys(null)).toBe(null);
+            expect(sortObjectKeys(undefined)).toBe(undefined);
+        });
+        it('should return the same object if input is an array', () => {
+            const arr = [3, 1, 2];
+            expect(sortObjectKeys(arr)).toBe(arr);
+        });
+        it('should return the same object if input is not an object', () => {
+            expect(sortObjectKeys('string')).toBe('string');
+            expect(sortObjectKeys(42)).toBe(42);
+            expect(sortObjectKeys(true)).toBe(true);
+        });
+        it('should preserve the original object (return a new object)', () => {
+            const obj = {
+                zebra: 'value3',
+                apple: 'value1'
+            };
+            const result = sortObjectKeys(obj);
+            expect(result).not.toBe(obj);
+            expect(obj).toEqual({
+                zebra: 'value3',
+                apple: 'value1'
+            });
+        });
+        it('should handle empty object', () => {
+            expect(sortObjectKeys({})).toEqual({});
+        });
+    });
+    describe('sortObjectKeysCaseInsensitive', () => {
+        it('should sort object keys alphabetically, case-insensitive', () => {
+            const obj = {
+                Zebra: 'value3',
+                apple: 'value1',
+                Banana: 'value2'
+            };
+            const result = sortObjectKeysCaseInsensitive(obj);
+            expect(Object.keys(result)).toEqual(['apple', 'Banana', 'Zebra']);
+            expect(result).toEqual({
+                apple: 'value1',
+                Banana: 'value2',
+                Zebra: 'value3'
+            });
+        });
+        it('should preserve original key case', () => {
+            const obj = {
+                CONTENT_TYPE: 'application/json',
+                Authorization: 'Bearer token',
+                accept: 'text/plain'
+            };
+            const result = sortObjectKeysCaseInsensitive(obj);
+            expect(Object.keys(result)).toEqual(['accept', 'Authorization', 'CONTENT_TYPE']);
+            expect(result.accept).toBe('text/plain');
+            expect(result.Authorization).toBe('Bearer token');
+            expect(result.CONTENT_TYPE).toBe('application/json');
+        });
+        it('should return the same object if input is null or undefined', () => {
+            expect(sortObjectKeysCaseInsensitive(null)).toBe(null);
+            expect(sortObjectKeysCaseInsensitive(undefined)).toBe(undefined);
+        });
+    });
+    describe('sortObjectKeysDeep', () => {
+        it('should recursively sort all object keys in a nested structure', () => {
+            const obj = {
+                zebra: {
+                    delta: 'value4',
+                    alpha: 'value1'
+                },
+                apple: {
+                    charlie: 'value3',
+                    bravo: 'value2'
+                }
+            };
+            const result = sortObjectKeysDeep(obj);
+            expect(Object.keys(result)).toEqual(['apple', 'zebra']);
+            expect(Object.keys(result.apple)).toEqual(['bravo', 'charlie']);
+            expect(Object.keys(result.zebra)).toEqual(['alpha', 'delta']);
+        });
+        it('should handle arrays and recursively sort objects within arrays', () => {
+            const obj = {
+                items: [
+                    { zebra: 'value3', apple: 'value1' },
+                    { delta: 'value4', alpha: 'value1' }
+                ]
+            };
+            const result = sortObjectKeysDeep(obj);
+            expect(Array.isArray(result.items)).toBe(true);
+            expect(Object.keys(result.items[0])).toEqual(['apple', 'zebra']);
+            expect(Object.keys(result.items[1])).toEqual(['alpha', 'delta']);
+        });
+        it('should handle mixed types in nested structure', () => {
+            const obj = {
+                number: 42,
+                string: 'hello',
+                boolean: true,
+                array: [1, 2, 3],
+                object: {
+                    nested: {
+                        z: 'last',
+                        a: 'first'
+                    }
+                }
+            };
+            const result = sortObjectKeysDeep(obj);
+            expect(Object.keys(result)).toEqual(['array', 'boolean', 'number', 'object', 'string']);
+            expect(Object.keys(result.object.nested)).toEqual(['a', 'z']);
+        });
+    });
+    describe('sortServerConfigEnvHeaders', () => {
+        it('should sort env and headers objects in a server configuration', () => {
+            const config = {
+                env: {
+                    NODE_ENV: 'production',
+                    API_KEY: 'secret',
+                    DEBUG: 'false'
+                },
+                headers: {
+                    'X-Custom-Header': 'value',
+                    Authorization: 'Bearer token',
+                    'Content-Type': 'application/json'
+                },
+                otherField: 'should not be affected'
+            };
+            const result = sortServerConfigEnvHeaders(config);
+            expect(Object.keys(result.env)).toEqual(['API_KEY', 'DEBUG', 'NODE_ENV']);
+            expect(Object.keys(result.headers)).toEqual([
+                'Authorization',
+                'Content-Type',
+                'X-Custom-Header'
+            ]);
+            expect(result.otherField).toBe('should not be affected');
+        });
+        it('should handle case where env or headers is undefined', () => {
+            const config1 = { headers: { Z: '1', A: '2' } };
+            const result1 = sortServerConfigEnvHeaders(config1);
+            expect(Object.keys(result1.headers)).toEqual(['A', 'Z']);
+            expect(result1.env).toBeUndefined();
+            const config2 = { env: { Z: '1', A: '2' } };
+            const result2 = sortServerConfigEnvHeaders(config2);
+            expect(Object.keys(result2.env)).toEqual(['A', 'Z']);
+            expect(result2.headers).toBeUndefined();
+        });
+        it('should handle empty env or headers objects', () => {
+            const config = {
+                env: {},
+                headers: {}
+            };
+            const result = sortServerConfigEnvHeaders(config);
+            expect(result.env).toEqual({});
+            expect(result.headers).toEqual({});
+        });
+        it('should preserve the original object structure', () => {
+            const config = {
+                env: { B: '2', A: '1' },
+                headers: { Y: '2', X: '1' },
+                command: 'npm start',
+                args: ['--verbose']
+            };
+            const result = sortServerConfigEnvHeaders(config);
+            expect(result.command).toBe('npm start');
+            expect(result.args).toEqual(['--verbose']);
+            expect(Object.keys(result.env)).toEqual(['A', 'B']);
+            expect(Object.keys(result.headers)).toEqual(['X', 'Y']);
+        });
+    });
+    describe('integration tests', () => {
+        it('should work with realistic server configuration scenario', () => {
+            const serverConfig = {
+                type: 'stdio',
+                command: 'npx mcp-server',
+                args: ['--config', 'config.json'],
+                env: {
+                    NODE_PATH: '/usr/local/lib/node_modules',
+                    PATH: '/usr/bin:/bin',
+                    HOME: '/home/user',
+                    DEBUG: 'mcp:*',
+                    API_KEY: 'sk-12345'
+                },
+                headers: {
+                    'User-Agent': 'MCP-Hub-Lite/1.0',
+                    Accept: 'application/json',
+                    Authorization: 'Bearer token123',
+                    'Content-Type': 'application/json'
+                }
+            };
+            const result = sortServerConfigEnvHeaders(serverConfig);
+            // Verify env is sorted case-insensitive
+            expect(Object.keys(result.env)).toEqual(['API_KEY', 'DEBUG', 'HOME', 'NODE_PATH', 'PATH']);
+            // Verify headers is sorted case-insensitive
+            expect(Object.keys(result.headers)).toEqual([
+                'Accept',
+                'Authorization',
+                'Content-Type',
+                'User-Agent'
+            ]);
+            // Verify other fields are preserved
+            expect(result.type).toBe('stdio');
+            expect(result.command).toBe('npx mcp-server');
+            expect(result.args).toEqual(['--config', 'config.json']);
+        });
+    });
+});

package/dist/server/tests/unit/utils/transport-factory.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=transport-factory.test.d.ts.map

package/dist/server/tests/unit/utils/transport-factory.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport-factory.test.d.ts","sourceRoot":"","sources":["../../../../../tests/unit/utils/transport-factory.test.ts"],"names":[],"mappings":""}