@jshookmcp/jshook 0.2.8 → 0.3.0

package/dist/InstrumentationSession-DLH0vd-z.mjs

@@ -0,0 +1,244 @@
+//#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-DdtnBdD4.mjs → MemoryController-CMtviNW_.mjs}

@@ -1,6 +1,6 @@
-import { cr as WRITE_HISTORY_MAX, q as FREEZE_DEFAULT_INTERVAL_MS } from "./constants-CCvsN80K.mjs";
-import { _ as WriteProcessMemory, b as openProcessForMemory, d as ReadProcessMemory, m as VirtualProtectEx, t as CloseHandle, u as PAGE } from "./Win32API-Bc0QnQsN.mjs";
-import { i as parsePattern } from "./NativeMemoryManager.utils-BML4q1ry.mjs";
+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
 /**

package/dist/{MemoryScanSession-RMixN3bX.mjs → MemoryScanSession-ITgb_NMi.mjs}

@@ -1,5 +1,5 @@
-import { Gt as SCAN_SESSION_MAX_COUNT, Kt as SCAN_SESSION_TTL_MS } from "./constants-CCvsN80K.mjs";
-import { n as parseAddress, t as formatAddress } from "./formatAddress-ChCSIRWT.mjs";
+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;
@@ -44,94 +44,97 @@ function getDefaultAlignment(type) {
 		default: return 1;
 	}
 }
-/**
-* Read a typed numeric value from a buffer at offset 0.
-*/
-function readTypedValue(buf, type) {
+function makeReader(type) {
 	switch (type) {
-		case "byte": return buf.readUInt8(0);
-		case "int8": return buf.readInt8(0);
-		case "int16": return buf.readInt16LE(0);
-		case "uint16": return buf.readUInt16LE(0);
-		case "int32": return buf.readInt32LE(0);
-		case "uint32": return buf.readUInt32LE(0);
-		case "int64": return buf.readBigInt64LE(0);
+		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.readBigUInt64LE(0);
-		case "float": return buf.readFloatLE(0);
-		case "double": return buf.readDoubleLE(0);
-		default: return buf.readInt32LE(0);
+		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);
 	}
 }
-/**
-* Check if two numeric values are approximately equal, using epsilon for floats.
-*/
-function approxEqual(a, b, type) {
-	if (typeof a === "bigint" && typeof b === "bigint") return a === b;
-	const na = Number(a);
-	const nb = Number(b);
-	if (type === "float") return Math.abs(na - nb) < FLOAT_EPSILON;
-	if (type === "double") return Math.abs(na - nb) < DOUBLE_EPSILON;
-	return na === nb;
+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);
 }
-/**
-* Compare a numeric value against another for ordering.
-* Returns negative if a < b, 0 if equal, positive if a > b.
-*/
-function compareValues(a, b) {
-	if (typeof a === "bigint" && typeof b === "bigint") {
-		if (a < b) return -1;
-		if (a > b) return 1;
-		return 0;
+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;
 	}
-	return Number(a) - Number(b);
+}
+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.
 *
-* @param current  - Current value buffer read from memory
-* @param previous - Previous value buffer from last scan (null on first scan)
-* @param target   - Target value buffer for exact/greater/less/not_equal comparisons
-* @param target2  - Second target value buffer for 'between' mode (upper bound)
-* @param mode     - Comparison mode
-* @param valueType - Value type for proper reading
+* 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) {
-	const cur = readTypedValue(current, valueType);
-	switch (mode) {
-		case "exact":
-			if (!target) return false;
-			return approxEqual(cur, readTypedValue(target, valueType), valueType);
-		case "unknown_initial": return true;
-		case "changed":
-			if (!previous) return false;
-			return !approxEqual(cur, readTypedValue(previous, valueType), valueType);
-		case "unchanged":
-			if (!previous) return true;
-			return approxEqual(cur, readTypedValue(previous, valueType), valueType);
-		case "increased":
-			if (!previous) return false;
-			return compareValues(cur, readTypedValue(previous, valueType)) > 0;
-		case "decreased":
-			if (!previous) return false;
-			return compareValues(cur, readTypedValue(previous, valueType)) < 0;
-		case "greater_than":
-			if (!target) return false;
-			return compareValues(cur, readTypedValue(target, valueType)) > 0;
-		case "less_than":
-			if (!target) return false;
-			return compareValues(cur, readTypedValue(target, valueType)) < 0;
-		case "between": {
-			if (!target || !target2) return false;
-			const lo = readTypedValue(target, valueType);
-			const hi = readTypedValue(target2, valueType);
-			return compareValues(cur, lo) >= 0 && compareValues(cur, hi) <= 0;
-		}
-		case "not_equal":
-			if (!target) return false;
-			return !approxEqual(cur, readTypedValue(target, valueType), valueType);
-		default: return false;
-	}
+	return getComparator(mode, valueType)(current, previous, target, target2);
 }
 //#endregion
 //#region src/native/MemoryScanSession.ts

package/dist/{MemoryScanner-QjK4ld0B.mjs → MemoryScanner-CiL7Z3ey.mjs}

@@ -1,9 +1,9 @@
-import { Ht as SCAN_GROUP_MAX_PATTERN_SIZE, Ut as SCAN_MAX_RESULTS_PER_SCAN, Vt as SCAN_DISPLAY_RESULTS_LIMIT, Wt as SCAN_POINTER_MAX_RESULTS, qt as SCAN_UNKNOWN_INITIAL_MAX_ADDRESSES } from "./constants-CCvsN80K.mjs";
-import { t as nativeMemoryManager } from "./NativeMemoryManager.impl-CB6gJ0NM.mjs";
-import { t as createPlatformProvider } from "./factory-CibqTNC8.mjs";
-import { i as parsePattern } from "./NativeMemoryManager.utils-BML4q1ry.mjs";
-import { n as parseAddress, t as formatAddress } from "./formatAddress-ChCSIRWT.mjs";
-import { n as getDefaultAlignment, r as getValueSize, scanSessionManager, t as compareScanValues } from "./MemoryScanSession-RMixN3bX.mjs";
+import { Cn as SCAN_UNKNOWN_INITIAL_MAX_ADDRESSES, _n as SCAN_DISPLAY_RESULTS_LIMIT, bn as SCAN_POINTER_MAX_RESULTS, vn as SCAN_GROUP_MAX_PATTERN_SIZE, yn as SCAN_MAX_RESULTS_PER_SCAN } from "./constants-CDZLOoVv.mjs";
+import { t as createPlatformProvider } from "./factory-C90tBff6.mjs";
+import { i as parsePattern } from "./NativeMemoryManager.utils-BBlAixF5.mjs";
+import { t as nativeMemoryManager } from "./NativeMemoryManager.impl-D9Lkovvn.mjs";
+import { n as parseAddress, t as formatAddress } from "./formatAddress-nnMvEohD.mjs";
+import { n as getDefaultAlignment, r as getValueSize, scanSessionManager, t as compareScanValues } from "./MemoryScanSession-ITgb_NMi.mjs";
 //#region src/native/MemoryScanner.ts
 /**
 * Memory Scanner — orchestrates iterative scan workflows.
@@ -21,10 +21,13 @@ import { n as getDefaultAlignment, r as getValueSize, scanSessionManager, t as c
 */
 var MemoryScanner = class {
 	nmm;
-	_provider = null;
+	providerCache = null;
 	get provider() {
-		if (!this._provider) this._provider = createPlatformProvider();
-		return this._provider;
+		if (!this.providerCache) this.providerCache = createPlatformProvider();
+		return this.providerCache;
+	}
+	set provider(value) {
+		this.providerCache = value;
 	}
 	constructor(nmm) {
 		this.nmm = nmm;
@@ -67,14 +70,28 @@ var MemoryScanner = class {
 					} catch {
 						break;
 					}
-					const alignStep = alignment > 0 ? alignment : 1;
-					const startOffset = alignment > 0 ? (alignStep - offset % alignStep) % alignStep : 0;
-					for (let i = startOffset; i <= chunk.length - valueSize; i += alignStep) {
-						const currentBuf = chunk.subarray(i, i + valueSize);
-						if (compareScanValues(currentBuf, null, targetBuf, null, "exact", valueType)) {
+					if (alignment === valueSize && valueSize > 0) {
+						const alignStep = this.getAlignStep(alignment);
+						let searchFrom = this.getAlignedChunkStart(chunkAddr, alignStep);
+						while (searchFrom <= chunk.length - valueSize && addresses.length < maxResults) {
+							const hit = chunk.indexOf(targetBuf, searchFrom);
+							if (hit === -1) break;
+							if (!this.isAlignedAddress(chunkAddr + BigInt(hit), alignStep)) {
+								searchFrom = hit + 1;
+								continue;
+							}
+							const addr = chunkAddr + BigInt(hit);
+							addresses.push(addr);
+							values.set(addr, Buffer.from(chunk.subarray(hit, hit + valueSize)));
+							searchFrom = hit + alignStep;
+						}
+					} else {
+						const alignStep = this.getAlignStep(alignment);
+						const chunkStart = this.getAlignedChunkStart(chunkAddr, alignStep);
+						for (let i = chunkStart; i <= chunk.length - valueSize; i += alignStep) if (Buffer.compare(chunk.subarray(i, i + valueSize), targetBuf) === 0) {
 							const addr = chunkAddr + BigInt(i);
 							addresses.push(addr);
-							values.set(addr, Buffer.from(currentBuf));
+							values.set(addr, Buffer.from(chunk.subarray(i, i + valueSize)));
 							if (addresses.length >= maxResults) break;
 						}
 					}
@@ -183,12 +200,12 @@ var MemoryScanner = class {
 					} catch {
 						break;
 					}
-					const alignStep = alignment > 0 ? alignment : 1;
-					for (let i = 0; i <= chunk.length - valueSize; i += alignStep) {
+					const alignStep = this.getAlignStep(alignment);
+					const chunkStart = this.getAlignedChunkStart(chunkAddr, alignStep);
+					for (let i = chunkStart; i <= chunk.length - valueSize; i += alignStep) {
 						const addr = chunkAddr + BigInt(i);
-						const currentBuf = chunk.subarray(i, i + valueSize);
 						addresses.push(addr);
-						values.set(addr, Buffer.from(currentBuf));
+						values.set(addr, Buffer.from(chunk.subarray(i, i + valueSize)));
 						if (addresses.length >= maxAddresses) break;
 					}
 				}
@@ -312,8 +329,9 @@ var MemoryScanner = class {
 					} catch {
 						break;
 					}
-					const alignStep = alignment > 0 ? alignment : 1;
-					for (let i = 0; i <= chunk.length - maxOffset; i += alignStep) {
+					const alignStep = this.getAlignStep(alignment);
+					const chunkStart = this.getAlignedChunkStart(chunkAddr, alignStep);
+					for (let i = chunkStart; i <= chunk.length - maxOffset; i += alignStep) {
 						let match = true;
 						for (let j = 0; j < maxOffset; j++) if (compositeMask[j] === 1 && chunk[i + j] !== compositePattern[j]) {
 							match = false;
@@ -342,6 +360,17 @@ var MemoryScanner = class {
 			elapsed
 		};
 	}
+	getAlignStep(alignment) {
+		return alignment > 0 ? alignment : 1;
+	}
+	getAlignedChunkStart(chunkAddr, alignStep) {
+		const align = BigInt(alignStep);
+		const remainder = chunkAddr % align;
+		return remainder === 0n ? 0 : Number(align - remainder);
+	}
+	isAlignedAddress(address, alignStep) {
+		return address % BigInt(alignStep) === 0n;
+	}
 	/**
 	* Pattern-based first scan for variable-length types (hex/string).
 	* Delegates to existing NativeMemoryManager.scanMemory.