@jshookmcp/jshook 0.3.0 → 0.3.1

package/dist/encoding-DJeqHmpd.mjs

@@ -1,1079 +0,0 @@
-import { a as argString, n as argEnum, r as argNumber } from "./parse-args-B4cY5Vx5.mjs";
-import "./definitions-DPRpZQ96.mjs";
-import { homedir, tmpdir } from "node:os";
-import { isAbsolute, resolve } from "node:path";
-import { readFile, realpath } from "node:fs/promises";
-//#region src/server/domains/encoding/encoding-protobuf.ts
-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 & 7n);
-		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
-	};
-}
-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$1(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")
-	};
-}
-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 === void 0) return { error: `Unexpected EOF while parsing varint at offset ${offset}` };
-		const byte = BigInt(current);
-		result |= (byte & 127n) << shift;
-		offset += 1;
-		if ((byte & 128n) === 0n) return {
-			value: result,
-			offset
-		};
-		shift += 7n;
-	}
-	return { error: `Varint exceeds 10 bytes at offset ${startOffset}` };
-}
-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";
-}
-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$1(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 >= 32 && code <= 126 || code === 9 || code === 10 || code === 13) printable += 1;
-	}
-	return printable / text.length >= .85;
-}
-//#endregion
-//#region src/server/domains/encoding/encoding-msgpack.ts
-function decodeMsgPack(buffer) {
-	const decoded = 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;
-}
-function decodeMsgPackValue(buffer, startOffset, depth) {
-	if (depth > 64) throw new Error("MessagePack decode depth exceeds safety limit");
-	const prefix = buffer[startOffset];
-	if (prefix === void 0) throw new Error(`Unexpected EOF at offset ${startOffset}`);
-	let offset = startOffset + 1;
-	if (prefix <= 127) return {
-		value: prefix,
-		offset
-	};
-	if (prefix >= 224) return {
-		value: prefix - 256,
-		offset
-	};
-	if (prefix >= 160 && prefix <= 191) {
-		const length = prefix & 31;
-		ensureRange(buffer, offset, length);
-		return {
-			value: buffer.subarray(offset, offset + length).toString("utf8"),
-			offset: offset + length
-		};
-	}
-	if (prefix >= 144 && prefix <= 159) {
-		const length = prefix & 15;
-		return decodeMsgPackArray(buffer, offset, length, depth + 1);
-	}
-	if (prefix >= 128 && prefix <= 143) {
-		const length = prefix & 15;
-		return decodeMsgPackMap(buffer, offset, length, depth + 1);
-	}
-	if (prefix === 192) return {
-		value: null,
-		offset
-	};
-	if (prefix === 194) return {
-		value: false,
-		offset
-	};
-	if (prefix === 195) return {
-		value: true,
-		offset
-	};
-	if (prefix === 204) {
-		ensureRange(buffer, offset, 1);
-		return {
-			value: buffer.readUInt8(offset),
-			offset: offset + 1
-		};
-	}
-	if (prefix === 205) {
-		ensureRange(buffer, offset, 2);
-		return {
-			value: buffer.readUInt16BE(offset),
-			offset: offset + 2
-		};
-	}
-	if (prefix === 206) {
-		ensureRange(buffer, offset, 4);
-		return {
-			value: buffer.readUInt32BE(offset),
-			offset: offset + 4
-		};
-	}
-	if (prefix === 207) {
-		ensureRange(buffer, offset, 8);
-		return {
-			value: bigIntToSafeValue(buffer.readBigUInt64BE(offset)),
-			offset: offset + 8
-		};
-	}
-	if (prefix === 208) {
-		ensureRange(buffer, offset, 1);
-		return {
-			value: buffer.readInt8(offset),
-			offset: offset + 1
-		};
-	}
-	if (prefix === 209) {
-		ensureRange(buffer, offset, 2);
-		return {
-			value: buffer.readInt16BE(offset),
-			offset: offset + 2
-		};
-	}
-	if (prefix === 210) {
-		ensureRange(buffer, offset, 4);
-		return {
-			value: buffer.readInt32BE(offset),
-			offset: offset + 4
-		};
-	}
-	if (prefix === 211) {
-		ensureRange(buffer, offset, 8);
-		return {
-			value: bigIntToSafeValue(buffer.readBigInt64BE(offset)),
-			offset: offset + 8
-		};
-	}
-	if (prefix === 202) {
-		ensureRange(buffer, offset, 4);
-		return {
-			value: buffer.readFloatBE(offset),
-			offset: offset + 4
-		};
-	}
-	if (prefix === 203) {
-		ensureRange(buffer, offset, 8);
-		return {
-			value: buffer.readDoubleBE(offset),
-			offset: offset + 8
-		};
-	}
-	if (prefix === 217) {
-		ensureRange(buffer, offset, 1);
-		const length = buffer.readUInt8(offset);
-		offset += 1;
-		ensureRange(buffer, offset, length);
-		return {
-			value: buffer.subarray(offset, offset + length).toString("utf8"),
-			offset: offset + length
-		};
-	}
-	if (prefix === 218) {
-		ensureRange(buffer, offset, 2);
-		const length = buffer.readUInt16BE(offset);
-		offset += 2;
-		ensureRange(buffer, offset, length);
-		return {
-			value: buffer.subarray(offset, offset + length).toString("utf8"),
-			offset: offset + length
-		};
-	}
-	if (prefix === 219) {
-		ensureRange(buffer, offset, 4);
-		const length = buffer.readUInt32BE(offset);
-		offset += 4;
-		ensureRange(buffer, offset, length);
-		return {
-			value: buffer.subarray(offset, offset + length).toString("utf8"),
-			offset: offset + length
-		};
-	}
-	if (prefix === 196) {
-		ensureRange(buffer, offset, 1);
-		const length = buffer.readUInt8(offset);
-		offset += 1;
-		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 === 197) {
-		ensureRange(buffer, offset, 2);
-		const length = buffer.readUInt16BE(offset);
-		offset += 2;
-		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 === 198) {
-		ensureRange(buffer, offset, 4);
-		const length = buffer.readUInt32BE(offset);
-		offset += 4;
-		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 === 220) {
-		ensureRange(buffer, offset, 2);
-		const length = buffer.readUInt16BE(offset);
-		offset += 2;
-		return decodeMsgPackArray(buffer, offset, length, depth + 1);
-	}
-	if (prefix === 221) {
-		ensureRange(buffer, offset, 4);
-		const length = buffer.readUInt32BE(offset);
-		offset += 4;
-		return decodeMsgPackArray(buffer, offset, length, depth + 1);
-	}
-	if (prefix === 222) {
-		ensureRange(buffer, offset, 2);
-		const length = buffer.readUInt16BE(offset);
-		offset += 2;
-		return decodeMsgPackMap(buffer, offset, length, depth + 1);
-	}
-	if (prefix === 223) {
-		ensureRange(buffer, offset, 4);
-		const length = buffer.readUInt32BE(offset);
-		offset += 4;
-		return decodeMsgPackMap(buffer, offset, length, depth + 1);
-	}
-	if (prefix >= 212 && prefix <= 216) {
-		const size = {
-			212: 1,
-			213: 2,
-			214: 4,
-			215: 8,
-			216: 16
-		}[prefix];
-		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 === 199 || prefix === 200 || prefix === 201) {
-		const lengthBytes = prefix === 199 ? 1 : prefix === 200 ? 2 : 4;
-		ensureRange(buffer, offset, lengthBytes);
-		const length = lengthBytes === 1 ? buffer.readUInt8(offset) : lengthBytes === 2 ? buffer.readUInt16BE(offset) : buffer.readUInt32BE(offset);
-		offset += lengthBytes;
-		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}`);
-}
-function decodeMsgPackArray(buffer, startOffset, length, depth) {
-	let offset = startOffset;
-	const values = [];
-	for (let index = 0; index < length; index += 1) {
-		const decoded = decodeMsgPackValue(buffer, offset, depth);
-		values.push(decoded.value);
-		offset = decoded.offset;
-	}
-	return {
-		value: values,
-		offset
-	};
-}
-function decodeMsgPackMap(buffer, startOffset, length, depth) {
-	let offset = startOffset;
-	const mapValue = {};
-	for (let index = 0; index < length; index += 1) {
-		const keyDecoded = decodeMsgPackValue(buffer, offset, depth);
-		offset = keyDecoded.offset;
-		const valueDecoded = decodeMsgPackValue(buffer, offset, depth);
-		offset = valueDecoded.offset;
-		const key = msgPackMapKey(keyDecoded.value);
-		mapValue[key] = valueDecoded.value;
-	}
-	return {
-		value: mapValue,
-		offset
-	};
-}
-function 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);
-	}
-}
-function 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}`);
-}
-//#endregion
-//#region src/server/domains/encoding/handlers/shared.ts
-/**
-* Encoding domain shared types, constants, and utility functions.
-* Extracted from EncodingHandlersBase.
-*/
-const MAGIC_SIGNATURES = [
-	{
-		format: "png",
-		bytes: [
-			137,
-			80,
-			78,
-			71
-		]
-	},
-	{
-		format: "jpeg",
-		bytes: [
-			255,
-			216,
-			255
-		]
-	},
-	{
-		format: "gif",
-		bytes: [
-			71,
-			73,
-			70
-		]
-	},
-	{
-		format: "wasm",
-		bytes: [
-			0,
-			97,
-			115,
-			109
-		]
-	},
-	{
-		format: "zip/apk",
-		bytes: [
-			80,
-			75,
-			3,
-			4
-		]
-	},
-	{
-		format: "pdf",
-		bytes: [
-			37,
-			80,
-			68,
-			70
-		]
-	}
-];
-const DETECT_SOURCE_SET = new Set([
-	"base64",
-	"hex",
-	"file",
-	"raw"
-]);
-const ENTROPY_SOURCE_SET = new Set([
-	"base64",
-	"hex",
-	"raw",
-	"file"
-]);
-const DECODE_ENCODING_SET = new Set([
-	"base64",
-	"hex",
-	"url",
-	"protobuf",
-	"msgpack"
-]);
-const OUTPUT_FORMAT_SET = new Set([
-	"hex",
-	"utf8",
-	"json"
-]);
-const INPUT_FORMAT_SET = new Set([
-	"utf8",
-	"hex",
-	"json"
-]);
-const OUTPUT_ENCODING_SET = new Set([
-	"base64",
-	"hex",
-	"url"
-]);
-function ok(payload) {
-	return { content: [{
-		type: "text",
-		text: JSON.stringify(payload, null, 2)
-	}] };
-}
-function fail(tool, error) {
-	return ok({
-		success: false,
-		tool,
-		error: error instanceof Error ? error.message : String(error)
-	});
-}
-function 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");
-}
-function decodeBase64String(value) {
-	const cleaned = value.trim().replace(/\s+/g, "");
-	if (cleaned.length === 0) return Buffer.alloc(0);
-	if (!looksLikeBase64(cleaned)) throw new Error("Invalid base64 string");
-	return Buffer.from(cleaned, "base64");
-}
-function decodeBinaryAuto(value) {
-	const trimmed = value.trim();
-	if (trimmed.length === 0) return Buffer.alloc(0);
-	if (looksLikeHex(trimmed)) return decodeHexString(trimmed);
-	if (looksLikeBase64(trimmed)) return decodeBase64String(trimmed);
-	return Buffer.from(trimmed, "utf8");
-}
-function 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);
-}
-function 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");
-		return cleaned.replace(/=+$/, "") === decoded.toString("base64").replace(/=+$/, "");
-	} catch {
-		return false;
-	}
-}
-function looksLikeUrlEncoded(value) {
-	return /%[0-9a-fA-F]{2}/.test(value) || /\+/.test(value);
-}
-function decodeUrl(value) {
-	return decodeURIComponent(value.replace(/\+/g, "%20"));
-}
-function encodeUrlBytes(buffer) {
-	let encoded = "";
-	for (const value of buffer.values()) encoded += value >= 48 && value <= 57 || value >= 65 && value <= 90 || value >= 97 && value <= 122 || value === 45 || value === 46 || value === 95 || value === 126 ? String.fromCharCode(value) : `%${value.toString(16).toUpperCase().padStart(2, "0")}`;
-	return encoded;
-}
-function toSafeUtf8(buffer) {
-	const text = buffer.toString("utf8");
-	if ((text.match(/\uFFFD/g) ?? []).length > 0) return null;
-	return text;
-}
-function tryParseJson(text) {
-	try {
-		return JSON.parse(text);
-	} catch {
-		return null;
-	}
-}
-function previewHex(buffer, maxBytes) {
-	return Array.from(buffer.subarray(0, maxBytes).values()).map((v) => v.toString(16).padStart(2, "0")).join(" ");
-}
-function 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((v) => v.toString(16).padStart(2, "0")).join(" ");
-		const ascii = Array.from(row.values()).map((v) => v >= 32 && v <= 126 ? String.fromCharCode(v) : ".").join("");
-		lines.push(`${offset.toString(16).padStart(8, "0")}  ${hex.padEnd(47)}  |${ascii}|`);
-	}
-	return lines.join("\n");
-}
-function renderDecodedOutput(params) {
-	const { encoding, outputFormat, buffer, jsonValue } = params;
-	if (outputFormat === "hex") return ok({
-		success: true,
-		encoding,
-		outputFormat,
-		byteLength: buffer.length,
-		result: buffer.toString("hex"),
-		hexDump: hexDump(buffer)
-	});
-	if (outputFormat === "utf8") return ok({
-		success: true,
-		encoding,
-		outputFormat,
-		byteLength: buffer.length,
-		result: buffer.toString("utf8")
-	});
-	const utf8 = toSafeUtf8(buffer);
-	const maybeJson = utf8 === null ? null : tryParseJson(utf8);
-	return ok({
-		success: true,
-		encoding,
-		outputFormat,
-		byteLength: buffer.length,
-		result: jsonValue ?? {
-			parsedJson: maybeJson,
-			utf8,
-			hex: buffer.toString("hex")
-		}
-	});
-}
-async function resolveBufferBySource(options) {
-	const { source, data, filePath, maxBytes } = options;
-	if (source === "file") {
-		if (!filePath) throw new Error("filePath is required when source=file");
-		const real = await realpath(resolve(filePath));
-		if (!(await Promise.all([
-			tmpdir(),
-			homedir(),
-			process.cwd()
-		].map(async (p) => {
-			const absolute = isAbsolute(p) ? p : resolve(p);
-			try {
-				return await realpath(absolute);
-			} catch {
-				return absolute;
-			}
-		}))).some((root) => real.startsWith(root))) throw new Error(`File access denied: path "${filePath}" is outside allowed directories`);
-		const fileBuffer = await readFile(real);
-		return typeof maxBytes === "number" ? fileBuffer.subarray(0, maxBytes) : fileBuffer;
-	}
-	if (source === "base64") {
-		if (!data) throw new Error("data is required for base64 source");
-		return decodeBase64String(data);
-	}
-	if (source === "hex") {
-		if (!data) throw new Error("data is required for hex source");
-		return decodeHexString(data);
-	}
-	return Buffer.from(data ?? "", "utf8");
-}
-async function resolveRequestBodyFromActivePage(collector, requestId) {
-	try {
-		const result = await (await collector.getActivePage()).evaluate((targetRequestId) => {
-			const pickBody = (entry) => {
-				if (!entry || typeof entry !== "object") return null;
-				const record = entry;
-				if (record.requestId !== targetRequestId) return null;
-				if (typeof record.responseBody === "string") return {
-					body: record.responseBody,
-					base64Encoded: Boolean(record.base64Encoded)
-				};
-				if (typeof record.body === "string") return {
-					body: record.body,
-					base64Encoded: Boolean(record.base64Encoded)
-				};
-				const response = record.response;
-				if (response && typeof response === "object") {
-					const rr = response;
-					if (typeof rr.body === "string") return {
-						body: rr.body,
-						base64Encoded: Boolean(rr.base64Encoded)
-					};
-				}
-				return null;
-			};
-			const searchArray = (payload) => {
-				if (!Array.isArray(payload)) return null;
-				for (const item of payload) {
-					const found = pickBody(item);
-					if (found) return found;
-				}
-				return null;
-			};
-			const fromMemory = searchArray(window.__capturedAPIs);
-			if (fromMemory) return fromMemory;
-			try {
-				const raw = window.localStorage.getItem("__capturedAPIs");
-				if (!raw) return null;
-				return searchArray(JSON.parse(raw));
-			} catch {
-				return null;
-			}
-		}, requestId);
-		if (!result || typeof result !== "object") return null;
-		const payload = result;
-		if (typeof payload.body !== "string") return null;
-		if (payload.base64Encoded) return Buffer.from(payload.body, "base64");
-		const maybeBase64 = payload.body.trim();
-		if (looksLikeBase64(maybeBase64)) return Buffer.from(maybeBase64, "base64");
-		return Buffer.from(payload.body, "utf8");
-	} catch {
-		return null;
-	}
-}
-function detectMagicFormats(buffer) {
-	const matches = [];
-	for (const signature of MAGIC_SIGNATURES) {
-		if (buffer.length < signature.bytes.length) continue;
-		let matched = true;
-		for (let i = 0; i < signature.bytes.length; i += 1) if (buffer[i] !== signature.bytes[i]) {
-			matched = false;
-			break;
-		}
-		if (matched) matches.push(signature.format);
-	}
-	return matches;
-}
-function detectStructuredFormats(buffer) {
-	const firstByte = buffer[0];
-	if (firstByte === void 0) return [];
-	const formats = /* @__PURE__ */ new Set();
-	if ([
-		8,
-		16,
-		24,
-		32
-	].includes(firstByte)) formats.add("protobuf");
-	if (firstByte >= 128 && firstByte <= 143 || firstByte >= 144 && firstByte <= 159 || firstByte >= 160 && firstByte <= 191) formats.add("messagepack");
-	if (firstByte >= 160 && firstByte <= 191 || firstByte >= 128 && firstByte <= 159) formats.add("cbor");
-	return Array.from(formats);
-}
-function detectEncodingSignals(source, data, buffer) {
-	const encodings = /* @__PURE__ */ new Set();
-	if (source === "base64" || data && looksLikeBase64(data.trim())) encodings.add("base64");
-	if (source === "hex" || data && looksLikeHex(data)) encodings.add("hex");
-	if (data && looksLikeUrlEncoded(data)) encodings.add("url-encoded");
-	if (buffer.length >= 3) {
-		const [a, b, c] = buffer;
-		if (a === 239 && b === 187 && c === 191) encodings.add("utf8-bom");
-	}
-	return Array.from(encodings);
-}
-function calculateShannonEntropy(buffer) {
-	if (buffer.length === 0) return 0;
-	const freq = Array.from({ length: 256 }, () => 0);
-	for (const value of buffer.values()) freq[value] += 1;
-	let entropy = 0;
-	for (const count of freq) {
-		if (count === 0) continue;
-		const p = count / buffer.length;
-		entropy -= p * Math.log2(p);
-	}
-	return Number(entropy.toFixed(6));
-}
-function calculateByteFrequency(buffer) {
-	if (buffer.length === 0) return [];
-	const freq = Array.from({ length: 256 }, () => 0);
-	for (const value of buffer.values()) freq[value] += 1;
-	const entries = [];
-	for (let v = 0; v < 256; v += 1) {
-		const count = freq[v];
-		if (count === 0) continue;
-		entries.push({
-			byte: `0x${v.toString(16).padStart(2, "0")}`,
-			count,
-			ratio: Number((count / buffer.length).toFixed(6))
-		});
-	}
-	entries.sort((a, b) => b.count - a.count);
-	return entries;
-}
-function calculateBlockEntropies(buffer, blockSize) {
-	if (buffer.length === 0) return [];
-	const blocks = [];
-	let index = 0;
-	for (let start = 0; start < buffer.length; start += blockSize) {
-		const end = Math.min(start + blockSize, buffer.length);
-		blocks.push({
-			index,
-			start,
-			end,
-			entropy: calculateShannonEntropy(buffer.subarray(start, end))
-		});
-		index += 1;
-	}
-	return blocks;
-}
-function assessEntropy(entropy, buffer) {
-	const ratio = printableRatio(buffer);
-	if (entropy < 3.8 && ratio > .85) return "plaintext";
-	if (entropy < 5.8) return "encoded";
-	if (entropy < 7.2) return "compressed";
-	if (entropy < 7.8) return "encrypted";
-	return "random";
-}
-function printableRatio(buffer) {
-	if (buffer.length === 0) return 1;
-	let printable = 0;
-	for (const value of buffer.values()) if (value >= 32 && value <= 126 || value === 9 || value === 10 || value === 13) printable += 1;
-	return printable / buffer.length;
-}
-//#endregion
-//#region src/server/domains/encoding/handlers.impl.core.runtime.ts
-var EncodingToolHandlers = class {
-	collector;
-	responseBodyResolver;
-	constructor(collector, responseBodyResolver) {
-		this.collector = collector;
-		this.responseBodyResolver = responseBodyResolver;
-	}
-	async resolveCapturedRequestBody(requestId) {
-		if (this.responseBodyResolver) try {
-			const payload = await this.responseBodyResolver(requestId);
-			if (payload && typeof payload.body === "string") {
-				if (payload.base64Encoded) return Buffer.from(payload.body, "base64");
-				const maybeBase64 = payload.body.trim();
-				if (looksLikeBase64(maybeBase64)) return Buffer.from(maybeBase64, "base64");
-				return Buffer.from(payload.body, "utf8");
-			}
-		} catch {}
-		return resolveRequestBodyFromActivePage(this.collector, requestId);
-	}
-	async handleBinaryDetectFormat(args) {
-		try {
-			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) {
-				buffer = await this.resolveCapturedRequestBody(requestId);
-				requestBodyUsed = buffer !== null;
-			}
-			if (!buffer) {
-				if (source !== "file" && !data) throw new Error("data is required for non-file source when requestId payload is unavailable");
-				buffer = await resolveBufferBySource({
-					source,
-					data,
-					filePath,
-					maxBytes: source === "file" ? 512 : void 0
-				});
-			}
-			const entropy = calculateShannonEntropy(buffer);
-			return ok({
-				success: true,
-				source,
-				requestId: requestId ?? null,
-				requestBodyUsed,
-				byteLength: buffer.length,
-				previewHex: previewHex(buffer, 64),
-				magicFormats: detectMagicFormats(buffer),
-				structuredFormats: detectStructuredFormats(buffer),
-				encodingSignals: detectEncodingSignals(source, data, buffer),
-				entropy,
-				assessment: assessEntropy(entropy, buffer),
-				topBytes: calculateByteFrequency(buffer).slice(0, 8)
-			});
-		} catch (error) {
-			return fail("binary_detect_format", error);
-		}
-	}
-	async handleBinaryDecode(args) {
-		try {
-			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 (!encoding) throw new Error("encoding is required");
-			if (encoding === "url") {
-				const decoded = decodeUrl(data);
-				if (outputFormat === "hex") {
-					const raw = Buffer.from(decoded, "utf8");
-					return ok({
-						success: true,
-						encoding,
-						outputFormat,
-						byteLength: raw.length,
-						result: raw.toString("hex"),
-						hexDump: hexDump(raw)
-					});
-				}
-				if (outputFormat === "utf8") return ok({
-					success: true,
-					encoding,
-					outputFormat,
-					result: decoded
-				});
-				return ok({
-					success: true,
-					encoding,
-					outputFormat,
-					result: tryParseJson(decoded) ?? { text: decoded }
-				});
-			}
-			const rawBuffer = encoding === "base64" ? decodeBase64String(data) : encoding === "hex" ? decodeHexString(data) : decodeBinaryAuto(data);
-			if (encoding === "protobuf") {
-				const parsed = parseProtobufMessage(rawBuffer, 0, 5);
-				return renderDecodedOutput({
-					encoding,
-					outputFormat,
-					buffer: rawBuffer,
-					jsonValue: {
-						fields: parsed.fields,
-						bytesConsumed: parsed.bytesConsumed,
-						error: parsed.error ?? null
-					}
-				});
-			}
-			if (encoding === "msgpack") return renderDecodedOutput({
-				encoding,
-				outputFormat,
-				buffer: rawBuffer,
-				jsonValue: decodeMsgPack(rawBuffer)
-			});
-			return renderDecodedOutput({
-				encoding,
-				outputFormat,
-				buffer: rawBuffer
-			});
-		} catch (error) {
-			return fail("binary_decode", error);
-		}
-	}
-	async handleBinaryEncode(args) {
-		try {
-			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");
-			let buffer;
-			if (inputFormat === "utf8") buffer = Buffer.from(data, "utf8");
-			else if (inputFormat === "hex") buffer = decodeHexString(data);
-			else {
-				const parsed = JSON.parse(data);
-				buffer = Buffer.from(JSON.stringify(parsed), "utf8");
-			}
-			const output = outputEncoding === "base64" ? buffer.toString("base64") : outputEncoding === "hex" ? buffer.toString("hex") : encodeUrlBytes(buffer);
-			return ok({
-				success: true,
-				inputFormat,
-				outputEncoding,
-				byteLength: buffer.length,
-				output
-			});
-		} catch (error) {
-			return fail("binary_encode", error);
-		}
-	}
-	async handleBinaryEntropyAnalysis(args) {
-		try {
-			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 = argNumber(args, "blockSize", 256);
-			const blockSize = Math.max(16, Math.min(8192, Math.trunc(blockSizeRaw || 256)));
-			const buffer = await resolveBufferBySource({
-				source,
-				data,
-				filePath
-			});
-			const overallEntropy = calculateShannonEntropy(buffer);
-			return ok({
-				success: true,
-				source,
-				byteLength: buffer.length,
-				blockSize,
-				overallEntropy,
-				blockEntropies: calculateBlockEntropies(buffer, blockSize),
-				byteFrequency: calculateByteFrequency(buffer).slice(0, 20),
-				assessment: assessEntropy(overallEntropy, buffer)
-			});
-		} catch (error) {
-			return fail("binary_entropy_analysis", error);
-		}
-	}
-	async handleProtobufDecodeRaw(args) {
-		try {
-			const data = argString(args, "data", "");
-			if (!data) throw new Error("data is required");
-			const maxDepthRaw = argNumber(args, "maxDepth", 5);
-			const maxDepth = Math.max(1, Math.min(20, Math.trunc(maxDepthRaw || 5)));
-			const buffer = decodeBase64String(data);
-			const parsed = parseProtobufMessage(buffer, 0, maxDepth);
-			return ok({
-				success: parsed.error === void 0,
-				byteLength: buffer.length,
-				maxDepth,
-				parsedBytes: parsed.bytesConsumed,
-				fields: parsed.fields,
-				error: parsed.error ?? null
-			});
-		} catch (error) {
-			return fail("protobuf_decode_raw", error);
-		}
-	}
-};
-//#endregion
-export { EncodingToolHandlers };