@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/tests/server/domains/debugger/watch-expressions.test.js

@@ -0,0 +1,134 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { WatchExpressionsHandlers } from '../../../../src/server/domains/debugger/handlers/watch-expressions.js';
+function parseJson(response) {
+    const firstContent = response.content[0];
+    if (!firstContent) {
+        throw new Error('Missing response content');
+    }
+    return JSON.parse(firstContent.text);
+}
+describe('WatchExpressionsHandlers', () => {
+    const watchManager = {
+        addWatch: vi.fn((_expression, _name) => 'watch-default'),
+        removeWatch: vi.fn((_watchId) => false),
+        getAllWatches: vi.fn(() => []),
+        evaluateAll: vi.fn(async (_callFrameId) => []),
+        clearAll: vi.fn(() => undefined),
+    };
+    const debuggerManager = {
+        getWatchManager: vi.fn(() => watchManager),
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('adds a watch expression and falls back to the expression as the display name', async () => {
+        watchManager.addWatch.mockReturnValueOnce('watch-1');
+        const handlers = new WatchExpressionsHandlers({ debuggerManager });
+        const body = parseJson(await handlers.handleWatchAdd({ expression: 'window.token' }));
+        expect(watchManager.addWatch).toHaveBeenCalledWith('window.token', undefined);
+        expect(body).toEqual({
+            success: true,
+            message: 'Watch expression added',
+            watchId: 'watch-1',
+            expression: 'window.token',
+            name: 'window.token',
+        });
+    });
+    it('returns a structured error when adding a watch fails', async () => {
+        watchManager.addWatch.mockImplementationOnce(() => {
+            throw new Error('bad watch');
+        });
+        const handlers = new WatchExpressionsHandlers({ debuggerManager });
+        const body = parseJson(await handlers.handleWatchAdd({ expression: 'boom()' }));
+        expect(body).toEqual({
+            success: false,
+            message: 'Failed to add watch expression',
+            error: 'bad watch',
+        });
+    });
+    it('reports whether removing a watch actually removed anything', async () => {
+        watchManager.removeWatch.mockReturnValueOnce(false);
+        const handlers = new WatchExpressionsHandlers({ debuggerManager });
+        const body = parseJson(await handlers.handleWatchRemove({ watchId: 'missing' }));
+        expect(body).toEqual({
+            success: false,
+            message: 'Watch expression not found',
+            watchId: 'missing',
+        });
+    });
+    it('lists all registered watch expressions', async () => {
+        watchManager.getAllWatches.mockReturnValueOnce([
+            {
+                id: 'watch-1',
+                expression: 'token',
+                name: 'token',
+                enabled: true,
+                lastValue: undefined,
+                lastError: null,
+                valueHistory: [],
+                createdAt: 1,
+            },
+        ]);
+        const handlers = new WatchExpressionsHandlers({ debuggerManager });
+        const body = parseJson(await handlers.handleWatchList({}));
+        expect(body).toEqual({
+            success: true,
+            message: 'Found 1 watch expression(s)',
+            watches: [
+                {
+                    id: 'watch-1',
+                    expression: 'token',
+                    name: 'token',
+                    enabled: true,
+                    lastValue: undefined,
+                    lastError: null,
+                    valueHistory: [],
+                    createdAt: 1,
+                },
+            ],
+        });
+    });
+    it('evaluates all watch expressions in a call frame', async () => {
+        watchManager.evaluateAll.mockResolvedValueOnce([
+            {
+                watchId: 'watch-1',
+                name: 'token',
+                expression: 'token',
+                value: 'abc',
+                error: null,
+                valueChanged: true,
+                timestamp: 1,
+            },
+        ]);
+        const handlers = new WatchExpressionsHandlers({ debuggerManager });
+        const body = parseJson(await handlers.handleWatchEvaluateAll({ callFrameId: 'frame-1' }));
+        expect(watchManager.evaluateAll).toHaveBeenCalledWith('frame-1');
+        expect(body).toEqual({
+            success: true,
+            message: 'Evaluated 1 watch expression(s)',
+            results: [
+                {
+                    watchId: 'watch-1',
+                    name: 'token',
+                    expression: 'token',
+                    value: 'abc',
+                    error: null,
+                    valueChanged: true,
+                    timestamp: 1,
+                },
+            ],
+        });
+    });
+    it('returns a structured error when clearing watches fails', async () => {
+        watchManager.clearAll.mockImplementationOnce(() => {
+            throw new Error('clear failed');
+        });
+        const handlers = new WatchExpressionsHandlers({ debuggerManager });
+        const body = parseJson(await handlers.handleWatchClearAll({}));
+        expect(body).toEqual({
+            success: false,
+            message: 'Failed to clear watch expressions',
+            error: 'clear failed',
+        });
+    });
+});

package/dist/tests/server/domains/debugger/xhr-breakpoint.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/server/domains/debugger/xhr-breakpoint.test.js

@@ -0,0 +1,91 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { XHRBreakpointHandlers } from '../../../../src/server/domains/debugger/handlers/xhr-breakpoint.js';
+function parseJson(response) {
+    const firstContent = response.content[0];
+    if (!firstContent) {
+        throw new Error('Missing response content');
+    }
+    return JSON.parse(firstContent.text);
+}
+describe('XHRBreakpointHandlers', () => {
+    const xhrManager = {
+        setXHRBreakpoint: vi.fn(async (_urlPattern) => 'xhr-default'),
+        removeXHRBreakpoint: vi.fn(async (_breakpointId) => false),
+        getAllXHRBreakpoints: vi.fn(() => []),
+    };
+    function createDebuggerManager(withAdvancedFeatures = true) {
+        const debuggerManager = {
+            getXHRManager: vi.fn(() => xhrManager),
+        };
+        if (withAdvancedFeatures) {
+            debuggerManager.ensureAdvancedFeatures = vi.fn(async () => undefined);
+        }
+        return debuggerManager;
+    }
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it('sets an XHR breakpoint and initializes advanced features when supported', async () => {
+        const debuggerManager = createDebuggerManager(true);
+        xhrManager.setXHRBreakpoint.mockResolvedValueOnce('xhr-1');
+        const handlers = new XHRBreakpointHandlers({ debuggerManager });
+        const body = parseJson(await handlers.handleXHRBreakpointSet({ urlPattern: '/api/' }));
+        expect(debuggerManager.ensureAdvancedFeatures).toHaveBeenCalledOnce();
+        expect(xhrManager.setXHRBreakpoint).toHaveBeenCalledWith('/api/');
+        expect(body).toEqual({
+            success: true,
+            message: 'XHR breakpoint set',
+            breakpointId: 'xhr-1',
+            urlPattern: '/api/',
+        });
+    });
+    it('reports when an XHR breakpoint id is not found during removal', async () => {
+        const debuggerManager = createDebuggerManager(true);
+        xhrManager.removeXHRBreakpoint.mockResolvedValueOnce(false);
+        const handlers = new XHRBreakpointHandlers({ debuggerManager });
+        const body = parseJson(await handlers.handleXHRBreakpointRemove({ breakpointId: 'missing' }));
+        expect(body).toEqual({
+            success: false,
+            message: 'XHR breakpoint not found',
+            breakpointId: 'missing',
+        });
+    });
+    it('returns a structured failure when setting an XHR breakpoint fails', async () => {
+        const debuggerManager = createDebuggerManager(true);
+        xhrManager.setXHRBreakpoint.mockRejectedValueOnce(new Error('xhr boom'));
+        const handlers = new XHRBreakpointHandlers({ debuggerManager });
+        const body = parseJson(await handlers.handleXHRBreakpointSet({ urlPattern: '/broken/' }));
+        expect(body).toEqual({
+            success: false,
+            message: 'Failed to set XHR breakpoint',
+            error: 'xhr boom',
+        });
+    });
+    it('lists all XHR breakpoints without requiring optional advanced support', async () => {
+        const debuggerManager = createDebuggerManager(false);
+        xhrManager.getAllXHRBreakpoints.mockReturnValueOnce([
+            {
+                id: 'xhr-1',
+                urlPattern: '/api/',
+                enabled: true,
+                hitCount: 0,
+                createdAt: 1,
+            },
+        ]);
+        const handlers = new XHRBreakpointHandlers({ debuggerManager });
+        const body = parseJson(await handlers.handleXHRBreakpointList({}));
+        expect(body).toEqual({
+            success: true,
+            message: 'Found 1 XHR breakpoint(s)',
+            breakpoints: [
+                {
+                    id: 'xhr-1',
+                    urlPattern: '/api/',
+                    enabled: true,
+                    hitCount: 0,
+                    createdAt: 1,
+                },
+            ],
+        });
+    });
+});

package/dist/tests/server/domains/encoding/analysis.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
-import { EncodingToolHandlersAnalysis } from '../../../../src/server/domains/encoding/handlers.impl.core.runtime.analysis.js';
-class TestableAnalysis extends EncodingToolHandlersAnalysis {
+import { EncodingHandlersBase } from '../../../../src/server/domains/encoding/handlers.base.js';
+class TestableAnalysis extends EncodingHandlersBase {
     constructor() {
         super(null);
     }
@@ -29,7 +29,7 @@ class TestableAnalysis extends EncodingToolHandlersAnalysis {
         return super.printableRatio(buffer);
     }
 }
-describe('EncodingToolHandlersAnalysis (pure analysis utilities)', () => {
+describe('EncodingHandlersBase (analysis utilities)', () => {
     const analysis = new TestableAnalysis();
     describe('detectMagicFormats', () => {
         it.each([

package/dist/tests/server/domains/encoding/exports.test.d.ts

@@ -0,0 +1 @@
+import '../shared/manifest-test-mocks.js';

package/dist/tests/server/domains/encoding/exports.test.js

@@ -0,0 +1,21 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import '../shared/manifest-test-mocks.js';
+import { assertDomainExportContract } from '../shared/export-contract-helpers.js';
+describe('server/domains/encoding exports', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.resetModules();
+    });
+    it('exposes encoding tool definitions and a matching manifest', async () => {
+        expect.hasAssertions();
+        await assertDomainExportContract({
+            expectedDomain: 'encoding',
+            definitionExportNames: ['encodingTools'],
+            loadDefinitions: () => import('../../../../src/server/domains/encoding/definitions.js'),
+            getToolArrays: (module) => [
+                module.encodingTools,
+            ],
+            loadManifest: () => import('../../../../src/server/domains/encoding/manifest.js'),
+        });
+    });
+});

package/dist/tests/server/domains/encoding/format.test.js

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
-import { EncodingToolHandlersFormat } from '../../../../src/server/domains/encoding/handlers.impl.core.runtime.format.js';
-class TestableFormat extends EncodingToolHandlersFormat {
+import { EncodingHandlersBase } from '../../../../src/server/domains/encoding/handlers.base.js';
+class TestableFormat extends EncodingHandlersBase {
     constructor() {
         super(null);
     }
@@ -54,7 +54,7 @@ class TestableFormat extends EncodingToolHandlersFormat {
     }
 }
 const format = new TestableFormat();
-describe('EncodingToolHandlersFormat (pure utility methods)', () => {
+describe('EncodingHandlersBase (format utilities)', () => {
     describe('isMostlyPrintableText', () => {
         it('returns true for empty string', () => {
             expect(format.isMostlyPrintableText('')).toBe(true);

package/dist/tests/server/domains/encoding/msgpack.test.js

@@ -1,29 +1,13 @@
 import { describe, it, expect } from 'vitest';
-import { EncodingToolHandlersMsgPack } from '../../../../src/server/domains/encoding/handlers.impl.core.runtime.msgpack.js';
-class TestableMsgPack extends EncodingToolHandlersMsgPack {
-    constructor() {
-        super(null);
-    }
-    decodeMsgPack(buffer) {
-        return super.decodeMsgPack(buffer);
-    }
-    decodeMsgPackValue(buffer, startOffset, depth) {
-        return super.decodeMsgPackValue(buffer, startOffset, depth);
-    }
-    decodeMsgPackArray(buffer, startOffset, length, depth) {
-        return super.decodeMsgPackArray(buffer, startOffset, length, depth);
-    }
-    decodeMsgPackMap(buffer, startOffset, length, depth) {
-        return super.decodeMsgPackMap(buffer, startOffset, length, depth);
-    }
-    msgPackMapKey(value) {
-        return super.msgPackMapKey(value);
-    }
-    ensureRange(buffer, offset, length) {
-        return super.ensureRange(buffer, offset, length);
-    }
-}
-const tool = new TestableMsgPack();
+import { decodeMsgPack, decodeMsgPackArray, decodeMsgPackMap, decodeMsgPackValue, ensureRange, msgPackMapKey, } from '../../../../src/server/domains/encoding/encoding-msgpack.js';
+const tool = {
+    decodeMsgPack,
+    decodeMsgPackValue,
+    decodeMsgPackArray,
+    decodeMsgPackMap,
+    msgPackMapKey,
+    ensureRange,
+};
 const b = (...bytes) => Buffer.from(bytes);
 const concat = (...parts) => Buffer.concat(parts);
 function u16be(value) {

package/dist/tests/server/domains/encoding/protobuf.test.js

@@ -1,26 +1,12 @@
 import { describe, it, expect } from 'vitest';
-import { EncodingToolHandlersProtobuf } from '../../../../src/server/domains/encoding/handlers.impl.core.runtime.protobuf.js';
-class TestableProtobuf extends EncodingToolHandlersProtobuf {
-    constructor() {
-        super(null);
-    }
-    parseProtobufMessage(buffer, depth, maxDepth) {
-        return super.parseProtobufMessage(buffer, depth, maxDepth);
-    }
-    decodeLengthDelimited(payload, depth, maxDepth) {
-        return super.decodeLengthDelimited(payload, depth, maxDepth);
-    }
-    tryParseVarint(buffer, startOffset) {
-        return super.tryParseVarint(buffer, startOffset);
-    }
-    protobufWireTypeName(wireType) {
-        return super.protobufWireTypeName(wireType);
-    }
-    bigIntToSafeValue(value) {
-        return super.bigIntToSafeValue(value);
-    }
-}
-const tool = new TestableProtobuf();
+import { bigIntToSafeValue, decodeLengthDelimited, parseProtobufMessage, protobufWireTypeName, tryParseVarint, } from '../../../../src/server/domains/encoding/encoding-protobuf.js';
+const tool = {
+    parseProtobufMessage,
+    decodeLengthDelimited,
+    tryParseVarint,
+    protobufWireTypeName,
+    bigIntToSafeValue,
+};
 function encodeVarint(value) {
     let remaining = typeof value === 'bigint' ? value : BigInt(value);
     if (remaining < 0n) {

package/dist/tests/server/domains/encoding/runtime-shared.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/server/domains/encoding/runtime-shared.test.js

@@ -0,0 +1,234 @@
+import { describe, it, expect } from 'vitest';
+import { DECODE_ENCODING_SET, DETECT_SOURCE_SET, ENTROPY_SOURCE_SET, INPUT_FORMAT_SET, MAGIC_SIGNATURES, OUTPUT_ENCODING_SET, OUTPUT_FORMAT_SET, } from '../../../../src/server/domains/encoding/handlers.impl.core.runtime.shared.js';
+describe('encoding/handlers.impl.core.runtime.shared', () => {
+    describe('DETECT_SOURCE_SET', () => {
+        it('contains all expected DetectSource values', () => {
+            const expected = ['base64', 'hex', 'file', 'raw'];
+            for (const val of expected) {
+                expect(DETECT_SOURCE_SET.has(val)).toBe(true);
+            }
+        });
+        it('has exactly 4 members', () => {
+            expect(DETECT_SOURCE_SET.size).toBe(4);
+        });
+        it('rejects unknown source values', () => {
+            expect(DETECT_SOURCE_SET.has('invalid')).toBe(false);
+            expect(DETECT_SOURCE_SET.has('')).toBe(false);
+            expect(DETECT_SOURCE_SET.has('BASE64')).toBe(false);
+        });
+        it('is typed as ReadonlySet (no add method on type)', () => {
+            expect(DETECT_SOURCE_SET).toBeInstanceOf(Set);
+        });
+    });
+    describe('ENTROPY_SOURCE_SET', () => {
+        it('contains all expected EntropySource values', () => {
+            const expected = ['base64', 'hex', 'raw', 'file'];
+            for (const val of expected) {
+                expect(ENTROPY_SOURCE_SET.has(val)).toBe(true);
+            }
+        });
+        it('has exactly 4 members', () => {
+            expect(ENTROPY_SOURCE_SET.size).toBe(4);
+        });
+        it('rejects unknown values', () => {
+            expect(ENTROPY_SOURCE_SET.has('binary')).toBe(false);
+        });
+    });
+    describe('DECODE_ENCODING_SET', () => {
+        it('contains all expected DecodeEncoding values', () => {
+            const expected = ['base64', 'hex', 'url', 'protobuf', 'msgpack'];
+            for (const val of expected) {
+                expect(DECODE_ENCODING_SET.has(val)).toBe(true);
+            }
+        });
+        it('has exactly 5 members', () => {
+            expect(DECODE_ENCODING_SET.size).toBe(5);
+        });
+        it('rejects unknown encoding values', () => {
+            expect(DECODE_ENCODING_SET.has('utf8')).toBe(false);
+            expect(DECODE_ENCODING_SET.has('ascii')).toBe(false);
+        });
+    });
+    describe('OUTPUT_FORMAT_SET', () => {
+        it('contains all expected OutputFormat values', () => {
+            const expected = ['hex', 'utf8', 'json'];
+            for (const val of expected) {
+                expect(OUTPUT_FORMAT_SET.has(val)).toBe(true);
+            }
+        });
+        it('has exactly 3 members', () => {
+            expect(OUTPUT_FORMAT_SET.size).toBe(3);
+        });
+        it('rejects unknown format values', () => {
+            expect(OUTPUT_FORMAT_SET.has('binary')).toBe(false);
+            expect(OUTPUT_FORMAT_SET.has('base64')).toBe(false);
+        });
+    });
+    describe('INPUT_FORMAT_SET', () => {
+        it('contains all expected InputFormat values', () => {
+            const expected = ['utf8', 'hex', 'json'];
+            for (const val of expected) {
+                expect(INPUT_FORMAT_SET.has(val)).toBe(true);
+            }
+        });
+        it('has exactly 3 members', () => {
+            expect(INPUT_FORMAT_SET.size).toBe(3);
+        });
+        it('rejects unknown format values', () => {
+            expect(INPUT_FORMAT_SET.has('base64')).toBe(false);
+            expect(INPUT_FORMAT_SET.has('raw')).toBe(false);
+        });
+    });
+    describe('OUTPUT_ENCODING_SET', () => {
+        it('contains all expected OutputEncoding values', () => {
+            const expected = ['base64', 'hex', 'url'];
+            for (const val of expected) {
+                expect(OUTPUT_ENCODING_SET.has(val)).toBe(true);
+            }
+        });
+        it('has exactly 3 members', () => {
+            expect(OUTPUT_ENCODING_SET.size).toBe(3);
+        });
+        it('rejects unknown encoding values', () => {
+            expect(OUTPUT_ENCODING_SET.has('utf8')).toBe(false);
+            expect(OUTPUT_ENCODING_SET.has('protobuf')).toBe(false);
+        });
+    });
+    describe('MAGIC_SIGNATURES', () => {
+        it('is a non-empty array', () => {
+            expect(MAGIC_SIGNATURES.length).toBeGreaterThan(0);
+        });
+        it('contains expected formats', () => {
+            const formats = MAGIC_SIGNATURES.map((sig) => sig.format);
+            expect(formats).toContain('png');
+            expect(formats).toContain('jpeg');
+            expect(formats).toContain('gif');
+            expect(formats).toContain('wasm');
+            expect(formats).toContain('zip/apk');
+            expect(formats).toContain('pdf');
+        });
+        it('has exactly 6 signatures', () => {
+            expect(MAGIC_SIGNATURES.length).toBe(6);
+        });
+        it('each signature has format string and bytes array', () => {
+            for (const sig of MAGIC_SIGNATURES) {
+                expect(typeof sig.format).toBe('string');
+                expect(sig.format.length).toBeGreaterThan(0);
+                expect(Array.isArray(sig.bytes)).toBe(true);
+                expect(sig.bytes.length).toBeGreaterThanOrEqual(3);
+            }
+        });
+        it('all bytes are valid uint8 values (0-255)', () => {
+            for (const sig of MAGIC_SIGNATURES) {
+                for (const byte of sig.bytes) {
+                    expect(byte).toBeGreaterThanOrEqual(0);
+                    expect(byte).toBeLessThanOrEqual(255);
+                    expect(Number.isInteger(byte)).toBe(true);
+                }
+            }
+        });
+        it('has unique format names', () => {
+            const formats = MAGIC_SIGNATURES.map((sig) => sig.format);
+            expect(new Set(formats).size).toBe(formats.length);
+        });
+        it.each([
+            { format: 'png', expectedBytes: [0x89, 0x50, 0x4e, 0x47] },
+            { format: 'jpeg', expectedBytes: [0xff, 0xd8, 0xff] },
+            { format: 'gif', expectedBytes: [0x47, 0x49, 0x46] },
+            { format: 'wasm', expectedBytes: [0x00, 0x61, 0x73, 0x6d] },
+            { format: 'zip/apk', expectedBytes: [0x50, 0x4b, 0x03, 0x04] },
+            { format: 'pdf', expectedBytes: [0x25, 0x50, 0x44, 0x46] },
+        ])('$format has correct magic bytes', ({ format, expectedBytes }) => {
+            const sig = MAGIC_SIGNATURES.find((s) => s.format === format);
+            expect(sig).toBeDefined();
+            expect(Array.from(sig.bytes)).toEqual(expectedBytes);
+        });
+        it('is typed as ReadonlyArray', () => {
+            expect(Array.isArray(MAGIC_SIGNATURES)).toBe(true);
+        });
+    });
+    describe('type contracts (compile-time + structural)', () => {
+        it('MagicSignature has expected shape', () => {
+            const sig = { format: 'test', bytes: [0x00] };
+            expect(sig.format).toBe('test');
+            expect(sig.bytes).toEqual([0x00]);
+        });
+        it('ByteFrequencyEntry has expected shape', () => {
+            const entry = { byte: '0x41', count: 10, ratio: 0.5 };
+            expect(entry.byte).toBe('0x41');
+            expect(entry.count).toBe(10);
+            expect(entry.ratio).toBe(0.5);
+        });
+        it('ProtobufFieldNode has expected shape', () => {
+            const node = {
+                index: 0,
+                fieldNumber: 1,
+                wireType: 0,
+                wireTypeName: 'varint',
+                value: 42,
+            };
+            expect(node.index).toBe(0);
+            expect(node.fieldNumber).toBe(1);
+            expect(node.wireType).toBe(0);
+            expect(node.wireTypeName).toBe('varint');
+            expect(node.value).toBe(42);
+        });
+        it('ProtobufParseResult has expected shape', () => {
+            const result = {
+                fields: [],
+                bytesConsumed: 0,
+            };
+            expect(result.fields).toEqual([]);
+            expect(result.bytesConsumed).toBe(0);
+            expect(result.error).toBeUndefined();
+        });
+        it('ProtobufParseResult can include error', () => {
+            const result = {
+                fields: [],
+                bytesConsumed: 0,
+                error: 'parse failed',
+            };
+            expect(result.error).toBe('parse failed');
+        });
+        it('MsgPackDecodeResult has expected shape', () => {
+            const result = { value: 'hello', offset: 6 };
+            expect(result.value).toBe('hello');
+            expect(result.offset).toBe(6);
+        });
+        it('EntropyAssessment type accepts all valid values', () => {
+            const values = [
+                'plaintext',
+                'encoded',
+                'compressed',
+                'encrypted',
+                'random',
+            ];
+            expect(values).toHaveLength(5);
+            values.forEach((v) => expect(typeof v).toBe('string'));
+        });
+    });
+    describe('set cross-relationships', () => {
+        it('DETECT_SOURCE_SET and ENTROPY_SOURCE_SET share base64, hex, raw, file', () => {
+            for (const val of ['base64', 'hex', 'raw', 'file']) {
+                expect(DETECT_SOURCE_SET.has(val)).toBe(true);
+                expect(ENTROPY_SOURCE_SET.has(val)).toBe(true);
+            }
+        });
+        it('DECODE_ENCODING_SET includes base64 and hex (shared with source sets)', () => {
+            expect(DECODE_ENCODING_SET.has('base64')).toBe(true);
+            expect(DECODE_ENCODING_SET.has('hex')).toBe(true);
+        });
+        it('OUTPUT_ENCODING_SET includes base64 and hex (shared with decode set)', () => {
+            expect(OUTPUT_ENCODING_SET.has('base64')).toBe(true);
+            expect(OUTPUT_ENCODING_SET.has('hex')).toBe(true);
+        });
+        it('INPUT_FORMAT_SET and OUTPUT_FORMAT_SET both contain hex', () => {
+            expect(INPUT_FORMAT_SET.has('hex')).toBe(true);
+            expect(OUTPUT_FORMAT_SET.has('hex')).toBe(true);
+        });
+        it('INPUT_FORMAT_SET contains json, OUTPUT_FORMAT_SET also contains json', () => {
+            expect(INPUT_FORMAT_SET.has('json')).toBe(true);
+            expect(OUTPUT_FORMAT_SET.has('json')).toBe(true);
+        });
+    });
+});

package/dist/tests/server/domains/encoding/runtime.test.d.ts

@@ -0,0 +1 @@
+export {};