@jshookmcp/jshook 0.2.7 → 0.2.9

package/dist/manifest-DCyjf4n2.mjs

@@ -0,0 +1,294 @@
+import { t as logger } from "./logger-Dh_xb7_2.mjs";
+import { t as createProgressDebouncer } from "./EventBus-DgPmwpeu.mjs";
+import { n as toolLookup, t as ensureBrowserCore } from "./registry-D-6e18lB.mjs";
+import { t as coreTools } from "./definitions-C1UvM5Iy.mjs";
+//#region src/modules/deobfuscator/LLMDeobfuscator.ts
+/** Maximum code snippet size sent to the LLM (chars) to avoid token overflow */
+const MAX_CODE_SNIPPET = 2e3;
+/** Maximum number of identifiers to send in one request */
+const MAX_IDENTIFIERS = 20;
+var LLMDeobfuscator = class {
+	constructor(bridge) {
+		this.bridge = bridge;
+	}
+	/**
+	* Check if the underlying sampling bridge supports LLM delegation.
+	*/
+	isAvailable() {
+		return this.bridge.isSamplingSupported();
+	}
+	/**
+	* Use the client's LLM to suggest meaningful names for obfuscated identifiers.
+	*
+	* @param code - The obfuscated code snippet (truncated to MAX_CODE_SNIPPET)
+	* @param identifiers - Array of obfuscated identifier names to rename
+	* @returns Map of old → new names, or `null` if sampling unavailable/failed
+	*/
+	async suggestVariableNames(code, identifiers) {
+		if (!this.bridge.isSamplingSupported()) {
+			logger.debug("LLMDeobfuscator: sampling not available, skipping name suggestion");
+			return null;
+		}
+		const trimmedIds = identifiers.slice(0, MAX_IDENTIFIERS);
+		const trimmedCode = code.slice(0, MAX_CODE_SNIPPET);
+		const userMessage = [
+			"Given this obfuscated JavaScript code, suggest meaningful variable/function names",
+			`for these identifiers: ${trimmedIds.join(", ")}`,
+			"",
+			"```javascript",
+			trimmedCode,
+			"```",
+			"",
+			"Respond ONLY with a valid JSON array of objects with fields:",
+			"  { \"original\": \"<old_name>\", \"suggested\": \"<new_name>\", \"confidence\": \"high\"|\"medium\"|\"low\" }",
+			"",
+			"Rules:",
+			"- Use camelCase for variables/functions, PascalCase for classes",
+			"- If uncertain, use confidence \"low\"",
+			"- If the name is already meaningful, keep it and mark confidence \"high\""
+		].join("\n");
+		const result = await this.bridge.sampleText({
+			systemPrompt: "You are an expert JavaScript reverse engineer. You specialize in deobfuscation and renaming obfuscated identifiers to semantically meaningful names. Output only valid JSON.",
+			userMessage,
+			maxTokens: 256,
+			temperature: .3,
+			modelHint: "haiku"
+		});
+		if (!result) return null;
+		return this.parseNameSuggestions(result, trimmedIds);
+	}
+	/**
+	* Use the client's LLM to infer the purpose of a function from its code.
+	*
+	* @param code - The function's code snippet
+	* @returns A brief description of the function's purpose, or null
+	*/
+	async inferFunctionPurpose(code) {
+		if (!this.bridge.isSamplingSupported()) return null;
+		const trimmedCode = code.slice(0, MAX_CODE_SNIPPET);
+		return (await this.bridge.sampleText({
+			systemPrompt: "You are a JavaScript reverse engineer. Analyze code and describe its purpose in one concise sentence.",
+			userMessage: `What does this function do?\n\n\`\`\`javascript\n${trimmedCode}\n\`\`\`\n\nRespond with a single sentence.`,
+			maxTokens: 100,
+			temperature: .2,
+			modelHint: "haiku"
+		}))?.trim() ?? null;
+	}
+	/**
+	* Parse the LLM's JSON response into structured name suggestions.
+	* Robust against malformed output.
+	*/
+	parseNameSuggestions(rawResponse, expectedIds) {
+		try {
+			const jsonMatch = rawResponse.match(/\[[\s\S]*\]/);
+			if (!jsonMatch) {
+				logger.warn("LLMDeobfuscator: no JSON array found in LLM response");
+				return [];
+			}
+			const parsed = JSON.parse(jsonMatch[0]);
+			if (!Array.isArray(parsed)) return [];
+			const expectedSet = new Set(expectedIds);
+			return parsed.filter((item) => typeof item === "object" && item !== null && typeof item.original === "string" && typeof item.suggested === "string").filter((item) => expectedSet.has(item.original)).map((item) => ({
+				original: item.original,
+				suggested: item.suggested,
+				confidence: [
+					"high",
+					"medium",
+					"low"
+				].includes(item.confidence) ? item.confidence : "low"
+			}));
+		} catch (error) {
+			logger.warn("LLMDeobfuscator: failed to parse LLM response:", error);
+			return [];
+		}
+	}
+};
+//#endregion
+//#region src/server/domains/analysis/manifest.ts
+const DOMAIN = "core";
+const DEP_KEY = "coreAnalysisHandlers";
+const t = toolLookup(coreTools);
+let globalContext = null;
+/**
+* Analysis-domain bind helper that threads `_meta.progressToken` into
+* a throttled `onProgress` callback — same pattern as memory/manifest.ts.
+*/
+function bindWithProgress(invoke) {
+	return (deps) => {
+		const handler = deps[DEP_KEY];
+		return (args) => {
+			const _meta = args._meta;
+			let onProgress;
+			if (_meta?.progressToken !== void 0 && globalContext) onProgress = createProgressDebouncer(globalContext.eventBus, _meta.progressToken);
+			return invoke(handler, {
+				...args,
+				onProgress
+			});
+		};
+	};
+}
+const b = bindWithProgress;
+async function ensure(ctx) {
+	const { Deobfuscator, AdvancedDeobfuscator, ObfuscationDetector, CodeAnalyzer, CryptoDetector, HookManager } = await import("./modules-C184v-S9.mjs").then((n) => n.t);
+	const { CoreAnalysisHandlers } = await import("./analysis-CL9uACt9.mjs");
+	globalContext = ctx;
+	await ensureBrowserCore(ctx);
+	if (!ctx.deobfuscator || !ctx.advancedDeobfuscator || !ctx.obfuscationDetector || !ctx.analyzer || !ctx.cryptoDetector || !ctx.hookManager || !ctx.coreAnalysisHandlers) {
+		if (!ctx.deobfuscator) ctx.deobfuscator = new Deobfuscator();
+		if (!ctx.advancedDeobfuscator) ctx.advancedDeobfuscator = new AdvancedDeobfuscator();
+		if (!ctx.obfuscationDetector) ctx.obfuscationDetector = new ObfuscationDetector();
+		if (!ctx.analyzer) ctx.analyzer = new CodeAnalyzer();
+		if (!ctx.cryptoDetector) ctx.cryptoDetector = new CryptoDetector();
+		if (!ctx.hookManager) ctx.hookManager = new HookManager();
+		if (!ctx.coreAnalysisHandlers) ctx.coreAnalysisHandlers = new CoreAnalysisHandlers({
+			collector: ctx.collector,
+			scriptManager: ctx.scriptManager,
+			deobfuscator: ctx.deobfuscator,
+			advancedDeobfuscator: ctx.advancedDeobfuscator,
+			obfuscationDetector: ctx.obfuscationDetector,
+			analyzer: ctx.analyzer,
+			cryptoDetector: ctx.cryptoDetector,
+			hookManager: ctx.hookManager
+		});
+	}
+	return ctx.coreAnalysisHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["workflow", "full"],
+	ensure,
+	workflowRule: {
+		patterns: [/(deobfuscate|deobfusc|beautify|analyze).*(javascript|js|script|code)/i, /(反混淆|美化|分析).*(javascript|js|脚本|代码)/i],
+		priority: 85,
+		tools: [
+			"deobfuscate",
+			"extract_function_tree",
+			"llm_suggest_names"
+		],
+		hint: "JavaScript analysis workflow: collect -> deobfuscate -> inspect function tree | LLM-powered naming"
+	},
+	prerequisites: { collect_code: [{
+		condition: "Browser must be launched",
+		fix: "Call browser_launch or browser_attach first"
+	}] },
+	registrations: [
+		{
+			tool: t("collect_code"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleCollectCode(a))
+		},
+		{
+			tool: t("search_in_scripts"),
+			domain: DOMAIN,
+			profiles: [
+				"search",
+				"workflow",
+				"full"
+			],
+			bind: b((h, a) => h.handleSearchInScripts(a))
+		},
+		{
+			tool: t("extract_function_tree"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleExtractFunctionTree(a))
+		},
+		{
+			tool: t("deobfuscate"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleDeobfuscate(a))
+		},
+		{
+			tool: t("understand_code"),
+			domain: DOMAIN,
+			profiles: [
+				"search",
+				"workflow",
+				"full"
+			],
+			bind: b((h, a) => h.handleUnderstandCode(a))
+		},
+		{
+			tool: t("detect_crypto"),
+			domain: DOMAIN,
+			profiles: [
+				"search",
+				"workflow",
+				"full"
+			],
+			bind: b((h, a) => h.handleDetectCrypto(a))
+		},
+		{
+			tool: t("manage_hooks"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleManageHooks(a))
+		},
+		{
+			tool: t("detect_obfuscation"),
+			domain: DOMAIN,
+			profiles: [
+				"search",
+				"workflow",
+				"full"
+			],
+			bind: b((h, a) => h.handleDetectObfuscation(a))
+		},
+		{
+			tool: t("webcrack_unpack"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleWebcrackUnpack(a))
+		},
+		{
+			tool: t("clear_collected_data"),
+			domain: DOMAIN,
+			bind: b((h) => h.handleClearCollectedData())
+		},
+		{
+			tool: t("get_collection_stats"),
+			domain: DOMAIN,
+			bind: b((h) => h.handleGetCollectionStats())
+		},
+		{
+			tool: t("webpack_enumerate"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleWebpackEnumerate(a))
+		},
+		{
+			tool: t("llm_suggest_names"),
+			domain: DOMAIN,
+			bind: bindWithProgress(async (_h, args) => {
+				if (!globalContext) return { content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: false,
+						error: "Server context not initialized"
+					})
+				}] };
+				const deob = new LLMDeobfuscator(globalContext.samplingBridge);
+				if (!deob.isAvailable()) return { content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: false,
+						error: "Sampling not supported by this client",
+						hint: "The connected MCP client does not declare sampling capabilities. Try using Claude Desktop or another sampling-capable client."
+					})
+				}] };
+				const code = typeof args.code === "string" ? args.code : "";
+				const identifiers = Array.isArray(args.identifiers) ? args.identifiers.filter((id) => typeof id === "string") : [];
+				const suggestions = await deob.suggestVariableNames(code, identifiers);
+				return { content: [{
+					type: "text",
+					text: JSON.stringify({
+						success: true,
+						suggestions: suggestions ?? [],
+						samplingUsed: true
+					})
+				}] };
+			})
+		}
+	]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-DHsnKgP6.mjs

@@ -0,0 +1,60 @@
+import { n as toolLookup } from "./registry-D-6e18lB.mjs";
+import { t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
+import { t as transformTools } from "./definitions-Cq-zroAU.mjs";
+//#region src/server/domains/transform/manifest.ts
+const DOMAIN = "transform";
+const DEP_KEY = "transformHandlers";
+const t = toolLookup(transformTools);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { CodeCollector } = await import("./modules-C184v-S9.mjs").then((n) => n.t);
+	const { TransformToolHandlers } = await import("./transform-CiYJfNX0.mjs");
+	if (!ctx.collector) {
+		ctx.collector = new CodeCollector(ctx.config.puppeteer);
+		ctx.registerCaches();
+	}
+	if (!ctx.transformHandlers) ctx.transformHandlers = new TransformToolHandlers(ctx.collector);
+	return ctx.transformHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	registrations: [
+		{
+			tool: t("ast_transform_preview"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleAstTransformPreview(a))
+		},
+		{
+			tool: t("ast_transform_chain"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleAstTransformChain(a))
+		},
+		{
+			tool: t("ast_transform_apply"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleAstTransformApply(a))
+		},
+		{
+			tool: t("crypto_extract_standalone"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleCryptoExtractStandalone(a))
+		},
+		{
+			tool: t("crypto_test_harness"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleCryptoTestHarness(a))
+		},
+		{
+			tool: t("crypto_compare"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleCryptoCompare(a))
+		}
+	]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-Df_dliIe.mjs

@@ -0,0 +1,55 @@
+import { n as toolLookup } from "./registry-D-6e18lB.mjs";
+import { t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
+import { t as encodingTools } from "./definitions-D3VsGcvz.mjs";
+//#region src/server/domains/encoding/manifest.ts
+const DOMAIN = "encoding";
+const DEP_KEY = "encodingHandlers";
+const t = toolLookup(encodingTools);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { CodeCollector } = await import("./modules-C184v-S9.mjs").then((n) => n.t);
+	const { EncodingToolHandlers } = await import("./encoding-Bvz5jLRv.mjs");
+	if (!ctx.collector) {
+		ctx.collector = new CodeCollector(ctx.config.puppeteer);
+		ctx.registerCaches();
+	}
+	if (!ctx.encodingHandlers) ctx.encodingHandlers = new EncodingToolHandlers(ctx.collector);
+	return ctx.encodingHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["workflow", "full"],
+	ensure,
+	registrations: [
+		{
+			tool: t("binary_detect_format"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleBinaryDetectFormat(a))
+		},
+		{
+			tool: t("binary_decode"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleBinaryDecode(a))
+		},
+		{
+			tool: t("binary_encode"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleBinaryEncode(a))
+		},
+		{
+			tool: t("binary_entropy_analysis"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleBinaryEntropyAnalysis(a))
+		},
+		{
+			tool: t("protobuf_decode_raw"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleProtobufDecodeRaw(a))
+		}
+	]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-Dh8WBmEW.mjs

@@ -0,0 +1,129 @@
+import { n as asJsonResponse } from "./response-BQVP-xUn.mjs";
+import { n as toolLookup } from "./registry-D-6e18lB.mjs";
+import { t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
+const skiaTools = [
+	{
+		name: "skia_detect_renderer",
+		description: "Detect the active Skia renderer backend from the current page context.",
+		inputSchema: {
+			type: "object",
+			properties: {},
+			required: []
+		}
+	},
+	{
+		name: "skia_extract_scene",
+		description: "Extract a lightweight Skia scene tree from the selected canvas.",
+		inputSchema: {
+			type: "object",
+			properties: { canvasId: { type: "string" } },
+			required: []
+		}
+	},
+	{
+		name: "skia_correlate_objects",
+		description: "Correlate requested Skia node identifiers with the extracted scene tree.",
+		inputSchema: {
+			type: "object",
+			properties: {
+				canvasId: {
+					type: "string",
+					description: "Optional canvas element ID to target for correlation."
+				},
+				skiaNodeIds: {
+					type: "array",
+					items: { type: "string" },
+					description: "Optional list of Skia node identifiers to correlate."
+				}
+			},
+			required: []
+		}
+	}
+];
+//#endregion
+//#region src/server/domains/skia-capture/manifest.ts
+const DOMAIN = "skia-capture";
+const DEP_KEY = "skiaCaptureHandlers";
+const PROFILES = ["workflow", "full"];
+const lookup = toolLookup(skiaTools);
+const bind = (invoke) => bindByDepKey(DEP_KEY, async (handler, args) => {
+	return asJsonResponse(await invoke(handler, args));
+});
+async function ensure(ctx) {
+	const { SkiaCaptureHandlers } = await import("./handlers-CTsDAO6p.mjs");
+	const existing = ctx.getDomainInstance(DEP_KEY);
+	if (existing) return existing;
+	const handlers = new SkiaCaptureHandlers({
+		pageController: ctx.pageController ?? null,
+		eventBus: ctx.eventBus
+	});
+	ctx.setDomainInstance(DEP_KEY, handlers);
+	return handlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: PROFILES,
+	registrations: [
+		{
+			tool: lookup("skia_detect_renderer"),
+			domain: DOMAIN,
+			bind: bind((handler, args) => handler.handleSkiaDetectRenderer(args))
+		},
+		{
+			tool: lookup("skia_extract_scene"),
+			domain: DOMAIN,
+			bind: bind((handler, args) => handler.handleSkiaExtractScene(args))
+		},
+		{
+			tool: lookup("skia_correlate_objects"),
+			domain: DOMAIN,
+			bind: bind((handler, args) => handler.handleSkiaCorrelateObjects(args))
+		}
+	],
+	ensure,
+	workflowRule: {
+		patterns: [
+			/\b(skia|gpu|render(er)?|scene\s?(tree|graph)|draw\s?call|raster|paint|layer)\b/i,
+			/skia.*(render|detect|scene)/i,
+			/canvas.*skia/i,
+			/gpu.*backend/i
+		],
+		priority: 78,
+		tools: [
+			"skia_detect_renderer",
+			"skia_extract_scene",
+			"skia_correlate_objects"
+		],
+		hint: "Skia pipeline analysis: detect GPU backend → dump scene tree → correlate with JS objects."
+	},
+	prerequisites: {
+		skia_detect_renderer: [{
+			condition: "Browser must be running with CDP attached",
+			fix: "Call browser_launch or browser_attach first"
+		}],
+		skia_extract_scene: [{
+			condition: "Browser must be running with CDP attached",
+			fix: "Call browser_launch or browser_attach first"
+		}],
+		skia_correlate_objects: [{
+			condition: "V8 heap snapshot should be available for robust matching",
+			fix: "Run v8_heap_snapshot_capture before correlation"
+		}]
+	},
+	toolDependencies: [{
+		from: "canvas",
+		to: "skia-capture",
+		relation: "uses",
+		weight: .9
+	}, {
+		from: "skia_correlate_objects",
+		to: "v8_heap_snapshot_capture",
+		relation: "precedes",
+		weight: .6
+	}]
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-DhKRAT8_.mjs

@@ -0,0 +1,92 @@
+import { n as toolLookup } from "./registry-D-6e18lB.mjs";
+import { t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
+import { t as tool } from "./tool-builder-DCbIC5Eo.mjs";
+//#region src/server/domains/trace/definitions.tools.ts
+const TRACE_TOOLS = [
+	tool("trace_recording", (t) => t.desc("Start or stop time-travel trace recording into a SQLite database.\n\nRecording captures events from Debugger, Runtime, Network, Page, and EventBus.\nUse action=\"stop\" to finalize and get a session summary.").enum("action", ["start", "stop"], "Recording action").array("cdpDomains", { type: "string" }, "CDP domains to record (action=start, default: Debugger, Runtime, Network, Page)").boolean("recordMemoryDeltas", "Record memory write deltas (action=start)", { default: true }).required("action").idempotent()),
+	tool("query_trace_sql", (t) => t.desc("Execute a read-only SQL query against a trace database.\n\nAvailable tables:\n- events(id, timestamp, category, event_type, data, script_id, line_number)\n- memory_deltas(id, timestamp, address, old_value, new_value, size, value_type)\n- heap_snapshots(id, timestamp, snapshot_data, summary)\n- metadata(key, value)\n\nReturns columns, rows, and row count.\n\nExamples:\nquery_trace_sql(sql=\"SELECT * FROM events WHERE category='debugger' ORDER BY timestamp\")\nquery_trace_sql(sql=\"SELECT address, COUNT(*) as writes FROM memory_deltas GROUP BY address ORDER BY writes DESC LIMIT 10\")\nquery_trace_sql(sql=\"SELECT * FROM events WHERE timestamp BETWEEN 1000 AND 2000\", dbPath=\"artifacts/traces/my-trace.db\")").string("sql", "SQL query to execute (SELECT only — write operations are rejected)").string("dbPath", "Path to trace DB file. Uses the active recording if omitted.").required("sql").query()),
+	tool("seek_to_timestamp", (t) => t.desc("Reconstruct application state at a specific timestamp from a recorded trace.\n\nReturns a structured snapshot including:\n- Events near the timestamp\n- Debugger state (last pause, call stack)\n- Memory state (latest values per address)\n- Network state (completed requests)\n- Nearest heap snapshot\n\nExamples:\nseek_to_timestamp(timestamp=1711000000000)\nseek_to_timestamp(timestamp=1711000000000, windowMs=500)\nseek_to_timestamp(timestamp=1711000000000, dbPath=\"artifacts/traces/my-trace.db\")").number("timestamp", "Target timestamp in milliseconds since epoch").string("dbPath", "Path to trace DB file. Uses the active recording if omitted.").number("windowMs", "Time window around timestamp to include in ms", { default: 100 }).required("timestamp").query()),
+	tool("diff_heap_snapshots", (t) => t.desc("Compare two heap snapshots from a trace and return the differences.\n\nShows:\n- New object types (in snapshot 2 but not 1)\n- Deleted object types (in snapshot 1 but not 2)\n- Changed objects (count or size differs)\n- Total size delta\n\nUseful for identifying state changes in obfuscated code.\n\nExamples:\ndiff_heap_snapshots(snapshotId1=1, snapshotId2=2)\ndiff_heap_snapshots(snapshotId1=1, snapshotId2=3, dbPath=\"artifacts/traces/my-trace.db\")").number("snapshotId1", "First snapshot ID (earlier)").number("snapshotId2", "Second snapshot ID (later)").string("dbPath", "Path to trace DB file. Uses the active recording if omitted.").required("snapshotId1", "snapshotId2").query()),
+	tool("export_trace", (t) => t.desc("Export a trace database to Chrome Trace Event JSON format.\n\nThe resulting file can be loaded in:\n- chrome://tracing\n- Perfetto UI (ui.perfetto.dev)\n\nMaps events to the standard trace event format with name, category, phase, timestamp.\n\nExamples:\nexport_trace()\nexport_trace(dbPath=\"artifacts/traces/my-trace.db\")\nexport_trace(outputPath=\"my-export.json\")").string("dbPath", "Path to trace DB file. Uses the active recording if omitted.").string("outputPath", "Output JSON file path. Auto-generated if omitted.").idempotent()),
+	tool("summarize_trace", (t) => t.desc("Generate a compact, LLM-friendly summary of a trace database.\n\nAvoids sending raw trace data that may exceed context windows. Three detail levels:\n- compact: category aggregation + timeline overview (~10% of raw size)\n- balanced: compact + key moments (breakpoints, exceptions, network completions) [DEFAULT]\n- full: passthrough — returns all events without compression\n\nAlso detects memory anomalies: addresses with significantly more writes than average.\n\nExamples:\nsummarize_trace()\nsummarize_trace(detail=\"compact\")\nsummarize_trace(detail=\"balanced\", dbPath=\"artifacts/traces/my-trace.db\")").enum("detail", [
+		"compact",
+		"balanced",
+		"full"
+	], "Summary detail level", { default: "balanced" }).string("dbPath", "Path to trace DB file. Uses the active recording if omitted.").query())
+];
+//#endregion
+//#region src/server/domains/trace/manifest.ts
+const DOMAIN = "trace";
+const DEP_KEY = "traceHandlers";
+const t = toolLookup(TRACE_TOOLS);
+const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+async function ensure(ctx) {
+	const { TraceRecorder } = await import("./TraceRecorder-DgxyVbdQ.mjs");
+	const { TraceToolHandlers } = await import("./handlers-DdFzXLvF.mjs");
+	if (!ctx.traceRecorder || !ctx.traceHandlers) {
+		if (!ctx.traceRecorder) ctx.traceRecorder = new TraceRecorder();
+		if (!ctx.traceHandlers) ctx.traceHandlers = new TraceToolHandlers(ctx.traceRecorder, ctx);
+	}
+	return ctx.traceHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	prerequisites: {},
+	workflowRule: {
+		patterns: [
+			/trace/i,
+			/time.?travel/i,
+			/replay/i,
+			/recorded?\s+events?/i
+		],
+		priority: 70,
+		tools: [
+			"trace_recording",
+			"query_trace_sql",
+			"seek_to_timestamp",
+			"diff_heap_snapshots",
+			"export_trace",
+			"summarize_trace"
+		],
+		hint: "Start recording → perform actions → stop recording → summarize/query/seek/diff/export"
+	},
+	registrations: [
+		{
+			tool: t("trace_recording"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleTraceRecording(a))
+		},
+		{
+			tool: t("query_trace_sql"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleQueryTraceSql(a))
+		},
+		{
+			tool: t("seek_to_timestamp"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleSeekToTimestamp(a))
+		},
+		{
+			tool: t("diff_heap_snapshots"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleDiffHeapSnapshots(a))
+		},
+		{
+			tool: t("export_trace"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleExportTrace(a))
+		},
+		{
+			tool: t("summarize_trace"),
+			domain: DOMAIN,
+			bind: b((h, a) => h.handleSummarizeTrace(a))
+		}
+	]
+};
+//#endregion
+export { manifest as default };