@jshookmcp/jshook 0.2.9 → 0.3.0

package/dist/{manifest-BmtZzQiQ2.mjs → manifest-DlbMW4v4.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/macro/definitions.ts
 const macroTools = [tool("run_macro", (t) => t.desc("Execute a registered macro by ID with inline progress and atomic bailout").string("macroId", "Macro ID to execute").prop("inputOverrides", {
 	type: "object",
@@ -14,10 +14,20 @@ const macroTools = [tool("run_macro", (t) => t.desc("Execute a registered macro
 //#region src/server/domains/macro/manifest.ts
 const DOMAIN = "macro";
 const DEP_KEY = "macroHandlers";
-const t = toolLookup(macroTools);
-const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(macroTools),
+	entries: [{
+		tool: "run_macro",
+		method: "handleRunMacro"
+	}, {
+		tool: "list_macros",
+		method: "handleListMacros"
+	}]
+});
 async function ensure(ctx) {
-	const { MacroToolHandlers } = await import("./handlers-U6L4xhuF.mjs");
+	const { MacroToolHandlers } = await import("./handlers-CVv2H1uq.mjs");
 	const existing = ctx.getDomainInstance(DEP_KEY);
 	if (existing) return existing;
 	const handlers = new MacroToolHandlers(ctx);
@@ -31,15 +41,7 @@ const manifest = {
 	depKey: DEP_KEY,
 	profiles: ["full"],
 	ensure,
-	registrations: [{
-		tool: t("run_macro"),
-		domain: DOMAIN,
-		bind: b((h, a) => h.handleRunMacro(a))
-	}, {
-		tool: t("list_macros"),
-		domain: DOMAIN,
-		bind: b((h) => h.handleListMacros())
-	}]
+	registrations
 };
 //#endregion
 export { manifest as default };

package/dist/{manifest-DrbmZcFl2.mjs → manifest-DmVfbH0w.mjs}

@@ -1,42 +1,129 @@
-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 { i as asToolResponse } from "./response-CWhh2aLo.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/protocol-analysis/definitions.ts
 const protocolAnalysisTools = [
-	tool("payload_template_build", (t) => t.desc("Build a binary payload from declarative field definitions.").idempotent()),
-	tool("payload_mutate", (t) => t.desc("Apply deterministic byte-level mutations to a hex payload. Useful for protocol probing, boundary testing, and replay preparation.").string("hexPayload", "Source payload as a hex string").array("mutations", {
+	tool("payload_template_build", (t) => t.desc("Build a deterministic payload from field definitions.").array("fields", {
 		type: "object",
 		properties: {
+			name: {
+				type: "string",
+				description: "Field name"
+			},
+			type: {
+				type: "string",
+				enum: [
+					"u8",
+					"u16",
+					"u32",
+					"i8",
+					"i16",
+					"i32",
+					"string",
+					"bytes"
+				],
+				description: "Field type"
+			},
+			value: { description: "Numeric or string field value" },
+			encoding: {
+				type: "string",
+				enum: [
+					"utf8",
+					"ascii",
+					"hex",
+					"base64"
+				],
+				description: "String/bytes encoding override"
+			},
+			length: {
+				type: "number",
+				description: "Optional fixed length"
+			},
+			padByte: {
+				type: "number",
+				description: "Optional pad byte"
+			}
+		},
+		required: [
+			"name",
+			"type",
+			"value"
+		]
+	}, "Field definitions in output order").enum("endian", ["big", "little"], "Integer byte order", { default: "big" }).required("fields").idempotent()),
+	tool("payload_mutate", (t) => t.desc("Apply deterministic byte-level mutations to a hex payload.").string("hexPayload", "Source payload as a hex string").array("mutations", {
+		type: "object",
+		properties: {
+			strategy: {
+				type: "string",
+				enum: [
+					"set_byte",
+					"flip_bit",
+					"overwrite_bytes",
+					"append_bytes",
+					"truncate",
+					"increment_integer"
+				],
+				description: "Mutation strategy"
+			},
 			offset: {
 				type: "number",
 				description: "Zero-based byte offset"
 			},
-			length: {
+			value: {
 				type: "number",
-				description: "Mutation length in bytes (default: 1, ignored for replace_hex when valueHex is longer)"
+				description: "Byte value for set_byte"
 			},
-			mode: {
+			bit: {
+				type: "number",
+				description: "Bit index for flip_bit"
+			},
+			data: {
+				type: "string",
+				description: "Mutation data for overwrite/append"
+			},
+			encoding: {
 				type: "string",
 				enum: [
-					"zero",
-					"ff",
-					"flip_bits",
-					"increment_u8",
-					"decrement_u8",
-					"replace_hex"
+					"utf8",
+					"ascii",
+					"hex",
+					"base64"
 				],
-				description: "Mutation strategy"
+				description: "Data encoding for overwrite/append"
 			},
-			valueHex: {
+			length: {
+				type: "number",
+				description: "Target length for truncate"
+			},
+			width: {
+				type: "number",
+				enum: [
+					1,
+					2,
+					4
+				],
+				description: "Integer width in bytes"
+			},
+			delta: {
+				type: "number",
+				description: "Increment/decrement delta"
+			},
+			endian: {
 				type: "string",
-				description: "Replacement hex bytes for replace_hex mode"
+				enum: ["big", "little"],
+				description: "Integer byte order"
+			},
+			signed: {
+				type: "boolean",
+				description: "Treat increment target as signed"
 			}
 		},
-		required: ["offset", "mode"]
+		required: ["strategy"]
 	}, "Byte-level mutations to apply in order").required("hexPayload", "mutations")),
 	tool("ethernet_frame_build", (t) => t.desc("Build a deterministic Ethernet II frame from source/destination MAC addresses, EtherType, and payload bytes.").string("destinationMac", "Destination MAC address in colon, dash, dotted, or plain hex form").string("sourceMac", "Source MAC address in colon, dash, dotted, or plain hex form").string("etherType", "EtherType name (arp, ipv4, ipv6, vlan) or a 16-bit hex value such as 0800").string("payloadHex", "Frame payload as a hex string").required("destinationMac", "sourceMac", "etherType", "payloadHex").idempotent()),
 	tool("arp_build", (t) => t.desc("Build a deterministic ARP payload for Ethernet/IPv4 style address resolution packets.").enum("operation", ["request", "reply"], "ARP operation code", { default: "request" }).string("senderMac", "Sender hardware address").string("senderIp", "Sender IPv4 address").string("targetMac", "Target hardware address (use zeros for requests)", { default: "00:00:00:00:00:00" }).string("targetIp", "Target IPv4 address").number("hardwareType", "Hardware type number. Default: 1 (Ethernet)", { default: 1 }).string("protocolType", "Protocol type name (ipv4) or 16-bit hex value. Default: ipv4", { default: "ipv4" }).number("hardwareSize", "Hardware address size in bytes. Default: 6", { default: 6 }).number("protocolSize", "Protocol address size in bytes. Default: 4", { default: 4 }).required("senderMac", "senderIp", "targetIp").idempotent()),
-	tool("raw_ip_packet_build", (t) => t.desc("Build a deterministic raw IPv4 or IPv6 packet header around an existing payload.").string("destinationIp", "Destination IPv4/IPv6 address").string("protocol", "Protocol/next-header name (icmp, tcp, udp, icmpv6) or an 8-bit integer string/hex value").string("payloadHex", "Inner payload as a hex string", { default: "" }).number("ttl", "IPv4 TTL or IPv6 hop limit fallback. Default: 64", { default: 64 }).number("hopLimit", "Explicit IPv6 hop limit override").number("identification", "IPv4 identification field. Default: 0", { default: 0 }).boolean("dontFragment", "Set the IPv4 DF flag", { default: false }).boolean("moreFragments", "Set the IPv4 MF flag", { default: false }).number("fragmentOffset", "IPv4 fragment offset in 8-byte units. Default: 0", { default: 0 }).number("dscp", "IPv4 DSCP or IPv6 traffic-class DSCP value (0-63). Default: 0", { default: 0 }).number("ecn", "IPv4/IPv6 ECN bits (0-3). Default: 0", { default: 0 }).number("flowLabel", "IPv6 flow label (0-1048575). Default: 0", { default: 0 }).required("version", "sourceIp", "destinationIp", "protocol").idempotent()),
+	tool("raw_ip_packet_build", (t) => t.desc("Build a deterministic IPv4 or IPv6 packet.").enum("version", ["ipv4", "ipv6"], "IP version", { default: "ipv4" }).string("sourceIp", "Source IPv4/IPv6 address").string("destinationIp", "Destination IPv4/IPv6 address").string("protocol", "Protocol/next-header name (icmp, tcp, udp, icmpv6) or an 8-bit integer string/hex value").string("payloadHex", "Inner payload as a hex string", { default: "" }).number("ttl", "IPv4 TTL or IPv6 hop limit fallback. Default: 64", { default: 64 }).number("hopLimit", "Explicit IPv6 hop limit override").number("identification", "IPv4 identification field. Default: 0", { default: 0 }).boolean("dontFragment", "Set the IPv4 DF flag", { default: false }).boolean("moreFragments", "Set the IPv4 MF flag", { default: false }).number("fragmentOffset", "IPv4 fragment offset in 8-byte units. Default: 0", { default: 0 }).number("dscp", "IPv4 DSCP or IPv6 traffic-class DSCP value (0-63). Default: 0", { default: 0 }).number("ecn", "IPv4/IPv6 ECN bits (0-3). Default: 0", { default: 0 }).number("flowLabel", "IPv6 flow label (0-1048575). Default: 0", { default: 0 }).required("version", "sourceIp", "destinationIp", "protocol").idempotent()),
 	tool("icmp_echo_build", (t) => t.desc("Build a deterministic ICMPv4 echo request or reply payload with an automatically computed checksum.").enum("operation", ["request", "reply"], "ICMP echo operation", { default: "request" }).number("identifier", "ICMP echo identifier field. Default: 0", { default: 0 }).number("sequenceNumber", "ICMP echo sequence number field. Default: 0", { default: 0 }).string("payloadHex", "Optional ICMP payload as a hex string", { default: "" }).idempotent()),
 	tool("checksum_apply", (t) => t.desc("Apply a deterministic 16-bit Internet checksum across a payload slice, optionally zeroing and writing the checksum field back into the packet.").string("hexPayload", "Source payload as a hex string").number("startOffset", "Inclusive start offset for checksum range. Default: 0", { default: 0 }).number("endOffset", "Exclusive end offset for checksum range. Default: payload length").number("zeroOffset", "Optional checksum field offset to zero before calculation").number("zeroLength", "Checksum field width in bytes when zeroOffset is set. Default: 2", { default: 2 }).number("writeOffset", "Optional destination offset for writing the computed checksum. Defaults to zeroOffset when provided").enum("endian", ["big", "little"], "Byte order used when writing the checksum back", { default: "big" }).required("hexPayload").idempotent()),
 	tool("pcap_write", (t) => t.desc("Write a compact classic PCAP file from deterministic packet byte records.").string("path", "Destination path for the PCAP file").array("packets", {
@@ -66,7 +153,7 @@ const protocolAnalysisTools = [
 		type: "object",
 		description: "Pattern specification object",
 		additionalProperties: true
-	}).required("name", "spec").idempotent()),
+	}).required("spec").idempotent()),
 	tool("proto_auto_detect", (t) => t.desc("Auto-detect a protocol pattern from one or more hex payload samples").array("hexPayloads", { type: "string" }, "Hex payload samples").required("hexPayloads").query()),
 	tool("proto_export_schema", (t) => t.desc("Export a protocol pattern to a .proto-like schema definition").string("patternId", "Pattern ID to export").required("patternId").query()),
 	tool("proto_infer_fields", (t) => t.desc("Infer likely protocol fields from repeated hex payload samples").array("hexPayloads", { type: "string" }, "Hex payload samples").required("hexPayloads").query()),
@@ -103,106 +190,101 @@ const protocolAnalysisTools = [
 		type: "object",
 		description: "State machine definition with states and transitions",
 		additionalProperties: true
-	}).query())
+	}).query()),
+	tool("proto_fingerprint", (t) => t.desc("Identify protocol type from hex payload samples (TLS, HTTP, DNS, WebSocket, SSH).").array("hexPayloads", { type: "string" }, "Hex payload samples to fingerprint").boolean("includeKnownProtocols", "Match against known protocol signatures", { default: true }).boolean("includeFieldHints", "Suggest likely field boundaries", { default: true }).required("hexPayloads").query())
 ];
 //#endregion
 //#region src/server/domains/protocol-analysis/manifest.ts
 const DOMAIN = "protocol-analysis";
 const DEP_KEY = "protocolAnalysisHandlers";
-const t = toolLookup(protocolAnalysisTools);
-const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
-async function ensure(ctx) {
-	const { ProtocolAnalysisHandlers } = await import("./handlers-D6j6yka7.mjs");
-	const existing = ctx.getDomainInstance(DEP_KEY);
-	if (existing) return existing;
-	const handlers = new ProtocolAnalysisHandlers(void 0, void 0, ctx.eventBus);
-	ctx.setDomainInstance(DEP_KEY, handlers);
-	return handlers;
-}
-const manifest = {
-	kind: "domain-manifest",
-	version: 1,
+const registrations = defineMethodRegistrations({
 	domain: DOMAIN,
 	depKey: DEP_KEY,
-	profiles: ["full"],
-	ensure,
-	registrations: [
+	lookup: toolLookup(protocolAnalysisTools),
+	wrapResult: asToolResponse,
+	entries: [
 		{
-			tool: t("proto_define_pattern"),
-			domain: DOMAIN,
-			bind: b((handlers, args) => handlers.handleDefinePattern(args))
+			tool: "proto_define_pattern",
+			method: "handleDefinePattern"
 		},
 		{
-			tool: t("proto_auto_detect"),
-			domain: DOMAIN,
-			bind: b((handlers, args) => handlers.handleAutoDetect(args))
+			tool: "proto_auto_detect",
+			method: "handleAutoDetect"
 		},
 		{
-			tool: t("proto_infer_fields"),
-			domain: DOMAIN,
-			bind: b((handlers, args) => handlers.handleInferFields(args))
+			tool: "proto_infer_fields",
+			method: "handleInferFields"
 		},
 		{
-			tool: t("proto_infer_state_machine"),
-			domain: DOMAIN,
-			bind: b((handlers, args) => handlers.handleInferStateMachine(args))
+			tool: "proto_infer_state_machine",
+			method: "handleInferStateMachine"
 		},
 		{
-			tool: t("proto_export_schema"),
-			domain: DOMAIN,
-			bind: b((handlers, args) => handlers.handleExportSchema(args))
+			tool: "proto_export_schema",
+			method: "handleExportSchema"
 		},
 		{
-			tool: t("proto_visualize_state"),
-			domain: DOMAIN,
-			bind: b((handlers, args) => handlers.handleVisualizeState(args))
+			tool: "proto_visualize_state",
+			method: "handleVisualizeState"
 		},
 		{
-			tool: t("payload_template_build"),
-			domain: DOMAIN,
-			bind: b((handlers, args) => handlers.handlePayloadTemplateBuild(args))
+			tool: "payload_template_build",
+			method: "handlePayloadTemplateBuild"
 		},
 		{
-			tool: t("payload_mutate"),
-			domain: DOMAIN,
-			bind: b((handlers, args) => handlers.handlePayloadMutate(args))
+			tool: "payload_mutate",
+			method: "handlePayloadMutate"
 		},
 		{
-			tool: t("ethernet_frame_build"),
-			domain: DOMAIN,
-			bind: b((handlers, args) => handlers.handleEthernetFrameBuild(args))
+			tool: "ethernet_frame_build",
+			method: "handleEthernetFrameBuild"
 		},
 		{
-			tool: t("arp_build"),
-			domain: DOMAIN,
-			bind: b((handlers, args) => handlers.handleArpBuild(args))
+			tool: "arp_build",
+			method: "handleArpBuild"
 		},
 		{
-			tool: t("raw_ip_packet_build"),
-			domain: DOMAIN,
-			bind: b((handlers, args) => handlers.handleRawIpPacketBuild(args))
+			tool: "raw_ip_packet_build",
+			method: "handleRawIpPacketBuild"
 		},
 		{
-			tool: t("icmp_echo_build"),
-			domain: DOMAIN,
-			bind: b((handlers, args) => handlers.handleIcmpEchoBuild(args))
+			tool: "icmp_echo_build",
+			method: "handleIcmpEchoBuild"
 		},
 		{
-			tool: t("checksum_apply"),
-			domain: DOMAIN,
-			bind: b((handlers, args) => handlers.handleChecksumApply(args))
+			tool: "checksum_apply",
+			method: "handleChecksumApply"
 		},
 		{
-			tool: t("pcap_write"),
-			domain: DOMAIN,
-			bind: b((handlers, args) => handlers.handlePcapWrite(args))
+			tool: "pcap_write",
+			method: "handlePcapWrite"
 		},
 		{
-			tool: t("pcap_read"),
-			domain: DOMAIN,
-			bind: b((handlers, args) => handlers.handlePcapRead(args))
+			tool: "pcap_read",
+			method: "handlePcapRead"
+		},
+		{
+			tool: "proto_fingerprint",
+			method: "handleProtoFingerprint"
 		}
-	],
+	]
+});
+async function ensure(ctx) {
+	const { ProtocolAnalysisHandlers } = await import("./handlers-Dx2d7jt7.mjs");
+	const existing = ctx.getDomainInstance(DEP_KEY);
+	if (existing) return existing;
+	const handlers = new ProtocolAnalysisHandlers(void 0, void 0, ctx.eventBus);
+	ctx.setDomainInstance(DEP_KEY, handlers);
+	return handlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	registrations,
 	prerequisites: {
 		proto_auto_detect: [{
 			condition: "At least one hex payload sample is required",
@@ -220,10 +302,16 @@ const manifest = {
 			/infer\s+(protocol|fields|state\s*machine)/i,
 			/proto.*export|proto.*schema|proto.*diagram/i,
 			/payload\s+(template|build|mutate)|packet\s+(template|mutate)/i,
-			/ethernet|arp|ipv4|ipv6|pcap|internet\s+checksum|raw\s+packet/i
+			/ethernet|arp|ipv4|ipv6|pcap|internet\s+checksum|raw\s+packet/i,
+			/(decode|payload|bytes?|hex|protobuf|msgpack).*(protocol|field|state\s*machine)/i,
+			/(base64|hex|protobuf|msgpack).*(payload|protocol|field|decode)/i,
+			/(crypto\s*harness|checksum|payload\s+rebuild|payload\s+template).*(protocol|payload|decode)/i,
+			/(无状态|纯算|确定性|解码|载荷|字节|报文).*(协议|字段|状态机)/i
 		],
 		priority: .6,
 		tools: [
+			"binary_detect_format",
+			"binary_decode",
 			"proto_auto_detect",
 			"proto_infer_fields",
 			"proto_define_pattern",
@@ -232,22 +320,55 @@ const manifest = {
 			"proto_visualize_state",
 			"payload_template_build",
 			"payload_mutate",
+			"checksum_apply",
+			"crypto_test_harness",
 			"ethernet_frame_build",
 			"arp_build",
 			"raw_ip_packet_build",
 			"icmp_echo_build",
-			"checksum_apply",
 			"pcap_write",
 			"pcap_read"
 		],
 		hint: "Capture or craft packet bytes -> build Ethernet/ARP/IP/ICMP headers -> apply deterministic checksums and payload mutations -> read/write compact PCAP files -> infer fields or state machines from resulting payloads"
 	},
-	toolDependencies: [{
-		from: "network",
-		to: "protocol-analysis",
-		relation: "uses",
-		weight: .7
-	}]
+	toolDependencies: [
+		{
+			from: "network_get_requests",
+			to: "binary_decode",
+			relation: "suggests",
+			weight: .9
+		},
+		{
+			from: "binary_decode",
+			to: "proto_auto_detect",
+			relation: "precedes",
+			weight: .95
+		},
+		{
+			from: "proto_auto_detect",
+			to: "proto_infer_fields",
+			relation: "precedes",
+			weight: .95
+		},
+		{
+			from: "proto_infer_fields",
+			to: "proto_infer_state_machine",
+			relation: "precedes",
+			weight: .9
+		},
+		{
+			from: "detect_crypto",
+			to: "crypto_test_harness",
+			relation: "suggests",
+			weight: .8
+		},
+		{
+			from: "network",
+			to: "protocol-analysis",
+			relation: "uses",
+			weight: .7
+		}
+	]
 };
 //#endregion
 export { manifest as default };

package/dist/manifest-Dog6Ddjr.mjs

@@ -0,0 +1,109 @@
+import { n as toolLookup, t as ensureBrowserCore } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { t as debuggerTools } from "./definitions-BbkvZkiv.mjs";
+//#region src/server/domains/debugger/manifest.ts
+const DOMAIN = "debugger";
+const DEP_KEY = "debuggerHandlers";
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(debuggerTools),
+	entries: [
+		{
+			tool: "debugger_lifecycle",
+			method: "handleDebuggerLifecycle"
+		},
+		{
+			tool: "debugger_pause",
+			method: "handleDebuggerPause"
+		},
+		{
+			tool: "debugger_resume",
+			method: "handleDebuggerResume"
+		},
+		{
+			tool: "debugger_step",
+			method: "handleDebuggerStep"
+		},
+		{
+			tool: "breakpoint",
+			method: "handleBreakpoint"
+		},
+		{
+			tool: "get_call_stack",
+			method: "handleGetCallStack"
+		},
+		{
+			tool: "debugger_evaluate",
+			method: "handleDebuggerEvaluateDispatch"
+		},
+		{
+			tool: "debugger_wait_for_paused",
+			method: "handleDebuggerWaitForPaused"
+		},
+		{
+			tool: "debugger_get_paused_state",
+			method: "handleDebuggerGetPausedState"
+		},
+		{
+			tool: "get_object_properties",
+			method: "handleGetObjectProperties"
+		},
+		{
+			tool: "get_scope_variables_enhanced",
+			method: "handleGetScopeVariablesEnhanced"
+		},
+		{
+			tool: "debugger_session",
+			method: "handleDebuggerSession"
+		},
+		{
+			tool: "watch",
+			method: "handleWatch"
+		},
+		{
+			tool: "blackbox_add",
+			method: "handleBlackboxAdd"
+		},
+		{
+			tool: "blackbox_add_common",
+			method: "handleBlackboxAddCommon"
+		},
+		{
+			tool: "blackbox_list",
+			method: "handleBlackboxList"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { DebuggerManager, RuntimeInspector } = await import("./modules-tZozf0LQ.mjs").then((n) => n.t);
+	const { DebuggerToolHandlers } = await import("./debugger-RS3RSAqs.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
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-DvgU5FWb.mjs

@@ -0,0 +1,58 @@
+import { n as toolLookup } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { t as graphqlTools } from "./definitions-Pp5LI2H4.mjs";
+//#region src/server/domains/graphql/manifest.ts
+const DOMAIN = "graphql";
+const DEP_KEY = "graphqlHandlers";
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(graphqlTools),
+	entries: [
+		{
+			tool: "call_graph_analyze",
+			method: "handleCallGraphAnalyze"
+		},
+		{
+			tool: "script_replace_persist",
+			method: "handleScriptReplacePersist"
+		},
+		{
+			tool: "graphql_introspect",
+			method: "handleGraphqlIntrospect"
+		},
+		{
+			tool: "graphql_extract_queries",
+			method: "handleGraphqlExtractQueries"
+		},
+		{
+			tool: "graphql_replay",
+			method: "handleGraphqlReplay"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { CodeCollector, ConsoleMonitor } = await import("./modules-tZozf0LQ.mjs").then((n) => n.t);
+	const { GraphQLToolHandlers } = await import("./graphql-CoHrhweh.mjs");
+	if (!ctx.collector) {
+		ctx.collector = new CodeCollector(ctx.config.puppeteer);
+		ctx.registerCaches();
+	}
+	if (!ctx.consoleMonitor) ctx.consoleMonitor = new ConsoleMonitor(ctx.collector);
+	if (!ctx.graphqlHandlers) ctx.graphqlHandlers = new GraphQLToolHandlers({
+		collector: ctx.collector,
+		consoleMonitor: ctx.consoleMonitor
+	});
+	return ctx.graphqlHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["workflow", "full"],
+	ensure,
+	registrations
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-HsfDBs7j.mjs

@@ -0,0 +1,50 @@
+import { n as toolLookup } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { t as sourcemapTools } from "./definitions-DAgIyjxM.mjs";
+//#region src/server/domains/sourcemap/manifest.ts
+const DOMAIN = "sourcemap";
+const DEP_KEY = "sourcemapHandlers";
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(sourcemapTools),
+	entries: [
+		{
+			tool: "sourcemap_discover",
+			method: "handleSourcemapDiscover"
+		},
+		{
+			tool: "sourcemap_fetch_and_parse",
+			method: "handleSourcemapFetchAndParse"
+		},
+		{
+			tool: "sourcemap_reconstruct_tree",
+			method: "handleSourcemapReconstructTree"
+		},
+		{
+			tool: "sourcemap_parse_v4",
+			method: "handleSourcemapParseV4"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { CodeCollector } = await import("./modules-tZozf0LQ.mjs").then((n) => n.t);
+	const { SourcemapToolHandlers } = await import("./sourcemap-BIDHUVXy.mjs");
+	if (!ctx.collector) {
+		ctx.collector = new CodeCollector(ctx.config.puppeteer);
+		ctx.registerCaches();
+	}
+	if (!ctx.sourcemapHandlers) ctx.sourcemapHandlers = new SourcemapToolHandlers(ctx.collector);
+	return ctx.sourcemapHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	registrations
+};
+//#endregion
+export { manifest as default };