@jshookmcp/jshook 0.2.8 → 0.2.9

package/dist/encoding-Bvz5jLRv.mjs

@@ -0,0 +1,1065 @@
+import { a as argString, n as argEnum, r as argNumber } from "./parse-args-BlRjqlkL.mjs";
+import "./definitions-D3VsGcvz.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;
+	constructor(collector) {
+		this.collector = collector;
+	}
+	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 resolveRequestBodyFromActivePage(this.collector, 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 };