@jshookmcp/jshook 0.2.9 → 0.3.0

package/dist/definitions-uzkjBwa7.mjs

@@ -0,0 +1,258 @@
+import { t as tool } from "./tool-builder-BHJp32mV.mjs";
+import { t as networkAuthorizationSchema } from "./authorization-schema-DRqyJMSk.mjs";
+//#region src/server/domains/network/definitions/analysis-tools.ts
+const analysisTools = [
+	tool("network_extract_auth", (t) => t.desc("Extract authentication data from captured network requests.").number("minConfidence", "Minimum confidence threshold 0-1", {
+		default: .4,
+		minimum: 0,
+		maximum: 1
+	})),
+	tool("network_export_har", (t) => t.desc("Export captured network traffic as HAR.").string("outputPath", "File path to write the HAR file. If omitted, returns HAR as JSON.").boolean("includeBodies", "Include response bodies in the HAR (may be slow for large captures). Default: false", { default: false }).openWorld()),
+	tool("network_replay_request", (t) => t.desc("Replay a captured network request with optional changes.").string("requestId", "Request ID from network_get_requests to replay").object("headerPatch", { additionalProperties: { type: "string" } }, "Headers to add or override (key-value pairs)").object("sessionProfile", {
+		cookies: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					value: { type: "string" },
+					domain: { type: "string" },
+					path: { type: "string" },
+					expires: { type: "number" },
+					httpOnly: { type: "boolean" },
+					secure: { type: "boolean" },
+					sameSite: {
+						type: "string",
+						enum: [
+							"Strict",
+							"Lax",
+							"None"
+						]
+					}
+				},
+				required: ["name", "value"]
+			}
+		},
+		userAgent: { type: "string" },
+		acceptLanguage: { type: "string" },
+		referer: { type: "string" },
+		clientHints: {
+			type: "object",
+			properties: {
+				"sec-ch-ua": { type: "string" },
+				"sec-ch-ua-mobile": { type: "string" },
+				"sec-ch-ua-platform": { type: "string" },
+				"sec-ch-ua-full-version-list": { type: "string" }
+			}
+		},
+		platform: { type: "string" },
+		origin: { type: "string" },
+		collectedAt: { type: "number" },
+		ttlSec: { type: "number" }
+	}, "Inject browser cookies, User-Agent and Accept-Language from a captured session into the replay.").string("bodyPatch", "Replace the entire request body with this string").string("methodOverride", "Override the HTTP method").string("urlOverride", "Override the request URL").object("authorization", networkAuthorizationSchema, "Request-scoped authorization policy for private-network or insecure-HTTP replay. Use exact hosts/CIDRs instead of process-wide bypasses.").string("authorizationCapability", "Base64url-encoded JSON capability for request-scoped authorization. Payload fields mirror authorization and must include requestId.").number("timeoutMs", "Request timeout in milliseconds", {
+		default: 3e4,
+		minimum: 1e3,
+		maximum: 12e4
+	}).boolean("dryRun", "Preview the request without sending it", { default: true }).requiredOpenWorld("requestId")),
+	tool("network_intercept", (t) => t.desc("Manage network interception rules.").enum("action", [
+		"add",
+		"list",
+		"disable"
+	], "Intercept operation").string("urlPattern", "URL pattern to match").enum("urlPatternType", ["glob", "regex"], "How to interpret urlPattern", { default: "glob" }).enum("stage", ["Request", "Response"], "Intercept stage. Response (default) intercepts after server responds.", { default: "Response" }).number("responseCode", "HTTP status code to return", {
+		default: 200,
+		minimum: 100,
+		maximum: 599
+	}).object("responseHeaders", { additionalProperties: { type: "string" } }, "Custom response headers as key-value pairs.").string("responseBody", "Custom response body string.").array("rules", {
+		type: "object",
+		properties: {
+			urlPattern: { type: "string" },
+			urlPatternType: {
+				type: "string",
+				enum: ["glob", "regex"]
+			},
+			stage: {
+				type: "string",
+				enum: ["Request", "Response"]
+			},
+			responseCode: { type: "number" },
+			responseHeaders: {
+				type: "object",
+				additionalProperties: { type: "string" }
+			},
+			responseBody: { type: "string" }
+		},
+		required: ["urlPattern"]
+	}, "Rule objects to add").string("ruleId", "Rule ID to remove").boolean("all", "Remove all rules", { default: false }).required("action")),
+	tool("network_tls_fingerprint", (t) => t.desc("Compute TLS/HTTP fingerprint hashes for bot detection.").enum("mode", [
+		"analyze_request",
+		"compute_tls",
+		"compute_http"
+	], "Fingerprint mode").string("requestId", "Request ID to analyze").array("tlsVersions", { type: "string" }, "TLS version codes in order").array("ciphers", { type: "string" }, "Cipher suite codes in order").array("extensions", { type: "string" }, "Extension type codes in order").array("signatureAlgorithms", { type: "string" }, "Signature algorithm codes in order").enum("protocol", [
+		"tls",
+		"quic",
+		"dtls"
+	], "Transport protocol type", { default: "tls" }).boolean("sni", "Whether SNI (Server Name Indication) extension is present", { default: true }).string("alpn", "ALPN value").array("httpHeaders", { type: "string" }, "HTTP header names in order").string("userAgent", "User-Agent value").string("httpMethod", "HTTP method", { default: "GET" }).string("httpVersion", "HTTP version", { default: "1.1" }).string("cookieHeader", "Cookie header value").string("acceptLanguage", "Accept-Language header value").boolean("includeAnalysis", "Include detailed fingerprint breakdown", { default: true }).required("mode")),
+	tool("network_bot_detect_analyze", (t) => t.desc("Analyze captured requests for bot-detection signals.").number("limit", "Maximum requests to analyze", {
+		default: 50,
+		minimum: 1,
+		maximum: 500
+	}).boolean("includeDetails", "Include per-request analysis details", { default: false }).query())
+];
+//#endregion
+//#region src/server/domains/network/definitions/capture-tools.ts
+const captureTools = [
+	tool("network_enable", (t) => t.desc("Enable network request monitoring.").boolean("enableExceptions", "Also capture uncaught exceptions", { default: true })),
+	tool("network_disable", (t) => t.desc("Disable network request monitoring").destructive()),
+	tool("network_get_status", (t) => t.desc("Get network monitoring status.").query()),
+	tool("network_monitor", (t) => t.desc("Manage network request monitoring.").enum("action", [
+		"enable",
+		"disable",
+		"status"
+	], "Action to perform").boolean("enableExceptions", "Only for enable action: Also capture uncaught exceptions", { default: true }).required("action")),
+	tool("network_get_requests", (t) => t.desc("Get captured network requests.").string("url", "Filter by URL substring").string("urlRegex", "Filter by URL regex pattern").string("method", "Filter by HTTP method (GET, POST, PUT, DELETE)").number("sinceTimestamp", "Only return requests after this epoch timestamp (milliseconds). Useful for incremental polling.").string("sinceRequestId", "Only return requests after this requestId (exclusive). Useful for incremental retrieval.").number("tail", "Return the last N requests after filtering").number("limit", "Maximum number of results per page", {
+		default: 100,
+		minimum: 1,
+		maximum: 1e3
+	}).number("offset", "Skip results for pagination", {
+		default: 0,
+		minimum: 0
+	}).boolean("autoEnable", "Auto-enable network monitoring when currently disabled", { default: true }).boolean("enableExceptions", "When autoEnable=true, also enable uncaught exception monitoring", { default: true })),
+	tool("network_get_response_body", (t) => t.desc("Get the response body for a captured request.").string("requestId", "Request ID (from network_get_requests)").number("maxSize", "Maximum response size in bytes", {
+		default: 1e5,
+		minimum: 1024,
+		maximum: 2e7
+	}).boolean("returnSummary", "Return only size and preview instead of full body", { default: false }).number("retries", "Retry count when response body is not yet available", {
+		default: 3,
+		minimum: 0,
+		maximum: 10
+	}).number("retryIntervalMs", "Retry interval in milliseconds", {
+		default: 500,
+		minimum: 100,
+		maximum: 1e4
+	}).boolean("autoEnable", "Auto-enable network monitoring when currently disabled", { default: false }).boolean("enableExceptions", "When autoEnable=true, also enable uncaught exception monitoring", { default: true }).required("requestId")),
+	tool("network_get_stats", (t) => t.desc("Get network statistics.").query()),
+	tool("performance_get_metrics", (t) => t.desc("Get page performance metrics.").boolean("includeTimeline", "Include detailed timeline events", { default: false }).query()),
+	tool("performance_coverage", (t) => t.desc("Start or stop code coverage recording.").enum("action", ["start", "stop"], "Coverage action").required("action")),
+	tool("performance_take_heap_snapshot", (t) => t.desc("Take a V8 heap memory snapshot")),
+	tool("performance_trace", (t) => t.desc("Start or stop a Chrome performance trace.").enum("action", ["start", "stop"], "Trace action").array("categories", { type: "string" }, "Trace categories to capture").boolean("screenshots", "Capture screenshots during tracing", { default: false }).string("artifactPath", "Custom output path").required("action")),
+	tool("profiler_cpu", (t) => t.desc("Start or stop CPU profiling.").enum("action", ["start", "stop"], "Profiler action").string("artifactPath", "Custom output path").required("action")),
+	tool("profiler_heap_sampling", (t) => t.desc("Start or stop heap allocation sampling.").enum("action", ["start", "stop"], "Sampling action").number("samplingInterval", "Sampling interval in bytes", {
+		default: 32768,
+		minimum: 256,
+		maximum: 1048576
+	}).string("artifactPath", "Custom output path").number("topN", "Number of top allocators to return", {
+		default: 20,
+		minimum: 1,
+		maximum: 100
+	}).required("action"))
+];
+//#endregion
+//#region src/server/domains/network/definitions/console-tools.ts
+const consoleTools = [
+	tool("console_get_exceptions", (t) => t.desc("Get captured uncaught exceptions from the page").string("url", "Filter by URL substring").number("limit", "Maximum number of exceptions to return", {
+		default: 50,
+		minimum: 1,
+		maximum: 1e3
+	}).readOnly()),
+	tool("console_inject", (t) => t.desc("Inject an in-page script, XHR, fetch, or function monitor.").enum("type", [
+		"script",
+		"xhr",
+		"fetch",
+		"function"
+	], "Injection type").string("functionName", "Global function path to trace").boolean("persistent", "Keep the injection across page navigations", { default: false }).required("type").openWorld()),
+	tool("console_inject_fetch_interceptor", (t) => t.desc("Inject a fetch interceptor.").boolean("persistent", "Keep the injection across page navigations", { default: false }).openWorld()),
+	tool("console_inject_xhr_interceptor", (t) => t.desc("Inject an XMLHttpRequest interceptor.").boolean("persistent", "Keep the injection across page navigations", { default: false }).openWorld()),
+	tool("console_buffers", (t) => t.desc("Manage injected interceptor state.").enum("action", ["clear", "reset"], "Buffer action: clear buffers or reset interceptors").required("action"))
+];
+//#endregion
+//#region src/server/domains/network/definitions/probe-tools.ts
+const probeTools = [tool("network_traceroute", (t) => t.desc("Run an ICMP traceroute.").string("target", "Target hostname or IP address to trace route to").number("maxHops", "Maximum number of hops", {
+	default: 30,
+	minimum: 1,
+	maximum: 64
+}).number("timeout", "Per-hop timeout in milliseconds", {
+	default: 5e3,
+	minimum: 100,
+	maximum: 3e4
+}).number("packetSize", "ICMP echo request payload size in bytes", {
+	default: 32,
+	minimum: 8,
+	maximum: 65500
+}).required("target").query()), tool("network_icmp_probe", (t) => t.desc("Run an ICMP echo probe.").string("target", "Target hostname or IP address to probe").number("ttl", "Time-to-live value", {
+	default: 128,
+	minimum: 1,
+	maximum: 255
+}).number("packetSize", "ICMP echo request payload size in bytes", {
+	default: 32,
+	minimum: 8,
+	maximum: 65500
+}).number("timeout", "Timeout in milliseconds", {
+	default: 5e3,
+	minimum: 100,
+	maximum: 3e4
+}).required("target").query())];
+//#endregion
+//#region src/server/domains/network/definitions/transport-tools.ts
+const transportTools = [
+	tool("http_request_build", (t) => t.desc("Build a raw HTTP/1.x request payload.").string("method", "HTTP method token").string("target", "Request target, such as /path, *, or an absolute-form URL").string("host", "Optional Host header value to inject when addHostHeader is enabled").object("headers", { additionalProperties: { type: "string" } }, "Optional HTTP headers to include in the request").string("body", "Optional UTF-8 request body").enum("httpVersion", ["1.0", "1.1"], "HTTP protocol version to emit", { default: "1.1" }).boolean("addHostHeader", "Auto-add the Host header when host is provided", { default: true }).boolean("addContentLength", "Auto-add Content-Length when a body is present and Transfer-Encoding is absent", { default: true }).boolean("addConnectionClose", "Auto-add Connection: close when absent", { default: true }).requiredOpenWorld("method", "target")),
+	tool("http_plain_request", (t) => t.desc("Send a raw HTTP request over plain TCP.").string("host", "Target hostname or IP literal").number("port", "TCP port to connect to. Default: 80", {
+		default: 80,
+		minimum: 1,
+		maximum: 65535
+	}).string("requestText", "Raw HTTP request text to send as UTF-8 bytes").object("authorization", networkAuthorizationSchema, "Request-scoped authorization policy for private-network or insecure-HTTP targets. Use exact hosts/CIDRs instead of process-wide bypasses.").number("timeoutMs", "Socket timeout in milliseconds", {
+		default: 3e4,
+		minimum: 1e3,
+		maximum: 12e4
+	}).number("maxResponseBytes", "Maximum number of raw response bytes to capture before truncating the exchange", {
+		default: 512e3,
+		minimum: 1024,
+		maximum: 10485760
+	}).requiredOpenWorld("host", "requestText")),
+	tool("http2_probe", (t) => t.desc("Probe an HTTP/2 endpoint.").string("url", "Absolute http:// or https:// URL to probe").string("method", "HTTP method token to send. Default: GET").object("headers", { additionalProperties: { type: "string" } }, "Optional request headers to include. Header names are normalized to lowercase for HTTP/2.").string("body", "Optional UTF-8 request body to send with the probe").array("alpnProtocols", { type: "string" }, "ALPN protocols to offer").object("authorization", networkAuthorizationSchema, "Request-scoped authorization policy for private-network or insecure-HTTP targets. Use exact hosts/CIDRs instead of process-wide bypasses.").number("timeoutMs", "Probe timeout in milliseconds", {
+		default: 3e4,
+		minimum: 1e3,
+		maximum: 12e4
+	}).number("maxBodyBytes", "Maximum number of response body bytes to capture for the snippet before truncating", {
+		default: 32768,
+		minimum: 1024,
+		maximum: 1048576
+	}).requiredOpenWorld("url")),
+	tool("http2_frame_build", (t) => t.desc("Build a raw HTTP/2 frame.").string("frameType", "HTTP/2 frame type: DATA, SETTINGS, PING, WINDOW_UPDATE, RST_STREAM, GOAWAY, or RAW").number("streamId", "Stream identifier (0 for connection-level frames). Default: 0", {
+		default: 0,
+		minimum: 0,
+		maximum: 2147483647
+	}).number("flags", "Raw flags byte (0-255). Overrides type-specific defaults when set.", {
+		minimum: 0,
+		maximum: 255
+	}).number("frameTypeCode", "Explicit frame type code for RAW frames (0-255). Required when frameType is RAW.", {
+		minimum: 0,
+		maximum: 255
+	}).string("payloadHex", "Frame payload as a hex string. Mutually exclusive with payloadText.").string("payloadText", "Frame payload as a text string. Mutually exclusive with payloadHex.").string("payloadEncoding", "Encoding for payloadText: utf8 or ascii. Default: utf8").array("settings", {
+		type: "object",
+		properties: {
+			id: { type: "number" },
+			value: { type: "number" }
+		},
+		required: ["id", "value"]
+	}, "Array of {id, value} entries for SETTINGS frames").boolean("ack", "Set the ACK flag on SETTINGS or PING frames").string("pingOpaqueDataHex", "Exactly 8 bytes of opaque data for PING frames (hex string)").number("windowSizeIncrement", "Window size increment for WINDOW_UPDATE frames (1 to 2^31-1)").number("errorCode", "Error code for RST_STREAM or GOAWAY frames (0 to 2^32-1)").number("lastStreamId", "Last stream ID for GOAWAY frames (0 to 2^31-1)").string("debugDataText", "Optional debug data for GOAWAY frames").string("debugDataEncoding", "Encoding for debugDataText: utf8 or ascii. Default: utf8").requiredOpenWorld("frameType")),
+	tool("network_rtt_measure", (t) => t.desc("Measure round-trip time to a target URL.").string("url", "Target URL to measure RTT to").string("probeType", "Probe type: tcp, tls, or http. Default: tcp", { default: "tcp" }).number("iterations", "Number of probe iterations (1-50). Default: 5", {
+		default: 5,
+		minimum: 1,
+		maximum: 50
+	}).number("timeoutMs", "Per-probe timeout in milliseconds (100-30000). Default: 5000", {
+		default: 5e3,
+		minimum: 100,
+		maximum: 3e4
+	}).object("authorization", { additionalProperties: { type: "string" } }, "Authorization policy for network access").requiredOpenWorld("url"))
+];
+//#endregion
+//#region src/server/domains/network/definitions.ts
+const advancedTools = [
+	...captureTools,
+	...consoleTools,
+	...transportTools,
+	...analysisTools,
+	...probeTools
+];
+//#endregion
+export { advancedTools as t };

package/dist/{definitions-Cq-zroAU.mjs → definitions-va-AnLuQ.mjs}

@@ -1,4 +1,4 @@
-import { t as tool } from "./tool-builder-DCbIC5Eo.mjs";
+import { t as tool } from "./tool-builder-BHJp32mV.mjs";
 //#region src/server/domains/transform/definitions.ts
 const transformsEnum = [
 	"constant_fold",
@@ -11,7 +11,7 @@ const transformTools = [
 	tool("ast_transform_preview", (t) => t.desc("Preview lightweight AST-like transforms (string/regex based) and return before/after diff.").string("code", "Source code to transform.").array("transforms", {
 		type: "string",
 		enum: transformsEnum
-	}, "Ordered transform list.").boolean("preview", "Whether to generate line diff output.", { default: true }).required("code", "transforms")),
+	}, "Ordered transform list.").boolean("preview", "Whether to generate line diff output.", { default: true }).required("code", "transforms").query()),
 	tool("ast_transform_chain", (t) => t.desc("Create and store an in-memory transform chain.").string("name", "Chain name.").array("transforms", {
 		type: "string",
 		enum: transformsEnum
@@ -21,8 +21,8 @@ const transformTools = [
 		enum: transformsEnum
 	}, "Direct transform list (used when chainName is not provided).")),
 	tool("crypto_extract_standalone", (t) => t.desc("Extract crypto/sign/encrypt function from current page and generate standalone runnable code.").string("targetFunction", "Target function name/path, e.g. \"window.sign\".").boolean("includePolyfills", "Include minimal runtime polyfills.", { default: true }).required("targetFunction")),
-	tool("crypto_test_harness", (t) => t.desc("Run extracted crypto code in worker_threads + vm sandbox and return deterministic test results.").string("code", "Standalone function code.").string("functionName", "Exported function name to execute.").array("testInputs", { type: "string" }, "Input list for test execution.").required("code", "functionName", "testInputs")),
-	tool("crypto_compare", (t) => t.desc("Compare two crypto implementations against identical test vectors.").string("code1", "Implementation A code.").string("code2", "Implementation B code.").string("functionName", "Function name shared by both implementations.").array("testInputs", { type: "string" }, "Input list for comparison.").required("code1", "code2", "functionName", "testInputs"))
+	tool("crypto_test_harness", (t) => t.desc("Run extracted crypto code in worker_threads + vm sandbox and return deterministic test results.").string("code", "Standalone function code.").string("functionName", "Exported function name to execute.").array("testInputs", { type: "string" }, "Input list for test execution.").required("code", "functionName", "testInputs").query()),
+	tool("crypto_compare", (t) => t.desc("Compare two crypto implementations against identical test vectors.").string("code1", "Implementation A code.").string("code2", "Implementation B code.").string("functionName", "Function name shared by both implementations.").array("testInputs", { type: "string" }, "Input list for comparison.").required("code1", "code2", "functionName", "testInputs").query())
 ];
 //#endregion
 export { transformTools as t };

package/dist/{encoding-Bvz5jLRv.mjs → encoding-DJeqHmpd.mjs}

@@ -1,5 +1,5 @@
-import { a as argString, n as argEnum, r as argNumber } from "./parse-args-BlRjqlkL.mjs";
-import "./definitions-D3VsGcvz.mjs";
+import { a as argString, n as argEnum, r as argNumber } from "./parse-args-B4cY5Vx5.mjs";
+import "./definitions-DPRpZQ96.mjs";
 import { homedir, tmpdir } from "node:os";
 import { isAbsolute, resolve } from "node:path";
 import { readFile, realpath } from "node:fs/promises";
@@ -882,8 +882,22 @@ function printableRatio(buffer) {
 //#region src/server/domains/encoding/handlers.impl.core.runtime.ts
 var EncodingToolHandlers = class {
 	collector;
-	constructor(collector) {
+	responseBodyResolver;
+	constructor(collector, responseBodyResolver) {
 		this.collector = collector;
+		this.responseBodyResolver = responseBodyResolver;
+	}
+	async resolveCapturedRequestBody(requestId) {
+		if (this.responseBodyResolver) try {
+			const payload = await this.responseBodyResolver(requestId);
+			if (payload && typeof payload.body === "string") {
+				if (payload.base64Encoded) return Buffer.from(payload.body, "base64");
+				const maybeBase64 = payload.body.trim();
+				if (looksLikeBase64(maybeBase64)) return Buffer.from(maybeBase64, "base64");
+				return Buffer.from(payload.body, "utf8");
+			}
+		} catch {}
+		return resolveRequestBodyFromActivePage(this.collector, requestId);
 	}
 	async handleBinaryDetectFormat(args) {
 		try {
@@ -894,7 +908,7 @@ var EncodingToolHandlers = class {
 			let buffer = null;
 			let requestBodyUsed = false;
 			if (source === "raw" && requestId) {
-				buffer = await resolveRequestBodyFromActivePage(this.collector, requestId);
+				buffer = await this.resolveCapturedRequestBody(requestId);
 				requestBodyUsed = buffer !== null;
 			}
 			if (!buffer) {

package/dist/{evidence-graph-bridge-C_fv9PuC.mjs → evidence-graph-bridge-DcYizFk2.mjs}

@@ -26,6 +26,7 @@ var CrossDomainEvidenceBridge = class {
 		const label = input.method ? `${input.method} ${input.url}` : input.url;
 		const node = this.graph.addNode("network-request", label, {
 			domain: "network",
+			requestId: input.requestId,
 			url: input.url,
 			method: input.method ?? "GET"
 		});

package/dist/{factory-DxlGh9Xf.mjs → factory-C90tBff6.mjs}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./chunk-CjcI7cDX.mjs";
-import { _ as WriteProcessMemory, b as openProcessForMemory, d as ReadProcessMemory, f as VirtualAllocEx, h as VirtualQueryEx, i as GetModuleBaseName, l as MEM, m as VirtualProtectEx, n as EnumProcessModules, p as VirtualFreeEx, s as GetModuleInformation, t as CloseHandle, u as PAGE, v as isKoffiAvailable, y as isWindows } from "./Win32API-CePkipZY.mjs";
-import { _ as machVmReadOverwrite, a as VM_PROT, b as taskForPid, c as dyldImageCount, d as kernReturnName, f as machPortDeallocate, g as machVmProtect, h as machVmDeallocate, i as VM_FLAGS, l as isDarwin, m as machVmAllocate, n as KERN, o as dyldGetImageHeader, p as machTaskSelf, r as SM, s as dyldGetImageName, u as isKoffiAvailableOnDarwin, v as machVmRegion, y as machVmWrite } from "./DarwinAPI-BNPxu0RH.mjs";
+import { _ as WriteProcessMemory, b as openProcessForMemory, d as ReadProcessMemory, f as VirtualAllocEx, h as VirtualQueryEx, i as GetModuleBaseName, l as MEM, m as VirtualProtectEx, n as EnumProcessModules, p as VirtualFreeEx, s as GetModuleInformation, t as CloseHandle, u as PAGE, v as isKoffiAvailable, y as isWindows } from "./Win32API-C2kjj0ze.mjs";
+import { _ as machVmReadOverwrite, a as VM_PROT, b as taskForPid, c as dyldImageCount, d as kernReturnName, f as machPortDeallocate, g as machVmProtect, h as machVmDeallocate, i as VM_FLAGS, l as isDarwin, m as machVmAllocate, n as KERN, o as dyldGetImageHeader, p as machTaskSelf, r as SM, s as dyldGetImageName, u as isKoffiAvailableOnDarwin, v as machVmRegion, y as machVmWrite } from "./DarwinAPI-ETyy0xyo.mjs";
 import fs from "node:fs";
 //#region src/native/platform/win32/Win32MemoryProvider.ts
 const handleMap$1 = /* @__PURE__ */ new WeakMap();
@@ -287,13 +287,13 @@ var DarwinMemoryProvider = class {
 	}
 	enumerateModules(handle) {
 		const h = getDarwinHandle(handle);
-		if (handle.pid === process.pid) return this._enumerateModulesSelf();
-		return this._enumerateModulesRemote(h.task);
+		if (handle.pid === process.pid) return this.enumerateModulesSelf();
+		return this.enumerateModulesRemote(h.task);
 	}
 	/**
 	* Enumerate modules for the current process using dyld APIs (fast path).
 	*/
-	_enumerateModulesSelf() {
+	enumerateModulesSelf() {
 		const count = dyldImageCount();
 		const modules = [];
 		for (let i = 0; i < count; i++) {
@@ -315,7 +315,7 @@ var DarwinMemoryProvider = class {
 	* This reads the target process's dyld info structures from memory.
 	* Falls back to an empty list if the info struct cannot be located.
 	*/
-	_enumerateModulesRemote(task) {
+	enumerateModulesRemote(task) {
 		const modules = [];
 		let address = 0n;
 		for (let i = 0; i < 1e4; i++) {

package/dist/flat-target-session-Dgax2Cy3.mjs

@@ -0,0 +1,29 @@
+//#region src/modules/browser/flat-target-session.ts
+function readSessionId(response) {
+	if (typeof response !== "object" || response === null) return null;
+	const sessionId = response.sessionId;
+	return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : null;
+}
+function readAttachedSessionId(session) {
+	const sessionId = session.id?.();
+	return typeof sessionId === "string" && sessionId.length > 0 ? sessionId : null;
+}
+async function attachToFlatTarget(parentSession, targetId) {
+	const sessionId = readSessionId(await parentSession.send("Target.attachToTarget", {
+		targetId,
+		flatten: true
+	}));
+	if (!sessionId) throw new Error(`Target.attachToTarget did not return sessionId for ${targetId}`);
+	const connection = parentSession.connection?.();
+	if (!connection || typeof connection.session !== "function") throw new Error(`CDP connection lookup unavailable for attached target ${targetId}`);
+	const attachedSession = connection.session(sessionId);
+	if (!attachedSession) throw new Error(`CDP attached target session ${sessionId} was not registered for ${targetId}`);
+	return attachedSession;
+}
+async function detachFromFlatTarget(parentSession, attachedSession) {
+	const sessionId = readAttachedSessionId(attachedSession);
+	if (!sessionId) throw new Error("CDP attached target session id unavailable for detach");
+	await parentSession.send("Target.detachFromTarget", { sessionId });
+}
+//#endregion
+export { detachFromFlatTarget as n, attachToFlatTarget as t };