@jshookmcp/jshook 0.1.9 → 0.2.1

package/dist/src/server/MCPServer.search.dynamicBoost.js

@@ -1,163 +0,0 @@
-import { logger } from '../utils/logger.js';
-import { getToolMinimalTier, getTierIndex, TIER_ORDER, } from './ToolCatalog.js';
-import { boostProfile } from './MCPServer.boost.js';
-import { DYNAMIC_BOOST_STRATEGY, DYNAMIC_BOOST_SKIP_SEARCH_TO_FULL, DYNAMIC_BOOST_MAX_JUMP, } from '../constants.js';
-export function analyzeSearchResultTiers(ctx, results, activeNames, opts) {
-    if (results.length === 0) {
-        return { targetTier: null, tierCounts: {}, considered: [] };
-    }
-    const scoreThreshold = opts?.scoreThreshold ?? 0.6;
-    const minCandidates = opts?.minCandidates ?? 3;
-    const strategy = opts?.strategy ?? DYNAMIC_BOOST_STRATEGY;
-    const inactive = results.filter((r) => !activeNames.has(r.name));
-    if (inactive.length === 0) {
-        return { targetTier: null, tierCounts: {}, considered: [] };
-    }
-    const topScore = inactive[0]?.score ?? 0;
-    const threshold = topScore * scoreThreshold;
-    const candidates = inactive.filter((r, idx) => r.score >= threshold || idx < minCandidates);
-    const tierCounts = { search: 0, workflow: 0, full: 0 };
-    const tierScores = { search: 0, workflow: 0, full: 0 };
-    const tierIndices = [];
-    const considered = [];
-    for (const tool of candidates) {
-        const extRecord = ctx.extensionToolsByName.get(tool.name);
-        if (extRecord?.boostTier) {
-            const boostTier = extRecord.boostTier;
-            const idx = getTierIndex(boostTier);
-            if (idx >= 0) {
-                tierIndices.push(idx);
-                tierCounts[boostTier] = (tierCounts[boostTier] ?? 0) + 1;
-                tierScores[boostTier] = (tierScores[boostTier] ?? 0) + tool.score;
-                considered.push(tool.name);
-                continue;
-            }
-        }
-        const tier = getToolMinimalTier(tool.name);
-        if (tier) {
-            const idx = getTierIndex(tier);
-            if (idx >= 0) {
-                tierIndices.push(idx);
-                tierCounts[tier] = (tierCounts[tier] ?? 0) + 1;
-                tierScores[tier] = (tierScores[tier] ?? 0) + tool.score;
-                considered.push(tool.name);
-            }
-        }
-    }
-    if (tierIndices.length === 0) {
-        return { targetTier: null, tierCounts: tierCounts, considered };
-    }
-    let maxTierIndex;
-    switch (strategy) {
-        case 'top1':
-            maxTierIndex = tierIndices[0] ?? 0;
-            break;
-        case 'majority':
-            const totalCandidates = tierIndices.length;
-            const majorityThreshold = totalCandidates / 2;
-            let bestTierIndex = -1;
-            let maxCount = 0;
-            for (const [tier, count] of Object.entries(tierCounts)) {
-                if (count > maxCount && count >= majorityThreshold) {
-                    maxCount = count;
-                    bestTierIndex = getTierIndex(tier);
-                }
-            }
-            maxTierIndex = bestTierIndex >= 0 ? bestTierIndex : Math.min(...tierIndices);
-            break;
-        case 'weighted':
-            let bestWeightedTierIdx = -1;
-            let maxWeightedScore = -Infinity;
-            for (const [tier, weightedScore] of Object.entries(tierScores)) {
-                if (weightedScore > maxWeightedScore) {
-                    maxWeightedScore = weightedScore;
-                    bestWeightedTierIdx = getTierIndex(tier);
-                }
-            }
-            maxTierIndex = bestWeightedTierIdx >= 0 ? bestWeightedTierIdx : Math.min(...tierIndices);
-            break;
-        case 'max':
-        default:
-            maxTierIndex = Math.max(...tierIndices);
-            break;
-    }
-    const targetTier = TIER_ORDER[maxTierIndex];
-    return {
-        targetTier: targetTier ?? null,
-        tierCounts: tierCounts,
-        considered,
-    };
-}
-export function validateBoostGuardrails(currentTier, targetTier) {
-    const currentIdx = getTierIndex(currentTier);
-    const targetIdx = getTierIndex(targetTier);
-    if (targetIdx <= currentIdx) {
-        return { allowed: true };
-    }
-    const tierJump = targetIdx - currentIdx;
-    if (tierJump > DYNAMIC_BOOST_MAX_JUMP) {
-        const adjustedIdx = currentIdx + DYNAMIC_BOOST_MAX_JUMP;
-        const adjustedTier = TIER_ORDER[adjustedIdx];
-        if (!adjustedTier) {
-            return {
-                allowed: false,
-                reason: `Max tier jump (${DYNAMIC_BOOST_MAX_JUMP}) exceeded, and could not determine adjusted tier`,
-            };
-        }
-        logger.info(`[boost-guardrail] Tier jump ${tierJump} exceeds max ${DYNAMIC_BOOST_MAX_JUMP}. Adjusting from ${targetTier} to ${adjustedTier}`);
-        return {
-            allowed: true,
-            reason: `Tier jump limited from ${tierJump} to ${DYNAMIC_BOOST_MAX_JUMP}`,
-            adjustedTier,
-        };
-    }
-    if (DYNAMIC_BOOST_SKIP_SEARCH_TO_FULL && currentTier === 'search' && targetTier === 'full') {
-        logger.info(`[boost-guardrail] Blocked direct search->full jump. Adjusting to workflow tier instead`);
-        return {
-            allowed: true,
-            reason: 'Direct search->full upgrade blocked by guardrail, adjusting to workflow',
-            adjustedTier: 'workflow',
-        };
-    }
-    return { allowed: true };
-}
-export async function silentBoostToTierWithRetry(ctx, targetTier, opts) {
-    const maxAttempts = opts?.maxAttempts ?? 3;
-    const initialDelay = opts?.initialDelay ?? 30;
-    const exponentialBackoff = opts?.exponentialBackoff ?? true;
-    let lastError = null;
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-        try {
-            logger.info(`[silent-boost] Attempt ${attempt}/${maxAttempts}: boosting to ${targetTier}`);
-            const result = await boostProfile(ctx, targetTier);
-            if (result.success) {
-                logger.info(`[silent-boost] Successfully boosted to ${targetTier} on attempt ${attempt}`);
-                return { success: true, attempts: attempt };
-            }
-            logger.warn(`[silent-boost] Boost returned failure on attempt ${attempt}:`, result.error);
-            return { success: false, attempts: attempt };
-        }
-        catch (error) {
-            lastError = error instanceof Error ? error : new Error(String(error));
-            logger.warn(`[silent-boost] Attempt ${attempt} failed with error:`, lastError.message);
-            if (attempt < maxAttempts) {
-                const delay = exponentialBackoff
-                    ? initialDelay * Math.pow(2, attempt - 1)
-                    : initialDelay;
-                logger.info(`[silent-boost] Retrying after ${delay}ms...`);
-                await sleep(delay);
-            }
-        }
-    }
-    logger.error(`[silent-boost] All ${maxAttempts} attempts failed. Last error:`, lastError?.message);
-    return { success: false, attempts: maxAttempts };
-}
-export function backfillIsActive(results, activeNames) {
-    for (const result of results) {
-        result.isActive = activeNames.has(result.name);
-    }
-    return results;
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}

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

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

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

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

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

@@ -1,24 +0,0 @@
-import { EncodingToolHandlersFormat } from '../../domains/encoding/handlers.impl.core.runtime.format.js';
-import { type ByteFrequencyEntry, type DetectSource, type EntropyAssessment, type EntropySource } from '../../domains/encoding/handlers.impl.core.runtime.shared.js';
-export declare class EncodingToolHandlersAnalysis extends EncodingToolHandlersFormat {
-    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.format.js

@@ -1,191 +0,0 @@
-export class EncodingToolHandlersFormat {
-    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,
-        });
-    }
-}

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

@@ -1,10 +0,0 @@
-import { EncodingToolHandlersProtobuf } from '../../domains/encoding/handlers.impl.core.runtime.protobuf.js';
-import type { MsgPackDecodeResult } from '../../domains/encoding/handlers.impl.core.runtime.shared.js';
-export declare class EncodingToolHandlersMsgPack extends EncodingToolHandlersProtobuf {
-    protected decodeMsgPack(buffer: Buffer): unknown;
-    protected decodeMsgPackValue(buffer: Buffer, startOffset: number, depth: number): MsgPackDecodeResult;
-    protected decodeMsgPackArray(buffer: Buffer, startOffset: number, length: number, depth: number): MsgPackDecodeResult;
-    protected decodeMsgPackMap(buffer: Buffer, startOffset: number, length: number, depth: number): MsgPackDecodeResult;
-    protected msgPackMapKey(value: unknown): string;
-    protected ensureRange(buffer: Buffer, offset: number, length: number): void;
-}

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

@@ -1,268 +0,0 @@
-import { EncodingToolHandlersProtobuf } from '../../domains/encoding/handlers.impl.core.runtime.protobuf.js';
-export class EncodingToolHandlersMsgPack extends EncodingToolHandlersProtobuf {
-    decodeMsgPack(buffer) {
-        const decoded = this.decodeMsgPackValue(buffer, 0, 0);
-        if (decoded.offset !== buffer.length) {
-            throw new Error(`MessagePack decode ended early: consumed ${decoded.offset} of ${buffer.length} bytes`);
-        }
-        return decoded.value;
-    }
-    decodeMsgPackValue(buffer, startOffset, depth) {
-        if (depth > 64) {
-            throw new Error('MessagePack decode depth exceeds safety limit');
-        }
-        const prefix = buffer[startOffset];
-        if (prefix === undefined) {
-            throw new Error(`Unexpected EOF at offset ${startOffset}`);
-        }
-        let offset = startOffset + 1;
-        if (prefix <= 0x7f) {
-            return { value: prefix, offset };
-        }
-        if (prefix >= 0xe0) {
-            return { value: prefix - 0x100, offset };
-        }
-        if (prefix >= 0xa0 && prefix <= 0xbf) {
-            const length = prefix & 0x1f;
-            this.ensureRange(buffer, offset, length);
-            const value = buffer.subarray(offset, offset + length).toString('utf8');
-            return { value, offset: offset + length };
-        }
-        if (prefix >= 0x90 && prefix <= 0x9f) {
-            const length = prefix & 0x0f;
-            return this.decodeMsgPackArray(buffer, offset, length, depth + 1);
-        }
-        if (prefix >= 0x80 && prefix <= 0x8f) {
-            const length = prefix & 0x0f;
-            return this.decodeMsgPackMap(buffer, offset, length, depth + 1);
-        }
-        if (prefix === 0xc0)
-            return { value: null, offset };
-        if (prefix === 0xc2)
-            return { value: false, offset };
-        if (prefix === 0xc3)
-            return { value: true, offset };
-        if (prefix === 0xcc) {
-            this.ensureRange(buffer, offset, 1);
-            const value = buffer.readUInt8(offset);
-            return { value, offset: offset + 1 };
-        }
-        if (prefix === 0xcd) {
-            this.ensureRange(buffer, offset, 2);
-            const value = buffer.readUInt16BE(offset);
-            return { value, offset: offset + 2 };
-        }
-        if (prefix === 0xce) {
-            this.ensureRange(buffer, offset, 4);
-            const value = buffer.readUInt32BE(offset);
-            return { value, offset: offset + 4 };
-        }
-        if (prefix === 0xcf) {
-            this.ensureRange(buffer, offset, 8);
-            const value = buffer.readBigUInt64BE(offset);
-            return { value: this.bigIntToSafeValue(value), offset: offset + 8 };
-        }
-        if (prefix === 0xd0) {
-            this.ensureRange(buffer, offset, 1);
-            const value = buffer.readInt8(offset);
-            return { value, offset: offset + 1 };
-        }
-        if (prefix === 0xd1) {
-            this.ensureRange(buffer, offset, 2);
-            const value = buffer.readInt16BE(offset);
-            return { value, offset: offset + 2 };
-        }
-        if (prefix === 0xd2) {
-            this.ensureRange(buffer, offset, 4);
-            const value = buffer.readInt32BE(offset);
-            return { value, offset: offset + 4 };
-        }
-        if (prefix === 0xd3) {
-            this.ensureRange(buffer, offset, 8);
-            const value = buffer.readBigInt64BE(offset);
-            return { value: this.bigIntToSafeValue(value), offset: offset + 8 };
-        }
-        if (prefix === 0xca) {
-            this.ensureRange(buffer, offset, 4);
-            const value = buffer.readFloatBE(offset);
-            return { value, offset: offset + 4 };
-        }
-        if (prefix === 0xcb) {
-            this.ensureRange(buffer, offset, 8);
-            const value = buffer.readDoubleBE(offset);
-            return { value, offset: offset + 8 };
-        }
-        if (prefix === 0xd9) {
-            this.ensureRange(buffer, offset, 1);
-            const length = buffer.readUInt8(offset);
-            offset += 1;
-            this.ensureRange(buffer, offset, length);
-            const value = buffer.subarray(offset, offset + length).toString('utf8');
-            return { value, offset: offset + length };
-        }
-        if (prefix === 0xda) {
-            this.ensureRange(buffer, offset, 2);
-            const length = buffer.readUInt16BE(offset);
-            offset += 2;
-            this.ensureRange(buffer, offset, length);
-            const value = buffer.subarray(offset, offset + length).toString('utf8');
-            return { value, offset: offset + length };
-        }
-        if (prefix === 0xdb) {
-            this.ensureRange(buffer, offset, 4);
-            const length = buffer.readUInt32BE(offset);
-            offset += 4;
-            this.ensureRange(buffer, offset, length);
-            const value = buffer.subarray(offset, offset + length).toString('utf8');
-            return { value, offset: offset + length };
-        }
-        if (prefix === 0xc4) {
-            this.ensureRange(buffer, offset, 1);
-            const length = buffer.readUInt8(offset);
-            offset += 1;
-            this.ensureRange(buffer, offset, length);
-            const payload = buffer.subarray(offset, offset + length);
-            return {
-                value: { type: 'bytes', base64: payload.toString('base64'), hex: payload.toString('hex') },
-                offset: offset + length,
-            };
-        }
-        if (prefix === 0xc5) {
-            this.ensureRange(buffer, offset, 2);
-            const length = buffer.readUInt16BE(offset);
-            offset += 2;
-            this.ensureRange(buffer, offset, length);
-            const payload = buffer.subarray(offset, offset + length);
-            return {
-                value: { type: 'bytes', base64: payload.toString('base64'), hex: payload.toString('hex') },
-                offset: offset + length,
-            };
-        }
-        if (prefix === 0xc6) {
-            this.ensureRange(buffer, offset, 4);
-            const length = buffer.readUInt32BE(offset);
-            offset += 4;
-            this.ensureRange(buffer, offset, length);
-            const payload = buffer.subarray(offset, offset + length);
-            return {
-                value: { type: 'bytes', base64: payload.toString('base64'), hex: payload.toString('hex') },
-                offset: offset + length,
-            };
-        }
-        if (prefix === 0xdc) {
-            this.ensureRange(buffer, offset, 2);
-            const length = buffer.readUInt16BE(offset);
-            offset += 2;
-            return this.decodeMsgPackArray(buffer, offset, length, depth + 1);
-        }
-        if (prefix === 0xdd) {
-            this.ensureRange(buffer, offset, 4);
-            const length = buffer.readUInt32BE(offset);
-            offset += 4;
-            return this.decodeMsgPackArray(buffer, offset, length, depth + 1);
-        }
-        if (prefix === 0xde) {
-            this.ensureRange(buffer, offset, 2);
-            const length = buffer.readUInt16BE(offset);
-            offset += 2;
-            return this.decodeMsgPackMap(buffer, offset, length, depth + 1);
-        }
-        if (prefix === 0xdf) {
-            this.ensureRange(buffer, offset, 4);
-            const length = buffer.readUInt32BE(offset);
-            offset += 4;
-            return this.decodeMsgPackMap(buffer, offset, length, depth + 1);
-        }
-        if (prefix >= 0xd4 && prefix <= 0xd8) {
-            const sizeByPrefix = {
-                0xd4: 1,
-                0xd5: 2,
-                0xd6: 4,
-                0xd7: 8,
-                0xd8: 16,
-            };
-            const size = sizeByPrefix[prefix];
-            this.ensureRange(buffer, offset, 1 + size);
-            const extType = buffer.readInt8(offset);
-            const payload = buffer.subarray(offset + 1, offset + 1 + size);
-            return {
-                value: {
-                    type: 'ext',
-                    extType,
-                    base64: payload.toString('base64'),
-                    hex: payload.toString('hex'),
-                },
-                offset: offset + 1 + size,
-            };
-        }
-        if (prefix === 0xc7 || prefix === 0xc8 || prefix === 0xc9) {
-            const lengthBytes = prefix === 0xc7 ? 1 : prefix === 0xc8 ? 2 : 4;
-            this.ensureRange(buffer, offset, lengthBytes);
-            const length = lengthBytes === 1
-                ? buffer.readUInt8(offset)
-                : lengthBytes === 2
-                    ? buffer.readUInt16BE(offset)
-                    : buffer.readUInt32BE(offset);
-            offset += lengthBytes;
-            this.ensureRange(buffer, offset, 1 + length);
-            const extType = buffer.readInt8(offset);
-            const payload = buffer.subarray(offset + 1, offset + 1 + length);
-            return {
-                value: {
-                    type: 'ext',
-                    extType,
-                    base64: payload.toString('base64'),
-                    hex: payload.toString('hex'),
-                },
-                offset: offset + 1 + length,
-            };
-        }
-        throw new Error(`Unsupported MessagePack prefix 0x${prefix.toString(16)} at offset ${startOffset}`);
-    }
-    decodeMsgPackArray(buffer, startOffset, length, depth) {
-        let offset = startOffset;
-        const values = [];
-        for (let index = 0; index < length; index += 1) {
-            const decoded = this.decodeMsgPackValue(buffer, offset, depth);
-            values.push(decoded.value);
-            offset = decoded.offset;
-        }
-        return { value: values, offset };
-    }
-    decodeMsgPackMap(buffer, startOffset, length, depth) {
-        let offset = startOffset;
-        const mapValue = {};
-        for (let index = 0; index < length; index += 1) {
-            const keyDecoded = this.decodeMsgPackValue(buffer, offset, depth);
-            offset = keyDecoded.offset;
-            const valueDecoded = this.decodeMsgPackValue(buffer, offset, depth);
-            offset = valueDecoded.offset;
-            const key = this.msgPackMapKey(keyDecoded.value);
-            mapValue[key] = valueDecoded.value;
-        }
-        return { value: mapValue, offset };
-    }
-    msgPackMapKey(value) {
-        if (typeof value === 'string')
-            return value;
-        if (typeof value === 'number')
-            return String(value);
-        if (typeof value === 'boolean')
-            return String(value);
-        if (typeof value === 'bigint')
-            return value.toString();
-        if (value === null)
-            return 'null';
-        try {
-            return JSON.stringify(value);
-        }
-        catch {
-            return String(value);
-        }
-    }
-    ensureRange(buffer, offset, length) {
-        if (offset < 0 || length < 0 || offset + length > buffer.length) {
-            throw new Error(`Unexpected EOF while reading ${length} bytes at offset ${offset}`);
-        }
-    }
-}

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

@@ -1 +0,0 @@
-export { EncodingToolHandlersMsgPack as EncodingToolHandlersParsers } from '../../domains/encoding/handlers.impl.core.runtime.msgpack.js';

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

@@ -1 +0,0 @@
-export { EncodingToolHandlersMsgPack as EncodingToolHandlersParsers } from '../../domains/encoding/handlers.impl.core.runtime.msgpack.js';

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

@@ -1,13 +0,0 @@
-import { EncodingToolHandlersAnalysis } from '../../domains/encoding/handlers.impl.core.runtime.analysis.js';
-import type { ProtobufParseResult } from '../../domains/encoding/handlers.impl.core.runtime.shared.js';
-export declare class EncodingToolHandlersProtobuf extends EncodingToolHandlersAnalysis {
-    protected parseProtobufMessage(buffer: Buffer, depth: number, maxDepth: number): ProtobufParseResult;
-    protected decodeLengthDelimited(payload: Buffer, depth: number, maxDepth: number): unknown;
-    protected tryParseVarint(buffer: Buffer, startOffset: number): {
-        value?: bigint;
-        offset?: number;
-        error?: string;
-    };
-    protected protobufWireTypeName(wireType: number): string;
-    protected bigIntToSafeValue(value: bigint): number | string;
-}