@jshookmcp/jshook 0.3.0 → 0.3.1

package/dist/InstrumentationSession-DLH0vd-z.mjs

@@ -1,244 +0,0 @@
-//#region src/server/instrumentation/InstrumentationSession.ts
-let nextId = 0;
-function uid(prefix) {
-	return `${prefix}-${Date.now().toString(36)}-${(++nextId).toString(36)}`;
-}
-function isRecord(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function parseToolPayload(response) {
-	const firstText = response.content.find((item) => item.type === "text" && typeof item.text === "string");
-	if (!firstText) throw new Error("Expected JSON text payload from wrapped tool response");
-	let parsed;
-	try {
-		parsed = JSON.parse(firstText.text);
-	} catch (error) {
-		throw new Error(
-			/* istanbul ignore next */
-			`Wrapped tool returned non-JSON text payload: ${error instanceof Error ? error.message : String(error)}`,
-			{ cause: error }
-		);
-	}
-	if (!isRecord(parsed)) throw new Error("Wrapped tool returned JSON that is not an object");
-	return parsed;
-}
-function getStringArray(value) {
-	return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
-}
-var InstrumentationSessionManager = class {
-	/** All sessions (including destroyed). */
-	sessions = /* @__PURE__ */ new Map();
-	/** Session ID → operations. */
-	operations = /* @__PURE__ */ new Map();
-	/** Session ID → artifacts. */
-	artifacts = /* @__PURE__ */ new Map();
-	/** Operation ID → owning session ID (reverse index). */
-	operationIndex = /* @__PURE__ */ new Map();
-	/** Optional evidence graph bridge for auto-population (EVID-04). */
-	evidenceBridge;
-	/** Set the evidence graph bridge for auto-populating evidence nodes. */
-	setEvidenceBridge(bridge) {
-		this.evidenceBridge = bridge;
-	}
-	createSession(name) {
-		const id = uid("sess");
-		const info = {
-			id,
-			name,
-			createdAt: Date.now(),
-			operationCount: 0,
-			artifactCount: 0,
-			status: "active"
-		};
-		this.sessions.set(id, info);
-		this.operations.set(id, []);
-		this.artifacts.set(id, []);
-		return info;
-	}
-	destroySession(sessionId) {
-		const session = this.sessions.get(sessionId);
-		if (!session) throw new Error(`Session "${sessionId}" not found`);
-		session.status = "destroyed";
-		/* istanbul ignore next */
-		const ops = this.operations.get(sessionId) ?? [];
-		for (const op of ops) if (op.status === "active") op.status = "completed";
-	}
-	listSessions() {
-		return [...this.sessions.values()].filter((s) => s.status === "active");
-	}
-	getSession(sessionId) {
-		return this.sessions.get(sessionId);
-	}
-	registerOperation(sessionId, type, target, config) {
-		const session = this.sessions.get(sessionId);
-		if (!session) throw new Error(`Session "${sessionId}" not found`);
-		if (session.status === "destroyed") throw new Error(`Session "${sessionId}" is destroyed — cannot register new operations`);
-		const id = uid("op");
-		const op = {
-			id,
-			sessionId,
-			type,
-			target,
-			config,
-			createdAt: Date.now(),
-			status: "active"
-		};
-		const ops = this.operations.get(sessionId);
-		ops.push(op);
-		this.operationIndex.set(id, sessionId);
-		session.operationCount = ops.length;
-		this.evidenceBridge?.onOperation(op);
-		return op;
-	}
-	getSessionOperations(sessionId) {
-		/* istanbul ignore next */
-		return this.operations.get(sessionId) ?? [];
-	}
-	recordArtifact(operationId, data) {
-		const sessionId = this.operationIndex.get(operationId);
-		if (!sessionId) throw new Error(`Operation "${operationId}" not found`);
-		const op = (this.operations.get(sessionId) ?? []).find((o) => o.id === operationId);
-		if (!op) throw new Error(`Operation "${operationId}" metadata missing`);
-		const artifact = {
-			operationId,
-			sessionId,
-			type: op.type,
-			timestamp: Date.now(),
-			data
-		};
-		const sessionArtifacts = this.artifacts.get(sessionId);
-		sessionArtifacts.push(artifact);
-		const session = this.sessions.get(sessionId);
-		session.artifactCount = sessionArtifacts.length;
-		this.evidenceBridge?.onArtifact(artifact);
-		return artifact;
-	}
-	getArtifacts(sessionId, type) {
-		/* istanbul ignore next */
-		const all = this.artifacts.get(sessionId) ?? [];
-		if (!type) return all;
-		return all.filter((a) => a.type === type);
-	}
-	getSessionSnapshot(sessionId) {
-		const session = this.sessions.get(sessionId);
-		if (!session) return;
-		return {
-			session,
-			stats: this.getSessionStats(sessionId),
-			operations: [...this.getSessionOperations(sessionId)],
-			artifacts: [...this.getArtifacts(sessionId)]
-		};
-	}
-	listSessionSnapshots() {
-		return this.listSessions().map((session) => ({
-			session,
-			stats: this.getSessionStats(session.id),
-			operations: [...this.getSessionOperations(session.id)],
-			artifacts: [...this.getArtifacts(session.id)]
-		}));
-	}
-	async applyHookPreset(sessionId, presetInvoker, args) {
-		const presetNames = getStringArray(args["presets"]);
-		const target = (typeof args["preset"] === "string" ? args["preset"] : void 0) ?? (presetNames.length > 0 ? presetNames.join(", ") : "hook_preset");
-		return this.executeTrackedTool({
-			sessionId,
-			type: "runtime-hook",
-			target,
-			config: { ...args },
-			invoke: () => presetInvoker.handleHookPreset(args),
-			isSuccessful: (payload) => {
-				return getStringArray(payload.injected).length > 0;
-			},
-			buildArtifacts: (payload) => {
-				const injected = getStringArray(payload.injected);
-				return [{
-					presetIds: injected,
-					failedPresets: Array.isArray(payload.failed) ? payload.failed.filter((item) => isRecord(item) && typeof item["preset"] === "string" && typeof item["error"] === "string") : [],
-					injectionPoint: payload.method === "evaluateOnNewDocument" ? "before-load" : "runtime",
-					scriptContent: injected.join(", "),
-					body: payload
-				}];
-			}
-		});
-	}
-	async replayNetworkRequest(sessionId, replayInvoker, args) {
-		const requestId = typeof args["requestId"] === "string" ? args["requestId"] : "network_replay";
-		const urlOverride = typeof args["urlOverride"] === "string" ? args["urlOverride"] : void 0;
-		return this.executeTrackedTool({
-			sessionId,
-			type: "network-intercept",
-			target: requestId,
-			config: { ...args },
-			invoke: () => replayInvoker.handleNetworkReplayRequest(args),
-			buildArtifacts: (payload) => {
-				if (payload.dryRun === true && isRecord(payload.preview)) return [{
-					requestId,
-					url: typeof payload.preview["url"] === "string" ? payload.preview["url"] : urlOverride,
-					method: typeof payload.preview["method"] === "string" ? payload.preview["method"] : void 0,
-					headers: isRecord(payload.preview["headers"]) ? payload.preview["headers"] : void 0,
-					body: payload.preview["body"],
-					replayMode: "dry-run"
-				}];
-				return [{
-					requestId: typeof payload.requestId === "string" ? payload.requestId : requestId,
-					url: urlOverride,
-					method: typeof args["methodOverride"] === "string" ? args["methodOverride"] : void 0,
-					headers: isRecord(payload.headers) ? payload.headers : void 0,
-					body: payload.body,
-					statusCode: typeof payload.status === "number" ? payload.status : void 0,
-					statusText: typeof payload.statusText === "string" ? payload.statusText : void 0,
-					bodyTruncated: typeof payload.bodyTruncated === "boolean" ? payload.bodyTruncated : void 0,
-					replayMode: "live"
-				}];
-			}
-		});
-	}
-	getSessionStats(sessionId) {
-		const session = this.sessions.get(sessionId);
-		if (!session) return {
-			operationCount: 0,
-			artifactCount: 0
-		};
-		return {
-			operationCount: session.operationCount,
-			artifactCount: session.artifactCount
-		};
-	}
-	findOperation(operationId) {
-		const sessionId = this.operationIndex.get(operationId);
-		if (!sessionId) return;
-		/* istanbul ignore next */
-		return (this.operations.get(sessionId) ?? []).find((operation) => operation.id === operationId);
-	}
-	setOperationStatus(operationId, status) {
-		const operation = this.findOperation(operationId);
-		if (operation) operation.status = status;
-	}
-	async executeTrackedTool(spec) {
-		const operation = this.registerOperation(spec.sessionId, spec.type, spec.target, spec.config);
-		try {
-			const payload = parseToolPayload(await spec.invoke());
-			if (!(spec.isSuccessful ? spec.isSuccessful(payload) : payload["success"] !== false)) {
-				this.setOperationStatus(operation.id, "failed");
-				return {
-					operation,
-					artifacts: [],
-					payload
-				};
-			}
-			/* istanbul ignore next */
-			const artifacts = (spec.buildArtifacts?.(payload) ?? []).map((artifactData) => this.recordArtifact(operation.id, artifactData));
-			this.setOperationStatus(operation.id, "completed");
-			return {
-				operation,
-				artifacts,
-				payload
-			};
-		} catch (error) {
-			this.setOperationStatus(operation.id, "failed");
-			throw error;
-		}
-	}
-};
-//#endregion
-export { InstrumentationSessionManager };

package/dist/MemoryController-CMtviNW_.mjs

@@ -1,167 +0,0 @@
-import { Vr as WRITE_HISTORY_MAX, Z as FREEZE_DEFAULT_INTERVAL_MS } from "./constants-CDZLOoVv.mjs";
-import { _ as WriteProcessMemory, b as openProcessForMemory, d as ReadProcessMemory, m as VirtualProtectEx, t as CloseHandle, u as PAGE } from "./Win32API-C2kjj0ze.mjs";
-import { i as parsePattern } from "./NativeMemoryManager.utils-BBlAixF5.mjs";
-import { randomUUID } from "node:crypto";
-//#region src/native/MemoryController.ts
-/**
-* Memory Controller — freeze, undo/redo writes, memory dump.
-*
-* @module MemoryController
-*/
-var MemoryController = class {
-	freezes = /* @__PURE__ */ new Map();
-	writeHistory = [];
-	undoneStack = [];
-	/** Write a typed value to memory (with undo support) */
-	async writeValue(pid, address, value, valueType) {
-		const addr = BigInt(address.startsWith("0x") ? address : `0x${address}`);
-		const { patternBytes } = parsePattern(value, valueType);
-		const newBuf = Buffer.from(patternBytes);
-		const handle = openProcessForMemory(pid, true);
-		try {
-			const oldBuf = ReadProcessMemory(handle, addr, newBuf.length);
-			const { oldProtect } = VirtualProtectEx(handle, addr, newBuf.length, PAGE.READWRITE);
-			WriteProcessMemory(handle, addr, newBuf);
-			VirtualProtectEx(handle, addr, newBuf.length, oldProtect);
-			const entry = {
-				id: randomUUID(),
-				pid,
-				address: `0x${addr.toString(16).toUpperCase()}`,
-				oldValue: Array.from(oldBuf),
-				newValue: Array.from(newBuf),
-				timestamp: Date.now(),
-				undone: false
-			};
-			this.writeHistory.push(entry);
-			this.undoneStack = [];
-			if (this.writeHistory.length > WRITE_HISTORY_MAX) this.writeHistory = this.writeHistory.slice(-WRITE_HISTORY_MAX);
-			return entry;
-		} finally {
-			CloseHandle(handle);
-		}
-	}
-	/** Undo last write */
-	async undo() {
-		for (let i = this.writeHistory.length - 1; i >= 0; i--) {
-			const entry = this.writeHistory[i];
-			if (!entry.undone) {
-				const addr = BigInt(entry.address);
-				const oldBuf = Buffer.from(entry.oldValue);
-				const handle = openProcessForMemory(entry.pid, true);
-				try {
-					const { oldProtect } = VirtualProtectEx(handle, addr, oldBuf.length, PAGE.READWRITE);
-					WriteProcessMemory(handle, addr, oldBuf);
-					VirtualProtectEx(handle, addr, oldBuf.length, oldProtect);
-				} finally {
-					CloseHandle(handle);
-				}
-				entry.undone = true;
-				this.undoneStack.push(entry);
-				return entry;
-			}
-		}
-		return null;
-	}
-	/** Redo last undone write */
-	async redo() {
-		const entry = this.undoneStack.pop();
-		if (!entry) return null;
-		const addr = BigInt(entry.address);
-		const newBuf = Buffer.from(entry.newValue);
-		const handle = openProcessForMemory(entry.pid, true);
-		try {
-			const { oldProtect } = VirtualProtectEx(handle, addr, newBuf.length, PAGE.READWRITE);
-			WriteProcessMemory(handle, addr, newBuf);
-			VirtualProtectEx(handle, addr, newBuf.length, oldProtect);
-		} finally {
-			CloseHandle(handle);
-		}
-		entry.undone = false;
-		return entry;
-	}
-	/** Freeze: continuously write value at interval */
-	async freeze(pid, address, value, valueType, intervalMs) {
-		const addr = BigInt(address.startsWith("0x") ? address : `0x${address}`);
-		const { patternBytes } = parsePattern(value, valueType);
-		const valueBuf = Buffer.from(patternBytes);
-		const interval = intervalMs ?? FREEZE_DEFAULT_INTERVAL_MS;
-		const entry = {
-			id: randomUUID(),
-			pid,
-			address: `0x${addr.toString(16).toUpperCase()}`,
-			value: Array.from(valueBuf),
-			valueType,
-			intervalMs: interval,
-			isActive: true
-		};
-		entry.timer = setInterval(() => {
-			try {
-				const handle = openProcessForMemory(pid, true);
-				try {
-					const { oldProtect } = VirtualProtectEx(handle, addr, valueBuf.length, PAGE.READWRITE);
-					WriteProcessMemory(handle, addr, valueBuf);
-					VirtualProtectEx(handle, addr, valueBuf.length, oldProtect);
-				} finally {
-					CloseHandle(handle);
-				}
-			} catch {
-				entry.isActive = false;
-				if (entry.timer) clearInterval(entry.timer);
-			}
-		}, interval);
-		this.freezes.set(entry.id, entry);
-		return entry;
-	}
-	/** Unfreeze */
-	async unfreeze(freezeId) {
-		const entry = this.freezes.get(freezeId);
-		if (!entry) return false;
-		if (entry.timer) clearInterval(entry.timer);
-		entry.isActive = false;
-		this.freezes.delete(freezeId);
-		return true;
-	}
-	/** Unfreeze all */
-	async unfreezeAll() {
-		let count = 0;
-		for (const [id] of this.freezes) {
-			await this.unfreeze(id);
-			count++;
-		}
-		return count;
-	}
-	/** List all active freezes */
-	listFreezes() {
-		return Array.from(this.freezes.values()).map(({ timer: _timer, ...rest }) => rest);
-	}
-	/** Dump memory region to Buffer */
-	async dumpMemory(pid, address, size) {
-		const addr = BigInt(address.startsWith("0x") ? address : `0x${address}`);
-		const handle = openProcessForMemory(pid, false);
-		try {
-			return ReadProcessMemory(handle, addr, size);
-		} finally {
-			CloseHandle(handle);
-		}
-	}
-	/** Dump memory region as hex string */
-	async dumpMemoryHex(pid, address, size) {
-		const buf = await this.dumpMemory(pid, address, size);
-		const lines = [];
-		const addr = BigInt(address.startsWith("0x") ? address : `0x${address}`);
-		for (let i = 0; i < buf.length; i += 16) {
-			const lineAddr = addr + BigInt(i);
-			const hex = Array.from(buf.subarray(i, Math.min(i + 16, buf.length))).map((b) => b.toString(16).padStart(2, "0")).join(" ");
-			const ascii = Array.from(buf.subarray(i, Math.min(i + 16, buf.length))).map((b) => b >= 32 && b <= 126 ? String.fromCharCode(b) : ".").join("");
-			lines.push(`${lineAddr.toString(16).padStart(12, "0")}  ${hex.padEnd(47)}  |${ascii}|`);
-		}
-		return lines.join("\n");
-	}
-	/** Get write history */
-	getWriteHistory() {
-		return [...this.writeHistory];
-	}
-};
-const memoryController = new MemoryController();
-//#endregion
-export { MemoryController, memoryController };

package/dist/MemoryScanSession-ITgb_NMi.mjs

@@ -1,278 +0,0 @@
-import { Sn as SCAN_SESSION_TTL_MS, xn as SCAN_SESSION_MAX_COUNT } from "./constants-CDZLOoVv.mjs";
-import { n as parseAddress, t as formatAddress } from "./formatAddress-nnMvEohD.mjs";
-import { randomUUID } from "node:crypto";
-//#region src/native/ScanComparators.ts
-const FLOAT_EPSILON = 1e-6;
-const DOUBLE_EPSILON = 1e-12;
-/**
-* Return the byte width for a given scan value type.
-*/
-function getValueSize(type) {
-	switch (type) {
-		case "byte":
-		case "int8": return 1;
-		case "int16":
-		case "uint16": return 2;
-		case "int32":
-		case "uint32":
-		case "float": return 4;
-		case "int64":
-		case "uint64":
-		case "double":
-		case "pointer": return 8;
-		case "hex":
-		case "string": return 0;
-		default: return 4;
-	}
-}
-/**
-* Return the natural alignment for a given value type.
-*/
-function getDefaultAlignment(type) {
-	switch (type) {
-		case "byte":
-		case "int8": return 1;
-		case "int16":
-		case "uint16": return 2;
-		case "int32":
-		case "uint32":
-		case "float": return 4;
-		case "int64":
-		case "uint64":
-		case "double":
-		case "pointer": return 8;
-		default: return 1;
-	}
-}
-function makeReader(type) {
-	switch (type) {
-		case "byte": return (buf) => buf.readUInt8(0);
-		case "int8": return (buf) => buf.readInt8(0);
-		case "int16": return (buf) => buf.readInt16LE(0);
-		case "uint16": return (buf) => buf.readUInt16LE(0);
-		case "int32": return (buf) => buf.readInt32LE(0);
-		case "uint32": return (buf) => buf.readUInt32LE(0);
-		case "int64": return (buf) => buf.readBigInt64LE(0);
-		case "uint64":
-		case "pointer": return (buf) => buf.readBigUInt64LE(0);
-		case "float": return (buf) => buf.readFloatLE(0);
-		case "double": return (buf) => buf.readDoubleLE(0);
-		default: return (buf) => buf.readInt32LE(0);
-	}
-}
-function makeApproxEqual(type) {
-	if (type === "float") return (a, b) => Math.abs(Number(a) - Number(b)) < FLOAT_EPSILON;
-	if (type === "double") return (a, b) => Math.abs(Number(a) - Number(b)) < DOUBLE_EPSILON;
-	if (type === "int64" || type === "uint64" || type === "pointer") return (a, b) => a === b;
-	return (a, b) => Number(a) === Number(b);
-}
-function makeComparator(mode, type) {
-	const read = makeReader(type);
-	const approxEq = makeApproxEqual(type);
-	const compare = type === "int64" || type === "uint64" || type === "pointer" ? (a, b) => {
-		const ba = BigInt(a);
-		const bb = BigInt(b);
-		return ba < bb ? -1 : ba > bb ? 1 : 0;
-	} : (a, b) => Number(a) - Number(b);
-	switch (mode) {
-		case "exact": return (cur, _prev, tgt, _tgt2) => {
-			if (!tgt) return false;
-			return approxEq(read(cur), read(tgt));
-		};
-		case "unknown_initial": return () => true;
-		case "changed": return (cur, prev, _tgt, _tgt2) => {
-			if (!prev) return false;
-			return !approxEq(read(cur), read(prev));
-		};
-		case "unchanged": return (cur, prev, _tgt, _tgt2) => {
-			if (!prev) return true;
-			return approxEq(read(cur), read(prev));
-		};
-		case "increased": return (cur, prev, _tgt, _tgt2) => {
-			if (!prev) return false;
-			return compare(read(cur), read(prev)) > 0;
-		};
-		case "decreased": return (cur, prev, _tgt, _tgt2) => {
-			if (!prev) return false;
-			return compare(read(cur), read(prev)) < 0;
-		};
-		case "greater_than": return (cur, _prev, tgt, _tgt2) => {
-			if (!tgt) return false;
-			return compare(read(cur), read(tgt)) > 0;
-		};
-		case "less_than": return (cur, _prev, tgt, _tgt2) => {
-			if (!tgt) return false;
-			return compare(read(cur), read(tgt)) < 0;
-		};
-		case "between": return (cur, _prev, tgt, tgt2) => {
-			if (!tgt || !tgt2) return false;
-			return compare(read(cur), read(tgt)) >= 0 && compare(read(cur), read(tgt2)) <= 0;
-		};
-		case "not_equal": return (cur, _prev, tgt, _tgt2) => {
-			if (!tgt) return false;
-			return !approxEq(read(cur), read(tgt));
-		};
-		default: return () => false;
-	}
-}
-const comparatorCache = /* @__PURE__ */ new Map();
-function getComparator(mode, valueType) {
-	const key = `${mode}:${valueType}`;
-	let comp = comparatorCache.get(key);
-	if (!comp) {
-		comp = makeComparator(mode, valueType);
-		comparatorCache.set(key, comp);
-	}
-	return comp;
-}
-/**
-* Compare scan values according to the specified mode.
-*
-* Dispatches to a monomorphic specialist comparator that is cached per
-* (mode, valueType) pair. This avoids per-call switch dispatch on valueType
-* in the hot scan loop, allowing V8 TurboFan to inline and optimize the
-* typed read + compare path.
-*/
-function compareScanValues(current, previous, target, target2, mode, valueType) {
-	return getComparator(mode, valueType)(current, previous, target, target2);
-}
-//#endregion
-//#region src/native/MemoryScanSession.ts
-/**
-* Scan Session Manager — manages in-memory scan sessions for iterative scanning.
-*
-* Sessions persist scan results across multiple scan iterations, allowing
-* the CE-style workflow: first scan → next scan → narrow down → find target.
-*
-* @module MemoryScanSession
-*/
-var MemoryScanSessionManager = class {
-	sessions = /* @__PURE__ */ new Map();
-	maxSessions;
-	sessionTtlMs;
-	constructor(maxSessions = SCAN_SESSION_MAX_COUNT, sessionTtlMs = SCAN_SESSION_TTL_MS) {
-		this.maxSessions = maxSessions;
-		this.sessionTtlMs = sessionTtlMs;
-	}
-	/** Create a new scan session for a given PID and value type. */
-	createSession(pid, options) {
-		this.cleanup();
-		if (this.sessions.size >= this.maxSessions) {
-			let oldestId = null;
-			let oldestTime = Infinity;
-			for (const [id, session] of this.sessions) if (session.createdAt < oldestTime) {
-				oldestTime = session.createdAt;
-				oldestId = id;
-			}
-			if (oldestId) this.sessions.delete(oldestId);
-		}
-		const id = randomUUID();
-		const alignment = options.alignment ?? getDefaultAlignment(options.valueType);
-		const now = Date.now();
-		const session = {
-			id,
-			pid,
-			valueType: options.valueType,
-			alignment,
-			createdAt: now,
-			lastScanAt: now,
-			scanCount: 0,
-			addresses: [],
-			previousValues: /* @__PURE__ */ new Map()
-		};
-		this.sessions.set(id, session);
-		return id;
-	}
-	/** Get session by ID. Throws if not found or expired. */
-	getSession(sessionId) {
-		const session = this.sessions.get(sessionId);
-		if (!session) throw new Error(`Scan session not found: ${sessionId}`);
-		if (Date.now() - session.lastScanAt > this.sessionTtlMs) {
-			this.sessions.delete(sessionId);
-			throw new Error(`Scan session expired: ${sessionId}`);
-		}
-		return session;
-	}
-	/** Update session with new scan results (bigint addresses). */
-	updateSession(sessionId, addresses, values) {
-		const session = this.getSession(sessionId);
-		session.addresses = addresses;
-		session.previousValues = values;
-		session.lastScanAt = Date.now();
-		session.scanCount++;
-	}
-	/** List all active sessions. */
-	listSessions() {
-		this.cleanup();
-		const result = [];
-		const now = Date.now();
-		for (const session of this.sessions.values()) {
-			const ageMs = now - session.createdAt;
-			const ageMin = Math.floor(ageMs / 6e4);
-			const ageSec = Math.floor(ageMs % 6e4 / 1e3);
-			result.push({
-				id: session.id,
-				pid: session.pid,
-				valueType: session.valueType,
-				addressCount: session.addresses.length,
-				scanCount: session.scanCount,
-				age: ageMin > 0 ? `${ageMin}m${ageSec}s` : `${ageSec}s`
-			});
-		}
-		return result;
-	}
-	/** Delete a session. */
-	deleteSession(sessionId) {
-		return this.sessions.delete(sessionId);
-	}
-	/** Clean up expired sessions. Returns count of cleaned sessions. */
-	cleanup() {
-		const now = Date.now();
-		let count = 0;
-		for (const [id, session] of this.sessions) if (now - session.lastScanAt > this.sessionTtlMs) {
-			this.sessions.delete(id);
-			count++;
-		}
-		return count;
-	}
-	/** Export session data for persistence (JSON serialization). */
-	exportSession(sessionId) {
-		const session = this.getSession(sessionId);
-		const serializable = {
-			...session,
-			addresses: session.addresses.map((addr) => formatAddress(addr)),
-			previousValues: Array.from(session.previousValues.entries()).map(([addr, buf]) => [formatAddress(addr), buf.toString("hex")])
-		};
-		return JSON.stringify(serializable);
-	}
-	/** Import session from exported JSON data. Returns new session id. */
-	importSession(data) {
-		const parsed = JSON.parse(data);
-		const id = randomUUID();
-		const now = Date.now();
-		const previousValues = /* @__PURE__ */ new Map();
-		if (Array.isArray(parsed.previousValues)) {
-			for (const [addr, hex] of parsed.previousValues) if (typeof addr === "string" && typeof hex === "string") previousValues.set(parseAddress(addr), Buffer.from(hex, "hex"));
-		}
-		const addresses = [];
-		if (Array.isArray(parsed.addresses)) {
-			for (const addr of parsed.addresses) if (typeof addr === "string") addresses.push(parseAddress(addr));
-		}
-		const session = {
-			id,
-			pid: parsed.pid,
-			valueType: parsed.valueType,
-			alignment: parsed.alignment ?? 4,
-			createdAt: now,
-			lastScanAt: now,
-			scanCount: parsed.scanCount ?? 0,
-			addresses,
-			previousValues
-		};
-		this.sessions.set(id, session);
-		return id;
-	}
-};
-const scanSessionManager = new MemoryScanSessionManager();
-//#endregion
-export { MemoryScanSessionManager, getDefaultAlignment as n, getValueSize as r, scanSessionManager, compareScanValues as t };