@jshookmcp/jshook 0.2.8 → 0.3.0

package/dist/manifest-BU7qzUyX.mjs

@@ -0,0 +1,418 @@
+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",
+	"int8",
+	"int16",
+	"uint16",
+	"int32",
+	"uint32",
+	"int64",
+	"uint64",
+	"float",
+	"double",
+	"string",
+	"hex",
+	"pointer"
+];
+const ScanCompareModeOptions = [
+	"exact",
+	"unknown_initial",
+	"changed",
+	"unchanged",
+	"increased",
+	"decreased",
+	"greater_than",
+	"less_than",
+	"between",
+	"not_equal"
+];
+const memoryScanToolDefinitions = [
+	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: {
+				type: "boolean",
+				description: "Only scan writable regions"
+			},
+			executable: {
+				type: "boolean",
+				description: "Only scan executable regions"
+			},
+			moduleOnly: {
+				type: "boolean",
+				description: "Only scan module-backed regions"
+			}
+		},
+		description: "Filter which memory regions to scan"
+	}).requiredOpenWorld("pid", "value", "valueType")),
+	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" },
+			executable: { type: "boolean" },
+			moduleOnly: { type: "boolean" }
+		}
+	}).requiredOpenWorld("pid", "valueType")),
+	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: {
+				type: "number",
+				description: "Byte offset from base"
+			},
+			value: {
+				type: "string",
+				description: "Expected value at offset"
+			},
+			type: {
+				type: "string",
+				enum: [...ScanValueTypeOptions],
+				description: "Value type at offset"
+			}
+		},
+		required: [
+			"offset",
+			"value",
+			"type"
+		]
+	}, "Array of {offset, value, type} patterns").number("alignment", "Alignment for base address (default: 4)").number("maxResults", "Maximum results (default: 1,000,000)").required("pid", "pattern").query()),
+	tool("memory_scan_session", (t) => t.desc(`Manage scan sessions. Actions: list (all sessions), delete (by sessionId), export (as JSON).`).enum("action", [
+		"list",
+		"delete",
+		"export"
+	], "Session management action").string("sessionId", "Scan session ID (required for delete/export)").required("action")),
+	tool("memory_pointer_chain", (t) => t.desc(`Multi-level pointer chain operations.
+
+Actions:
+- scan: Find pointer chains to a target address
+- validate: Validate chains by re-dereferencing
+- resolve: Resolve a single chain to its current target
+- export: Export chains as JSON`).enum("action", [
+		"scan",
+		"validate",
+		"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.").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()),
+	tool("memory_breakpoint", (t) => t.desc(`Hardware breakpoint operations using x64 debug registers (DR0-DR3). Max 4 concurrent.
+
+Actions:
+- set: Set a breakpoint (requires pid, address, access)
+- remove: Remove by breakpointId
+- list: List all active breakpoints
+- trace: Set temporary breakpoint, collect N hits, then auto-remove`).enum("action", [
+		"set",
+		"remove",
+		"list",
+		"trace"
+	], "Breakpoint operation").number("pid", "Target process ID (action=set/trace)").string("address", "Address hex (action=set/trace)").enum("access", [
+		"read",
+		"write",
+		"readwrite",
+		"execute"
+	], "Access type (action=set/trace)").number("size", "Watch size in bytes (action=set, default: 4)").string("breakpointId", "Breakpoint ID (action=remove)").number("maxHits", "Max hits to collect (action=trace, default: 50)").number("timeoutMs", "Timeout ms (action=trace, default: 10000)").required("action").destructive()),
+	tool("memory_patch_bytes", (t) => t.desc("Write bytes to target process at address. Saves original bytes for undo. Use for runtime code patching.").number("pid", "Target process ID").string("address", "Address to patch (hex)").array("bytes", { type: "number" }, "Byte values to write (e.g. [0x90, 0x90])").required("pid", "address", "bytes").destructive().openWorld()),
+	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/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.
+
+Actions:
+- apply: Hook and apply speed multiplier (requires pid, speed)
+- set: Adjust speed on active hack (requires pid, speed)`).enum("action", ["apply", "set"], "Speedhack action").number("pid", "Target process ID").number("speed", "Speed multiplier").required("action", "pid", "speed").destructive()),
+	tool("memory_write_history", (t) => t.desc("Undo or redo the last memory write operation.").enum("action", ["undo", "redo"], "History action").required("action").destructive().openWorld()),
+	tool("memory_heap_enumerate", (t) => t.desc("Enumerate all heaps and heap blocks in a process via Toolhelp32 snapshot. Returns heap list with block counts, sizes, and overall statistics.").number("pid", "Target process ID").number("maxBlocks", "Maximum blocks to enumerate per heap (default: 10000)").required("pid").query()),
+	tool("memory_heap_stats", (t) => t.desc("Get detailed heap statistics with size distribution buckets (0-64B, 64B-1KB, 1-64KB, 64KB-1MB, >1MB), fragmentation ratio, and aggregate metrics.").number("pid", "Target process ID").required("pid").query()),
+	tool("memory_heap_anomalies", (t) => t.desc("Detect heap anomalies: heap spray patterns (many same-size blocks), possible use-after-free (non-zero free blocks), and suspicious block sizes (0 or >100MB).").number("pid", "Target process ID").required("pid").query()),
+	tool("memory_pe_headers", (t) => t.desc("Parse PE headers (DOS, NT, File, Optional) from a module base address in process memory. Returns machine type, entry point, image base, section count, and data directory info.").number("pid", "Target process ID").string("moduleBase", "Module base address (hex, e.g. \"0x7ff612340000\")").required("pid", "moduleBase").query()),
+	tool("memory_pe_imports_exports", (t) => t.desc("Parse import and/or export tables from a PE module in process memory. Returns DLL names, function names, ordinals, hints, and forwarded exports.").number("pid", "Target process ID").string("moduleBase", "Module base address (hex)").enum("table", [
+		"imports",
+		"exports",
+		"both"
+	], "Which table to parse", { default: "both" }).required("pid", "moduleBase").query()),
+	tool("memory_inline_hook_detect", (t) => t.desc("Detect inline hooks by comparing the first 16 bytes of each exported function on disk vs in memory. Identifies JMP rel32, JMP abs64, PUSH+RET hooks and decodes jump targets.").number("pid", "Target process ID").string("moduleName", "Module name filter (optional — scans all modules if omitted)").required("pid").query()),
+	tool("memory_anticheat_detect", (t) => t.desc("Scan process imports for anti-debug/anti-cheat mechanisms: IsDebuggerPresent, NtQueryInformationProcess, timing checks (QPC, GetTickCount), thread hiding, heap flag checks, and DR register inspection. Each detection includes a bypass suggestion.").number("pid", "Target process ID").required("pid").query()),
+	tool("memory_guard_pages", (t) => t.desc("Find all memory regions with PAGE_GUARD protection in a process. Guard pages are often used as anti-tampering mechanisms or stack overflow detection.").number("pid", "Target process ID").required("pid").query()),
+	tool("memory_integrity_check", (t) => t.desc("Check executable memory regions against their corresponding on-disk PE files (.text sections) to detect modifications like inline hooks or code patches.").number("pid", "Target process ID").required("pid").query())
+];
+//#endregion
+//#region src/server/domains/memory/manifest.ts
+const DOMAIN = "memory";
+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-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-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-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);
+	return ctxAny[DEP_KEY];
+}
+function bindByKey(invoke) {
+	return (deps) => {
+		const handler = deps[DEP_KEY];
+		return (args) => {
+			const meta = args._meta;
+			let onProgress;
+			if (meta?.progressToken !== void 0 && globalContext) onProgress = createProgressDebouncer(globalContext.eventBus, meta.progressToken);
+			return invoke(handler, {
+				...args,
+				onProgress
+			});
+		};
+	};
+}
+function toolByName(name) {
+	const tool = memoryScanToolDefinitions.find((t) => t.name === name);
+	if (!tool) throw new Error(`Memory tool not found: ${name}`);
+	return tool;
+}
+const WIN32_ONLY_TOOLS = new Set([
+	"memory_heap_enumerate",
+	"memory_heap_stats",
+	"memory_heap_anomalies",
+	"memory_pe_headers",
+	"memory_pe_imports_exports",
+	"memory_inline_hook_detect",
+	"memory_anticheat_detect",
+	"memory_guard_pages",
+	"memory_integrity_check",
+	"memory_breakpoint",
+	"memory_speedhack"
+]);
+const allRegistrations = [
+	{
+		tool: toolByName("memory_first_scan"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleFirstScan(a))
+	},
+	{
+		tool: toolByName("memory_next_scan"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleNextScan(a))
+	},
+	{
+		tool: toolByName("memory_unknown_scan"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleUnknownScan(a))
+	},
+	{
+		tool: toolByName("memory_pointer_scan"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handlePointerScan(a))
+	},
+	{
+		tool: toolByName("memory_group_scan"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleGroupScan(a))
+	},
+	{
+		tool: toolByName("memory_scan_session"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleScanSessionDispatch(a))
+	},
+	{
+		tool: toolByName("memory_pointer_chain"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handlePointerChainDispatch(a))
+	},
+	{
+		tool: toolByName("memory_structure_analyze"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleStructureAnalyze(a))
+	},
+	{
+		tool: toolByName("memory_vtable_parse"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleVtableParse(a))
+	},
+	{
+		tool: toolByName("memory_structure_export_c"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleStructureExportC(a))
+	},
+	{
+		tool: toolByName("memory_structure_compare"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleStructureCompare(a))
+	},
+	{
+		tool: toolByName("memory_breakpoint"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleBreakpointDispatch(a))
+	},
+	{
+		tool: toolByName("memory_patch_bytes"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handlePatchBytes(a))
+	},
+	{
+		tool: toolByName("memory_patch_nop"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handlePatchNop(a))
+	},
+	{
+		tool: toolByName("memory_patch_undo"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handlePatchUndo(a))
+	},
+	{
+		tool: toolByName("memory_code_caves"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleCodeCaves(a))
+	},
+	{
+		tool: toolByName("memory_write_value"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleWriteValue(a))
+	},
+	{
+		tool: toolByName("memory_freeze"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleFreezeDispatch(a))
+	},
+	{
+		tool: toolByName("memory_dump"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleDump(a))
+	},
+	{
+		tool: toolByName("memory_speedhack"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleSpeedhackDispatch(a))
+	},
+	{
+		tool: toolByName("memory_write_history"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleWriteHistoryDispatch(a))
+	},
+	{
+		tool: toolByName("memory_heap_enumerate"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleHeapEnumerate(a))
+	},
+	{
+		tool: toolByName("memory_heap_stats"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleHeapStats(a))
+	},
+	{
+		tool: toolByName("memory_heap_anomalies"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleHeapAnomalies(a))
+	},
+	{
+		tool: toolByName("memory_pe_headers"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handlePEHeaders(a))
+	},
+	{
+		tool: toolByName("memory_pe_imports_exports"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handlePEImportsExports(a))
+	},
+	{
+		tool: toolByName("memory_inline_hook_detect"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleInlineHookDetect(a))
+	},
+	{
+		tool: toolByName("memory_anticheat_detect"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleAntiCheatDetect(a))
+	},
+	{
+		tool: toolByName("memory_guard_pages"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleGuardPages(a))
+	},
+	{
+		tool: toolByName("memory_integrity_check"),
+		domain: DOMAIN,
+		bind: bindByKey((h, a) => h.handleIntegrityCheck(a))
+	}
+];
+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)),
+	workflowRule: {
+		patterns: [
+			/memory\s*scan/i,
+			/cheat\s*engine/i,
+			/find\s*(value|address|variable|struct)/i,
+			/scan\s*(for|memory)/i,
+			/pointer\s*(chain|scan)/i,
+			/struct(ure)?\s*(analy|infer|dissect)/i,
+			/vtable|rtti/i,
+			/breakpoint|watchpoint|hardware\s*bp/i,
+			/patch\s*(byte|nop|code)/i,
+			/code\s*cave/i,
+			/freeze|unfreeze/i,
+			/speedhack|time\s*(hack|scale)/i,
+			/memory\s*(dump|hex)/i,
+			/undo|redo/i,
+			/heap|堆\s*(分析|枚举|异常)/i,
+			/PE\s*(header|import|export)|inline.*hook/i,
+			/anti.?cheat|anti.?debug|反作弊|反调试/i,
+			/guard\s*page|integrity\s*check|代码完整性/i,
+			/内存\s*(扫描|搜索|分析|结构|断点|注入|冻结|加速|堆|模块|反作弊)/i
+		],
+		priority: 90,
+		tools: [
+			"memory_first_scan",
+			"memory_next_scan",
+			"memory_unknown_scan",
+			"memory_pointer_chain",
+			"memory_structure_analyze",
+			"memory_vtable_parse",
+			"memory_scan_session",
+			...IS_WIN32 ? ["memory_breakpoint", "memory_speedhack"] : [],
+			"memory_patch_bytes",
+			"memory_freeze",
+			"memory_dump",
+			...IS_WIN32 ? [
+				"memory_speedhack",
+				"memory_heap_enumerate",
+				"memory_pe_headers",
+				"memory_anticheat_detect"
+			] : [],
+			"memory_write_history"
+		],
+		hint: IS_WIN32 ? "Memory domain: scan → narrow → pointer chain → structure | breakpoint trace → patch/NOP → freeze | speedhack | heap analysis | PE introspection | anti-cheat detection" : "Memory domain: scan → narrow → pointer chain → structure | patch/NOP → freeze | dump"
+	}
+};
+//#endregion
+export { manifest as default };

package/dist/manifest-Bl62e8WK.mjs

@@ -0,0 +1,49 @@
+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 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-BoZnSoj-.mjs");
+	if (!ctx.sharedStateBoardHandlers) ctx.sharedStateBoardHandlers = new SharedStateBoardHandlers();
+	const scheduler = ctx.getDomainInstance("snapshotScheduler");
+	const stateDir = ctx.getDomainInstance("snapshotStateDir");
+	ctx.sharedStateBoardHandlers.setPersistNotifier(scheduler ? () => scheduler.notifyDirty() : void 0);
+	if (scheduler && stateDir && !ctx.getDomainInstance("sharedStateBoardSnapshotRegistered")) {
+		scheduler.register(resolve(stateDir, "state-board", "current.json"), ctx.sharedStateBoardHandlers.getStore());
+		ctx.setDomainInstance("sharedStateBoardSnapshotRegistered", true);
+	}
+	return ctx.sharedStateBoardHandlers;
+}
+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-Bo5cXjdt.mjs

@@ -0,0 +1,82 @@
+import { n as toolLookup } from "./registry-Bl8ZQW61.mjs";
+import { n as defineMethodRegistrations } from "./bind-helpers-ClV34xdn.mjs";
+import { t as wasmTools } from "./definitions-BEoYofW5.mjs";
+//#region src/server/domains/wasm/manifest.ts
+const DOMAIN = "wasm";
+const DEP_KEY = "wasmHandlers";
+const registrations = defineMethodRegistrations({
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	lookup: toolLookup(wasmTools),
+	entries: [
+		{
+			tool: "wasm_capabilities",
+			method: "handleWasmCapabilities"
+		},
+		{
+			tool: "wasm_dump",
+			method: "handleWasmDump"
+		},
+		{
+			tool: "wasm_disassemble",
+			method: "handleWasmDisassemble"
+		},
+		{
+			tool: "wasm_decompile",
+			method: "handleWasmDecompile"
+		},
+		{
+			tool: "wasm_inspect_sections",
+			method: "handleWasmInspectSections"
+		},
+		{
+			tool: "wasm_offline_run",
+			method: "handleWasmOfflineRun"
+		},
+		{
+			tool: "wasm_optimize",
+			method: "handleWasmOptimize"
+		},
+		{
+			tool: "wasm_vmp_trace",
+			method: "handleWasmVmpTrace"
+		},
+		{
+			tool: "wasm_memory_inspect",
+			method: "handleWasmMemoryInspect"
+		},
+		{
+			tool: "wasm_to_c",
+			method: "handleWasmToC"
+		},
+		{
+			tool: "wasm_detect_obfuscation",
+			method: "handleWasmDetectObfuscation"
+		},
+		{
+			tool: "wasm_instrument_trace",
+			method: "handleWasmInstrumentTrace"
+		}
+	]
+});
+async function ensure(ctx) {
+	const { CodeCollector } = await import("./modules-tZozf0LQ.mjs").then((n) => n.t);
+	const { WasmToolHandlers } = await import("./wasm-BYx5UOeG.mjs");
+	if (!ctx.collector) {
+		ctx.collector = new CodeCollector(ctx.config.puppeteer);
+		ctx.registerCaches();
+	}
+	if (!ctx.wasmHandlers) ctx.wasmHandlers = new WasmToolHandlers(ctx.collector);
+	return ctx.wasmHandlers;
+}
+const manifest = {
+	kind: "domain-manifest",
+	version: 1,
+	domain: DOMAIN,
+	depKey: DEP_KEY,
+	profiles: ["full"],
+	ensure,
+	registrations
+};
+//#endregion
+export { manifest as default };