@jshookmcp/jshook 0.2.9 → 0.3.0

package/dist/manifest-Bv65_e2W.mjs

@@ -0,0 +1,101 @@
+import { n as toolLookup } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { t as processToolDefinitions } from "./definitions-DJA27nsL.mjs";
+//#region src/server/domains/process/manifest.ts
+const DOMAIN = "process";
+const DEP_KEY = "processHandlers";
+const t = toolLookup(processToolDefinitions);
+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-BTbgcVc6.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 = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: t,
+	entries: [
+		{
+			tool: "electron_attach",
+			method: "handleElectronAttach"
+		},
+		{
+			tool: "process_windows",
+			method: "handleProcessWindows"
+		},
+		{
+			tool: "process_check_debug_port",
+			method: "handleProcessCheckDebugPort"
+		},
+		{
+			tool: "process_launch_debug",
+			method: "handleProcessLaunchDebug"
+		},
+		{
+			tool: "memory_read",
+			method: "handleMemoryRead"
+		},
+		{
+			tool: "memory_write",
+			method: "handleMemoryWrite"
+		},
+		{
+			tool: "memory_scan",
+			method: "handleMemoryScan"
+		},
+		{
+			tool: "memory_check_protection",
+			method: "handleMemoryCheckProtection"
+		},
+		{
+			tool: "memory_scan_filtered",
+			method: "handleMemoryScanFiltered"
+		},
+		{
+			tool: "memory_batch_write",
+			method: "handleMemoryBatchWrite"
+		},
+		{
+			tool: "memory_dump_region",
+			method: "handleMemoryDumpRegion"
+		},
+		{
+			tool: "memory_list_regions",
+			method: "handleMemoryListRegions"
+		},
+		{
+			tool: "memory_audit_export",
+			method: "handleMemoryAuditExport"
+		},
+		{
+			tool: "inject_dll",
+			method: "handleInjectDll"
+		},
+		{
+			tool: "inject_shellcode",
+			method: "handleInjectShellcode"
+		},
+		{
+			tool: "check_debug_port",
+			method: "handleCheckDebugPort"
+		},
+		{
+			tool: "enumerate_modules",
+			method: "handleEnumerateModules"
+		}
+	]
+});
+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-BytNIF4Z.mjs

@@ -0,0 +1,117 @@
+import { n as toolLookup } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { t as tool } from "./tool-builder-BHJp32mV.mjs";
+import { t as networkAuthorizationSchema } from "./authorization-schema-DRqyJMSk.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.").enum("action", [
+		"create",
+		"list",
+		"destroy",
+		"status"
+	], "Session operation").string("name", "Optional session name for create").string("sessionId", "Session ID (required for destroy/status)").required("action")),
+	tool("instrumentation_operation", (t) => t.desc("Manage operations inside an instrumentation session.").enum("action", ["register", "list"], "Operation").string("sessionId", "Session ID").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 artifacts captured by instrumentation operations.").enum("action", ["record", "query"], "Artifact operation").string("sessionId", "Session ID").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 hook presets inside an instrumentation session.").string("sessionId", "Session ID").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 captured network request inside an instrumentation session.").string("sessionId", "Session ID").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").object("authorization", networkAuthorizationSchema, "Optional request-scoped authorization for private-network or insecure-HTTP replay.").string("authorizationCapability", "Optional base64url-encoded request-scoped authorization capability.").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 registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(instrumentationTools),
+	entries: [
+		{
+			tool: "instrumentation_session",
+			method: "handleSessionDispatch"
+		},
+		{
+			tool: "instrumentation_operation",
+			method: "handleOperationDispatch"
+		},
+		{
+			tool: "instrumentation_artifact",
+			method: "handleArtifactDispatch"
+		},
+		{
+			tool: "instrumentation_hook_preset",
+			method: "handleHookPreset"
+		},
+		{
+			tool: "instrumentation_network_replay",
+			method: "handleNetworkReplay"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { ReverseEvidenceGraph } = await import("./ReverseEvidenceGraph-C02-gXOh.mjs").then((n) => n.t);
+	const { InstrumentationSessionManager } = await import("./InstrumentationSession-DLH0vd-z.mjs");
+	const { EvidenceGraphBridge } = await import("./EvidenceGraphBridge-318Oi0Lf.mjs");
+	const { InstrumentationHandlers } = await import("./handlers-BtYq60bM2.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
+};
+//#endregion
+export { manifest as default };

package/dist/{manifest-BqrQ4Tpj.mjs → manifest-C-xtsjS3.mjs}

@@ -1,6 +1,6 @@
-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";
+import { n as toolLookup } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { t as tool } from "./tool-builder-BHJp32mV.mjs";
 //#region src/server/domains/adb-bridge/definitions.ts
 const adbBridgeTools = [
 	tool("adb_apk_analyze", (t) => t.desc("Analyze an installed APK — package name, version, permissions, activities, se...").string("serial", "Required. Android device serial or emulator id.").string("packageName", "Required. Android package name, for example com.example.app.").requiredOpenWorld("serial", "packageName")),
@@ -11,27 +11,27 @@ const adbBridgeTools = [
 //#region src/server/domains/adb-bridge/manifest.ts
 const DOMAIN = "adb-bridge";
 const DEP_KEY = "adbBridgeHandlers";
-const toolByName = toolLookup(adbBridgeTools);
-const bind = (invoke) => bindByDepKey(DEP_KEY, invoke);
-const registrations = [
-	{
-		tool: toolByName("adb_apk_analyze"),
-		domain: DOMAIN,
-		bind: bind((handlers, args) => handlers.handleAnalyzeApk(args))
-	},
-	{
-		tool: toolByName("adb_webview_list"),
-		domain: DOMAIN,
-		bind: bind((handlers, args) => handlers.handleWebViewList(args))
-	},
-	{
-		tool: toolByName("adb_webview_attach"),
-		domain: DOMAIN,
-		bind: bind((handlers, args) => handlers.handleWebViewAttach(args))
-	}
-];
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(adbBridgeTools),
+	entries: [
+		{
+			tool: "adb_apk_analyze",
+			method: "handleAnalyzeApk"
+		},
+		{
+			tool: "adb_webview_list",
+			method: "handleWebViewList"
+		},
+		{
+			tool: "adb_webview_attach",
+			method: "handleWebViewAttach"
+		}
+	]
+});
 async function ensure(ctx) {
-	const { ADBBridgeHandlers } = await import("./handlers-tiy7EIBp.mjs");
+	const { ADBBridgeHandlers } = await import("./handlers-Dl5a7JS4.mjs");
 	const existingHandlers = ctx.getDomainInstance(DEP_KEY);
 	if (existingHandlers) return existingHandlers;
 	const handlers = new ADBBridgeHandlers();

package/dist/{manifest-NXctwWQq.mjs → manifest-CDYl7OhA.mjs}

@@ -1,13 +1,42 @@
-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 workflowToolDefinitions } from "./definitions-Cke7zEb8.mjs";
+import { n as toolLookup, t as ensureBrowserCore } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { t as workflowToolDefinitions } from "./definitions-Cea8Lgl7.mjs";
 //#region src/server/domains/workflow/manifest.ts
 const DOMAIN = "workflow";
 const DEP_KEY = "workflowHandlers";
-const t = toolLookup(workflowToolDefinitions);
-const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(workflowToolDefinitions),
+	entries: [
+		{
+			tool: "page_script_register",
+			method: "handlePageScriptRegister"
+		},
+		{
+			tool: "page_script_run",
+			method: "handlePageScriptRun"
+		},
+		{
+			tool: "api_probe_batch",
+			method: "handleApiProbeBatch"
+		},
+		{
+			tool: "js_bundle_search",
+			method: "handleJsBundleSearch"
+		},
+		{
+			tool: "list_extension_workflows",
+			method: "handleListExtensionWorkflows"
+		},
+		{
+			tool: "run_extension_workflow",
+			method: "handleRunExtensionWorkflow"
+		}
+	]
+});
 async function ensure(ctx) {
-	const { WorkflowHandlers } = await import("./workflow-f3xJOcjx.mjs");
+	const { WorkflowHandlers } = await import("./workflow-BpuKEtvn.mjs");
 	await ensureBrowserCore(ctx);
 	const browserHandlers = ctx.handlerDeps.browserHandlers;
 	const advancedHandlers = ctx.handlerDeps.advancedHandlers;
@@ -31,38 +60,7 @@ const manifest = {
 		tools: ["run_extension_workflow", "list_extension_workflows"],
 		hint: "Extension workflow: list available workflows -> run the best matching workflow"
 	},
-	registrations: [
-		{
-			tool: t("page_script_register"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handlePageScriptRegister(a))
-		},
-		{
-			tool: t("page_script_run"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handlePageScriptRun(a))
-		},
-		{
-			tool: t("api_probe_batch"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleApiProbeBatch(a))
-		},
-		{
-			tool: t("js_bundle_search"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleJsBundleSearch(a))
-		},
-		{
-			tool: t("list_extension_workflows"),
-			domain: DOMAIN,
-			bind: b((h) => h.handleListExtensionWorkflows())
-		},
-		{
-			tool: t("run_extension_workflow"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleRunExtensionWorkflow(a))
-		}
-	]
+	registrations
 };
 //#endregion
 export { manifest as default };

package/dist/manifest-CRZ3xmkD.mjs

@@ -0,0 +1,61 @@
+import { n as toolLookup } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { t as PROXY_TOOLS } from "./definitions-j9KdHVNR.mjs";
+//#region src/server/domains/proxy/manifest.ts
+const DOMAIN = "proxy";
+const DEP_KEY = "proxyHandlers";
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(PROXY_TOOLS),
+	entries: [
+		{
+			tool: "proxy_start",
+			method: "handleProxyStart"
+		},
+		{
+			tool: "proxy_stop",
+			method: "handleProxyStop"
+		},
+		{
+			tool: "proxy_status",
+			method: "handleProxyStatus"
+		},
+		{
+			tool: "proxy_export_ca",
+			method: "handleProxyExportCa"
+		},
+		{
+			tool: "proxy_add_rule",
+			method: "handleProxyAddRule"
+		},
+		{
+			tool: "proxy_get_requests",
+			method: "handleProxyGetRequests"
+		},
+		{
+			tool: "proxy_clear_logs",
+			method: "handleProxyClearLogs"
+		},
+		{
+			tool: "proxy_setup_adb_device",
+			method: "handleProxySetupAdbDevice"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { ProxyHandlers } = await import("./proxy-r8YN6nP1.mjs");
+	if (!ctx.proxyHandlers) ctx.proxyHandlers = new ProxyHandlers();
+	return ctx.proxyHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	registrations
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-CoW6u4Tp.mjs

@@ -0,0 +1,132 @@
+import { n as toolLookup } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { t as tool } from "./tool-builder-BHJp32mV.mjs";
+//#region src/server/domains/trace/definitions.tools.ts
+const TRACE_TOOLS = [
+	tool("trace_recording", (t) => t.desc("Start or stop trace recording into a SQLite database.").enum("action", ["start", "stop"], "Recording action").array("cdpDomains", { type: "string" }, "CDP domains to record (default: Debugger, Runtime, Network, Page)").boolean("recordMemoryDeltas", "Record memory write deltas", { default: true }).boolean("recordResponseBodies", "Persist response bodies when available.", { default: true }).boolean("streamResponseChunks", "Capture response chunks when the browser supports it.", { default: true }).number("networkBodyMaxBytes", "Maximum response body bytes to persist per request", {
+		default: 10485760,
+		minimum: 1024,
+		maximum: 104857600
+	}).number("networkInlineBodyBytes", "Bodies up to this size are stored inline in SQLite; larger ones go to artifacts", {
+		default: 262144,
+		minimum: 1024,
+		maximum: 10485760
+	}).required("action").idempotent()),
+	tool("start_trace_recording", (t) => t.desc("Start trace recording into a SQLite database.").array("cdpDomains", { type: "string" }, "CDP domains to record (default: Debugger, Runtime, Network, Page)").boolean("recordMemoryDeltas", "Record memory write deltas", { default: true }).boolean("recordResponseBodies", "Persist response bodies when available.", { default: true }).boolean("streamResponseChunks", "Capture response chunks when the browser supports it.", { default: true }).number("networkBodyMaxBytes", "Maximum response body bytes to persist per request", {
+		default: 10485760,
+		minimum: 1024,
+		maximum: 104857600
+	}).number("networkInlineBodyBytes", "Bodies up to this size are stored inline in SQLite; larger ones go to artifacts", {
+		default: 262144,
+		minimum: 1024,
+		maximum: 10485760
+	}).idempotent()),
+	tool("stop_trace_recording", (t) => t.desc("Stop trace recording and return the final session summary.").idempotent()),
+	tool("query_trace_sql", (t) => t.desc("Execute a read-only SQL query against a trace database.").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 trace state at a specific timestamp.").number("timestamp", "Target timestamp in milliseconds").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 }).enum("timeDomain", ["wall", "monotonic"], "Interpret timestamp using wall or monotonic time", { default: "wall" }).required("timestamp").query()),
+	tool("trace_get_network_flow", (t) => t.desc("Get a recorded request-scoped network flow from a trace.").string("requestId", "Network requestId to retrieve from the trace").string("dbPath", "Path to trace DB file. Uses the active recording if omitted.").boolean("includeBody", "Include persisted response body metadata/content when available", { default: true }).boolean("includeChunks", "Include recorded response chunk timing data", { default: true }).boolean("includeEvents", "Include related network events from the trace", { default: true }).number("chunkLimit", "Maximum number of chunks to return", {
+		default: 200,
+		minimum: 1,
+		maximum: 5e3
+	}).number("maxBodyBytes", "Maximum response body bytes to inline before summarizing", {
+		default: 1e5,
+		minimum: 1024,
+		maximum: 52428800
+	}).boolean("returnSummary", "Return body summary even when body is within maxBodyBytes", { default: false }).required("requestId").query()),
+	tool("diff_heap_snapshots", (t) => t.desc("Compare two heap snapshots from a trace.").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.").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 summary of a trace database.").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 registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(TRACE_TOOLS),
+	entries: [
+		{
+			tool: "trace_recording",
+			method: "handleTraceRecording"
+		},
+		{
+			tool: "start_trace_recording",
+			method: "handleStartTraceRecording"
+		},
+		{
+			tool: "stop_trace_recording",
+			method: "handleStopTraceRecording"
+		},
+		{
+			tool: "query_trace_sql",
+			method: "handleQueryTraceSql"
+		},
+		{
+			tool: "seek_to_timestamp",
+			method: "handleSeekToTimestamp"
+		},
+		{
+			tool: "trace_get_network_flow",
+			method: "handleGetTraceNetworkFlow"
+		},
+		{
+			tool: "diff_heap_snapshots",
+			method: "handleDiffHeapSnapshots"
+		},
+		{
+			tool: "export_trace",
+			method: "handleExportTrace"
+		},
+		{
+			tool: "summarize_trace",
+			method: "handleSummarizeTrace"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { TraceRecorder } = await import("./TraceRecorder-B41Z5XBj.mjs");
+	const { TraceToolHandlers } = await import("./handlers-HujRKC3b.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",
+			"start_trace_recording",
+			"stop_trace_recording",
+			"query_trace_sql",
+			"seek_to_timestamp",
+			"trace_get_network_flow",
+			"diff_heap_snapshots",
+			"export_trace",
+			"summarize_trace"
+		],
+		hint: "Start recording → perform actions → stop recording → summarize/query/seek/diff/export"
+	},
+	registrations
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-Cq5zN_8A.mjs

@@ -0,0 +1,50 @@
+import { n as toolLookup, t as ensureBrowserCore } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { t as encodingTools } from "./definitions-DPRpZQ96.mjs";
+//#region src/server/domains/encoding/manifest.ts
+const DOMAIN = "encoding";
+const DEP_KEY = "encodingHandlers";
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(encodingTools),
+	entries: [
+		{
+			tool: "binary_detect_format",
+			method: "handleBinaryDetectFormat"
+		},
+		{
+			tool: "binary_decode",
+			method: "handleBinaryDecode"
+		},
+		{
+			tool: "binary_encode",
+			method: "handleBinaryEncode"
+		},
+		{
+			tool: "binary_entropy_analysis",
+			method: "handleBinaryEntropyAnalysis"
+		},
+		{
+			tool: "protobuf_decode_raw",
+			method: "handleProtobufDecodeRaw"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { EncodingToolHandlers } = await import("./encoding-DJeqHmpd.mjs");
+	await ensureBrowserCore(ctx);
+	if (!ctx.encodingHandlers) ctx.encodingHandlers = new EncodingToolHandlers(ctx.collector, async (requestId) => ctx.consoleMonitor?.getResponseBody(requestId) ?? null);
+	return ctx.encodingHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["workflow", "full"],
+	ensure,
+	registrations
+};
+//#endregion
+export { manifest as default };