@jshookmcp/jshook 0.2.9 → 0.3.0

package/dist/wasm-BYx5UOeG.mjs

@@ -0,0 +1,1044 @@
+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 };