@jshookmcp/jshook 0.3.0 → 0.3.2

package/dist/wasm-BYx5UOeG.mjs

@@ -1,1044 +0,0 @@
-import { Cr as WASM_BITWISE_OPS_THRESHOLD, Dr as WASM_VM_DISPATCH_MIN_LOOPS, Er as WASM_TOOL_TIMEOUT_MS, Tr as WASM_OPTIMIZE_TIMEOUT_MS, wr as WASM_DEAD_CODE_MIN_MATCHES } from "./constants-CDZLOoVv.mjs";
-import { o as ExternalToolRunner } from "./modules-tZozf0LQ.mjs";
-import { i as resolveArtifactPath } from "./artifacts-DkfosXH3.mjs";
-import { a as argString, o as argStringArray, r as argNumber, s as argStringRequired, t as argBool } from "./parse-args-B4cY5Vx5.mjs";
-import { n as capabilityReport } from "./capabilities-CcHlvWgK.mjs";
-import { t as ToolRegistry } from "./ToolRegistry-B9krbTtI.mjs";
-import { t as R } from "./ResponseBuilder-CJXWmWNw.mjs";
-import "./definitions-BEoYofW5.mjs";
-import { tmpdir } from "node:os";
-import { createHash } from "node:crypto";
-import { join, normalize, resolve, sep } from "node:path";
-import { mkdir, stat, writeFile } from "node:fs/promises";
-//#region src/server/domains/wasm/handlers/shared.ts
-/**
-* Shared types and state for WASM sub-handlers.
-*/
-const isRecord = (value) => typeof value === "object" && value !== null;
-const hasErrorResult = (value) => isRecord(value) && typeof value.error === "string";
-function validateOutputPath(outputPath) {
-	const safe = resolve(outputPath);
-	const cwd = normalize(process.cwd());
-	const tmp = normalize(tmpdir());
-	if (!safe.startsWith(`${cwd}${sep}`) && !safe.startsWith(`${tmp}${sep}`)) throw new Error("Path traversal blocked: outputPath must be under project root or temp directory");
-	return safe;
-}
-//#endregion
-//#region src/server/domains/wasm/handlers/external-base.ts
-var ExternalToolHandlersBase = class {
-	constructor(state) {
-		this.state = state;
-	}
-	ok(payload) {
-		return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				success: true,
-				...payload
-			}, null, 2)
-		}] };
-	}
-	fail(error, exitCode) {
-		return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				success: false,
-				error,
-				...exitCode === void 0 ? {} : { exitCode }
-			}, null, 2)
-		}] };
-	}
-	async writeTextArtifact(options) {
-		const { outputPath, artifact, content, pathMode = "display" } = options;
-		if (outputPath) {
-			const safePath = validateOutputPath(outputPath);
-			await writeFile(safePath, content, "utf-8");
-			return safePath;
-		}
-		const { absolutePath, displayPath } = await resolveArtifactPath(artifact);
-		await writeFile(absolutePath, content, "utf-8");
-		return pathMode === "absolute" ? absolutePath : displayPath;
-	}
-	async resolveArtifactOutputPath(options) {
-		const { outputPath, artifact, pathMode = "absolute" } = options;
-		if (outputPath) return validateOutputPath(outputPath);
-		const { absolutePath, displayPath } = await resolveArtifactPath(artifact);
-		return pathMode === "display" ? displayPath : absolutePath;
-	}
-	preview(text, maxLines) {
-		const lines = text.split("\n");
-		return lines.slice(0, maxLines).join("\n") + (lines.length > maxLines ? "\n... (truncated)" : "");
-	}
-	async tryStatSize(path) {
-		try {
-			return (await stat(path)).size;
-		} catch {
-			return 0;
-		}
-	}
-};
-//#endregion
-//#region src/server/domains/wasm/handlers/external-analysis-handlers.ts
-function isExplicitLocalFilePath(input) {
-	return /^[a-z]:[\\/]/i.test(input) || /^\\\\[^\\]+\\[^\\]+/i.test(input) || /^file:\/\//i.test(input) || /^\/(?:Users|home|tmp|var|etc|opt|usr|srv|mnt|media|private|root|run|dev|proc|sys|Library|Volumes)(?:\/|$)/.test(input);
-}
-var ExternalAnalysisHandlers = class extends ExternalToolHandlersBase {
-	async handleWasmDetectObfuscation(args) {
-		const inputPath = argStringRequired(args, "inputPath");
-		const verbose = argBool(args, "verbose", false);
-		const disasmResult = await this.state.runner.run({
-			tool: "wabt.wasm2wat",
-			args: [inputPath],
-			timeoutMs: WASM_TOOL_TIMEOUT_MS
-		});
-		if (!disasmResult.ok) return this.fail(`Failed to disassemble: ${disasmResult.stderr}`);
-		const wat = disasmResult.stdout;
-		const detections = [];
-		const brTableCount = (wat.match(/br_table/g) || []).length;
-		if (brTableCount > 5) detections.push({
-			type: "control-flow-flattening",
-			confidence: Math.min(brTableCount / 20, .95),
-			description: `${brTableCount} br_table dispatches detected — likely flattened control flow`
-		});
-		const xorChainCount = (wat.match(/i32\.xor/g) || []).length;
-		const rotCount = (wat.match(/i32\.rotl|i32\.rotr/g) || []).length;
-		const shiftCount = (wat.match(/i32\.shl|i32\.shr_[su]/g) || []).length;
-		if (xorChainCount + rotCount + shiftCount > WASM_BITWISE_OPS_THRESHOLD) detections.push({
-			type: "constant-encoding",
-			confidence: Math.min((xorChainCount + rotCount + shiftCount) / 50, .9),
-			description: `High density of bitwise ops (${xorChainCount} xor, ${shiftCount} shift, ${rotCount} rotate) — constant decoding`
-		});
-		const deadCodeMatches = wat.match(/br\s+(?:\$\d+|\d+)\s*\n\s*(?!end\b|\))\S.*$/gm) || [];
-		if (deadCodeMatches.length > WASM_DEAD_CODE_MIN_MATCHES) detections.push({
-			type: "dead-code-injection",
-			confidence: Math.min(deadCodeMatches.length / 30, .85),
-			description: `${deadCodeMatches.length} code blocks after unconditional branches`
-		});
-		const hasLoop = /\(loop/.test(wat);
-		const hasBrTable = /br_table/.test(wat);
-		const hasLocalGet = /local\.get\s+\d+/.test(wat);
-		if (hasLoop && hasBrTable && hasLocalGet) {
-			const loopCount = (wat.match(/\(loop/g) || []).length;
-			if (loopCount > WASM_VM_DISPATCH_MIN_LOOPS) detections.push({
-				type: "vm-dispatch",
-				confidence: .75,
-				description: `Loop + br_table + local.get pattern (${loopCount} loops) — possible WASM VM interpreter`
-			});
-		}
-		const funcCount = (wat.match(/\(func\s/g) || []).length;
-		const totalSize = wat.length;
-		if (funcCount > 0 && totalSize / funcCount > 5e3) detections.push({
-			type: "code-bloat",
-			confidence: .5,
-			description: `Average ${(totalSize / funcCount).toFixed(0)} chars/function across ${funcCount} functions — unusually large`
-		});
-		const hasObfuscation = detections.length > 0;
-		const maxConfidence = detections.reduce((max, detection) => Math.max(max, detection.confidence), 0);
-		return this.ok({
-			inputPath,
-			hasObfuscation,
-			overallConfidence: hasObfuscation ? maxConfidence : 0,
-			detectionCount: detections.length,
-			detections,
-			summary: hasObfuscation ? `Detected ${detections.length} obfuscation pattern(s). Highest confidence: ${(maxConfidence * 100).toFixed(0)}%` : "No obfuscation patterns detected.",
-			...verbose ? { watPreview: this.preview(wat, 200) } : {}
-		});
-	}
-	async handleWasmInstrumentTrace(args) {
-		const inputPath = argStringRequired(args, "inputPath");
-		const allHooks = argBool(args, "allHooks", true);
-		const hookTypes = argStringArray(args, "hooks");
-		const outputPath = argString(args, "outputPath");
-		const disasmResult = await this.state.runner.run({
-			tool: "wabt.wasm2wat",
-			args: [inputPath],
-			timeoutMs: WASM_TOOL_TIMEOUT_MS
-		});
-		if (!disasmResult.ok) return this.fail(disasmResult.stderr);
-		const wat = disasmResult.stdout;
-		const hooks = allHooks ? [
-			"call",
-			"memory",
-			"branch",
-			"loop",
-			"local"
-		] : hookTypes.length > 0 ? hookTypes : ["call"];
-		const funcMatches = wat.match(/\(func\s/g) || [];
-		const exportMatches = wat.match(/\(export/g) || [];
-		const importMatches = wat.match(/\(import/g) || [];
-		const tableMatches = wat.match(/\(table\b/g) || [];
-		const callIndirectMatches = wat.match(/\bcall_indirect\b/g) || [];
-		const exportNames = [];
-		const importEntries = [];
-		const exportRe = /\(export\s+"([^"]+)"\s+\((\w+)\s+(\$?[\w.]+)\)\)/g;
-		const importRe = /\(import\s+"([^"]+)"\s+"([^"]+)"/g;
-		let match;
-		while ((match = exportRe.exec(wat)) !== null) if (match[1]) exportNames.push(match[1]);
-		while ((match = importRe.exec(wat)) !== null) if (match[1] && match[2]) importEntries.push({
-			module: match[1],
-			name: match[2]
-		});
-		const hookPreamble = `
-  const hookedExports = {};
-  for (const [k, v] of Object.entries(instance.exports)) { hookedExports[k] = v; }`;
-		const hookInitCode = {
-			call: `
-  const callLog = [];
-  for (const [name, value] of Object.entries(instance.exports)) {
-    if (typeof value === 'function') {
-      hookedExports[name] = new Proxy(value, {
-        apply(target, thisArg, argumentsList) {
-          const entry = { type: 'call', name, args: argumentsList.map(String), timestamp: Date.now() };
-          callLog.push(entry);
-          try {
-            const result = Reflect.apply(target, thisArg, argumentsList);
-            callLog.push({ type: 'return', name, result: String(result), timestamp: Date.now() });
-            return result;
-          } catch (err) {
-            callLog.push({ type: 'throw', name, error: String(err), timestamp: Date.now() });
-            throw err;
-          }
-        }
-      });
-    }
-  }`,
-			memory: `
-  const memoryLog = [];
-  const originalMemory = instance.exports.memory || Object.values(instance.exports).find(e => e instanceof WebAssembly.Memory);
-  const memTracker = { reads: 0, writes: 0, growEvents: [] };
-  if (originalMemory) {
-    const memSnapshot = () => {
-      const view = new DataView(originalMemory.buffer);
-      return { byteLength: view.byteLength, pages: view.byteLength / 65536 };
-    };
-    memTracker.snapshot = memSnapshot;
-    const origGrow = originalMemory.grow?.bind(originalMemory);
-    if (origGrow) {
-      originalMemory.grow = function(delta) {
-        const beforePages = originalMemory.buffer.byteLength / 65536;
-        memoryLog.push({ op: 'grow', delta, beforePages, timestamp: Date.now() });
-        memTracker.growEvents.push({ delta, beforePages });
-        return origGrow(delta);
-      };
-    }
-    const memProxy = new Proxy(originalMemory, {
-      get(target, prop) {
-        if (prop === 'buffer') {
-          memTracker.reads++;
-        }
-        const val = Reflect.get(target, prop, target);
-        return typeof val === 'function' ? val.bind(target) : val;
-      }
-    });
-    const memExportName = Object.entries(instance.exports).find(([, v]) => v === originalMemory)?.[0] || 'memory';
-    hookedExports[memExportName] = memProxy;
-    memTracker.buffer = originalMemory.buffer;
-  }`,
-			branch: `
-  // === Branch Hook: Tracks JS-visible WebAssembly.Table access only ===
-  // Internal call_indirect dispatch stays inside the Wasm engine and is not observable from JS.
-  const branchLog = [];
-  for (const [tableName, table] of Object.entries(instance.exports)) {
-    if (!(table instanceof WebAssembly.Table)) continue;
-    const origGet = table.get.bind(table);
-    const origGrow = table.grow?.bind(table);
-    hookedExports[tableName] = new Proxy(table, {
-        get(t, prop) {
-          if (prop === 'get') {
-            return (idx) => {
-              branchLog.push({ type: 'table_get', table: tableName, index: idx, timestamp: Date.now() });
-              return origGet(idx);
-            };
-          }
-          if (prop === 'grow' && origGrow) {
-            return (delta) => {
-              branchLog.push({ type: 'table_grow', table: tableName, delta, timestamp: Date.now() });
-              return origGrow(delta);
-            };
-          }
-          const val = t[prop];
-          return typeof val === 'function' ? val.bind(t) : val;
-        }
-      });
-  }`,
-			loop: `
-  const loopLog = [];
-  const loopCallCounts = {};
-  const loopSource = hookedExports;
-  for (const [name, value] of Object.entries(loopSource)) {
-    if (typeof value === 'function') {
-      hookedExports[name] = new Proxy(value, {
-        apply(target, thisArg, args) {
-          loopCallCounts[name] = (loopCallCounts[name] || 0) + 1;
-          if (loopCallCounts[name] > 1) {
-            loopLog.push({ type: 'loop-iteration', func: name, count: loopCallCounts[name], timestamp: Date.now() });
-          }
-          return Reflect.apply(target, thisArg, args);
-        }
-      });
-    }
-  }`,
-			local: `
-  const localLog = [];
-  for (const [globalName, global] of Object.entries(instance.exports)) {
-    if (!(global instanceof WebAssembly.Global)) continue;
-    hookedExports[globalName] = new Proxy(global, {
-      get(target, prop) {
-        if (prop === 'valueOf' || prop === Symbol.toPrimitive) {
-          return (...args) => Reflect.apply(target.valueOf, target, args);
-        }
-        const val = Reflect.get(target, prop, target);
-        if (prop === 'value' && typeof val === 'function') {
-          return target.valueOf();
-        }
-        return typeof val === 'function' ? val.bind(target) : val;
-      },
-      set(target, prop, newValue) {
-        if (prop === 'value') {
-          const oldValue = target.valueOf();
-          localLog.push({ type: 'global-set', name: globalName, oldValue, newValue, timestamp: Date.now() });
-          target.value = newValue;
-          return true;
-        }
-        return Reflect.set(target, prop, newValue, target);
-      }
-    });
-  }`
-		};
-		const activeHooks = hooks.filter((hook) => hook in hookInitCode);
-		const activeHookCode = hookPreamble + "\n" + activeHooks.map((hook) => hookInitCode[hook]).join("\n");
-		const inputPathLiteral = JSON.stringify(inputPath);
-		const importNamespaceCode = [...new Set(importEntries.map(({ module }) => module))].filter((moduleName) => moduleName !== "env").map((moduleName) => `    ${JSON.stringify(moduleName)}: {},`).join("\n");
-		const importStubCode = importEntries.map(({ module, name }) => {
-			const safeModule = JSON.stringify(module);
-			const safeName = JSON.stringify(name);
-			return `if (!imports[${safeModule}]) imports[${safeModule}] = {};\n  if (!imports[${safeModule}][${safeName}]) imports[${safeModule}][${safeName}] = () => {};`;
-		}).join("\n  ");
-		const wrapper = `// WASM Instrumentation Wrapper (Wasabi-style)
-// Generated by jshookmcp wasm_instrument_trace
-// Hooks: ${activeHooks.join(", ")}
-// Functions: ${funcMatches.length} | Exports: ${exportNames.join(", ") || "none"} | Imports: ${importEntries.length}
-
-(async function() {
-  const wasmBytes = await fetch(${inputPathLiteral}).then(r => r.arrayBuffer());
-  const module = await WebAssembly.compile(wasmBytes);
-
-  const imports = {
-    env: {
-      abort: () => console.warn('[wasabi] abort called'),
-      memory: new WebAssembly.Memory({ initial: 256, maximum: 1024 }),
-      seed: () => Math.random(),
-      'Math.log': Math.log,
-      'Math.random': Math.random,
-      console: { log: (...a) => console.log('[wasabi]', ...a) },
-    },
-${importNamespaceCode ? `${importNamespaceCode}\n` : ""}  };
-
-  ${importStubCode}
-
-  const instance = await WebAssembly.instantiate(module, imports);
-
-${activeHookCode}
-
-  const tracedExports = hookedExports;
-
-  return {
-    instance,
-    exports: tracedExports,
-    hooks: {
-${activeHooks.map((hook) => {
-			return `      ${hook}: ${hook === "call" ? "callLog" : hook === "memory" ? "memoryLog" : hook === "branch" ? "branchLog" : hook === "loop" ? "loopLog" : "localLog"}`;
-		}).join(",\n")}
-    },
-    stats: {
-      functions: ${funcMatches.length},
-      exports: ${exportMatches.length},
-      imports: ${importMatches.length},
-      exportNames: ${JSON.stringify(exportNames)},
-      hookTypes: ${JSON.stringify(activeHooks)}
-    }
-  };
-})();
-`;
-		let savedPath;
-		if (outputPath) {
-			const safePath = validateOutputPath(outputPath);
-			await writeFile(safePath, wrapper, "utf-8");
-			savedPath = safePath;
-		} else savedPath = await this.writeTextArtifact({
-			artifact: {
-				category: "wasm",
-				toolName: "wasm-instrument",
-				ext: "js"
-			},
-			content: wrapper
-		});
-		const inputPathLooksLocal = isExplicitLocalFilePath(inputPath);
-		const warnings = [inputPathLooksLocal ? "Wrapper embeds the provided inputPath into browser-side fetch(). Local filesystem paths are not browser-accessible; provide an http(s) URL instead, or upload the module with wasm_dump and use the resulting URL." : void 0, activeHooks.includes("branch") && callIndirectMatches.length > 0 ? `Branch hook only observes JS-visible WebAssembly.Table access. This module contains ${callIndirectMatches.length} call_indirect site(s), which are dispatched inside the Wasm engine and will not appear in branch logs.` : void 0].filter((warning) => typeof warning === "string" && warning.length > 0);
-		const warning = warnings.length > 0 ? warnings.join(" ") : void 0;
-		return this.ok({
-			artifactPath: savedPath,
-			hookTypes: activeHooks,
-			functionCount: funcMatches.length,
-			exportCount: exportMatches.length,
-			importCount: importMatches.length,
-			wrapperSizeBytes: wrapper.length,
-			note: "Wasabi-style instrumentation wrapper generated. Load in browser with WASM module to trace execution.",
-			metadata: {
-				inputPathKind: inputPathLooksLocal ? "local-path" : "url",
-				wrapperFetchesBrowserUrl: true,
-				...activeHooks.includes("branch") ? {
-					branchHookMode: "js-table-access-only",
-					callIndirectSites: callIndirectMatches.length,
-					tableCount: tableMatches.length
-				} : {}
-			},
-			...warning ? { warning } : {}
-		});
-	}
-};
-//#endregion
-//#region src/server/domains/wasm/handlers/external-conversion-handlers.ts
-var ExternalConversionHandlers = class extends ExternalToolHandlersBase {
-	async handleWasmDisassemble(args) {
-		const inputPath = argStringRequired(args, "inputPath");
-		const outputPath = argString(args, "outputPath");
-		const foldExprs = argBool(args, "foldExprs", true);
-		const toolArgs = [
-			inputPath,
-			"-o",
-			"/dev/stdout"
-		];
-		if (foldExprs) toolArgs.push("--fold-exprs");
-		const result = await this.state.runner.run({
-			tool: "wabt.wasm2wat",
-			args: toolArgs,
-			timeoutMs: WASM_TOOL_TIMEOUT_MS
-		});
-		if (!result.ok) return this.fail(result.stderr, result.exitCode ?? void 0);
-		const savedPath = await this.writeTextArtifact({
-			outputPath,
-			artifact: {
-				category: "wasm",
-				toolName: "wasm-disassemble",
-				ext: "wat"
-			},
-			content: result.stdout
-		});
-		return this.ok({
-			artifactPath: savedPath,
-			totalLines: result.stdout.split("\n").length,
-			sizeBytes: result.stdout.length,
-			preview: this.preview(result.stdout, 50),
-			durationMs: result.durationMs
-		});
-	}
-	async handleWasmDecompile(args) {
-		const inputPath = argStringRequired(args, "inputPath");
-		const outputPath = argString(args, "outputPath");
-		const result = await this.state.runner.run({
-			tool: "wabt.wasm-decompile",
-			args: [
-				inputPath,
-				"-o",
-				"/dev/stdout"
-			],
-			timeoutMs: WASM_TOOL_TIMEOUT_MS
-		});
-		if (!result.ok) return this.fail(result.stderr, result.exitCode ?? void 0);
-		const savedPath = await this.writeTextArtifact({
-			outputPath,
-			artifact: {
-				category: "wasm",
-				toolName: "wasm-decompile",
-				ext: "dcmp"
-			},
-			content: result.stdout
-		});
-		return this.ok({
-			artifactPath: savedPath,
-			totalLines: result.stdout.split("\n").length,
-			preview: this.preview(result.stdout, 60),
-			durationMs: result.durationMs
-		});
-	}
-	async handleWasmInspectSections(args) {
-		const inputPath = argStringRequired(args, "inputPath");
-		const flags = ({
-			headers: "-h",
-			details: "-x",
-			disassemble: "-d",
-			all: "-h -x -d"
-		}[argString(args, "sections", "details")] || "-x").split(" ");
-		const result = await this.state.runner.run({
-			tool: "wabt.wasm-objdump",
-			args: [...flags, inputPath],
-			timeoutMs: WASM_TOOL_TIMEOUT_MS
-		});
-		if (!result.ok) return this.fail(result.stderr, result.exitCode ?? void 0);
-		return this.ok({
-			totalLines: result.stdout.split("\n").length,
-			preview: this.preview(result.stdout, 100),
-			durationMs: result.durationMs
-		});
-	}
-	async handleWasmToC(args) {
-		const inputPath = argStringRequired(args, "inputPath");
-		const outputDir = argString(args, "outputDir");
-		const destDir = await this.resolveArtifactOutputPath({
-			outputPath: outputDir,
-			artifact: {
-				category: "wasm",
-				toolName: "wasm2c",
-				ext: "dir"
-			},
-			pathMode: "absolute"
-		});
-		await mkdir(destDir, { recursive: true });
-		const nameOnly = resolve(inputPath).replace(/\.wasm$/i, "").split(/[/\\]/).pop() || "output";
-		const cFile = join(destDir, `${nameOnly}.c`);
-		const hFile = join(destDir, `${nameOnly}.h`);
-		const result = await this.state.runner.run({
-			tool: "wabt.wasm2c",
-			args: [
-				inputPath,
-				"-o",
-				cFile
-			],
-			timeoutMs: WASM_TOOL_TIMEOUT_MS
-		});
-		if (!result.ok) return this.fail(result.stderr, result.exitCode ?? void 0);
-		return this.ok({
-			outputDir: destDir,
-			cFile,
-			hFile,
-			cSizeBytes: await this.tryStatSize(cFile),
-			hSizeBytes: await this.tryStatSize(hFile),
-			durationMs: result.durationMs
-		});
-	}
-};
-//#endregion
-//#region src/server/domains/wasm/handlers/external-runtime-handlers.ts
-var ExternalRuntimeHandlers = class extends ExternalToolHandlersBase {
-	async handleWasmOfflineRun(args) {
-		const inputPath = argStringRequired(args, "inputPath");
-		const functionName = argStringRequired(args, "functionName");
-		const fnArgs = argStringArray(args, "args");
-		const runtime = argString(args, "runtime", "auto");
-		const timeoutMs = argNumber(args, "timeoutMs", 1e4);
-		let toolName;
-		if (runtime === "auto") {
-			const probes = await this.state.runner.probeAll();
-			if (probes["runtime.wasmtime"]?.available) toolName = "runtime.wasmtime";
-			else if (probes["runtime.wasmer"]?.available) toolName = "runtime.wasmer";
-			else return this.fail("No WASM runtime found. Install wasmtime or wasmer.");
-		} else toolName = runtime === "wasmer" ? "runtime.wasmer" : "runtime.wasmtime";
-		const runArgs = toolName === "runtime.wasmtime" ? [
-			"run",
-			"--invoke",
-			functionName,
-			inputPath,
-			...fnArgs
-		] : [
-			"run",
-			inputPath,
-			"--invoke",
-			functionName,
-			"--",
-			...fnArgs
-		];
-		const result = await this.state.runner.run({
-			tool: toolName,
-			args: runArgs,
-			timeoutMs
-		});
-		return this.ok({
-			runtime: toolName,
-			functionName,
-			args: fnArgs,
-			output: result.stdout.trim(),
-			stderr: result.stderr.trim() || void 0,
-			exitCode: result.exitCode,
-			durationMs: result.durationMs,
-			success: result.ok
-		});
-	}
-	async handleWasmOptimize(args) {
-		const inputPath = argStringRequired(args, "inputPath");
-		const outputPath = argString(args, "outputPath");
-		const level = argString(args, "level", "O2");
-		const destPath = await this.resolveArtifactOutputPath({
-			outputPath,
-			artifact: {
-				category: "wasm",
-				toolName: "wasm-opt",
-				ext: "wasm"
-			},
-			pathMode: "absolute"
-		});
-		const result = await this.state.runner.run({
-			tool: "binaryen.wasm-opt",
-			args: [
-				`-${level}`,
-				inputPath,
-				"-o",
-				destPath
-			],
-			timeoutMs: WASM_OPTIMIZE_TIMEOUT_MS
-		});
-		if (!result.ok) return this.fail(result.stderr, result.exitCode ?? void 0);
-		const inputSize = await this.tryStatSize(inputPath);
-		const outputSize = await this.tryStatSize(destPath);
-		return this.ok({
-			artifactPath: destPath,
-			optimizationLevel: level,
-			inputSizeBytes: inputSize,
-			outputSizeBytes: outputSize,
-			reductionPercent: inputSize > 0 ? ((1 - outputSize / inputSize) * 100).toFixed(1) : "0",
-			durationMs: result.durationMs
-		});
-	}
-};
-//#endregion
-//#region src/server/domains/wasm/handlers/external-tool-handlers.ts
-var ExternalToolHandlers = class {
-	conversion;
-	runtime;
-	analysis;
-	constructor(state) {
-		this.conversion = new ExternalConversionHandlers(state);
-		this.runtime = new ExternalRuntimeHandlers(state);
-		this.analysis = new ExternalAnalysisHandlers(state);
-	}
-	handleWasmDisassemble(args) {
-		return this.conversion.handleWasmDisassemble(args);
-	}
-	handleWasmDecompile(args) {
-		return this.conversion.handleWasmDecompile(args);
-	}
-	handleWasmInspectSections(args) {
-		return this.conversion.handleWasmInspectSections(args);
-	}
-	handleWasmOfflineRun(args) {
-		return this.runtime.handleWasmOfflineRun(args);
-	}
-	handleWasmOptimize(args) {
-		return this.runtime.handleWasmOptimize(args);
-	}
-	handleWasmToC(args) {
-		return this.conversion.handleWasmToC(args);
-	}
-	handleWasmDetectObfuscation(args) {
-		return this.analysis.handleWasmDetectObfuscation(args);
-	}
-	handleWasmInstrumentTrace(args) {
-		return this.analysis.handleWasmInstrumentTrace(args);
-	}
-};
-//#endregion
-//#region src/server/domains/wasm/handlers/browser-handlers.ts
-/**
-* Browser sub-handler — dump, vmpTrace, memoryInspect.
-*/
-var BrowserHandlers = class {
-	state;
-	constructor(state) {
-		this.state = state;
-	}
-	async handleWasmDump(args) {
-		const moduleIndex = argNumber(args, "moduleIndex", 0);
-		const outputPath = argString(args, "outputPath");
-		const page = await this.state.collector.getActivePage();
-		const result = await page.evaluate((idx) => {
-			const hooksRaw = window.__aiHooks?.["preset-webassembly-full"];
-			if (!Array.isArray(hooksRaw) || hooksRaw.length === 0) return { error: "No WASM modules captured. Ensure the webassembly-full hook preset is active and the page has loaded WASM." };
-			const instantiatedEvents = hooksRaw.filter((e) => e.type === "instantiated");
-			if (idx >= instantiatedEvents.length) return { error: `Module index ${idx} out of range. Found ${instantiatedEvents.length} instantiated modules.` };
-			const event = instantiatedEvents[idx];
-			return {
-				exports: event.exports,
-				importMods: event.importMods,
-				size: event.size,
-				moduleCount: instantiatedEvents.length
-			};
-		}, moduleIndex);
-		if (hasErrorResult(result)) return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				success: false,
-				error: result.error
-			})
-		}] };
-		const wasmBytes = await page.evaluate((idx) => {
-			const storage = window.__wasmModuleStorage;
-			if (!storage?.[idx]) return null;
-			const buffer = storage[idx];
-			return Array.from(new Uint8Array(buffer));
-		}, moduleIndex);
-		let savedPath;
-		let hash;
-		if (wasmBytes) {
-			const buffer = Buffer.from(wasmBytes);
-			hash = createHash("sha256").update(buffer).digest("hex").substring(0, 16);
-			if (outputPath) {
-				const safePath = validateOutputPath(outputPath);
-				await writeFile(safePath, buffer);
-				savedPath = safePath;
-			} else {
-				const { absolutePath, displayPath } = await resolveArtifactPath({
-					category: "wasm",
-					toolName: "wasm-dump",
-					target: hash,
-					ext: "wasm"
-				});
-				await writeFile(absolutePath, buffer);
-				savedPath = displayPath;
-			}
-		} else savedPath = "(binary not available — hook did not store raw bytes)";
-		return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				success: true,
-				artifactPath: savedPath,
-				hash,
-				size: result.size,
-				exports: result.exports,
-				importModules: result.importMods,
-				totalModules: result.moduleCount,
-				hint: wasmBytes ? "Use wasm_disassemble or wasm_decompile on the dumped file for further analysis." : "Binary not captured. Inject hook_preset(\"webassembly-full\") BEFORE page navigation, with window.__wasmModuleStorage patching."
-			}, null, 2)
-		}] };
-	}
-	async handleWasmVmpTrace(args) {
-		const maxEvents = argNumber(args, "maxEvents", 5e3);
-		const filterModule = argString(args, "filterModule");
-		const traceData = await (await this.state.collector.getActivePage()).evaluate((opts) => {
-			const hooksRaw = window.__aiHooks?.["preset-webassembly-full"];
-			if (!Array.isArray(hooksRaw) || hooksRaw.length === 0) return { error: "No WASM hook data. Inject hook_preset(\"webassembly-full\") and reload the page." };
-			let importCalls = hooksRaw.filter((e) => e.type === "import_call");
-			if (opts.filterModule) importCalls = importCalls.filter((e) => e.mod === opts.filterModule);
-			const limited = importCalls.slice(0, opts.maxEvents);
-			const fnCounts = {};
-			for (const call of limited) {
-				const key = `${String(call.mod)}.${String(call.fn)}`;
-				fnCounts[key] = (fnCounts[key] || 0) + 1;
-			}
-			const sorted = Object.entries(fnCounts).toSorted((a, b) => b[1] - a[1]).slice(0, 30).map(([name, count]) => ({
-				name,
-				count
-			}));
-			return {
-				totalEvents: importCalls.length,
-				capturedEvents: limited.length,
-				topFunctions: sorted,
-				trace: limited.slice(0, 200).map((e) => ({
-					mod: e.mod,
-					fn: e.fn,
-					args: e.args,
-					ts: e.ts
-				}))
-			};
-		}, {
-			maxEvents,
-			filterModule
-		});
-		if (hasErrorResult(traceData)) return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				success: false,
-				error: traceData.error
-			})
-		}] };
-		return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				success: true,
-				...traceData,
-				hint: "Top functions show VMP handler dispatch patterns. Use wasm_disassemble to analyze their implementation."
-			}, null, 2)
-		}] };
-	}
-	async handleWasmMemoryInspect(args) {
-		const offset = argNumber(args, "offset", 0);
-		const length = Math.min(argNumber(args, "length", 256), 65536);
-		const format = argString(args, "format", "both");
-		const searchPattern = argString(args, "searchPattern");
-		const memData = await (await this.state.collector.getActivePage()).evaluate((opts) => {
-			const win = window;
-			const hooksRaw = win.__aiHooks?.["preset-webassembly-full"];
-			const memoryEvents = (Array.isArray(hooksRaw) ? hooksRaw : []).filter((e) => e.type === "memory_created");
-			const instances = win.__wasmInstances;
-			if (!Array.isArray(instances) || instances.length === 0) return { error: "No WASM memory available. Ensure the webassembly-full hook is active and a WASM module is instantiated." };
-			try {
-				const memory = instances[0].exports?.memory;
-				if (!memory?.buffer) return { error: "WASM module has no exported memory." };
-				const buffer = new Uint8Array(memory.buffer);
-				const slice = Array.from(buffer.slice(opts.offset, opts.offset + opts.length));
-				let searchResults;
-				if (opts.searchPattern) {
-					searchResults = [];
-					const pattern = opts.searchPattern;
-					if (/^[0-9a-fA-F\s]+$/.test(pattern)) {
-						const hexBytes = pattern.replace(/\s/g, "").match(/.{2}/g)?.map((h) => parseInt(h, 16)) || [];
-						for (let i = opts.offset; i <= Math.min(opts.offset + opts.length - hexBytes.length, buffer.length - hexBytes.length); i++) {
-							let match = true;
-							for (let j = 0; j < hexBytes.length; j++) if (buffer[i + j] !== hexBytes[j]) {
-								match = false;
-								break;
-							}
-							if (match) searchResults.push({ offset: i });
-						}
-					} else {
-						const patternBytes = new TextEncoder().encode(pattern);
-						for (let i = opts.offset; i <= Math.min(opts.offset + opts.length - patternBytes.length, buffer.length - patternBytes.length); i++) {
-							let match = true;
-							for (let j = 0; j < patternBytes.length; j++) if (buffer[i + j] !== patternBytes[j]) {
-								match = false;
-								break;
-							}
-							if (match) searchResults.push({ offset: i });
-						}
-					}
-				}
-				return {
-					totalMemoryPages: memory.buffer.byteLength / 65536,
-					totalMemoryBytes: memory.buffer.byteLength,
-					requestedOffset: opts.offset,
-					requestedLength: opts.length,
-					data: slice,
-					searchResults,
-					memoryInfo: memoryEvents[0] || null
-				};
-			} catch (e) {
-				return { error: `Failed to read WASM memory: ${e instanceof Error ? e.message : String(e)}` };
-			}
-		}, {
-			offset,
-			length,
-			searchPattern
-		});
-		if (hasErrorResult(memData)) return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				success: false,
-				error: memData.error
-			})
-		}] };
-		const data = memData.data;
-		let hexDump = "";
-		let asciiDump = "";
-		if (format === "hex" || format === "both") for (let i = 0; i < data.length; i += 16) {
-			const row = data.slice(i, i + 16);
-			const addr = (offset + i).toString(16).padStart(8, "0");
-			const hex = row.map((b) => b.toString(16).padStart(2, "0")).join(" ");
-			const ascii = row.map((b) => b >= 32 && b < 127 ? String.fromCharCode(b) : ".").join("");
-			hexDump += `${addr}  ${hex.padEnd(48)}  |${ascii}|\n`;
-		}
-		if (format === "ascii") asciiDump = data.map((b) => b >= 32 && b < 127 ? String.fromCharCode(b) : ".").join("");
-		return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				success: true,
-				totalMemoryPages: memData.totalMemoryPages,
-				totalMemoryBytes: memData.totalMemoryBytes,
-				offset,
-				length: data.length,
-				hexDump: format !== "ascii" ? hexDump : void 0,
-				asciiDump: format === "ascii" ? asciiDump : void 0,
-				searchResults: memData.searchResults
-			}, null, 2)
-		}] };
-	}
-};
-//#endregion
-//#region src/server/domains/wasm/handlers/capability-handlers.ts
-function toolCapability(capability, toolName, available, reason, fix, tools, probe) {
-	return {
-		capability,
-		status: available ? "available" : "unavailable",
-		reason,
-		fix: available ? void 0 : fix,
-		details: {
-			tools,
-			...probe?.path ? { path: probe.path } : {},
-			...probe?.version ? { version: probe.version } : {},
-			backend: toolName
-		}
-	};
-}
-var CapabilityHandlers = class {
-	constructor(state) {
-		this.state = state;
-	}
-	async handleWasmCapabilities() {
-		const probes = await this.state.runner.probeAll();
-		const currentPageCapability = await this.getCurrentPageCapability();
-		const hasOfflineRuntime = probes["runtime.wasmtime"]?.available === true || probes["runtime.wasmer"]?.available === true;
-		return R.raw(capabilityReport("wasm_capabilities", [
-			currentPageCapability,
-			toolCapability("wabt_wasm2wat", "wabt.wasm2wat", probes["wabt.wasm2wat"]?.available === true, probes["wabt.wasm2wat"]?.reason, "Install WABT so wasm2wat is available on PATH.", ["wasm_disassemble"], probes["wabt.wasm2wat"]),
-			toolCapability("wabt_wasm_decompile", "wabt.wasm-decompile", probes["wabt.wasm-decompile"]?.available === true, probes["wabt.wasm-decompile"]?.reason, "Install WABT so wasm-decompile is available on PATH.", ["wasm_decompile"], probes["wabt.wasm-decompile"]),
-			toolCapability("wabt_wasm_objdump", "wabt.wasm-objdump", probes["wabt.wasm-objdump"]?.available === true, probes["wabt.wasm-objdump"]?.reason, "Install WABT so wasm-objdump is available on PATH.", ["wasm_inspect_sections"], probes["wabt.wasm-objdump"]),
-			toolCapability("binaryen_wasm_opt", "binaryen.wasm-opt", probes["binaryen.wasm-opt"]?.available === true, probes["binaryen.wasm-opt"]?.reason, "Install Binaryen so wasm-opt is available on PATH.", ["wasm_optimize"], probes["binaryen.wasm-opt"]),
-			{
-				capability: "wasm_offline_runtime",
-				status: hasOfflineRuntime ? "available" : "unavailable",
-				reason: hasOfflineRuntime ? void 0 : "No offline WASM runtime is available on PATH.",
-				fix: hasOfflineRuntime ? void 0 : "Install wasmtime or wasmer to enable wasm_offline_run.",
-				details: {
-					tools: ["wasm_offline_run"],
-					runtimes: {
-						wasmtime: probes["runtime.wasmtime"],
-						wasmer: probes["runtime.wasmer"]
-					},
-					preferredRuntime: probes["runtime.wasmtime"]?.available ? "runtime.wasmtime" : probes["runtime.wasmer"]?.available ? "runtime.wasmer" : null
-				}
-			}
-		]));
-	}
-	async getCurrentPageCapability() {
-		let page;
-		try {
-			page = await this.state.collector.getActivePage();
-		} catch (error) {
-			return {
-				capability: "wasm_browser_capture_current_page",
-				status: "unknown",
-				reason: `Current page probe failed: ${error instanceof Error ? error.message : String(error)}`,
-				fix: "Attach or launch a browser page before using browser-backed WASM tools.",
-				details: {
-					tools: [
-						"wasm_dump",
-						"wasm_vmp_trace",
-						"wasm_memory_inspect"
-					],
-					pageAttached: false
-				}
-			};
-		}
-		if (!page) return {
-			capability: "wasm_browser_capture_current_page",
-			status: "unknown",
-			reason: "No active page is attached.",
-			fix: "Attach or launch a browser page before using browser-backed WASM tools.",
-			details: {
-				tools: [
-					"wasm_dump",
-					"wasm_vmp_trace",
-					"wasm_memory_inspect"
-				],
-				pageAttached: false
-			}
-		};
-		try {
-			const probe = await page.evaluate(() => {
-				const win = window;
-				const hooksRaw = win.__aiHooks?.["preset-webassembly-full"];
-				const hooks = Array.isArray(hooksRaw) ? hooksRaw : [];
-				return {
-					url: location.href,
-					hookEventCount: hooks.length,
-					instantiatedCount: hooks.filter((entry) => entry.type === "instantiated").length,
-					importCallCount: hooks.filter((entry) => entry.type === "import_call").length,
-					memoryEventCount: hooks.filter((entry) => entry.type === "memory_created").length,
-					storageCount: Array.isArray(win.__wasmModuleStorage) ? win.__wasmModuleStorage.length : 0,
-					instanceCount: Array.isArray(win.__wasmInstances) ? win.__wasmInstances.length : 0
-				};
-			});
-			const available = probe.instantiatedCount > 0 || probe.memoryEventCount > 0 || probe.storageCount > 0 || probe.instanceCount > 0;
-			return {
-				capability: "wasm_browser_capture_current_page",
-				status: available ? "available" : "unavailable",
-				reason: available ? void 0 : "No captured WASM modules or exported memory are visible on the current page.",
-				fix: available ? void 0 : "Load a page that instantiates WASM. For dump/trace flows, inject hook_preset(\"webassembly-full\") before navigation.",
-				details: {
-					tools: [
-						"wasm_dump",
-						"wasm_vmp_trace",
-						"wasm_memory_inspect"
-					],
-					pageAttached: true,
-					...probe
-				}
-			};
-		} catch (error) {
-			return {
-				capability: "wasm_browser_capture_current_page",
-				status: "unknown",
-				reason: `Current page probe failed: ${error instanceof Error ? error.message : String(error)}`,
-				fix: "Ensure an attached page is still reachable before using browser-backed WASM tools.",
-				details: {
-					tools: [
-						"wasm_dump",
-						"wasm_vmp_trace",
-						"wasm_memory_inspect"
-					],
-					pageAttached: true
-				}
-			};
-		}
-	}
-};
-//#endregion
-//#region src/server/domains/wasm/handlers.impl.core.ts
-/**
-* WASM domain — composition facade.
-*
-* External tool operations in ./handlers/external-tool-handlers.ts.
-* Browser operations in ./handlers/browser-handlers.ts.
-*/
-var WasmToolHandlers = class {
-	state;
-	externalTools;
-	browser;
-	capabilities;
-	constructor(collector) {
-		const runner = new ExternalToolRunner(new ToolRegistry());
-		this.state = {
-			collector,
-			runner
-		};
-		this.externalTools = new ExternalToolHandlers(this.state);
-		this.browser = new BrowserHandlers(this.state);
-		this.capabilities = new CapabilityHandlers(this.state);
-	}
-	handleWasmCapabilities() {
-		return this.capabilities.handleWasmCapabilities();
-	}
-	handleWasmDump(args) {
-		return this.browser.handleWasmDump(args);
-	}
-	handleWasmDisassemble(args) {
-		return this.externalTools.handleWasmDisassemble(args);
-	}
-	handleWasmDecompile(args) {
-		return this.externalTools.handleWasmDecompile(args);
-	}
-	handleWasmInspectSections(args) {
-		return this.externalTools.handleWasmInspectSections(args);
-	}
-	handleWasmOfflineRun(args) {
-		return this.externalTools.handleWasmOfflineRun(args);
-	}
-	handleWasmOptimize(args) {
-		return this.externalTools.handleWasmOptimize(args);
-	}
-	handleWasmVmpTrace(args) {
-		return this.browser.handleWasmVmpTrace(args);
-	}
-	handleWasmMemoryInspect(args) {
-		return this.browser.handleWasmMemoryInspect(args);
-	}
-	handleWasmToC(args) {
-		return this.externalTools.handleWasmToC(args);
-	}
-	handleWasmDetectObfuscation(args) {
-		return this.externalTools.handleWasmDetectObfuscation(args);
-	}
-	handleWasmInstrumentTrace(args) {
-		return this.externalTools.handleWasmInstrumentTrace(args);
-	}
-};
-//#endregion
-export { WasmToolHandlers };