@jshookmcp/jshook 0.2.9 → 0.3.0

package/dist/{manifest-B3QVVeBS.mjs → manifest-6lNTMZAB2.mjs}

@@ -1,8 +1,9 @@
-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/mojo-ipc/definitions.ts
 const mojoIpcTools = [
+	tool("mojo_ipc_capabilities", (t) => t.desc("Report Mojo IPC monitoring availability.").query()),
 	tool("mojo_monitor", (t) => t.desc("Start or stop Mojo IPC monitoring for the active Chromium-based target.").enum("action", ["start", "stop"], "Monitor action").string("deviceId", "Optional device or transport identifier (action=start)").required("action")),
 	tool("mojo_decode_message", (t) => t.desc("Decode a Mojo IPC hex payload into a structured field map").string("hexPayload", "Hex-encoded Mojo IPC payload").required("hexPayload").query()),
 	tool("mojo_list_interfaces", (t) => t.desc("List discovered Mojo IPC interfaces and their pending message counts").query()),
@@ -12,10 +13,35 @@ const mojoIpcTools = [
 //#region src/server/domains/mojo-ipc/manifest.ts
 const DOMAIN = "mojo-ipc";
 const DEP_KEY = "mojoIpcHandlers";
-const toolByName = toolLookup(mojoIpcTools);
-const bind = (invoke) => bindByDepKey(DEP_KEY, invoke);
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(mojoIpcTools),
+	entries: [
+		{
+			tool: "mojo_ipc_capabilities",
+			method: "handleMojoIpcCapabilities"
+		},
+		{
+			tool: "mojo_monitor",
+			method: "handleMojoMonitorDispatch"
+		},
+		{
+			tool: "mojo_decode_message",
+			method: "handleMojoDecodeMessage"
+		},
+		{
+			tool: "mojo_list_interfaces",
+			method: "handleMojoListInterfaces"
+		},
+		{
+			tool: "mojo_messages_get",
+			method: "handleMojoMessagesGet"
+		}
+	]
+});
 async function ensure(ctx) {
-	const { MojoIPCHandlers } = await import("./mojo-ipc-B_H61Afw.mjs");
+	const { MojoIPCHandlers } = await import("./mojo-ipc-DXNEXEqb.mjs");
 	const existingHandlers = ctx.getDomainInstance(DEP_KEY);
 	if (existingHandlers) return existingHandlers;
 	const handlers = new MojoIPCHandlers(void 0, void 0, ctx.eventBus);
@@ -28,28 +54,7 @@ const manifest = {
 	domain: DOMAIN,
 	depKey: DEP_KEY,
 	profiles: ["full"],
-	registrations: [
-		{
-			tool: toolByName("mojo_monitor"),
-			domain: DOMAIN,
-			bind: bind((handlers, args) => handlers.handleMojoMonitorDispatch(args))
-		},
-		{
-			tool: toolByName("mojo_decode_message"),
-			domain: DOMAIN,
-			bind: bind((handlers, args) => handlers.handleMojoDecodeMessage(args))
-		},
-		{
-			tool: toolByName("mojo_list_interfaces"),
-			domain: DOMAIN,
-			bind: bind((handlers) => handlers.handleMojoListInterfaces())
-		},
-		{
-			tool: toolByName("mojo_messages_get"),
-			domain: DOMAIN,
-			bind: bind((handlers, args) => handlers.handleMojoMessagesGet(args))
-		}
-	],
+	registrations,
 	ensure,
 	workflowRule: {
 		patterns: [/\b(mojo|ipc|chromium\s?(ipc|message)|interface\s?(broker|registry))\b/i, /(mojo|ipc|chromium).*(monitor|capture|hook|trace)/i],

package/dist/manifest-B2duEHiH.mjs

@@ -0,0 +1,90 @@
+import { n as toolLookup } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { t as platformTools } from "./definitions-CVPD9hzZ.mjs";
+//#region src/server/domains/platform/manifest.ts
+const DOMAIN = "platform";
+const DEP_KEY = "platformHandlers";
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(platformTools),
+	entries: [
+		{
+			tool: "platform_capabilities",
+			method: "handlePlatformCapabilities"
+		},
+		{
+			tool: "miniapp_pkg_scan",
+			method: "handleMiniappPkgScan"
+		},
+		{
+			tool: "miniapp_pkg_unpack",
+			method: "handleMiniappPkgUnpack"
+		},
+		{
+			tool: "miniapp_pkg_analyze",
+			method: "handleMiniappPkgAnalyze"
+		},
+		{
+			tool: "asar_extract",
+			method: "handleAsarExtract"
+		},
+		{
+			tool: "electron_inspect_app",
+			method: "handleElectronInspectApp"
+		},
+		{
+			tool: "electron_scan_userdata",
+			method: "handleElectronScanUserdata"
+		},
+		{
+			tool: "asar_search",
+			method: "handleAsarSearch"
+		},
+		{
+			tool: "electron_check_fuses",
+			method: "handleElectronCheckFuses"
+		},
+		{
+			tool: "electron_patch_fuses",
+			method: "handleElectronPatchFuses"
+		},
+		{
+			tool: "v8_bytecode_decompile",
+			method: "handleV8BytecodeDecompile"
+		},
+		{
+			tool: "electron_launch_debug",
+			method: "handleElectronLaunchDebug"
+		},
+		{
+			tool: "electron_debug_status",
+			method: "handleElectronDebugStatus"
+		},
+		{
+			tool: "electron_ipc_sniff",
+			method: "handleElectronIPCSniff"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { CodeCollector } = await import("./modules-tZozf0LQ.mjs").then((n) => n.t);
+	const { PlatformToolHandlers } = await import("./platform-CYeFoTWp.mjs");
+	if (!ctx.collector) {
+		ctx.collector = new CodeCollector(ctx.config.puppeteer);
+		ctx.registerCaches();
+	}
+	if (!ctx.platformHandlers) ctx.platformHandlers = new PlatformToolHandlers(ctx.collector);
+	return ctx.platformHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	registrations
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-B6EY9Vm8.mjs

@@ -0,0 +1,57 @@
+import { n as toolLookup } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { t as coordinationTools } from "./definitions-BtWSHJ3o.mjs";
+//#region src/server/domains/coordination/manifest.ts
+const DOMAIN = "coordination";
+const DEP_KEY = "coordinationHandlers";
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(coordinationTools),
+	entries: [
+		{
+			tool: "create_task_handoff",
+			method: "handleCreateTaskHandoff"
+		},
+		{
+			tool: "complete_task_handoff",
+			method: "handleCompleteTaskHandoff"
+		},
+		{
+			tool: "get_task_context",
+			method: "handleGetTaskContext"
+		},
+		{
+			tool: "append_session_insight",
+			method: "handleAppendSessionInsight"
+		},
+		{
+			tool: "save_page_snapshot",
+			method: "handleSavePageSnapshot"
+		},
+		{
+			tool: "restore_page_snapshot",
+			method: "handleRestorePageSnapshot"
+		},
+		{
+			tool: "list_page_snapshots",
+			method: "handleListPageSnapshots"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { CoordinationHandlers } = await import("./coordination-DgItD9DL.mjs");
+	if (!ctx.coordinationHandlers) ctx.coordinationHandlers = new CoordinationHandlers(ctx);
+	return ctx.coordinationHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	registrations
+};
+//#endregion
+export { manifest as default };

package/dist/{manifest-gZ4s_UtG.mjs → manifest-B6nKSbyY.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/extension-registry/definitions.ts
 const extensionRegistryTools = [
 	tool("extension_list_installed", (t) => t.desc("List installed extensions from the local extension registry").query()),
@@ -26,10 +26,35 @@ const extensionRegistryTools = [
 //#region src/server/domains/extension-registry/manifest.ts
 const DOMAIN = "extension-registry";
 const DEP_KEY = "extensionRegistryHandlers";
-const t = toolLookup(extensionRegistryTools);
-const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(extensionRegistryTools),
+	entries: [
+		{
+			tool: "extension_list_installed",
+			method: "handleListInstalled"
+		},
+		{
+			tool: "extension_execute_in_context",
+			method: "handleExecuteInContext"
+		},
+		{
+			tool: "extension_reload",
+			method: "handleReload"
+		},
+		{
+			tool: "extension_uninstall",
+			method: "handleUninstall"
+		},
+		{
+			tool: "webhook",
+			method: "handleWebhookDispatch"
+		}
+	]
+});
 async function ensure(ctx) {
-	const { ExtensionRegistryHandlers } = await import("./handlers-DeLOCd5m.mjs");
+	const { ExtensionRegistryHandlers } = await import("./handlers-BzgcB4iv.mjs");
 	const existing = ctx.getDomainInstance(DEP_KEY);
 	if (existing) return existing;
 	const handlers = new ExtensionRegistryHandlers();
@@ -44,33 +69,7 @@ const manifest = {
 	depKey: DEP_KEY,
 	profiles: ["full"],
 	ensure,
-	registrations: [
-		{
-			tool: t("extension_list_installed"),
-			domain: DOMAIN,
-			bind: b((handlers) => handlers.handleListInstalled())
-		},
-		{
-			tool: t("extension_execute_in_context"),
-			domain: DOMAIN,
-			bind: b((handlers, args) => handlers.handleExecuteInContext(args))
-		},
-		{
-			tool: t("extension_reload"),
-			domain: DOMAIN,
-			bind: b((handlers, args) => handlers.handleReload(args))
-		},
-		{
-			tool: t("extension_uninstall"),
-			domain: DOMAIN,
-			bind: b((handlers, args) => handlers.handleUninstall(args))
-		},
-		{
-			tool: t("webhook"),
-			domain: DOMAIN,
-			bind: b((handlers, args) => handlers.handleWebhookDispatch(args))
-		}
-	],
+	registrations,
 	workflowRule: {
 		patterns: [/\b(extension|plugin|addon|webhook|c2|bluetooth|ble|hid|serial|esp32|registry)\b/i, /(install|uninstall|reload).*(extension|plugin)/i],
 		priority: 70,

package/dist/{manifest-2ToTpjv8.mjs → manifest-BL8AQNPF.mjs}

@@ -1,6 +1,6 @@
-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 tool } from "./tool-builder-DCbIC5Eo.mjs";
+import { n as toolLookup, t as ensureBrowserCore } 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/canvas/definitions.ts
 const canvasTools = [
 	tool("canvas_engine_fingerprint", (t) => t.desc("Detect Canvas/WebGL game engine instances running in the page (LayaAir, PixiJ...").query()),
@@ -16,13 +16,34 @@ const canvasTools = [
 //#region src/server/domains/canvas/manifest.ts
 const DOMAIN = "canvas";
 const DEP_KEY = "canvasHandlers";
-const t = toolLookup(canvasTools);
-const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(canvasTools),
+	entries: [
+		{
+			tool: "canvas_engine_fingerprint",
+			method: "handleFingerprint"
+		},
+		{
+			tool: "canvas_scene_dump",
+			method: "handleSceneDump"
+		},
+		{
+			tool: "canvas_pick_object_at_point",
+			method: "handlePick"
+		},
+		{
+			tool: "canvas_trace_click_handler",
+			method: "handleTraceClick"
+		}
+	]
+});
 async function ensure(ctx) {
-	const { DebuggerManager } = await import("./modules-C184v-S9.mjs").then((n) => n.t);
-	const { TraceRecorder } = await import("./TraceRecorder-DgxyVbdQ.mjs");
-	const { ReverseEvidenceGraph } = await import("./ReverseEvidenceGraph-Dlsk94LC.mjs").then((n) => n.t);
-	const { CanvasToolHandlers } = await import("./handlers-Bl8zkwz1.mjs");
+	const { DebuggerManager } = await import("./modules-tZozf0LQ.mjs").then((n) => n.t);
+	const { TraceRecorder } = await import("./TraceRecorder-B41Z5XBj.mjs");
+	const { ReverseEvidenceGraph } = await import("./ReverseEvidenceGraph-C02-gXOh.mjs").then((n) => n.t);
+	const { CanvasToolHandlers } = await import("./handlers-Dz9PYsCa.mjs");
 	await ensureBrowserCore(ctx);
 	if (!ctx.debuggerManager) ctx.debuggerManager = new DebuggerManager(ctx.collector);
 	if (!ctx.traceRecorder) ctx.traceRecorder = new TraceRecorder();
@@ -79,28 +100,7 @@ const manifest = {
 			fix: "Call debugger_lifecycle({ action: 'enable' }) first"
 		}]
 	},
-	registrations: [
-		{
-			tool: t("canvas_engine_fingerprint"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleFingerprint(a))
-		},
-		{
-			tool: t("canvas_scene_dump"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleSceneDump(a))
-		},
-		{
-			tool: t("canvas_pick_object_at_point"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handlePick(a))
-		},
-		{
-			tool: t("canvas_trace_click_handler"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleTraceClick(a))
-		}
-	]
+	registrations
 };
 //#endregion
 export { manifest as default };

package/dist/{manifest-DzwvxPJX.mjs → manifest-BSZvJJmV.mjs}

@@ -1,14 +1,31 @@
-import { n as toolLookup, t as ensureBrowserCore } from "./registry-D-6e18lB.mjs";
-import { n as getDep, t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
-import { n as hookPresetTools, t as aiHookTools } from "./definitions-BMfYXoNC.mjs";
+import { n as toolLookup, t as ensureBrowserCore } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { n as hookPresetTools, t as aiHookTools } from "./definitions-C1gCHO0i.mjs";
 //#region src/server/domains/hooks/manifest.ts
 const DOMAIN = "hooks";
 const DEP_KEY = "aiHookHandlers";
 const DEP_KEY_PRESET = "hookPresetHandlers";
 const t = toolLookup([...aiHookTools, ...hookPresetTools]);
-const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+const aiRegistrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: t,
+	entries: [{
+		tool: "ai_hook",
+		method: "handleAIHook"
+	}]
+});
+const presetRegistrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY_PRESET,
+	lookup: t,
+	entries: [{
+		tool: "hook_preset",
+		method: "handleHookPreset"
+	}]
+});
 async function ensure(ctx) {
-	const { AIHookToolHandlers, HookPresetToolHandlers } = await import("./hooks-CzCWByww.mjs");
+	const { AIHookToolHandlers, HookPresetToolHandlers } = await import("./hooks-B1B8NRHL.mjs");
 	await ensureBrowserCore(ctx);
 	if (!ctx.aiHookHandlers || !ctx.hookPresetHandlers) {
 		if (!ctx.aiHookHandlers) ctx.aiHookHandlers = new AIHookToolHandlers(ctx.pageController);
@@ -24,15 +41,7 @@ const manifest = {
 	secondaryDepKeys: ["hookPresetHandlers"],
 	profiles: ["full"],
 	ensure,
-	registrations: [{
-		tool: t("ai_hook"),
-		domain: DOMAIN,
-		bind: b((h, a) => h.handleAIHook(a))
-	}, {
-		tool: t("hook_preset"),
-		domain: DOMAIN,
-		bind: (deps) => (args) => getDep(deps, DEP_KEY_PRESET).handleHookPreset(args)
-	}]
+	registrations: [...aiRegistrations, ...presetRegistrations]
 };
 //#endregion
 export { manifest as default };

package/dist/{manifest-Sc_0JQ13.mjs → manifest-BU7qzUyX.mjs}

@@ -1,5 +1,5 @@
-import { t as createProgressDebouncer } from "./EventBus-DgPmwpeu.mjs";
-import { t as tool } from "./tool-builder-DCbIC5Eo.mjs";
+import { t as createProgressDebouncer } from "./EventBus-DFKvADm3.mjs";
+import { t as tool } from "./tool-builder-BHJp32mV.mjs";
 //#region src/server/domains/memory/definitions.ts
 const ScanValueTypeOptions = [
 	"byte",
@@ -29,7 +29,7 @@ const ScanCompareModeOptions = [
 	"not_equal"
 ];
 const memoryScanToolDefinitions = [
-	tool("memory_first_scan", (t) => t.desc("Start a new memory scan session.").string("value", "Value to search for (as string, e.g. \"100\", \"3.14\", \"48 65 6C 6C 6F\")").enum("valueType", [...ScanValueTypeOptions], "Data type of the value").number("alignment", "Alignment in bytes (0=unaligned, 4=4-byte aligned). Default: natural alignment for the type.").number("maxResults", "Maximum results to return (default: 1,000,000)").prop("regionFilter", {
+	tool("memory_first_scan", (t) => t.desc("Start a new memory scan session.").number("pid", "Target process ID").string("value", "Value to search for (as string, e.g. \"100\", \"3.14\", \"48 65 6C 6C 6F\")").enum("valueType", [...ScanValueTypeOptions], "Data type of the value").number("alignment", "Alignment in bytes (0=unaligned, 4=4-byte aligned). Default: natural alignment for the type.").number("maxResults", "Maximum results to return (default: 1,000,000)").prop("regionFilter", {
 		type: "object",
 		properties: {
 			writable: {
@@ -47,8 +47,8 @@ const memoryScanToolDefinitions = [
 		},
 		description: "Filter which memory regions to scan"
 	}).requiredOpenWorld("pid", "value", "valueType")),
-	tool("memory_next_scan", (t) => t.desc("Narrow an existing scan session.").enum("mode", [...ScanCompareModeOptions], "Comparison mode").string("value", "Target value for exact/greater_than/less_than/between/not_equal modes").string("value2", "Upper bound value for \"between\" mode").requiredOpenWorld("sessionId", "mode")),
-	tool("memory_unknown_scan", (t) => t.desc("Start an unknown initial value scan.").enum("valueType", [...ScanValueTypeOptions], "Data type to capture").number("alignment", "Alignment in bytes (default: natural for type)").number("maxResults", "Maximum addresses to capture (default: 5,000,000)").prop("regionFilter", {
+	tool("memory_next_scan", (t) => t.desc("Narrow an existing scan session.").string("sessionId", "Scan session ID").enum("mode", [...ScanCompareModeOptions], "Comparison mode").string("value", "Target value for exact/greater_than/less_than/between/not_equal modes").string("value2", "Upper bound value for \"between\" mode").requiredOpenWorld("sessionId", "mode")),
+	tool("memory_unknown_scan", (t) => t.desc("Start an unknown initial value scan.").number("pid", "Target process ID").enum("valueType", [...ScanValueTypeOptions], "Data type to capture").number("alignment", "Alignment in bytes (default: natural for type)").number("maxResults", "Maximum addresses to capture (default: 5,000,000)").prop("regionFilter", {
 		type: "object",
 		properties: {
 			writable: { type: "boolean" },
@@ -56,8 +56,8 @@ const memoryScanToolDefinitions = [
 			moduleOnly: { type: "boolean" }
 		}
 	}).requiredOpenWorld("pid", "valueType")),
-	tool("memory_pointer_scan", (t) => t.desc("Find pointers to a target address.").string("targetAddress", "Target address to find pointers to (hex, e.g. \"0x7FF612340000\")").number("maxResults", "Maximum results (default: 10,000)").boolean("moduleOnly", "Only scan module-backed regions").required("pid", "targetAddress").query().openWorld()),
-	tool("memory_group_scan", (t) => t.desc("Search for multiple values at known offsets simultaneously.").array("pattern", {
+	tool("memory_pointer_scan", (t) => t.desc("Find pointers to a target address.").number("pid", "Target process ID").string("targetAddress", "Target address to find pointers to (hex, e.g. \"0x7FF612340000\")").number("maxResults", "Maximum results (default: 10,000)").boolean("moduleOnly", "Only scan module-backed regions").required("pid", "targetAddress").query().openWorld()),
+	tool("memory_group_scan", (t) => t.desc("Search for multiple values at known offsets simultaneously.").number("pid", "Target process ID").array("pattern", {
 		type: "object",
 		properties: {
 			offset: {
@@ -97,7 +97,7 @@ Actions:
 		"resolve",
 		"export"
 	], "Chain operation").number("pid", "Target process ID").string("targetAddress", "Target address hex (action=scan)").number("maxDepth", "Max chain depth 1-6 (action=scan, default: 4)").number("maxOffset", "Max offset per level in bytes (action=scan, default: 4096)").boolean("staticOnly", "Only module-relative chains (action=scan, default: false)").array("modules", { type: "string" }, "Only scan specific modules (action=scan)").number("maxResults", "Max chains to return (action=scan, default: 1000)").string("chains", "JSON PointerChain[] (action=validate/export)").string("chain", "JSON single PointerChain (action=resolve)").required("action")),
-	tool("memory_structure_analyze", (t) => t.desc("Analyze memory at an address to infer data structure layout.").string("address", "Base address of the structure (hex)").number("size", "Size to analyze in bytes (default: 256)").array("otherInstances", { type: "string" }, "Additional instance addresses for cross-comparison").boolean("parseRtti", "Whether to attempt RTTI parsing (default: true)").required("pid", "address").query()),
+	tool("memory_structure_analyze", (t) => t.desc("Analyze memory at an address to infer data structure layout.").number("pid", "Target process ID").string("address", "Base address of the structure (hex)").number("size", "Size to analyze in bytes (default: 256)").array("otherInstances", { type: "string" }, "Additional instance addresses for cross-comparison").boolean("parseRtti", "Whether to attempt RTTI parsing (default: true)").required("pid", "address").query()),
 	tool("memory_vtable_parse", (t) => t.desc("Parse a vtable to enumerate virtual function pointers and resolve them to module+offset. Also attempts RTTI parsing for class name and inheritance hierarchy.").number("pid", "Target process ID").string("vtableAddress", "Address of the vtable (hex)").required("pid", "vtableAddress").query()),
 	tool("memory_structure_export_c", (t) => t.desc("Export an inferred structure as a C-style struct definition with offset comments and type annotations.").string("structure", "JSON string of InferredStruct to export").string("name", "Struct name (defaults to RTTI class name or \"UnknownStruct\")").required("structure").query()),
 	tool("memory_structure_compare", (t) => t.desc("Compare two structure instances to identify which fields differ (dynamic values like health/position) vs which are constant (vtable, type flags). Useful for finding important fields.").number("pid", "Target process ID").string("address1", "First instance address (hex)").string("address2", "Second instance address (hex)").number("size", "Size to compare in bytes (default: 256)").required("pid", "address1", "address2").query()),
@@ -122,7 +122,7 @@ Actions:
 	tool("memory_patch_nop", (t) => t.desc("NOP out instructions at address (replace with 0x90). Useful for disabling checks or jumps.").number("pid", "Target process ID").string("address", "Address to NOP (hex)").number("count", "Number of bytes to NOP").required("pid", "address", "count").destructive()),
 	tool("memory_patch_undo", (t) => t.desc("Undo a previous patch by restoring the original bytes.").string("patchId", "Patch ID to undo").required("patchId").destructive()),
 	tool("memory_code_caves", (t) => t.desc("Find code caves (runs of 0x00 or 0xCC) in executable sections of loaded modules. Returns largest caves first.").number("pid", "Target process ID").number("minSize", "Minimum cave size in bytes (default: 16)").required("pid").query()),
-	tool("memory_write_value", (t) => t.desc("Write a typed value to a memory address. Supports undo via memory_write_undo.").number("pid", "Target process ID").string("address", "Address to write to (hex)").string("value", "Value to write (as string)").enum("valueType", [...ScanValueTypeOptions], "Data type of the value").required("pid", "address", "value", "valueType").destructive()),
+	tool("memory_write_value", (t) => t.desc("Write a typed value to a memory address. Supports undo/redo via memory_write_history(action=undo|redo).").number("pid", "Target process ID").string("address", "Address to write to (hex)").string("value", "Value to write (as string)").enum("valueType", [...ScanValueTypeOptions], "Data type of the value").required("pid", "address", "value", "valueType").destructive()),
 	tool("memory_freeze", (t) => t.desc(`Freeze or unfreeze a memory address. Freeze continuously writes a value to prevent changes; unfreeze stops it.`).enum("action", ["freeze", "unfreeze"], "Freeze operation").number("pid", "Target process ID (action=freeze)").string("address", "Address to freeze hex (action=freeze)").string("value", "Value to maintain (action=freeze)").enum("valueType", [...ScanValueTypeOptions], "Data type (action=freeze)").number("intervalMs", "Write interval ms (action=freeze, default: 100)").string("freezeId", "Freeze ID to remove (action=unfreeze)").required("action").destructive()),
 	tool("memory_dump", (t) => t.desc("Dump memory region as hex with ASCII column. Outputs a formatted hex dump similar to xxd.").number("pid", "Target process ID").string("address", "Start address (hex)").number("size", "Size to dump in bytes (default: 256)").required("pid", "address").query()),
 	tool("memory_speedhack", (t) => t.desc(`Speedhack: hook time APIs to scale process time. Speed 2.0 = 2x faster, 0.5 = half speed.
@@ -152,25 +152,25 @@ const DEP_KEY = "memoryScanHandlers";
 const IS_WIN32 = (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) === "win32";
 let globalContext = null;
 async function ensure(ctx) {
-	const { MemoryScanHandlers } = await import("./handlers.impl-DS0d9fUw.mjs");
+	const { MemoryScanHandlers } = await import("./handlers.impl-XWXkQfyi.mjs");
 	globalContext = ctx;
 	const ctxAny = ctx;
 	if (ctxAny[DEP_KEY]) return ctxAny[DEP_KEY];
 	const [memoryScanner, scanSessionManager, pointerChainEngine, structureAnalyzer, codeInjector, memoryController] = await Promise.all([
-		import("./MemoryScanner-Bcpml6II.mjs"),
-		import("./MemoryScanSession-BsDZbLYm.mjs"),
-		import("./PointerChainEngine-BOhyVsjx.mjs"),
-		import("./StructureAnalyzer-DhFaPvRO.mjs"),
-		import("./CodeInjector-Cq8q01kp.mjs"),
-		import("./MemoryController-CbVdCIJF.mjs")
+		import("./MemoryScanner-CiL7Z3ey.mjs"),
+		import("./MemoryScanSession-ITgb_NMi.mjs"),
+		import("./PointerChainEngine-K7wN8Z-w.mjs"),
+		import("./StructureAnalyzer-Cav5AVSL.mjs"),
+		import("./CodeInjector-BdjRfNx7.mjs"),
+		import("./MemoryController-CMtviNW_.mjs")
 	]);
 	if (IS_WIN32) {
 		const [hardwareBreakpointEngine, speedhack, heapAnalyzer, peAnalyzer, antiCheatDetector] = await Promise.all([
-			import("./HardwareBreakpoint-B9gZCdFP.mjs"),
-			import("./Speedhack-CqdIFlQl.mjs"),
-			import("./HeapAnalyzer-BLDH0dCv.mjs"),
-			import("./PEAnalyzer-D1lzJ_VG.mjs"),
-			import("./AntiCheatDetector-BNk-EoBt.mjs")
+			import("./HardwareBreakpoint-Cc2AFq1Y.mjs"),
+			import("./Speedhack-D-z0umeT.mjs"),
+			import("./HeapAnalyzer-DruMgsgj.mjs"),
+			import("./PEAnalyzer-DMQ44gen.mjs"),
+			import("./AntiCheatDetector-CqGDXmfc.mjs")
 		]);
 		ctxAny[DEP_KEY] = new MemoryScanHandlers(memoryScanner.memoryScanner, scanSessionManager.scanSessionManager, pointerChainEngine.pointerChainEngine, structureAnalyzer.structureAnalyzer, hardwareBreakpointEngine.hardwareBreakpointEngine, codeInjector.codeInjector, memoryController.memoryController, speedhack.speedhack, heapAnalyzer.heapAnalyzer, peAnalyzer.peAnalyzer, antiCheatDetector.antiCheatDetector, ctx.eventBus);
 	} else ctxAny[DEP_KEY] = new MemoryScanHandlers(memoryScanner.memoryScanner, scanSessionManager.scanSessionManager, pointerChainEngine.pointerChainEngine, structureAnalyzer.structureAnalyzer, null, codeInjector.codeInjector, memoryController.memoryController, null, null, null, null, ctx.eventBus);
@@ -180,9 +180,9 @@ function bindByKey(invoke) {
 	return (deps) => {
 		const handler = deps[DEP_KEY];
 		return (args) => {
-			const _meta = args._meta;
+			const meta = args._meta;
 			let onProgress;
-			if (_meta?.progressToken !== void 0 && globalContext) onProgress = createProgressDebouncer(globalContext.eventBus, _meta.progressToken);
+			if (meta?.progressToken !== void 0 && globalContext) onProgress = createProgressDebouncer(globalContext.eventBus, meta.progressToken);
 			return invoke(handler, {
 				...args,
 				onProgress

package/dist/{manifest-CT7zZBV1.mjs → manifest-Bl62e8WK.mjs}

@@ -1,14 +1,31 @@
-import { n as toolLookup } from "./registry-D-6e18lB.mjs";
-import { t as bindByDepKey } from "./bind-helpers-xFfRF-qm.mjs";
-import { t as sharedStateBoardTools } from "./definitions-B3QdlrHv.mjs";
+import { n as toolLookup } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { t as sharedStateBoardTools } from "./definitions-DYVjOtxa.mjs";
 import { resolve } from "node:path";
 //#region src/server/domains/shared-state-board/manifest.ts
 const DOMAIN = "shared-state-board";
 const DEP_KEY = "sharedStateBoardHandlers";
-const t = toolLookup(sharedStateBoardTools);
-const b = (invoke) => bindByDepKey(DEP_KEY, invoke);
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(sharedStateBoardTools),
+	entries: [
+		{
+			tool: "state_board",
+			method: "handleDispatch"
+		},
+		{
+			tool: "state_board_watch",
+			method: "handleWatchDispatch"
+		},
+		{
+			tool: "state_board_io",
+			method: "handleIODispatch"
+		}
+	]
+});
 async function ensure(ctx) {
-	const { SharedStateBoardHandlers } = await import("./shared-state-board-DV-dpHFJ.mjs");
+	const { SharedStateBoardHandlers } = await import("./shared-state-board-BoZnSoj-.mjs");
 	if (!ctx.sharedStateBoardHandlers) ctx.sharedStateBoardHandlers = new SharedStateBoardHandlers();
 	const scheduler = ctx.getDomainInstance("snapshotScheduler");
 	const stateDir = ctx.getDomainInstance("snapshotStateDir");
@@ -26,23 +43,7 @@ const manifest = {
 	depKey: DEP_KEY,
 	profiles: ["workflow", "full"],
 	ensure,
-	registrations: [
-		{
-			tool: t("state_board"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleDispatch(a))
-		},
-		{
-			tool: t("state_board_watch"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleWatchDispatch(a))
-		},
-		{
-			tool: t("state_board_io"),
-			domain: DOMAIN,
-			bind: b((h, a) => h.handleIODispatch(a))
-		}
-	]
+	registrations
 };
 //#endregion
 export { manifest as default };