@jshookmcp/jshook 0.2.9 → 0.3.1

package/dist/manifest-DCyjf4n2.mjs

@@ -1,294 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,129 +0,0 @@
-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

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