@jshookmcp/jshook 0.2.9 → 0.3.0

package/dist/manifest-CQVhavRF.mjs

@@ -1,114 +0,0 @@
-import { n as toolLookup } from "./registry-D-6e18lB.mjs";
-import { t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
-import { t as processToolDefinitions } from "./definitions-B4rAvHNZ.mjs";
-//#region src/server/domains/process/manifest.ts
-const DOMAIN = "process";
-const DEP_KEY = "processHandlers";
-const t = toolLookup(processToolDefinitions);
-const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
-const EFFECTIVE_PLATFORM = process.env.JSHOOK_REGISTRY_PLATFORM === "win32" || process.env.JSHOOK_REGISTRY_PLATFORM === "linux" || process.env.JSHOOK_REGISTRY_PLATFORM === "darwin" ? process.env.JSHOOK_REGISTRY_PLATFORM : process.platform;
-async function ensure(ctx) {
-	const { ProcessToolHandlers } = await import("./process-QcbIy5Zq.mjs");
-	if (!ctx.processHandlers) ctx.processHandlers = new ProcessToolHandlers();
-	return ctx.processHandlers;
-}
-const IS_WIN32 = EFFECTIVE_PLATFORM === "win32";
-const WIN32_ONLY_TOOLS = new Set(["check_debug_port"]);
-const allRegistrations = [
-	{
-		tool: t("electron_attach"),
-		domain: DOMAIN,
-		bind: b((h, a) => h.handleElectronAttach(a))
-	},
-	{
-		tool: t("process_windows"),
-		domain: DOMAIN,
-		bind: b((h, a) => h.handleProcessWindows(a))
-	},
-	{
-		tool: t("process_check_debug_port"),
-		domain: DOMAIN,
-		bind: b((h, a) => h.handleProcessCheckDebugPort(a))
-	},
-	{
-		tool: t("process_launch_debug"),
-		domain: DOMAIN,
-		bind: b((h, a) => h.handleProcessLaunchDebug(a))
-	},
-	{
-		tool: t("memory_read"),
-		domain: DOMAIN,
-		bind: b((h, a) => h.handleMemoryRead(a))
-	},
-	{
-		tool: t("memory_write"),
-		domain: DOMAIN,
-		bind: b((h, a) => h.handleMemoryWrite(a))
-	},
-	{
-		tool: t("memory_scan"),
-		domain: DOMAIN,
-		bind: b((h, a) => h.handleMemoryScan(a))
-	},
-	{
-		tool: t("memory_check_protection"),
-		domain: DOMAIN,
-		bind: b((h, a) => h.handleMemoryCheckProtection(a))
-	},
-	{
-		tool: t("memory_scan_filtered"),
-		domain: DOMAIN,
-		bind: b((h, a) => h.handleMemoryScanFiltered(a))
-	},
-	{
-		tool: t("memory_batch_write"),
-		domain: DOMAIN,
-		bind: b((h, a) => h.handleMemoryBatchWrite(a))
-	},
-	{
-		tool: t("memory_dump_region"),
-		domain: DOMAIN,
-		bind: b((h, a) => h.handleMemoryDumpRegion(a))
-	},
-	{
-		tool: t("memory_list_regions"),
-		domain: DOMAIN,
-		bind: b((h, a) => h.handleMemoryListRegions(a))
-	},
-	{
-		tool: t("memory_audit_export"),
-		domain: DOMAIN,
-		bind: b((h, a) => h.handleMemoryAuditExport(a))
-	},
-	{
-		tool: t("inject_dll"),
-		domain: DOMAIN,
-		bind: b((h, a) => h.handleInjectDll(a))
-	},
-	{
-		tool: t("inject_shellcode"),
-		domain: DOMAIN,
-		bind: b((h, a) => h.handleInjectShellcode(a))
-	},
-	{
-		tool: t("check_debug_port"),
-		domain: DOMAIN,
-		bind: b((h, a) => h.handleCheckDebugPort(a))
-	},
-	{
-		tool: t("enumerate_modules"),
-		domain: DOMAIN,
-		bind: b((h, a) => h.handleEnumerateModules(a))
-	}
-];
-const manifest = {
-	kind: "domain-manifest",
-	version: 1,
-	domain: DOMAIN,
-	depKey: DEP_KEY,
-	profiles: ["full"],
-	ensure,
-	registrations: IS_WIN32 ? allRegistrations : allRegistrations.filter((r) => !WIN32_ONLY_TOOLS.has(r.tool.name))
-};
-//#endregion
-export { manifest as default };

package/dist/manifest-CV12bcrF.mjs

@@ -1,121 +0,0 @@
-import { n as toolLookup, t as ensureBrowserCore } from "./registry-D-6e18lB.mjs";
-import { t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
-import { t as debuggerTools } from "./definitions-DVGfrn7y.mjs";
-//#region src/server/domains/debugger/manifest.ts
-const DOMAIN = "debugger";
-const DEP_KEY = "debuggerHandlers";
-const t = toolLookup(debuggerTools);
-const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
-async function ensure(ctx) {
-	const { DebuggerManager, RuntimeInspector } = await import("./modules-C184v-S9.mjs").then((n) => n.t);
-	const { DebuggerToolHandlers } = await import("./debugger-gnKxRSN0.mjs");
-	await ensureBrowserCore(ctx);
-	if (!ctx.debuggerManager || !ctx.runtimeInspector || !ctx.debuggerHandlers) {
-		if (!ctx.debuggerManager) ctx.debuggerManager = new DebuggerManager(ctx.collector);
-		if (!ctx.runtimeInspector) ctx.runtimeInspector = new RuntimeInspector(ctx.collector, ctx.debuggerManager);
-		if (!ctx.debuggerHandlers) ctx.debuggerHandlers = new DebuggerToolHandlers(ctx.debuggerManager, ctx.runtimeInspector, ctx.eventBus);
-	}
-	return ctx.debuggerHandlers;
-}
-const manifest = {
-	kind: "domain-manifest",
-	version: 1,
-	domain: DOMAIN,
-	depKey: DEP_KEY,
-	profiles: ["workflow", "full"],
-	ensure,
-	prerequisites: {
-		debugger_lifecycle: [{
-			condition: "Browser must be launched",
-			fix: "Call browser_launch or browser_attach first"
-		}],
-		breakpoint: [{
-			condition: "Browser must be launched",
-			fix: "Call browser_launch and debugger_lifecycle(enable) first"
-		}]
-	},
-	registrations: [
-		{
-			tool: t("debugger_lifecycle"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleDebuggerLifecycle(a))
-		},
-		{
-			tool: t("debugger_pause"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleDebuggerPause(a))
-		},
-		{
-			tool: t("debugger_resume"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleDebuggerResume(a))
-		},
-		{
-			tool: t("debugger_step"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleDebuggerStep(a))
-		},
-		{
-			tool: t("breakpoint"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleBreakpoint(a))
-		},
-		{
-			tool: t("get_call_stack"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleGetCallStack(a))
-		},
-		{
-			tool: t("debugger_evaluate"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleDebuggerEvaluateDispatch(a))
-		},
-		{
-			tool: t("debugger_wait_for_paused"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleDebuggerWaitForPaused(a))
-		},
-		{
-			tool: t("debugger_get_paused_state"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleDebuggerGetPausedState(a))
-		},
-		{
-			tool: t("get_object_properties"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleGetObjectProperties(a))
-		},
-		{
-			tool: t("get_scope_variables_enhanced"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleGetScopeVariablesEnhanced(a))
-		},
-		{
-			tool: t("debugger_session"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleDebuggerSession(a))
-		},
-		{
-			tool: t("watch"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleWatch(a))
-		},
-		{
-			tool: t("blackbox_add"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleBlackboxAdd(a))
-		},
-		{
-			tool: t("blackbox_add_common"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleBlackboxAddCommon(a))
-		},
-		{
-			tool: t("blackbox_list"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleBlackboxList(a))
-		}
-	]
-};
-//#endregion
-export { manifest as default };

package/dist/manifest-CZLUCfG02.mjs

@@ -1,95 +0,0 @@
-import { n as toolLookup } from "./registry-D-6e18lB.mjs";
-import { t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
-import { t as platformTools } from "./definitions-6M-eejaT.mjs";
-//#region src/server/domains/platform/manifest.ts
-const DOMAIN = "platform";
-const DEP_KEY = "platformHandlers";
-const t = toolLookup(platformTools);
-const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
-async function ensure(ctx) {
-	const { CodeCollector } = await import("./modules-C184v-S9.mjs").then((n) => n.t);
-	const { PlatformToolHandlers } = await import("./platform-WmNn8Sxb.mjs");
-	if (!ctx.collector) {
-		ctx.collector = new CodeCollector(ctx.config.puppeteer);
-		ctx.registerCaches();
-	}
-	if (!ctx.platformHandlers) ctx.platformHandlers = new PlatformToolHandlers(ctx.collector);
-	return ctx.platformHandlers;
-}
-const manifest = {
-	kind: "domain-manifest",
-	version: 1,
-	domain: DOMAIN,
-	depKey: DEP_KEY,
-	profiles: ["full"],
-	ensure,
-	registrations: [
-		{
-			tool: t("miniapp_pkg_scan"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleMiniappPkgScan(a))
-		},
-		{
-			tool: t("miniapp_pkg_unpack"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleMiniappPkgUnpack(a))
-		},
-		{
-			tool: t("miniapp_pkg_analyze"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleMiniappPkgAnalyze(a))
-		},
-		{
-			tool: t("asar_extract"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleAsarExtract(a))
-		},
-		{
-			tool: t("electron_inspect_app"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleElectronInspectApp(a))
-		},
-		{
-			tool: t("electron_scan_userdata"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleElectronScanUserdata(a))
-		},
-		{
-			tool: t("asar_search"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleAsarSearch(a))
-		},
-		{
-			tool: t("electron_check_fuses"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleElectronCheckFuses(a))
-		},
-		{
-			tool: t("electron_patch_fuses"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleElectronPatchFuses(a))
-		},
-		{
-			tool: t("v8_bytecode_decompile"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleV8BytecodeDecompile(a))
-		},
-		{
-			tool: t("electron_launch_debug"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleElectronLaunchDebug(a))
-		},
-		{
-			tool: t("electron_debug_status"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleElectronDebugStatus(a))
-		},
-		{
-			tool: t("electron_ipc_sniff"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleElectronIPCSniff(a))
-		}
-	]
-};
-//#endregion
-export { manifest as default };

package/dist/manifest-D6phHKFd.mjs

@@ -1,131 +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/instrumentation/definitions.ts
-const queryTypes = [
-	"before-load-inject",
-	"runtime-hook",
-	"network-intercept",
-	"function-trace"
-];
-const instrumentationTools = [
-	tool("instrumentation_session", (t) => t.desc(`Manage instrumentation sessions that group hooks, intercepts, and traces.
-
-Actions:
-- create: Create a new session
-- list: List all active sessions
-- destroy: Destroy a session (requires sessionId)
-- status: Get detailed session status (requires sessionId)`).enum("action", [
-		"create",
-		"list",
-		"destroy",
-		"status"
-	], "Session operation").string("sessionId", "Session ID (required for destroy/status)").required("action")),
-	tool("instrumentation_operation", (t) => t.desc(`Manage operations within an instrumentation session.
-
-Actions:
-- register: Register a new operation (requires sessionId, type, target)
-- list: List operations in a session (requires sessionId)`).enum("action", ["register", "list"], "Operation").enum("type", queryTypes, "Instrumentation type (action=register)").string("target", "Function name, URL pattern, or script target (action=register)").object("config", {}, "Operation-specific config (action=register)").required("action", "sessionId")),
-	tool("instrumentation_artifact", (t) => t.desc(`Manage captured artifacts for instrumentation operations.
-
-Actions:
-- record: Record a captured artifact (requires operationId, data)
-- query: Query captured artifacts (requires sessionId)`).enum("action", ["record", "query"], "Artifact operation").string("operationId", "Operation ID (action=record)").object("data", {}, "Captured artifact payload (action=record)").enum("type", queryTypes, "Optional artifact type filter (action=query)").number("limit", "Max artifacts to return (action=query, default: 50)", { default: 50 }).required("action", "sessionId")),
-	tool("instrumentation_hook_preset", (t) => t.desc("Apply hooks domain preset hooks within an instrumentation session and persist...").string("preset", "Single preset id to inject").array("presets", { type: "string" }, "Multiple preset ids to inject in one call").boolean("captureStack", "Whether injected presets should capture stack traces", { default: false }).boolean("logToConsole", "Whether injected presets should log to console", { default: true }).enum("method", ["evaluate", "evaluateOnNewDocument"], "Injection method forwarded to hook_preset", { default: "evaluate" }).prop("customTemplate", {
-		type: "object",
-		additionalProperties: true,
-		description: "Optional inline custom preset definition"
-	}).prop("customTemplates", {
-		type: "array",
-		items: {
-			type: "object",
-			additionalProperties: true
-		},
-		description: "Optional inline custom preset definitions"
-	}).requiredOpenWorld("sessionId")),
-	tool("instrumentation_network_replay", (t) => t.desc("Replay a previously captured network request inside an instrumentation sessio...").string("requestId", "Captured request ID returned by network_get_requests").object("headerPatch", { additionalProperties: { type: "string" } }, "Optional request header overrides").string("bodyPatch", "Optional raw request body override").string("methodOverride", "Optional HTTP method override").string("urlOverride", "Optional destination URL override").number("timeoutMs", "Optional replay timeout in milliseconds").boolean("dryRun", "Preview the replay without sending the request", { default: true }).requiredOpenWorld("sessionId", "requestId"))
-];
-//#endregion
-//#region src/server/domains/instrumentation/manifest.ts
-const DOMAIN = "instrumentation";
-const DEP_KEY = "instrumentationHandlers";
-const t = toolLookup(instrumentationTools);
-const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
-async function ensure(ctx) {
-	const { ReverseEvidenceGraph } = await import("./ReverseEvidenceGraph-Dlsk94LC.mjs").then((n) => n.t);
-	const { InstrumentationSessionManager } = await import("./InstrumentationSession-CvPC7Jwy.mjs");
-	const { EvidenceGraphBridge } = await import("./EvidenceGraphBridge-SFesNera.mjs");
-	const { InstrumentationHandlers } = await import("./handlers-C87g8oCe.mjs");
-	const hookPresetHandlers = ctx.handlerDeps.hookPresetHandlers;
-	const advancedHandlers = ctx.handlerDeps.advancedHandlers;
-	let graph = ctx.getDomainInstance("evidenceGraph");
-	if (!graph) {
-		graph = new ReverseEvidenceGraph();
-		ctx.setDomainInstance("evidenceGraph", graph);
-	}
-	let sessionManager = ctx.getDomainInstance("instrumentationSessionManager");
-	if (!sessionManager) {
-		sessionManager = new InstrumentationSessionManager();
-		ctx.setDomainInstance("instrumentationSessionManager", sessionManager);
-	}
-	let bridge = ctx.getDomainInstance("evidenceGraphBridge");
-	if (!bridge) {
-		bridge = new EvidenceGraphBridge(graph);
-		ctx.setDomainInstance("evidenceGraphBridge", bridge);
-	}
-	sessionManager.setEvidenceBridge(bridge);
-	if (!ctx.instrumentationHandlers) ctx.instrumentationHandlers = new InstrumentationHandlers(sessionManager, {
-		hookPresetHandlers,
-		advancedHandlers
-	});
-	return ctx.instrumentationHandlers;
-}
-const manifest = {
-	kind: "domain-manifest",
-	version: 1,
-	domain: DOMAIN,
-	depKey: DEP_KEY,
-	profiles: ["full"],
-	ensure,
-	workflowRule: {
-		patterns: [/(hook|intercept|trace|instrument).*(session|unified|manage|all)/i, /(session|统一|会话).*(hook|拦截|追踪|仪器化|instrument)/i],
-		priority: 95,
-		tools: [
-			"instrumentation_session",
-			"instrumentation_operation",
-			"instrumentation_artifact",
-			"instrumentation_hook_preset",
-			"instrumentation_network_replay"
-		],
-		hint: "Instrumentation session: create session → attach hook presets / network replay → record artifacts → query artifacts → destroy when done"
-	},
-	registrations: [
-		{
-			tool: t("instrumentation_session"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleSessionDispatch(a))
-		},
-		{
-			tool: t("instrumentation_operation"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleOperationDispatch(a))
-		},
-		{
-			tool: t("instrumentation_artifact"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleArtifactDispatch(a))
-		},
-		{
-			tool: t("instrumentation_hook_preset"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleHookPreset(a))
-		},
-		{
-			tool: t("instrumentation_network_replay"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleNetworkReplay(a))
-		}
-	]
-};
-//#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-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 };