@jshookmcp/jshook 0.3.0 → 0.3.2

package/dist/manifest-Bv65_e2W.mjs

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

@@ -1,117 +0,0 @@
-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-C-xtsjS3.mjs

@@ -1,81 +0,0 @@
-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")),
-	tool("adb_webview_list", (t) => t.desc("List debuggable WebView targets via ADB port forwarding to Chrome DevTools.").string("serial", "Required. Android device serial or emulator id.").number("hostPort", "Optional. Local port to use for forwarding.", { default: 9222 }).requiredOpenWorld("serial")),
-	tool("adb_webview_attach", (t) => t.desc("Attach to a WebView via ADB port forwarding; returns WebSocket debugger URL for CDP.").string("serial", "Required. Android device serial or emulator id.").string("targetId", "Required. WebView target id returned by adb_webview_list.").number("hostPort", "Optional. Local port to use for forwarding.", { default: 9222 }).requiredOpenWorld("serial", "targetId"))
-];
-//#endregion
-//#region src/server/domains/adb-bridge/manifest.ts
-const DOMAIN = "adb-bridge";
-const DEP_KEY = "adbBridgeHandlers";
-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-Dl5a7JS4.mjs");
-	const existingHandlers = ctx.getDomainInstance(DEP_KEY);
-	if (existingHandlers) return existingHandlers;
-	const handlers = new ADBBridgeHandlers();
-	ctx.setDomainInstance(DEP_KEY, handlers);
-	return handlers;
-}
-const manifest = {
-	kind: "domain-manifest",
-	version: 1,
-	domain: DOMAIN,
-	depKey: DEP_KEY,
-	profiles: ["full"],
-	registrations,
-	ensure,
-	workflowRule: {
-		patterns: [/(android|adb|mobile|apk|device).*(list|shell|pull|analyze|dump)/i, /(adb|android).*(webview|chrome|debug|cdp|inspect)/i],
-		priority: 75,
-		tools: [
-			"adb_apk_analyze",
-			"adb_webview_list",
-			"adb_webview_attach"
-		],
-		hint: "Android/ADB: list devices → run shell commands → pull/analyze APK → debug WebViews via CDP"
-	},
-	prerequisites: {
-		"*": [{
-			condition: "ADB server binary must be in PATH",
-			fix: "Install Android Platform Tools: https://developer.android.com/studio/command-line/adb"
-		}],
-		adb_webview_list: [{
-			condition: "App must have android:debuggable=\"true\"",
-			fix: "Use a debug build of the Android app"
-		}],
-		adb_webview_attach: [{
-			condition: "App must have android:debuggable=\"true\"",
-			fix: "Use a debug build of the Android app"
-		}]
-	},
-	toolDependencies: [{
-		from: "browser",
-		to: "adb-bridge",
-		relation: "uses",
-		weight: .7
-	}]
-};
-//#endregion
-export { manifest as default };

package/dist/manifest-CDYl7OhA.mjs

@@ -1,66 +0,0 @@
-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 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-BpuKEtvn.mjs");
-	await ensureBrowserCore(ctx);
-	const browserHandlers = ctx.handlerDeps.browserHandlers;
-	const advancedHandlers = ctx.handlerDeps.advancedHandlers;
-	if (!ctx.workflowHandlers) ctx.workflowHandlers = new WorkflowHandlers({
-		browserHandlers,
-		advancedHandlers,
-		serverContext: ctx
-	});
-	return ctx.workflowHandlers;
-}
-const manifest = {
-	kind: "domain-manifest",
-	version: 1,
-	domain: DOMAIN,
-	depKey: DEP_KEY,
-	profiles: ["workflow", "full"],
-	ensure,
-	workflowRule: {
-		patterns: [/(workflow|extension|run)/i, /(工作流|扩展|运行)/i],
-		priority: 95,
-		tools: ["run_extension_workflow", "list_extension_workflows"],
-		hint: "Extension workflow: list available workflows -> run the best matching workflow"
-	},
-	registrations
-};
-//#endregion
-export { manifest as default };

package/dist/manifest-CRZ3xmkD.mjs

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

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

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