@jshookmcp/jshook 0.2.8 → 0.3.0

package/dist/transform-DRVgGG90.mjs

@@ -0,0 +1,1011 @@
+import { Fr as WORKER_POOL_MIN_WORKERS, Mr as WORKER_POOL_IDLE_TIMEOUT_MS, Nr as WORKER_POOL_JOB_TIMEOUT_MS, Pr as WORKER_POOL_MAX_WORKERS, _r as TRANSFORM_CRYPTO_POOL_MAX_OLD_GEN_MB, br as TRANSFORM_WORKER_TIMEOUT_MS, gr as TRANSFORM_CRYPTO_POOL_IDLE_TIMEOUT_MS, vr as TRANSFORM_CRYPTO_POOL_MAX_WORKERS, yr as TRANSFORM_CRYPTO_POOL_MAX_YOUNG_GEN_MB } from "./constants-CDZLOoVv.mjs";
+import { t as ProcessRegistry } from "./ProcessRegistry-zGg12QbE.mjs";
+import "./modules-tZozf0LQ.mjs";
+import { t as ScriptManager } from "./ScriptManager-ZuWD-0Jg.mjs";
+import { s as evaluateWithTimeout } from "./PageController-BPJNqqBN.mjs";
+import "./definitions-va-AnLuQ.mjs";
+import { Worker } from "node:worker_threads";
+//#region src/utils/WorkerPool.ts
+const DEFAULT_MIN_WORKERS = WORKER_POOL_MIN_WORKERS;
+const DEFAULT_MAX_WORKERS = WORKER_POOL_MAX_WORKERS;
+const DEFAULT_IDLE_TIMEOUT_MS = WORKER_POOL_IDLE_TIMEOUT_MS;
+const DEFAULT_JOB_TIMEOUT_MS = WORKER_POOL_JOB_TIMEOUT_MS;
+/**
+* Generic worker pool with O(1) dispatch, idle eviction, and graceful shutdown.
+*/
+var WorkerPool = class {
+	name;
+	workerScript;
+	minWorkers;
+	maxWorkers;
+	idleTimeoutMs;
+	resourceLimits;
+	workers = /* @__PURE__ */ new Map();
+	queuedJobs = [];
+	activeJobs = /* @__PURE__ */ new Map();
+	nextWorkerId = 1;
+	nextJobId = 1;
+	closed = false;
+	constructor(options) {
+		this.name = options.name ?? "worker-pool";
+		this.workerScript = options.workerScript;
+		this.minWorkers = options.minWorkers ?? DEFAULT_MIN_WORKERS;
+		this.maxWorkers = options.maxWorkers ?? DEFAULT_MAX_WORKERS;
+		this.idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+		this.resourceLimits = options.resourceLimits;
+		if (!this.workerScript || this.workerScript.trim().length === 0) throw this.toError("workerScript must be a non-empty string");
+		if (!Number.isInteger(this.minWorkers) || this.minWorkers < 0) throw this.toError("minWorkers must be an integer >= 0");
+		if (!Number.isInteger(this.maxWorkers) || this.maxWorkers < 1) throw this.toError("maxWorkers must be an integer >= 1");
+		if (this.minWorkers > this.maxWorkers) throw this.toError("minWorkers cannot be greater than maxWorkers");
+		this.ensureMinWorkers();
+	}
+	submit(payload, timeoutMs = DEFAULT_JOB_TIMEOUT_MS) {
+		if (this.closed) return Promise.reject(this.toError("pool is closed"));
+		return new Promise((resolve, reject) => {
+			const job = {
+				id: this.nextJobId++,
+				payload,
+				timeoutMs,
+				resolve,
+				reject
+			};
+			this.queuedJobs.push(job);
+			this.pumpQueue();
+		});
+	}
+	async warmup(count = 1) {
+		if (this.closed) return;
+		const toSpawn = Math.min(count, this.maxWorkers - this.workers.size);
+		for (let i = 0; i < toSpawn; i++) {
+			const worker = this.spawnWorker();
+			this.armIdleTimer(worker);
+		}
+	}
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		const closeError = this.toError("pool is closed");
+		while (this.queuedJobs.length > 0) this.queuedJobs.shift()?.reject(closeError);
+		for (const activeJob of this.activeJobs.values()) {
+			if (activeJob.timeoutHandle) clearTimeout(activeJob.timeoutHandle);
+			activeJob.reject(closeError);
+		}
+		this.activeJobs.clear();
+		const workerIds = Array.from(this.workers.keys());
+		await Promise.all(workerIds.map((workerId) => this.terminateWorker(workerId)));
+	}
+	/**
+	* Terminate all idle workers beyond minWorkers, freeing memory immediately
+	* instead of waiting for the idle timeout.
+	*/
+	async drainIdle() {
+		if (this.closed) return;
+		const toTerminate = [];
+		for (const [id, worker] of this.workers) if (!worker.busy && this.workers.size - toTerminate.length > this.minWorkers) toTerminate.push(id);
+		await Promise.all(toTerminate.map((id) => this.terminateWorker(id)));
+	}
+	ensureMinWorkers() {
+		/* v8 ignore next */
+		if (this.closed) return;
+		while (this.workers.size < this.minWorkers) this.spawnWorker();
+	}
+	pumpQueue() {
+		/* v8 ignore next */
+		if (this.closed) return;
+		while (this.queuedJobs.length > 0) {
+			let worker = this.findIdleWorker();
+			if (!worker) if (this.workers.size < this.maxWorkers) worker = this.spawnWorker();
+			else return;
+			const job = this.queuedJobs.shift();
+			/* v8 ignore next */
+			if (!job) return;
+			this.dispatchJob(worker, job);
+		}
+	}
+	findIdleWorker() {
+		for (const worker of this.workers.values()) if (!worker.busy) return worker;
+	}
+	spawnWorker() {
+		const id = this.nextWorkerId++;
+		const worker = new Worker(this.workerScript, {
+			eval: true,
+			resourceLimits: this.resourceLimits
+		});
+		if (typeof worker.unref === "function") worker.unref();
+		ProcessRegistry.register(worker);
+		const pooled = {
+			id,
+			worker,
+			busy: false,
+			activeJobId: null,
+			idleTimer: null
+		};
+		worker.on("message", (message) => this.handleWorkerMessage(id, message));
+		worker.on("error", (error) => this.handleWorkerFailure(id, error));
+		worker.on("exit", (code) => this.handleWorkerExit(id, code));
+		this.workers.set(id, pooled);
+		return pooled;
+	}
+	dispatchJob(worker, job) {
+		worker.busy = true;
+		worker.activeJobId = job.id;
+		if (worker.idleTimer) {
+			clearTimeout(worker.idleTimer);
+			worker.idleTimer = null;
+		}
+		const timeoutHandle = setTimeout(() => {
+			this.handleJobTimeout(job.id, job.timeoutMs);
+		}, job.timeoutMs);
+		this.activeJobs.set(job.id, {
+			...job,
+			workerId: worker.id,
+			timeoutHandle
+		});
+		try {
+			worker.worker.postMessage({
+				jobId: job.id,
+				payload: job.payload
+			});
+		} catch (error) {
+			const activeJob = this.activeJobs.get(job.id);
+			if (activeJob?.timeoutHandle) clearTimeout(activeJob.timeoutHandle);
+			this.activeJobs.delete(job.id);
+			worker.busy = false;
+			worker.activeJobId = null;
+			job.reject(this.toError(error instanceof Error ? error.message : String(error)));
+			this.terminateWorker(worker.id).then(() => {
+				this.ensureMinWorkers();
+				this.pumpQueue();
+			});
+		}
+	}
+	handleWorkerMessage(workerId, message) {
+		const envelope = message;
+		if (!envelope || typeof envelope !== "object" || typeof envelope.jobId !== "number") return;
+		const activeJob = this.activeJobs.get(envelope.jobId);
+		if (!activeJob) return;
+		if (activeJob.timeoutHandle) clearTimeout(activeJob.timeoutHandle);
+		this.activeJobs.delete(envelope.jobId);
+		const worker = this.workers.get(workerId);
+		if (worker) {
+			worker.busy = false;
+			worker.activeJobId = null;
+			this.armIdleTimer(worker);
+		}
+		if (!envelope.ok) activeJob.reject(this.toError(envelope.error ?? "worker task failed"));
+		else if (typeof envelope.result === "undefined") activeJob.reject(this.toError("worker returned empty result"));
+		else activeJob.resolve(envelope.result);
+		this.pumpQueue();
+	}
+	handleWorkerFailure(workerId, error) {
+		const worker = this.workers.get(workerId);
+		/* v8 ignore next */
+		if (!worker) return;
+		const activeJobId = worker.activeJobId;
+		if (activeJobId !== null) {
+			const activeJob = this.activeJobs.get(activeJobId);
+			if (activeJob) {
+				if (activeJob.timeoutHandle) clearTimeout(activeJob.timeoutHandle);
+				this.activeJobs.delete(activeJobId);
+				activeJob.reject(this.toError(error.message));
+			}
+		}
+		this.terminateWorker(workerId).then(() => {
+			this.ensureMinWorkers();
+			this.pumpQueue();
+		});
+	}
+	handleWorkerExit(workerId, code) {
+		const worker = this.workers.get(workerId);
+		/* v8 ignore next */
+		if (!worker) return;
+		const activeJobId = worker.activeJobId;
+		this.workers.delete(workerId);
+		if (worker.idleTimer) clearTimeout(worker.idleTimer);
+		if (activeJobId !== null) {
+			const activeJob = this.activeJobs.get(activeJobId);
+			if (activeJob) {
+				if (activeJob.timeoutHandle) clearTimeout(activeJob.timeoutHandle);
+				this.activeJobs.delete(activeJobId);
+				activeJob.reject(this.toError(`worker exited unexpectedly with code ${code}`));
+			}
+		}
+		this.ensureMinWorkers();
+		this.pumpQueue();
+	}
+	handleJobTimeout(jobId, timeoutMs) {
+		const activeJob = this.activeJobs.get(jobId);
+		/* v8 ignore next */
+		if (!activeJob) return;
+		this.activeJobs.delete(jobId);
+		activeJob.reject(this.toError(`worker task timed out after ${timeoutMs}ms`));
+		this.terminateWorker(activeJob.workerId).then(() => {
+			this.ensureMinWorkers();
+			this.pumpQueue();
+		});
+	}
+	armIdleTimer(worker) {
+		if (this.idleTimeoutMs <= 0 || this.workers.size <= this.minWorkers) return;
+		if (worker.idleTimer) clearTimeout(worker.idleTimer);
+		worker.idleTimer = setTimeout(() => {
+			const current = this.workers.get(worker.id);
+			/* v8 ignore next */
+			if (!current || current.busy || this.workers.size <= this.minWorkers) return;
+			this.terminateWorker(worker.id);
+		}, this.idleTimeoutMs);
+	}
+	async terminateWorker(workerId) {
+		const worker = this.workers.get(workerId);
+		/* v8 ignore next */
+		if (!worker) return;
+		this.workers.delete(workerId);
+		if (worker.idleTimer) clearTimeout(worker.idleTimer);
+		worker.idleTimer = null;
+		worker.worker.removeAllListeners("message");
+		worker.worker.removeAllListeners("error");
+		worker.worker.removeAllListeners("exit");
+		try {
+			await worker.worker.terminate();
+		} catch {}
+	}
+	toError(message) {
+		return /* @__PURE__ */ new Error(`[${this.name}] ${message}`);
+	}
+};
+const SUPPORTED_TRANSFORM_SET = new Set([
+	"constant_fold",
+	"string_decrypt",
+	"dead_code_remove",
+	"control_flow_flatten",
+	"rename_vars"
+]);
+const NUMERIC_BINARY_EXPR = /\b(-?\d+(?:\.\d+)?)\s*([+\-*/%])\s*(-?\d+(?:\.\d+)?)\b/g;
+const STRING_CONCAT_EXPR = /(['"])((?:\\.|(?!\1)[^\\])*)\1\s*\+\s*(['"])((?:\\.|(?!\3)[^\\])*)\3/g;
+const STRING_LITERAL_EXPR = /(['"])((?:\\.|(?!\1)[^\\])*)\1/g;
+const DEAD_CODE_IF_FALSE_WITH_ELSE = /if\s*\(\s*(?:false|0|!0\s*===\s*!1)\s*\)\s*\{([\s\S]*?)\}\s*else\s*\{([\s\S]*?)\}/g;
+const DEAD_CODE_IF_FALSE = /if\s*\(\s*(?:false|0|!0\s*===\s*!1)\s*\)\s*\{[\s\S]*?\}/g;
+const WORKER_TIMEOUT_MS = TRANSFORM_WORKER_TIMEOUT_MS;
+const CRYPTO_KEYWORDS = [
+	"cryptojs",
+	"md5",
+	"sha",
+	"hmac",
+	"sign",
+	"signature",
+	"encrypt",
+	"decrypt",
+	"aes",
+	"rsa"
+];
+const CRYPTO_TEST_WORKER_SCRIPT = `
+const __bootstrap = async () => {
+  const [workerThreads, vm, perfHooks] = await Promise.all([
+    import('node:worker_threads'), import('node:vm'), import('node:perf_hooks'),
+  ]);
+  const parentPort = workerThreads.parentPort;
+  const performance = perfHooks.performance;
+  if (!parentPort) throw new Error('worker parentPort is unavailable');
+  function normalizeOutput(value) {
+    if (value === undefined) return '__undefined__';
+    if (value === null) return 'null';
+    if (typeof value === 'string') return value;
+    if (typeof value === 'number' || typeof value === 'boolean' || typeof value === 'bigint') return String(value);
+    try { return JSON.stringify(value); } catch { return String(value); }
+  }
+  parentPort.on('message', async (msg) => {
+    const { jobId, payload } = msg;
+    try {
+      const { code, functionName, testInputs } = payload;
+      const sandbox = Object.create(null);
+      sandbox.console = Object.freeze({ log() {}, warn() {}, error() {} });
+      sandbox.Buffer = { from: (...args) => Buffer.from(...args), alloc: (size) => Buffer.alloc(Math.min(size, 1048576)), concat: (...args) => Buffer.concat(...args) };
+      Object.freeze(sandbox.Buffer);
+      sandbox.TextEncoder = TextEncoder; sandbox.TextDecoder = TextDecoder;
+      sandbox.atob = (v) => Buffer.from(String(v), 'base64').toString('binary');
+      sandbox.btoa = (v) => Buffer.from(String(v), 'binary').toString('base64');
+      sandbox.globalThis = sandbox; Object.freeze(sandbox);
+      const context = vm.createContext(sandbox);
+      const isValidIdentifier = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(functionName);
+      const targetExpression = isValidIdentifier
+        ? "(typeof " + functionName + " !== 'undefined' ? " + functionName + " : globalThis[" + JSON.stringify(functionName) + "])"
+        : "globalThis[" + JSON.stringify(functionName) + "]";
+      const script = new vm.Script(
+        "(() => {\\n" + code + "\\n;return " + targetExpression + ";\\n})()",
+        { timeout: 5000 },
+      );
+      const targetFn = script.runInContext(context, { timeout: 5000 });
+      if (typeof targetFn !== 'function') throw new Error("Function not found or not callable: " + functionName);
+      const rows = [];
+      for (const input of testInputs) {
+        const started = performance.now();
+        try {
+          const raw = targetFn(input);
+          const resolved = raw && typeof raw.then === 'function' ? await raw : raw;
+          rows.push({ input, output: normalizeOutput(resolved), duration: Number((performance.now() - started).toFixed(3)) });
+        } catch (err) {
+          rows.push({ input, output: '', error: err && err.message ? err.message : String(err), duration: Number((performance.now() - started).toFixed(3)) });
+        }
+      }
+      parentPort.postMessage({ jobId, ok: true, result: { ok: true, results: rows } });
+    } catch (error) {
+      parentPort.postMessage({ jobId, ok: true, result: { ok: false, error: error && error.message ? error.message : String(error), results: [] } });
+    }
+  });
+};
+__bootstrap().catch((error) => { if (typeof console !== 'undefined' && typeof console.error === 'function') console.error('crypto harness worker bootstrap failed:', error && error.message ? error.message : String(error)); });
+`;
+function createTransformSharedState(collector) {
+	return {
+		collector,
+		chains: /* @__PURE__ */ new Map(),
+		cryptoHarnessPool: new WorkerPool({
+			name: "crypto-harness",
+			workerScript: CRYPTO_TEST_WORKER_SCRIPT,
+			minWorkers: 0,
+			maxWorkers: TRANSFORM_CRYPTO_POOL_MAX_WORKERS,
+			idleTimeoutMs: TRANSFORM_CRYPTO_POOL_IDLE_TIMEOUT_MS,
+			resourceLimits: {
+				maxOldGenerationSizeMb: TRANSFORM_CRYPTO_POOL_MAX_OLD_GEN_MB,
+				maxYoungGenerationSizeMb: TRANSFORM_CRYPTO_POOL_MAX_YOUNG_GEN_MB,
+				stackSizeMb: 8
+			}
+		})
+	};
+}
+function toTextResponse(payload) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(payload, null, 2)
+	}] };
+}
+function fail(tool, error) {
+	return toTextResponse({
+		tool,
+		error: error instanceof Error ? error.message : String(error)
+	});
+}
+function parseTransforms(raw) {
+	const values = Array.isArray(raw) ? raw.map((item) => String(item).trim()).filter((item) => item.length > 0) : typeof raw === "string" ? raw.split(",").map((item) => item.trim()).filter((item) => item.length > 0) : [];
+	if (values.length === 0) throw new Error("transforms must contain at least one transform");
+	const unique = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const value of values) {
+		if (!SUPPORTED_TRANSFORM_SET.has(value)) throw new Error(`Unsupported transform: ${value}`);
+		if (!seen.has(value)) {
+			seen.add(value);
+			unique.push(value);
+		}
+	}
+	return unique;
+}
+function parseTestInputs(raw) {
+	if (!Array.isArray(raw)) throw new Error("testInputs must be an array of strings");
+	const normalized = raw.map((item) => String(item));
+	if (normalized.length === 0) throw new Error("testInputs cannot be empty");
+	return normalized;
+}
+function parseBoolean(raw, defaultValue) {
+	if (typeof raw === "boolean") return raw;
+	if (typeof raw === "string") {
+		const n = raw.trim().toLowerCase();
+		if ([
+			"true",
+			"1",
+			"yes",
+			"on"
+		].includes(n)) return true;
+		if ([
+			"false",
+			"0",
+			"no",
+			"off"
+		].includes(n)) return false;
+	}
+	if (typeof raw === "number") {
+		if (raw === 1) return true;
+		if (raw === 0) return false;
+	}
+	return defaultValue;
+}
+function requireString(raw, field) {
+	if (typeof raw !== "string" || raw.length === 0) throw new Error(`${field} must be a non-empty string`);
+	return raw;
+}
+function escapeStringContent(value, quote) {
+	const escapedControls = value.replace(/\\/g, "\\\\").replace(/\r/g, "\\r").replace(/\n/g, "\\n").replace(/\t/g, "\\t");
+	return quote === "\"" ? escapedControls.replace(/"/g, "\\\"") : escapedControls.replace(/'/g, "\\'");
+}
+function decodeEscapedString(value) {
+	return value.replace(/\\x([0-9a-fA-F]{2})/g, (_f, hex) => String.fromCharCode(parseInt(hex, 16))).replace(/\\u\{([0-9a-fA-F]{1,6})\}/g, (_f, hex) => String.fromCodePoint(parseInt(hex, 16))).replace(/\\u([0-9a-fA-F]{4})/g, (_f, hex) => String.fromCharCode(parseInt(hex, 16))).replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\v/g, "\v").replace(/\\f/g, "\f").replace(/\\0/g, "\0").replace(/\\"/g, "\"").replace(/\\'/g, "'").replace(/\\\\/g, "\\");
+}
+async function resolveScriptSource(collector, scriptId) {
+	let manager = null;
+	try {
+		manager = new ScriptManager(collector);
+		const script = await manager.getScriptSource(scriptId);
+		if (script?.source && script.source.length > 0) return script.source;
+	} catch {} finally {
+		if (manager) try {
+			await manager.close();
+		} catch {}
+	}
+	const fromCache = collector.getFileByUrl(scriptId);
+	if (fromCache?.content && fromCache.content.length > 0) return fromCache.content;
+	const pageSource = await (await collector.getActivePage()).evaluate(async (id) => {
+		const scripts = Array.from(document.scripts);
+		const byNumericIndex = Number(id);
+		if (Number.isInteger(byNumericIndex) && byNumericIndex >= 0 && byNumericIndex < scripts.length) {
+			const script = scripts[byNumericIndex];
+			if (script.textContent && script.textContent.trim().length > 0) return script.textContent;
+			if (script.src) try {
+				const r = await fetch(script.src);
+				if (r.ok) return await r.text();
+			} catch {}
+		}
+		for (const script of scripts) {
+			if (script.id === id || script.dataset?.scriptId === id) {
+				if (script.textContent && script.textContent.trim().length > 0) return script.textContent;
+				if (script.src) try {
+					const r = await fetch(script.src);
+					if (r.ok) return await r.text();
+				} catch {}
+			}
+			if (script.src && script.src.includes(id)) try {
+				const r = await fetch(script.src);
+				if (r.ok) return await r.text();
+			} catch {}
+		}
+		return "";
+	}, scriptId);
+	if (typeof pageSource === "string" && pageSource.length > 0) return pageSource;
+	throw new Error(`Unable to resolve source from scriptId: ${scriptId}`);
+}
+function extractLastSegment(value) {
+	const parts = (value.startsWith("window.") ? value.slice(7) : value).split(".").filter(Boolean);
+	return parts.length > 0 ? parts[parts.length - 1] : "";
+}
+function resolveFunctionName(targetFunction, targetPath, source) {
+	const c1 = extractLastSegment(targetFunction);
+	if (isValidIdentifier(c1)) return c1;
+	const c2 = extractLastSegment(targetPath);
+	if (isValidIdentifier(c2)) return c2;
+	const match = source.match(/function\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*\(/);
+	if (match?.[1] && isValidIdentifier(match[1])) return match[1];
+	return "extractedCryptoFn";
+}
+function isValidIdentifier(value) {
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value);
+}
+async function ensureCryptoPoolWarmed(pool) {
+	await pool.warmup(1);
+}
+function buildCryptoPolyfills() {
+	return `
+const __textEncoder = typeof TextEncoder !== 'undefined' ? new TextEncoder() : null;
+const __textDecoder = typeof TextDecoder !== 'undefined' ? new TextDecoder() : null;
+if (typeof globalThis.atob === 'undefined') { globalThis.atob = (value) => Buffer.from(String(value), 'base64').toString('binary'); }
+if (typeof globalThis.btoa === 'undefined') { globalThis.btoa = (value) => Buffer.from(String(value), 'binary').toString('base64'); }
+`.trim();
+}
+async function runCryptoHarness(pool, code, functionName, testInputs) {
+	try {
+		const msg = await pool.submit({
+			code,
+			functionName,
+			testInputs
+		}, WORKER_TIMEOUT_MS);
+		if (!msg.ok) return {
+			results: testInputs.map((input) => ({
+				input,
+				output: "",
+				duration: 0,
+				error: msg.error ?? "Worker execution failed"
+			})),
+			allPassed: false
+		};
+		const rows = Array.isArray(msg.results) ? msg.results : [];
+		return {
+			results: rows,
+			allPassed: rows.every((row) => !row.error)
+		};
+	} catch (error) {
+		return {
+			results: testInputs.map((input) => ({
+				input,
+				output: "",
+				duration: 0,
+				error: error instanceof Error ? error.message : String(error)
+			})),
+			allPassed: false
+		};
+	}
+}
+//#endregion
+//#region src/server/domains/transform/handlers/transform-operations.ts
+function resolveTransformsForApply(chains, chainName, transformsRaw) {
+	if (chainName.length > 0) {
+		const chain = chains.get(chainName);
+		if (!chain) throw new Error(`Transform chain not found: ${chainName}`);
+		return [...chain.transforms];
+	}
+	return parseTransforms(transformsRaw);
+}
+function applyTransforms(code, transforms) {
+	let transformed = code;
+	const appliedTransforms = [];
+	for (const transform of transforms) {
+		const before = transformed;
+		transformed = applySingleTransform(transformed, transform);
+		if (transformed !== before) appliedTransforms.push(transform);
+	}
+	return {
+		transformed,
+		appliedTransforms
+	};
+}
+function applySingleTransform(code, transform) {
+	switch (transform) {
+		case "constant_fold": return transformConstantFold(code);
+		case "string_decrypt": return transformStringDecrypt(code);
+		case "dead_code_remove": return transformDeadCodeRemove(code);
+		case "control_flow_flatten": return transformControlFlowFlatten(code);
+		case "rename_vars": return transformRenameVars(code);
+		default: return code;
+	}
+}
+function transformConstantFold(code) {
+	let current = code;
+	for (let round = 0; round < 4; round++) {
+		const stringFolded = current.replace(NUMERIC_BINARY_EXPR, (_full, leftRaw, operator, rightRaw) => {
+			const left = Number(leftRaw);
+			const right = Number(rightRaw);
+			if (!Number.isFinite(left) || !Number.isFinite(right)) return `${leftRaw}${operator}${rightRaw}`;
+			let value = null;
+			switch (operator) {
+				case "+":
+					value = left + right;
+					break;
+				case "-":
+					value = left - right;
+					break;
+				case "*":
+					value = left * right;
+					break;
+				case "/":
+					if (right !== 0) value = left / right;
+					break;
+				case "%":
+					if (right !== 0) value = left % right;
+					break;
+				default: value = null;
+			}
+			if (value === null || !Number.isFinite(value)) return `${leftRaw}${operator}${rightRaw}`;
+			return Number.isInteger(value) ? String(value) : String(Number(value.toFixed(12)));
+		}).replace(STRING_CONCAT_EXPR, (_full, q1, left, q2, right) => {
+			const quote = q1 === q2 ? q1 : "'";
+			return `${quote}${escapeStringContent(`${left}${right}`, quote)}${quote}`;
+		});
+		if (stringFolded === current) break;
+		current = stringFolded;
+	}
+	return current;
+}
+function transformStringDecrypt(code) {
+	return code.replace(STRING_LITERAL_EXPR, (_full, quote, inner) => {
+		const decoded = decodeEscapedString(inner);
+		if (decoded === inner) return `${quote}${inner}${quote}`;
+		return `${quote}${escapeStringContent(decoded, quote)}${quote}`;
+	});
+}
+function transformDeadCodeRemove(code) {
+	return code.replace(DEAD_CODE_IF_FALSE_WITH_ELSE, (_full, _ifBody, elseBody) => elseBody).replace(DEAD_CODE_IF_FALSE, "");
+}
+function transformControlFlowFlatten(code) {
+	return code.replace(/var\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*['"]([^'"]+)['"]\.split\(\s*['"]\|['"]\s*\)\s*;\s*var\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*0\s*;\s*while\s*\(\s*!!\[\]\s*\)\s*\{\s*switch\s*\(\s*\1\[\s*\3\+\+\s*\]\s*\)\s*\{([\s\S]*?)\}\s*break;\s*\}/g, (_full, _dispatcher, orderRaw, _cursor, switchBody) => {
+		const caseRegex = /case\s*['"]([^'"]+)['"]\s*:\s*([\s\S]*?)(?=case\s*['"]|default\s*:|$)/g;
+		const caseMap = /* @__PURE__ */ new Map();
+		let match;
+		while ((match = caseRegex.exec(switchBody)) !== null) {
+			const caseKey = match[1];
+			const cleaned = (match[2] ?? "").replace(/\bcontinue\s*;?/g, "").replace(/\bbreak\s*;?/g, "").trim();
+			if (caseKey && cleaned.length > 0) caseMap.set(caseKey, cleaned);
+		}
+		const rebuilt = orderRaw.split("|").map((item) => item.trim()).map((token) => caseMap.get(token)).filter((part) => typeof part === "string" && part.length > 0).join("\n");
+		return rebuilt.length > 0 ? rebuilt : _full;
+	});
+}
+function transformRenameVars(code) {
+	const declaredSingleLetterVars = /* @__PURE__ */ new Set();
+	const declarationRegex = /\b(?:var|let|const)\s+([A-Za-z])\b/g;
+	let match;
+	while ((match = declarationRegex.exec(code)) !== null) {
+		const name = match[1];
+		if (name) declaredSingleLetterVars.add(name);
+	}
+	if (declaredSingleLetterVars.size === 0) return code;
+	const renameMap = /* @__PURE__ */ new Map();
+	let counter = 1;
+	for (const name of declaredSingleLetterVars) {
+		renameMap.set(name, `var_${counter}`);
+		counter += 1;
+	}
+	return code.replace(/\b([A-Za-z])\b/g, (token, identifier, offset, full) => {
+		const replacement = renameMap.get(identifier);
+		if (!replacement) return token;
+		const prev = offset > 0 ? full[offset - 1] : "";
+		if (prev === "." || prev === "'" || prev === "\"" || prev === "`" || prev === "$") return token;
+		return replacement;
+	});
+}
+function buildDiff(original, transformed) {
+	if (original === transformed) return "";
+	const oldLines = original.split("\n");
+	const newLines = transformed.split("\n");
+	if (oldLines.length * newLines.length > 25e4) return buildFallbackDiff(oldLines, newLines);
+	const m = oldLines.length;
+	const n = newLines.length;
+	const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+	for (let i = m - 1; i >= 0; i--) for (let j = n - 1; j >= 0; j--) dp[i][j] = oldLines[i] === newLines[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
+	const diffLines = [];
+	let i = 0;
+	let j = 0;
+	while (i < m && j < n) {
+		if (oldLines[i] === newLines[j]) {
+			diffLines.push(` ${oldLines[i]}`);
+			i += 1;
+			j += 1;
+			continue;
+		}
+		if (dp[i + 1][j] >= dp[i][j + 1]) {
+			diffLines.push(`-${oldLines[i]}`);
+			i += 1;
+		} else {
+			diffLines.push(`+${newLines[j]}`);
+			j += 1;
+		}
+	}
+	while (i < m) {
+		diffLines.push(`-${oldLines[i]}`);
+		i += 1;
+	}
+	while (j < n) {
+		diffLines.push(`+${newLines[j]}`);
+		j += 1;
+	}
+	return diffLines.join("\n");
+}
+function buildFallbackDiff(oldLines, newLines) {
+	let start = 0;
+	while (start < oldLines.length && start < newLines.length && oldLines[start] === newLines[start]) start += 1;
+	let oldEnd = oldLines.length - 1;
+	let newEnd = newLines.length - 1;
+	while (oldEnd >= start && newEnd >= start && oldLines[oldEnd] === newLines[newEnd]) {
+		oldEnd -= 1;
+		newEnd -= 1;
+	}
+	const removed = oldLines.slice(start, oldEnd + 1).map((line) => `-${line}`);
+	const added = newLines.slice(start, newEnd + 1).map((line) => `+${line}`);
+	return [...removed, ...added].join("\n");
+}
+//#endregion
+//#region src/server/domains/transform/handlers/ast-handlers.ts
+var AstHandlers = class {
+	state;
+	constructor(state) {
+		this.state = state;
+	}
+	async handleAstTransformPreview(args) {
+		try {
+			const code = requireString(args.code, "code");
+			const transforms = parseTransforms(args.transforms);
+			const preview = parseBoolean(args.preview, true);
+			const result = applyTransforms(code, transforms);
+			const diff = preview ? buildDiff(code, result.transformed) : "";
+			return toTextResponse({
+				original: code,
+				transformed: result.transformed,
+				diff,
+				appliedTransforms: result.appliedTransforms
+			});
+		} catch (error) {
+			return fail("ast_transform_preview", error);
+		}
+	}
+	async handleAstTransformChain(args) {
+		try {
+			const name = requireString(args.name, "name").trim();
+			const description = typeof args.description === "string" && args.description.trim().length > 0 ? args.description.trim() : void 0;
+			const transforms = parseTransforms(args.transforms);
+			if (name.length === 0) throw new Error("name cannot be empty");
+			this.state.chains.set(name, {
+				name,
+				transforms,
+				description,
+				createdAt: Date.now()
+			});
+			return toTextResponse({
+				name,
+				transforms,
+				created: true
+			});
+		} catch (error) {
+			return fail("ast_transform_chain", error);
+		}
+	}
+	async handleAstTransformApply(args) {
+		try {
+			const chainName = typeof args.chainName === "string" ? args.chainName.trim() : "";
+			const inlineCode = typeof args.code === "string" ? args.code : "";
+			const scriptId = typeof args.scriptId === "string" ? args.scriptId.trim() : "";
+			const sourceCode = inlineCode.length > 0 ? inlineCode : scriptId.length > 0 ? await resolveScriptSource(this.state.collector, scriptId) : "";
+			if (sourceCode.length === 0) throw new Error("Either code or scriptId must be provided");
+			const result = applyTransforms(sourceCode, resolveTransformsForApply(this.state.chains, chainName, args.transforms));
+			return toTextResponse({
+				transformed: result.transformed,
+				stats: {
+					originalSize: sourceCode.length,
+					transformedSize: result.transformed.length,
+					transformsApplied: result.appliedTransforms
+				}
+			});
+		} catch (error) {
+			return fail("ast_transform_apply", error);
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/transform/handlers/crypto-handlers.ts
+var CryptoHandlers = class {
+	state;
+	constructor(state) {
+		this.state = state;
+	}
+	async runCryptoHarnessProxy(code, functionName, testInputs) {
+		return runCryptoHarness(this.state.cryptoHarnessPool, code, functionName, testInputs);
+	}
+	async handleCryptoExtractStandalone(args) {
+		try {
+			const targetFunction = requireString(args.targetFunction, "targetFunction").trim();
+			const includePolyfills = parseBoolean(args.includePolyfills, true);
+			const extracted = await evaluateWithTimeout(await this.state.collector.getActivePage(), (target, keywords) => {
+				const lowerKeywords = (Array.isArray(keywords) ? keywords : []).map((item) => String(item).toLowerCase());
+				const globalObj = window;
+				const scoreFunction = (path, source) => {
+					const text = (path + "\n" + source).toLowerCase();
+					let score = 0;
+					for (const keyword of lowerKeywords) if (text.includes(keyword)) score += 1;
+					return score;
+				};
+				const candidates = [];
+				const pushCandidate = (path, value, boost = 0) => {
+					if (typeof value !== "function") return;
+					const source = Function.prototype.toString.call(value);
+					if (source.includes("[native code]")) return;
+					const score = scoreFunction(path, source) + boost;
+					if (score <= 0 && boost <= 0) return;
+					candidates.push({
+						path,
+						source,
+						score
+					});
+				};
+				if (target.length > 0) pushCandidate(target, (() => {
+					const parts = (target.startsWith("window.") ? target.slice(7) : target).split(".").filter(Boolean);
+					let cursor = window;
+					for (const part of parts) {
+						if (cursor === null || cursor === void 0 || typeof cursor !== "object" && typeof cursor !== "function") return;
+						const carrier = cursor;
+						if (!(part in carrier)) return void 0;
+						cursor = carrier[part];
+					}
+					return cursor;
+				})(), 100);
+				const globalKeys = Object.getOwnPropertyNames(globalObj).slice(0, 800);
+				for (const key of globalKeys) {
+					const topValue = globalObj[key];
+					pushCandidate("window." + key, topValue);
+					if (topValue && typeof topValue === "object") {
+						const nestedObj = topValue;
+						const nestedKeys = Object.keys(nestedObj).slice(0, 40);
+						for (const nestedKey of nestedKeys) pushCandidate("window." + key + "." + nestedKey, nestedObj[nestedKey]);
+					}
+				}
+				candidates.sort((a, b) => b.score - a.score);
+				const selected = candidates[0];
+				if (!selected) return {
+					targetPath: null,
+					targetSource: "",
+					candidates: [],
+					dependencies: [],
+					dependencySnippets: []
+				};
+				const identifierRegex = /\b[A-Za-z_$][A-Za-z0-9_$]{1,}\b/g;
+				const reserved = new Set([
+					"function",
+					"return",
+					"const",
+					"let",
+					"var",
+					"if",
+					"else",
+					"for",
+					"while",
+					"switch",
+					"case",
+					"break",
+					"continue",
+					"new",
+					"this",
+					"window",
+					"globalThis",
+					"Math",
+					"JSON",
+					"Date",
+					"Array",
+					"Object",
+					"String",
+					"Number",
+					"Boolean",
+					"Promise",
+					"RegExp",
+					"Error",
+					"null",
+					"undefined",
+					"true",
+					"false",
+					"async",
+					"await"
+				]);
+				const dependencyNames = Array.from(new Set((selected.source.match(identifierRegex) ?? []).filter((name) => !reserved.has(name)))).slice(0, 30);
+				const dependencySnippets = [];
+				for (const depName of dependencyNames) {
+					if (!(depName in globalObj)) continue;
+					const depValue = globalObj[depName];
+					if (typeof depValue === "function") {
+						const depSource = Function.prototype.toString.call(depValue);
+						if (!depSource.includes("[native code]") && depSource.length < 5e4) dependencySnippets.push("const " + depName + " = " + depSource + ";");
+						continue;
+					}
+					if (depValue === null || typeof depValue === "string" || typeof depValue === "number" || typeof depValue === "boolean") {
+						dependencySnippets.push("const " + depName + " = " + JSON.stringify(depValue) + ";");
+						continue;
+					}
+					if (typeof depValue === "object") try {
+						const serialized = JSON.stringify(depValue);
+						if (serialized && serialized.length < 4e3) dependencySnippets.push("const " + depName + " = " + serialized + ";");
+					} catch {}
+				}
+				return {
+					targetPath: selected.path,
+					targetSource: selected.source,
+					candidates: candidates.slice(0, 20),
+					dependencies: dependencyNames,
+					dependencySnippets
+				};
+			}, targetFunction, CRYPTO_KEYWORDS);
+			if (!extracted || extracted.targetSource.trim().length === 0) throw new Error("No crypto/signature-like function found on current page");
+			const functionName = resolveFunctionName(targetFunction, extracted.targetPath ?? "", extracted.targetSource);
+			const dependencySnippets = extracted.dependencySnippets.filter((snippet) => !snippet.startsWith(`const ${functionName} = `));
+			const dependencies = extracted.dependencies.filter((name) => name !== functionName);
+			const sections = [`'use strict';`];
+			if (includePolyfills) sections.push(buildCryptoPolyfills());
+			if (dependencySnippets.length > 0) sections.push(dependencySnippets.join("\n"));
+			sections.push(`const ${functionName} = ${extracted.targetSource.trim()};`);
+			sections.push(`if (typeof globalThis !== 'undefined') { globalThis.${functionName} = ${functionName}; }`);
+			const extractedCode = sections.filter((part) => part.trim().length > 0).join("\n\n");
+			return toTextResponse({
+				extractedCode,
+				dependencies,
+				size: extractedCode.length
+			});
+		} catch (error) {
+			return fail("crypto_extract_standalone", error);
+		}
+	}
+	async handleCryptoTestHarness(args) {
+		try {
+			const code = requireString(args.code, "code");
+			const functionName = requireString(args.functionName, "functionName");
+			const testInputs = parseTestInputs(args.testInputs);
+			await ensureCryptoPoolWarmed(this.state.cryptoHarnessPool);
+			try {
+				const harness = await runCryptoHarness(this.state.cryptoHarnessPool, code, functionName, testInputs);
+				return toTextResponse({
+					results: harness.results.map((row) => ({
+						input: row.input,
+						output: row.output,
+						duration: row.duration,
+						...row.error ? { error: row.error } : {}
+					})),
+					allPassed: harness.allPassed
+				});
+			} finally {
+				this.state.cryptoHarnessPool.drainIdle?.();
+			}
+		} catch (error) {
+			return fail("crypto_test_harness", error);
+		}
+	}
+	async handleCryptoCompare(args) {
+		try {
+			const code1 = requireString(args.code1, "code1");
+			const code2 = requireString(args.code2, "code2");
+			const functionName = requireString(args.functionName, "functionName");
+			const testInputs = parseTestInputs(args.testInputs);
+			await ensureCryptoPoolWarmed(this.state.cryptoHarnessPool);
+			try {
+				const [run1, run2] = await Promise.all([runCryptoHarness(this.state.cryptoHarnessPool, code1, functionName, testInputs), runCryptoHarness(this.state.cryptoHarnessPool, code2, functionName, testInputs)]);
+				const rows = testInputs.map((input, index) => {
+					const left = run1.results[index] ?? {
+						input,
+						output: "",
+						duration: 0,
+						error: "missing result from implementation #1"
+					};
+					const right = run2.results[index] ?? {
+						input,
+						output: "",
+						duration: 0,
+						error: "missing result from implementation #2"
+					};
+					const sameOutput = left.output === right.output;
+					const noError = !left.error && !right.error;
+					return {
+						input,
+						output1: left.output,
+						output2: right.output,
+						duration1: left.duration,
+						duration2: right.duration,
+						match: sameOutput && noError,
+						...left.error ? { error1: left.error } : {},
+						...right.error ? { error2: right.error } : {}
+					};
+				});
+				const matches = rows.filter((row) => row.match).length;
+				return toTextResponse({
+					matches,
+					mismatches: rows.length - matches,
+					results: rows
+				});
+			} finally {
+				this.state.cryptoHarnessPool.drainIdle?.();
+			}
+		} catch (error) {
+			return fail("crypto_compare", error);
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/transform/handlers.impl.core.ts
+var TransformToolHandlers = class {
+	collector;
+	state;
+	ast;
+	crypto;
+	constructor(collector) {
+		this.collector = collector;
+		this.state = createTransformSharedState(collector);
+		this.ast = new AstHandlers(this.state);
+		this.crypto = new CryptoHandlers(this.state);
+	}
+	async close() {
+		await this.state.cryptoHarnessPool.close();
+	}
+	get chains() {
+		return this.state.chains;
+	}
+	get cryptoHarnessPool() {
+		return this.state.cryptoHarnessPool;
+	}
+	async runCryptoHarness(code, functionName, testInputs) {
+		return this.crypto.runCryptoHarnessProxy(code, functionName, testInputs);
+	}
+	handleAstTransformPreview = (args) => this.ast.handleAstTransformPreview(args);
+	handleAstTransformChain = (args) => this.ast.handleAstTransformChain(args);
+	handleAstTransformApply = (args) => this.ast.handleAstTransformApply(args);
+	handleCryptoExtractStandalone = (args) => this.crypto.handleCryptoExtractStandalone(args);
+	handleCryptoTestHarness = (args) => this.crypto.handleCryptoTestHarness(args);
+	handleCryptoCompare = (args) => this.crypto.handleCryptoCompare(args);
+};
+//#endregion
+export { TransformToolHandlers };