@jshookmcp/jshook 0.2.0 → 0.2.2

package/dist/src/server/domains/encoding/encoding-protobuf.js

@@ -0,0 +1,221 @@
+export function parseProtobufMessage(buffer, depth, maxDepth) {
+    const fields = [];
+    let offset = 0;
+    let fieldIndex = 0;
+    while (offset < buffer.length) {
+        const keyInfo = tryParseVarint(buffer, offset);
+        if (keyInfo.error) {
+            return {
+                fields,
+                bytesConsumed: offset,
+                error: keyInfo.error,
+            };
+        }
+        const keyValue = keyInfo.value;
+        offset = keyInfo.offset;
+        const fieldNumber = Number(keyValue >> 3n);
+        const wireType = Number(keyValue & 0x07n);
+        if (fieldNumber <= 0) {
+            return {
+                fields,
+                bytesConsumed: offset,
+                error: `Invalid field number ${fieldNumber} at offset ${offset}`,
+            };
+        }
+        if (wireType === 0) {
+            const varintInfo = tryParseVarint(buffer, offset);
+            if (varintInfo.error) {
+                return {
+                    fields,
+                    bytesConsumed: offset,
+                    error: varintInfo.error,
+                };
+            }
+            offset = varintInfo.offset;
+            fields.push({
+                index: fieldIndex,
+                fieldNumber,
+                wireType,
+                wireTypeName: protobufWireTypeName(wireType),
+                value: bigIntToSafeValue(varintInfo.value),
+            });
+        }
+        else if (wireType === 1) {
+            if (offset + 8 > buffer.length) {
+                return {
+                    fields,
+                    bytesConsumed: offset,
+                    error: `Unexpected EOF for fixed64 at offset ${offset}`,
+                };
+            }
+            const raw = buffer.subarray(offset, offset + 8);
+            const fixed64 = raw.readBigUInt64LE(0);
+            offset += 8;
+            fields.push({
+                index: fieldIndex,
+                fieldNumber,
+                wireType,
+                wireTypeName: protobufWireTypeName(wireType),
+                value: {
+                    uint64: bigIntToSafeValue(fixed64),
+                    hex: raw.toString('hex'),
+                },
+            });
+        }
+        else if (wireType === 2) {
+            const lengthInfo = tryParseVarint(buffer, offset);
+            if (lengthInfo.error) {
+                return {
+                    fields,
+                    bytesConsumed: offset,
+                    error: lengthInfo.error,
+                };
+            }
+            offset = lengthInfo.offset;
+            const lengthBigInt = lengthInfo.value;
+            if (lengthBigInt > BigInt(Number.MAX_SAFE_INTEGER)) {
+                return {
+                    fields,
+                    bytesConsumed: offset,
+                    error: `Length-delimited field is too large at offset ${offset}`,
+                };
+            }
+            const length = Number(lengthBigInt);
+            if (length < 0 || offset + length > buffer.length) {
+                return {
+                    fields,
+                    bytesConsumed: offset,
+                    error: `Invalid length-delimited field length=${length} at offset ${offset}`,
+                };
+            }
+            const payload = buffer.subarray(offset, offset + length);
+            offset += length;
+            fields.push({
+                index: fieldIndex,
+                fieldNumber,
+                wireType,
+                wireTypeName: protobufWireTypeName(wireType),
+                value: decodeLengthDelimited(payload, depth, maxDepth),
+            });
+        }
+        else if (wireType === 5) {
+            if (offset + 4 > buffer.length) {
+                return {
+                    fields,
+                    bytesConsumed: offset,
+                    error: `Unexpected EOF for fixed32 at offset ${offset}`,
+                };
+            }
+            const raw = buffer.subarray(offset, offset + 4);
+            const fixed32 = raw.readUInt32LE(0);
+            offset += 4;
+            fields.push({
+                index: fieldIndex,
+                fieldNumber,
+                wireType,
+                wireTypeName: protobufWireTypeName(wireType),
+                value: {
+                    uint32: fixed32,
+                    hex: raw.toString('hex'),
+                },
+            });
+        }
+        else {
+            return {
+                fields,
+                bytesConsumed: offset,
+                error: `Unsupported wire type ${wireType} at offset ${offset}`,
+            };
+        }
+        fieldIndex += 1;
+    }
+    return {
+        fields,
+        bytesConsumed: offset,
+    };
+}
+export function decodeLengthDelimited(payload, depth, maxDepth) {
+    if (payload.length === 0) {
+        return { kind: 'empty', length: 0 };
+    }
+    if (depth < maxDepth) {
+        const nested = parseProtobufMessage(payload, depth + 1, maxDepth);
+        if (!nested.error && nested.bytesConsumed === payload.length && nested.fields.length > 0) {
+            return {
+                kind: 'message',
+                fields: nested.fields,
+            };
+        }
+    }
+    const text = toSafeUtf8(payload);
+    if (text !== null && isMostlyPrintableText(text)) {
+        return {
+            kind: 'string',
+            value: text,
+        };
+    }
+    return {
+        kind: 'bytes',
+        length: payload.length,
+        hex: payload.toString('hex'),
+        base64: payload.toString('base64'),
+    };
+}
+export function tryParseVarint(buffer, startOffset) {
+    let result = 0n;
+    let shift = 0n;
+    let offset = startOffset;
+    for (let index = 0; index < 10; index += 1) {
+        const current = buffer[offset];
+        if (current === undefined) {
+            return { error: `Unexpected EOF while parsing varint at offset ${offset}` };
+        }
+        const byte = BigInt(current);
+        result |= (byte & 0x7fn) << shift;
+        offset += 1;
+        if ((byte & 0x80n) === 0n) {
+            return { value: result, offset };
+        }
+        shift += 7n;
+    }
+    return { error: `Varint exceeds 10 bytes at offset ${startOffset}` };
+}
+export function protobufWireTypeName(wireType) {
+    if (wireType === 0)
+        return 'varint';
+    if (wireType === 1)
+        return 'fixed64';
+    if (wireType === 2)
+        return 'length-delimited';
+    if (wireType === 5)
+        return 'fixed32';
+    return 'unknown';
+}
+export function bigIntToSafeValue(value) {
+    const max = BigInt(Number.MAX_SAFE_INTEGER);
+    const min = BigInt(Number.MIN_SAFE_INTEGER);
+    if (value <= max && value >= min) {
+        return Number(value);
+    }
+    return value.toString();
+}
+function toSafeUtf8(buffer) {
+    const text = buffer.toString('utf8');
+    if ((text.match(/\uFFFD/g) ?? []).length > 0) {
+        return null;
+    }
+    return text;
+}
+function isMostlyPrintableText(text) {
+    if (text.length === 0) {
+        return true;
+    }
+    let printable = 0;
+    for (const ch of text) {
+        const code = ch.charCodeAt(0);
+        if ((code >= 0x20 && code <= 0x7e) || code === 0x09 || code === 0x0a || code === 0x0d) {
+            printable += 1;
+        }
+    }
+    return printable / text.length >= 0.85;
+}

package/dist/src/server/domains/encoding/{handlers.impl.core.runtime.format.d.ts → handlers.base.d.ts}

@@ -1,6 +1,6 @@
 import type { CodeCollector } from '../../domains/shared/modules.js';
-import type { DecodeEncoding, OutputFormat } from '../../domains/encoding/handlers.impl.core.runtime.shared.js';
-export declare class EncodingToolHandlersFormat {
+import { type ByteFrequencyEntry, type DecodeEncoding, type DetectSource, type EntropyAssessment, type EntropySource, type OutputFormat } from '../../domains/encoding/handlers.impl.core.runtime.shared.js';
+export declare class EncodingHandlersBase {
     protected collector: CodeCollector;
     constructor(collector: CodeCollector);
     protected isMostlyPrintableText(text: string): boolean;
@@ -39,4 +39,24 @@ export declare class EncodingToolHandlersFormat {
             text: string;
         }[];
     };
+    protected resolveBufferBySource(options: {
+        source: DetectSource | EntropySource;
+        data?: string;
+        filePath?: string;
+        maxBytes?: number;
+    }): Promise<Buffer>;
+    protected resolveRequestBodyFromActivePage(requestId: string): Promise<Buffer | null>;
+    protected detectMagicFormats(buffer: Buffer): string[];
+    protected detectStructuredFormats(buffer: Buffer): string[];
+    protected detectEncodingSignals(source: DetectSource, data: string | undefined, buffer: Buffer): string[];
+    protected calculateShannonEntropy(buffer: Buffer): number;
+    protected calculateByteFrequency(buffer: Buffer): ByteFrequencyEntry[];
+    protected calculateBlockEntropies(buffer: Buffer, blockSize: number): Array<{
+        index: number;
+        start: number;
+        end: number;
+        entropy: number;
+    }>;
+    protected assessEntropy(entropy: number, buffer: Buffer): EntropyAssessment;
+    protected printableRatio(buffer: Buffer): number;
 }

package/dist/src/server/domains/encoding/{handlers.impl.core.runtime.analysis.js → handlers.base.js}

@@ -1,9 +1,196 @@
 import { readFile, realpath } from 'node:fs/promises';
-import { resolve, isAbsolute } from 'node:path';
-import { tmpdir, homedir } from 'node:os';
-import { EncodingToolHandlersFormat } from '../../domains/encoding/handlers.impl.core.runtime.format.js';
+import { isAbsolute, resolve } from 'node:path';
+import { homedir, tmpdir } from 'node:os';
 import { MAGIC_SIGNATURES, } from '../../domains/encoding/handlers.impl.core.runtime.shared.js';
-export class EncodingToolHandlersAnalysis extends EncodingToolHandlersFormat {
+export class EncodingHandlersBase {
+    collector;
+    constructor(collector) {
+        this.collector = collector;
+    }
+    isMostlyPrintableText(text) {
+        if (text.length === 0) {
+            return true;
+        }
+        let printable = 0;
+        for (const ch of text) {
+            const code = ch.charCodeAt(0);
+            if ((code >= 0x20 && code <= 0x7e) || code === 0x09 || code === 0x0a || code === 0x0d) {
+                printable += 1;
+            }
+        }
+        return printable / text.length >= 0.85;
+    }
+    previewHex(buffer, maxBytes) {
+        const sample = buffer.subarray(0, maxBytes);
+        return Array.from(sample.values())
+            .map((value) => value.toString(16).padStart(2, '0'))
+            .join(' ');
+    }
+    hexDump(buffer, bytesPerRow = 16) {
+        const lines = [];
+        for (let offset = 0; offset < buffer.length; offset += bytesPerRow) {
+            const row = buffer.subarray(offset, offset + bytesPerRow);
+            const hex = Array.from(row.values())
+                .map((value) => value.toString(16).padStart(2, '0'))
+                .join(' ');
+            const ascii = Array.from(row.values())
+                .map((value) => (value >= 0x20 && value <= 0x7e ? String.fromCharCode(value) : '.'))
+                .join('');
+            lines.push(`${offset.toString(16).padStart(8, '0')}  ${hex.padEnd(47)}  |${ascii}|`);
+        }
+        return lines.join('\n');
+    }
+    decodeHexString(value) {
+        const cleaned = value
+            .trim()
+            .replace(/^0x/i, '')
+            .replace(/[\s:,-]/g, '');
+        if (cleaned.length === 0) {
+            return Buffer.alloc(0);
+        }
+        if (cleaned.length % 2 !== 0 || !/^[0-9a-fA-F]+$/.test(cleaned)) {
+            throw new Error('Invalid hex string');
+        }
+        return Buffer.from(cleaned, 'hex');
+    }
+    decodeBase64String(value) {
+        const cleaned = value.trim().replace(/\s+/g, '');
+        if (cleaned.length === 0) {
+            return Buffer.alloc(0);
+        }
+        if (!this.looksLikeBase64(cleaned)) {
+            throw new Error('Invalid base64 string');
+        }
+        return Buffer.from(cleaned, 'base64');
+    }
+    decodeBinaryAuto(value) {
+        const trimmed = value.trim();
+        if (trimmed.length === 0) {
+            return Buffer.alloc(0);
+        }
+        if (this.looksLikeHex(trimmed)) {
+            return this.decodeHexString(trimmed);
+        }
+        if (this.looksLikeBase64(trimmed)) {
+            return this.decodeBase64String(trimmed);
+        }
+        return Buffer.from(trimmed, 'utf8');
+    }
+    looksLikeHex(value) {
+        const cleaned = value
+            .trim()
+            .replace(/^0x/i, '')
+            .replace(/[\s:,-]/g, '');
+        return cleaned.length > 0 && cleaned.length % 2 === 0 && /^[0-9a-fA-F]+$/.test(cleaned);
+    }
+    looksLikeBase64(value) {
+        const cleaned = value.trim().replace(/\s+/g, '');
+        if (cleaned.length === 0 || cleaned.length % 4 !== 0) {
+            return false;
+        }
+        if (!/^[A-Za-z0-9+/]*={0,2}$/.test(cleaned)) {
+            return false;
+        }
+        try {
+            const decoded = Buffer.from(cleaned, 'base64');
+            const normalizedInput = cleaned.replace(/=+$/, '');
+            const normalizedRoundtrip = decoded.toString('base64').replace(/=+$/, '');
+            return normalizedInput === normalizedRoundtrip;
+        }
+        catch {
+            return false;
+        }
+    }
+    looksLikeUrlEncoded(value) {
+        return /%[0-9a-fA-F]{2}/.test(value) || /\+/.test(value);
+    }
+    decodeUrl(value) {
+        return decodeURIComponent(value.replace(/\+/g, '%20'));
+    }
+    encodeUrlBytes(buffer) {
+        let encoded = '';
+        for (const value of buffer.values()) {
+            const isAlphaNum = (value >= 0x30 && value <= 0x39) ||
+                (value >= 0x41 && value <= 0x5a) ||
+                (value >= 0x61 && value <= 0x7a);
+            const isUnreserved = value === 0x2d || value === 0x2e || value === 0x5f || value === 0x7e;
+            if (isAlphaNum || isUnreserved) {
+                encoded += String.fromCharCode(value);
+            }
+            else {
+                encoded += `%${value.toString(16).toUpperCase().padStart(2, '0')}`;
+            }
+        }
+        return encoded;
+    }
+    toSafeUtf8(buffer) {
+        const text = buffer.toString('utf8');
+        if ((text.match(/\uFFFD/g) ?? []).length > 0) {
+            return null;
+        }
+        return text;
+    }
+    tryParseJson(text) {
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return null;
+        }
+    }
+    renderDecodedOutput(params) {
+        const { encoding, outputFormat, buffer, jsonValue } = params;
+        if (outputFormat === 'hex') {
+            return this.ok({
+                success: true,
+                encoding,
+                outputFormat,
+                byteLength: buffer.length,
+                result: buffer.toString('hex'),
+                hexDump: this.hexDump(buffer),
+            });
+        }
+        if (outputFormat === 'utf8') {
+            return this.ok({
+                success: true,
+                encoding,
+                outputFormat,
+                byteLength: buffer.length,
+                result: buffer.toString('utf8'),
+            });
+        }
+        const utf8 = this.toSafeUtf8(buffer);
+        const maybeJson = utf8 === null ? null : this.tryParseJson(utf8);
+        return this.ok({
+            success: true,
+            encoding,
+            outputFormat,
+            byteLength: buffer.length,
+            result: jsonValue ?? {
+                parsedJson: maybeJson,
+                utf8,
+                hex: buffer.toString('hex'),
+            },
+        });
+    }
+    ok(payload) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(payload, null, 2),
+                },
+            ],
+        };
+    }
+    fail(tool, error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return this.ok({
+            success: false,
+            tool,
+            error: message,
+        });
+    }
     async resolveBufferBySource(options) {
         const { source, data, filePath, maxBytes } = options;
         if (source === 'file') {
@@ -154,8 +341,7 @@ export class EncodingToolHandlersAnalysis extends EncodingToolHandlersFormat {
             (firstByte >= 0xa0 && firstByte <= 0xbf)) {
             formats.add('messagepack');
         }
-        if ((firstByte >= 0xa0 && firstByte <= 0xbf) ||
-            (firstByte >= 0x80 && firstByte <= 0x9f)) {
+        if ((firstByte >= 0xa0 && firstByte <= 0xbf) || (firstByte >= 0x80 && firstByte <= 0x9f)) {
             formats.add('cbor');
         }
         return Array.from(formats);
@@ -263,10 +449,7 @@ export class EncodingToolHandlersAnalysis extends EncodingToolHandlersFormat {
         }
         let printable = 0;
         for (const value of buffer.values()) {
-            if ((value >= 0x20 && value <= 0x7e) ||
-                value === 0x09 ||
-                value === 0x0a ||
-                value === 0x0d) {
+            if ((value >= 0x20 && value <= 0x7e) || value === 0x09 || value === 0x0a || value === 0x0d) {
                 printable += 1;
             }
         }

package/dist/src/server/domains/encoding/handlers.d.ts

@@ -1 +1 @@
-export { EncodingToolHandlers } from '../../domains/encoding/handlers.impl.js';
+export { EncodingToolHandlers } from '../../domains/encoding/handlers.impl.core.runtime.js';

package/dist/src/server/domains/encoding/handlers.impl.core.runtime.d.ts

@@ -1,5 +1,5 @@
-import { EncodingToolHandlersParsers } from '../../domains/encoding/handlers.impl.core.runtime.parsers.js';
-export declare class EncodingToolHandlers extends EncodingToolHandlersParsers {
+import { EncodingHandlersBase } from '../../domains/encoding/handlers.base.js';
+export declare class EncodingToolHandlers extends EncodingHandlersBase {
     handleBinaryDetectFormat(args: Record<string, unknown>): Promise<{
         content: {
             type: string;

package/dist/src/server/domains/encoding/handlers.impl.core.runtime.js

@@ -1,16 +1,15 @@
-import { EncodingToolHandlersParsers } from '../../domains/encoding/handlers.impl.core.runtime.parsers.js';
+import { EncodingHandlersBase } from '../../domains/encoding/handlers.base.js';
+import { parseProtobufMessage } from '../../domains/encoding/encoding-protobuf.js';
+import { decodeMsgPack } from '../../domains/encoding/encoding-msgpack.js';
 import { DECODE_ENCODING_SET, DETECT_SOURCE_SET, ENTROPY_SOURCE_SET, INPUT_FORMAT_SET, OUTPUT_ENCODING_SET, OUTPUT_FORMAT_SET, } from '../../domains/encoding/handlers.impl.core.runtime.shared.js';
-export class EncodingToolHandlers extends EncodingToolHandlersParsers {
+import { argString, argNumber, argEnum } from '../../domains/shared/parse-args.js';
+export class EncodingToolHandlers extends EncodingHandlersBase {
     async handleBinaryDetectFormat(args) {
         try {
-            const sourceRaw = args.source ?? 'raw';
-            if (!DETECT_SOURCE_SET.has(sourceRaw)) {
-                throw new Error(`Invalid source: ${sourceRaw}`);
-            }
-            const source = sourceRaw;
-            const data = typeof args.data === 'string' ? args.data : undefined;
-            const filePath = typeof args.filePath === 'string' ? args.filePath : undefined;
-            const requestId = typeof args.requestId === 'string' ? args.requestId : undefined;
+            const source = argEnum(args, 'source', DETECT_SOURCE_SET, 'raw');
+            const data = argString(args, 'data');
+            const filePath = argString(args, 'filePath');
+            const requestId = argString(args, 'requestId');
             let buffer = null;
             let requestBodyUsed = false;
             if (source === 'raw' && requestId) {
@@ -54,20 +53,15 @@ export class EncodingToolHandlers extends EncodingToolHandlersParsers {
     }
     async handleBinaryDecode(args) {
         try {
-            const data = typeof args.data === 'string' ? args.data : '';
-            const encodingRaw = args.encoding ?? '';
-            const outputFormatRaw = args.outputFormat ?? 'hex';
+            const data = argString(args, 'data', '');
+            const encoding = argEnum(args, 'encoding', DECODE_ENCODING_SET);
+            const outputFormat = argEnum(args, 'outputFormat', OUTPUT_FORMAT_SET, 'hex');
             if (!data) {
                 throw new Error('data is required');
             }
-            if (!DECODE_ENCODING_SET.has(encodingRaw)) {
-                throw new Error(`Invalid encoding: ${encodingRaw}`);
-            }
-            if (!OUTPUT_FORMAT_SET.has(outputFormatRaw)) {
-                throw new Error(`Invalid outputFormat: ${outputFormatRaw}`);
+            if (!encoding) {
+                throw new Error('encoding is required');
             }
-            const encoding = encodingRaw;
-            const outputFormat = outputFormatRaw;
             if (encoding === 'url') {
                 const decoded = this.decodeUrl(data);
                 if (outputFormat === 'hex') {
@@ -103,7 +97,7 @@ export class EncodingToolHandlers extends EncodingToolHandlersParsers {
                     ? this.decodeHexString(data)
                     : this.decodeBinaryAuto(data);
             if (encoding === 'protobuf') {
-                const parsed = this.parseProtobufMessage(rawBuffer, 0, 5);
+                const parsed = parseProtobufMessage(rawBuffer, 0, 5);
                 return this.renderDecodedOutput({
                     encoding,
                     outputFormat,
@@ -116,7 +110,7 @@ export class EncodingToolHandlers extends EncodingToolHandlersParsers {
                 });
             }
             if (encoding === 'msgpack') {
-                const parsed = this.decodeMsgPack(rawBuffer);
+                const parsed = decodeMsgPack(rawBuffer);
                 return this.renderDecodedOutput({
                     encoding,
                     outputFormat,
@@ -136,20 +130,12 @@ export class EncodingToolHandlers extends EncodingToolHandlersParsers {
     }
     async handleBinaryEncode(args) {
         try {
-            const data = typeof args.data === 'string' ? args.data : '';
-            const inputFormatRaw = args.inputFormat ?? '';
-            const outputEncodingRaw = args.outputEncoding ?? '';
+            const data = argString(args, 'data', '');
+            const inputFormat = argEnum(args, 'inputFormat', INPUT_FORMAT_SET, 'utf8');
+            const outputEncoding = argEnum(args, 'outputEncoding', OUTPUT_ENCODING_SET, 'base64');
             if (!data) {
                 throw new Error('data is required');
             }
-            if (!INPUT_FORMAT_SET.has(inputFormatRaw)) {
-                throw new Error(`Invalid inputFormat: ${inputFormatRaw}`);
-            }
-            if (!OUTPUT_ENCODING_SET.has(outputEncodingRaw)) {
-                throw new Error(`Invalid outputEncoding: ${outputEncodingRaw}`);
-            }
-            const inputFormat = inputFormatRaw;
-            const outputEncoding = outputEncodingRaw;
             let buffer;
             if (inputFormat === 'utf8') {
                 buffer = Buffer.from(data, 'utf8');
@@ -180,17 +166,13 @@ export class EncodingToolHandlers extends EncodingToolHandlersParsers {
     }
     async handleBinaryEntropyAnalysis(args) {
         try {
-            const sourceRaw = args.source ?? 'raw';
-            if (!ENTROPY_SOURCE_SET.has(sourceRaw)) {
-                throw new Error(`Invalid source: ${sourceRaw}`);
-            }
-            const source = sourceRaw;
-            const data = typeof args.data === 'string' ? args.data : undefined;
-            const filePath = typeof args.filePath === 'string' ? args.filePath : undefined;
+            const source = argEnum(args, 'source', ENTROPY_SOURCE_SET, 'raw');
+            const data = argString(args, 'data');
+            const filePath = argString(args, 'filePath');
             if (source !== 'file' && !data) {
                 throw new Error('data is required for non-file source');
             }
-            const blockSizeRaw = typeof args.blockSize === 'number' ? args.blockSize : 256;
+            const blockSizeRaw = argNumber(args, 'blockSize', 256);
             const blockSize = Math.max(16, Math.min(8192, Math.trunc(blockSizeRaw || 256)));
             const buffer = await this.resolveBufferBySource({
                 source,
@@ -218,14 +200,14 @@ export class EncodingToolHandlers extends EncodingToolHandlersParsers {
     }
     async handleProtobufDecodeRaw(args) {
         try {
-            const data = typeof args.data === 'string' ? args.data : '';
+            const data = argString(args, 'data', '');
             if (!data) {
                 throw new Error('data is required');
             }
-            const maxDepthRaw = typeof args.maxDepth === 'number' ? args.maxDepth : 5;
+            const maxDepthRaw = argNumber(args, 'maxDepth', 5);
             const maxDepth = Math.max(1, Math.min(20, Math.trunc(maxDepthRaw || 5)));
             const buffer = this.decodeBase64String(data);
-            const parsed = this.parseProtobufMessage(buffer, 0, maxDepth);
+            const parsed = parseProtobufMessage(buffer, 0, maxDepth);
             return this.ok({
                 success: parsed.error === undefined,
                 byteLength: buffer.length,

package/dist/src/server/domains/encoding/handlers.impl.core.runtime.shared.d.ts

@@ -30,7 +30,10 @@ export interface MsgPackDecodeResult {
     value: unknown;
     offset: number;
 }
-export declare const MAGIC_SIGNATURES: ReadonlyArray<MagicSignature>;
+export declare const MAGIC_SIGNATURES: {
+    format: string;
+    bytes: number[];
+}[];
 export declare const DETECT_SOURCE_SET: ReadonlySet<DetectSource>;
 export declare const ENTROPY_SOURCE_SET: ReadonlySet<EntropySource>;
 export declare const DECODE_ENCODING_SET: ReadonlySet<DecodeEncoding>;

package/dist/src/server/domains/encoding/handlers.impl.core.runtime.shared.js

@@ -6,8 +6,18 @@ export const MAGIC_SIGNATURES = [
     { format: 'zip/apk', bytes: [0x50, 0x4b, 0x03, 0x04] },
     { format: 'pdf', bytes: [0x25, 0x50, 0x44, 0x46] },
 ];
-export const DETECT_SOURCE_SET = new Set(['base64', 'hex', 'file', 'raw']);
-export const ENTROPY_SOURCE_SET = new Set(['base64', 'hex', 'raw', 'file']);
+export const DETECT_SOURCE_SET = new Set([
+    'base64',
+    'hex',
+    'file',
+    'raw',
+]);
+export const ENTROPY_SOURCE_SET = new Set([
+    'base64',
+    'hex',
+    'raw',
+    'file',
+]);
 export const DECODE_ENCODING_SET = new Set([
     'base64',
     'hex',

package/dist/src/server/domains/encoding/handlers.js

@@ -1 +1 @@
-export { EncodingToolHandlers } from '../../domains/encoding/handlers.impl.js';
+export { EncodingToolHandlers } from '../../domains/encoding/handlers.impl.core.runtime.js';