exoproc-accessors 0.1.0 → 0.6.2

package/dist/index.js

@@ -37,9 +37,9 @@ import {
   isModuleLoadedInProcessSync,
   MiddlewareAccessor,
   InittableMiddlewareAccessor,
-  isMiddlewareAccessor
+  isInittableAccessor,
+  HostAccessor
 } from "bun-xffi";
-
 class MsvcrtDependentMiddlewareAccessor extends InittableMiddlewareAccessor {
   async onInit() {
     if (this.isLocal)
@@ -61,27 +61,6 @@ class MsvcrtDependentMiddlewareAccessor extends InittableMiddlewareAccessor {
   }
 }
 
-class HostAccessor extends InittableMiddlewareAccessor {
-  get processId() {
-    return this._processId;
-  }
-  constructor(backend, root) {
-    super(backend, root ?? null);
-    if (!root) {
-      this.root = this;
-    }
-    let b = backend;
-    while (isMiddlewareAccessor(b)) {
-      b = b.backend;
-    }
-    if (b) {
-      this._processId = b.processId;
-    }
-  }
-  async onInit() {}
-  onInitSync() {}
-}
-
 class ThrowingHostAccessor extends HostAccessor {
   constructor(processId, root) {
     super(new ThrowingMemoryAccessor(processId), root);
@@ -92,7 +71,7 @@ class RedirectorHostAccessor extends HostAccessor {
   _target;
   constructor(processId, root) {
     super(new ThrowingMemoryAccessor(processId), root);
-    this._target = new ThrowingHostAccessor(processId, this.root);
+    this._target = new ThrowingHostAccessor(processId);
   }
   get target() {
     return this._target;
@@ -238,9 +217,51 @@ class RedirectorHostAccessor extends HostAccessor {
     }
   }
   async onInit() {}
+  async onDeinit() {
+    const t = this.getTarget();
+    if (t !== this && t !== this.root && isInittableAccessor(t)) {
+      await t.deinit();
+    }
+  }
   onInitSync() {}
 }
 
+class RacingHostAccessor extends RedirectorHostAccessor {
+  racers = [];
+  registerChild(child) {
+    if (!this.racers || !isInittableAccessor(child))
+      return;
+    this.racers.push(child);
+  }
+  startRacer(racer) {
+    return racer.init();
+  }
+  async race() {
+    if (this.racers.length === 0) {
+      throw new Error("RacingHostAccessor: no racers registered to race");
+    }
+    const attempts = this.racers.map((racer) => ({
+      racer,
+      settled: this.startRacer(racer)
+    }));
+    let winner;
+    try {
+      winner = await Promise.any(attempts.map((a) => a.settled.then(() => a.racer)));
+    } catch (err) {
+      throw new Error(`RacingHostAccessor: none of ${attempts.length} racer(s) could be initialized`, { cause: err });
+    }
+    for (const a of attempts) {
+      if (a.racer === winner)
+        continue;
+      this.releaseLoser(a.racer, a.settled);
+    }
+    return winner;
+  }
+  releaseLoser(racer, settled) {
+    settled.then(() => racer.deinit().catch(() => {})).catch(() => {});
+  }
+}
+
 class BootstrapHostAccessor extends RedirectorHostAccessor {
   constructor(processId, root) {
     super(processId, root);
@@ -258,7 +279,7 @@ class BootstrapHostAccessor extends RedirectorHostAccessor {
 
 class CallRedirectorAccessor extends MiddlewareAccessor {
   async alloc(size, address = null, protection = MemoryProtection.READWRITE, allocationType = MemoryState.COMMIT | MemoryState.RESERVE) {
-    const addressVal = address ? resolveAddress(address) : null;
+    const addressVal = address ? resolveAddress(address) : 0;
     const result = await this.root.call(Kernel32Impl.VirtualAlloc, addressVal, size, allocationType, protection);
     if (!result || Number(result) === 0) {
       throw new Error(`VirtualAlloc failed in remote process for size ${size}`);
@@ -266,7 +287,7 @@ class CallRedirectorAccessor extends MiddlewareAccessor {
     return result;
   }
   allocSync(size, address = null, protection = MemoryProtection.READWRITE, allocationType = MemoryState.COMMIT | MemoryState.RESERVE) {
-    const addressVal = address ? resolveAddress(address) : null;
+    const addressVal = address ? resolveAddress(address) : 0;
     const result = this.root.callSync(Kernel32Impl.VirtualAlloc, addressVal, size, allocationType, protection);
     if (!result || Number(result) === 0) {
       throw new Error(`VirtualAlloc failed in remote process for size ${size}`);
@@ -456,27 +477,56 @@ class IndirectCallRedirectorAccessor extends CallRedirectorAccessor {
     });
     return info;
   }
+  hasMsvcrt = null;
+  async checkMsvcrt() {
+    if (this.hasMsvcrt !== null)
+      return this.hasMsvcrt;
+    const msvcrtBase = MsvcrtLibrary.baseAddress;
+    if (msvcrtBase.isNull() || Number(msvcrtBase) === 0) {
+      this.hasMsvcrt = false;
+      return false;
+    }
+    this.hasMsvcrt = await isModuleLoadedInProcess(this.root, msvcrtBase);
+    return this.hasMsvcrt;
+  }
+  checkMsvcrtSync() {
+    if (this.hasMsvcrt !== null)
+      return this.hasMsvcrt;
+    const msvcrtBase = MsvcrtLibrary.baseAddress;
+    if (msvcrtBase.isNull() || Number(msvcrtBase) === 0) {
+      this.hasMsvcrt = false;
+      return false;
+    }
+    this.hasMsvcrt = isModuleLoadedInProcessSync(this.root, msvcrtBase);
+    return this.hasMsvcrt;
+  }
   async alloc(size, address = null, protection = MemoryProtection.READWRITE, allocationType = MemoryState.COMMIT | MemoryState.RESERVE) {
     if (protection === MemoryProtection.READWRITE && (address === null || address === undefined)) {
-      const result = await this.root.call(MsvcrtImpl.malloc, size);
-      if (!result || Number(result) === 0) {
-        throw new Error(`malloc failed in remote process for size ${size}`);
-      }
-      const allocatedAddr = Number(result);
-      this.mallocs.set(allocatedAddr, size);
-      return allocatedAddr;
+      try {
+        if (await this.checkMsvcrt()) {
+          const result = await this.root.call(MsvcrtImpl.malloc, size);
+          if (result && Number(result) !== 0) {
+            const allocatedAddr = Number(result);
+            this.mallocs.set(allocatedAddr, size);
+            return allocatedAddr;
+          }
+        }
+      } catch {}
     }
     return super.alloc(size, address, protection, allocationType);
   }
   allocSync(size, address = null, protection = MemoryProtection.READWRITE, allocationType = MemoryState.COMMIT | MemoryState.RESERVE) {
     if (protection === MemoryProtection.READWRITE && (address === null || address === undefined)) {
-      const result = this.root.callSync(MsvcrtImpl.malloc, size);
-      if (!result || Number(result) === 0) {
-        throw new Error(`malloc failed in remote process for size ${size}`);
-      }
-      const allocatedAddr = Number(result);
-      this.mallocs.set(allocatedAddr, size);
-      return allocatedAddr;
+      try {
+        if (this.checkMsvcrtSync()) {
+          const result = this.root.callSync(MsvcrtImpl.malloc, size);
+          if (result && Number(result) !== 0) {
+            const allocatedAddr = Number(result);
+            this.mallocs.set(allocatedAddr, size);
+            return allocatedAddr;
+          }
+        }
+      } catch {}
     }
     return super.allocSync(size, address, protection, allocationType);
   }
@@ -539,14 +589,35 @@ class IndirectCallRedirectorAccessor extends CallRedirectorAccessor {
 }
 
 class MarshallingCallableAccessor extends MiddlewareAccessor {
-  static bufferToMarshal(type, val) {
+  static marshalInfo(funcName, type, val) {
     const normType = normalizeType(type);
     if (normType === "cstring" && typeof val === "string") {
-      return Buffer.from(val + "\x00", "utf8");
-    } else if (normType === "cwstring" && typeof val === "string") {
-      return Buffer.from(val + "\x00", "utf16le");
-    } else if (val && typeof val === "object" && Buffer.isBuffer(val)) {
-      return val;
+      return { buf: Buffer.from(val + "\x00", "utf8") };
+    }
+    if (normType === "cwstring" && typeof val === "string") {
+      return { buf: Buffer.from(val + "\x00", "utf16le") };
+    }
+    if (typeof val === "string" && (normType === "ptr" || normType === "i64" || normType === "u64" || normType === "usize" || normType === "size_t")) {
+      const trimmed = val.trim();
+      if (!/^-?0x[0-9a-fA-F]+$/.test(trimmed)) {
+        const isAnsi = funcName ? funcName.endsWith("A") : false;
+        return {
+          buf: Buffer.from(val + "\x00", isAnsi ? "utf8" : "utf16le")
+        };
+      }
+    }
+    if (val && typeof val === "object") {
+      if (Buffer.isBuffer(val)) {
+        return { buf: val, writeBackTarget: val };
+      }
+      if (Buffer.isBuffer(val._backingBuffer)) {
+        const backing = val._backingBuffer;
+        return { buf: backing, writeBackTarget: backing };
+      }
+      if (ArrayBuffer.isView(val)) {
+        const viewBuf = Buffer.from(val.buffer, val.byteOffset, val.byteLength);
+        return { buf: viewBuf, writeBackTarget: viewBuf };
+      }
     }
     return null;
   }
@@ -555,16 +626,39 @@ class MarshallingCallableAccessor extends MiddlewareAccessor {
     const tempAllocations = [];
     try {
       const signatureArgs = func.args || [];
-      for (let i = 0;i < signatureArgs.length; i++) {
-        const buf = MarshallingCallableAccessor.bufferToMarshal(signatureArgs[i], args[i]);
-        if (!buf)
+      const totalArgs = Math.max(signatureArgs.length, args.length);
+      for (let i = 0;i < totalArgs; i++) {
+        const info = MarshallingCallableAccessor.marshalInfo(func.name, signatureArgs[i] || "", args[i]);
+        if (!info) {
+          if (typeof args[i] === "string" && /^-?0x[0-9a-fA-F]+$/.test(args[i].trim())) {
+            modifiedArgs[i] = Number(BigInt(args[i].trim()));
+          }
           continue;
-        const remoteAddr = Number(await this.root.alloc(buf.length));
-        await this.root.write(remoteAddr, buf);
-        tempAllocations.push({ address: remoteAddr, size: buf.length });
+        }
+        const allocLen = Math.max(info.buf.length, 1);
+        const remoteAddr = Number(await this.root.alloc(allocLen));
+        if (info.buf.length > 0) {
+          await this.root.write(remoteAddr, info.buf);
+        }
+        tempAllocations.push({
+          address: remoteAddr,
+          size: allocLen,
+          writeBackTarget: info.writeBackTarget
+        });
         modifiedArgs[i] = remoteAddr;
       }
-      return await this.backend.call(func, ...modifiedArgs);
+      const result = await this.backend.call(func, ...modifiedArgs);
+      for (const alloc of tempAllocations) {
+        if (alloc.writeBackTarget && alloc.writeBackTarget.length > 0) {
+          try {
+            const remoteBytes = await this.root.read(alloc.address, alloc.writeBackTarget.length);
+            if (remoteBytes && remoteBytes.length > 0) {
+              remoteBytes.copy(alloc.writeBackTarget, 0, 0, Math.min(remoteBytes.length, alloc.writeBackTarget.length));
+            }
+          } catch {}
+        }
+      }
+      return result;
     } finally {
       for (const alloc of tempAllocations) {
         try {
@@ -578,16 +672,39 @@ class MarshallingCallableAccessor extends MiddlewareAccessor {
     const tempAllocations = [];
     try {
       const signatureArgs = func.args || [];
-      for (let i = 0;i < signatureArgs.length; i++) {
-        const buf = MarshallingCallableAccessor.bufferToMarshal(signatureArgs[i], args[i]);
-        if (!buf)
+      const totalArgs = Math.max(signatureArgs.length, args.length);
+      for (let i = 0;i < totalArgs; i++) {
+        const info = MarshallingCallableAccessor.marshalInfo(func.name, signatureArgs[i] || "", args[i]);
+        if (!info) {
+          if (typeof args[i] === "string" && /^-?0x[0-9a-fA-F]+$/.test(args[i].trim())) {
+            modifiedArgs[i] = Number(BigInt(args[i].trim()));
+          }
           continue;
-        const remoteAddr = Number(this.root.allocSync(buf.length));
-        this.root.writeSync(remoteAddr, buf);
-        tempAllocations.push({ address: remoteAddr, size: buf.length });
+        }
+        const allocLen = Math.max(info.buf.length, 1);
+        const remoteAddr = Number(this.root.allocSync(allocLen));
+        if (info.buf.length > 0) {
+          this.root.writeSync(remoteAddr, info.buf);
+        }
+        tempAllocations.push({
+          address: remoteAddr,
+          size: allocLen,
+          writeBackTarget: info.writeBackTarget
+        });
         modifiedArgs[i] = remoteAddr;
       }
-      return this.backend.callSync(func, ...modifiedArgs);
+      const result = this.backend.callSync(func, ...modifiedArgs);
+      for (const alloc of tempAllocations) {
+        if (alloc.writeBackTarget && alloc.writeBackTarget.length > 0) {
+          try {
+            const remoteBytes = this.root.readSync(alloc.address, alloc.writeBackTarget.length);
+            if (remoteBytes && remoteBytes.length > 0) {
+              remoteBytes.copy(alloc.writeBackTarget, 0, 0, Math.min(remoteBytes.length, alloc.writeBackTarget.length));
+            }
+          } catch {}
+        }
+      }
+      return result;
     } finally {
       for (const alloc of tempAllocations) {
         try {
@@ -1022,29 +1139,33 @@ class FileTransferReadAccessor extends MsvcrtDependentMiddlewareAccessor {
     if (this.isInitializing || !this.tempFilePath) {
       return super.readAfterInit(address, size, offset);
     }
-    await this.ensureOpen();
-    const targetAddr = resolveAddress(address) + offset;
-    await this.backend.call(MsvcrtImpl.rewind, this.hFile);
-    const written = await this.backend.call(MsvcrtImpl.fwrite, targetAddr, 1, size, this.hFile);
-    if (Number(written) !== size) {
-      throw new Error(`fwrite failed to write entire memory block of size ${size} (wrote ${written})`);
-    }
-    await this.backend.call(MsvcrtImpl.fflush, this.hFile);
-    return fs.readFileSync(this.tempFilePath).subarray(0, size);
+    try {
+      await this.ensureOpen();
+      const targetAddr = resolveAddress(address) + offset;
+      await this.backend.call(MsvcrtImpl.rewind, this.hFile);
+      const written = await this.backend.call(MsvcrtImpl.fwrite, targetAddr, 1, size, this.hFile);
+      if (Number(written) === size) {
+        await this.backend.call(MsvcrtImpl.fflush, this.hFile);
+        return fs.readFileSync(this.tempFilePath).subarray(0, size);
+      }
+    } catch {}
+    return super.readAfterInit(address, size, offset);
   }
   readAfterInitSync(address, size, offset = 0) {
     if (this.isInitializingSync || !this.tempFilePath) {
       return super.readAfterInitSync(address, size, offset);
     }
-    this.ensureOpenSync();
-    const targetAddr = resolveAddress(address) + offset;
-    this.backend.callSync(MsvcrtImpl.rewind, this.hFile);
-    const written = this.backend.callSync(MsvcrtImpl.fwrite, targetAddr, 1, size, this.hFile);
-    if (Number(written) !== size) {
-      throw new Error(`fwrite failed to write entire memory block of size ${size} (wrote ${written})`);
-    }
-    this.backend.callSync(MsvcrtImpl.fflush, this.hFile);
-    return fs.readFileSync(this.tempFilePath).subarray(0, size);
+    try {
+      this.ensureOpenSync();
+      const targetAddr = resolveAddress(address) + offset;
+      this.backend.callSync(MsvcrtImpl.rewind, this.hFile);
+      const written = this.backend.callSync(MsvcrtImpl.fwrite, targetAddr, 1, size, this.hFile);
+      if (Number(written) === size) {
+        this.backend.callSync(MsvcrtImpl.fflush, this.hFile);
+        return fs.readFileSync(this.tempFilePath).subarray(0, size);
+      }
+    } catch {}
+    return super.readAfterInitSync(address, size, offset);
   }
 }
 
@@ -1129,14 +1250,16 @@ class FileTransferWriteAccessor extends MsvcrtDependentMiddlewareAccessor {
     }
     const targetAddr = resolveAddress(address) + offset;
     const buffer = data instanceof Buffer ? data : Buffer.from(data);
-    fs.writeFileSync(this.tempFilePath, buffer);
-    await this.ensureOpen();
-    await this.backend.call(MsvcrtImpl.rewind, this.hFile);
-    const readBytes = await this.backend.call(MsvcrtImpl.fread, targetAddr, 1, buffer.length, this.hFile);
-    if (Number(readBytes) !== buffer.length) {
-      throw new Error(`fread failed to read entire file block of size ${buffer.length} (read ${readBytes})`);
-    }
-    return Number(readBytes);
+    try {
+      fs.writeFileSync(this.tempFilePath, buffer);
+      await this.ensureOpen();
+      await this.backend.call(MsvcrtImpl.rewind, this.hFile);
+      const readBytes = await this.backend.call(MsvcrtImpl.fread, targetAddr, 1, buffer.length, this.hFile);
+      if (Number(readBytes) === buffer.length) {
+        return buffer.length;
+      }
+    } catch {}
+    return super.writeAfterInit(address, data, offset);
   }
   writeAfterInitSync(address, data, offset = 0) {
     if (this.isInitializingSync || !this.tempFilePath) {
@@ -1144,14 +1267,16 @@ class FileTransferWriteAccessor extends MsvcrtDependentMiddlewareAccessor {
     }
     const targetAddr = resolveAddress(address) + offset;
     const buffer = data instanceof Buffer ? data : Buffer.from(data);
-    fs.writeFileSync(this.tempFilePath, buffer);
-    this.ensureOpenSync();
-    this.backend.callSync(MsvcrtImpl.rewind, this.hFile);
-    const readBytes = this.backend.callSync(MsvcrtImpl.fread, targetAddr, 1, buffer.length, this.hFile);
-    if (Number(readBytes) !== buffer.length) {
-      throw new Error(`fread failed to read entire file block of size ${buffer.length} (read ${readBytes})`);
-    }
-    return Number(readBytes);
+    try {
+      fs.writeFileSync(this.tempFilePath, buffer);
+      this.ensureOpenSync();
+      this.backend.callSync(MsvcrtImpl.rewind, this.hFile);
+      const readBytes = this.backend.callSync(MsvcrtImpl.fread, targetAddr, 1, buffer.length, this.hFile);
+      if (Number(readBytes) === buffer.length) {
+        return buffer.length;
+      }
+    } catch {}
+    return super.writeAfterInitSync(address, data, offset);
   }
 }
 
@@ -1640,21 +1765,512 @@ class ScannerMiddleware extends MiddlewareAccessor {
     }
   }
 }
+// packages/accessors/src/indirect-nthread-host-accessor.ts
+import { AsyncLocalStorage } from "async_hooks";
+import {
+  isMiddlewareAccessor
+} from "bun-xffi";
+import { Thread } from "bun-winapi";
+import { NThread } from "bun-nthread";
+class IndirectNThreadHostAccessor extends HostAccessor {
+  nthreadRef;
+  bootstrapRoot;
+  get nthread() {
+    return this.nthreadRef instanceof NThreadRaceAccessor ? this.nthreadRef.target : this.nthreadRef;
+  }
+  constructor(backendOrPid, threadId, options = {}) {
+    let nthread;
+    let nthreadRoot;
+    if (typeof backendOrPid === "number") {
+      nthreadRoot = new RedirectorHostAccessor(backendOrPid);
+      nthread = new NThread(backendOrPid, threadId, options, nthreadRoot);
+    } else {
+      nthread = backendOrPid;
+    }
+    const pid = nthread.processId;
+    super(new ThrowingMemoryAccessor(pid));
+    const bootstrap = new BootstrapHostAccessor(pid, this);
+    this.bootstrapRoot = bootstrap;
+    bootstrap.backend = nthread;
+    const redirector = new IndirectCallRedirectorAccessor(nthread, bootstrap);
+    const machineCodePool = new MachineCodePoolMiddleware(redirector, bootstrap);
+    const memsetWrite = new MemsetWriteAccessor(machineCodePool, bootstrap);
+    const memcmpRead = new MemcmpReadAccessor(memsetWrite, bootstrap);
+    const fileWriter = new FileTransferWriteAccessor(memcmpRead, bootstrap);
+    const fileReader = new FileTransferReadAccessor(fileWriter, bootstrap);
+    const scanner = new ScannerMiddleware(fileReader, bootstrap);
+    const marshalling = new MarshallingCallableAccessor(scanner, bootstrap);
+    this.backend = marshalling;
+    let b = marshalling;
+    while (isMiddlewareAccessor(b)) {
+      b = b.backend;
+    }
+    if (b) {
+      this._processId = b.processId;
+    }
+    if (nthreadRoot) {
+      nthreadRoot.target = this;
+    }
+    this.nthreadRef = nthread;
+  }
+  async onInit() {
+    await this.bootstrapRoot.init();
+  }
+  onInitSync() {
+    this.bootstrapRoot.initSync();
+  }
+  async onDeinit() {
+    try {
+      await this.bootstrapRoot.deinit();
+    } catch {}
+    try {
+      const nt = this.nthread;
+      if (nt && typeof nt.deinit === "function") {
+        await nt.deinit();
+      }
+    } catch {}
+  }
+  onDeinitSync() {
+    try {
+      this.bootstrapRoot.deinitSync();
+    } catch {}
+    try {
+      const nt = this.nthread;
+      if (nt && typeof nt.deinitSync === "function") {
+        nt.deinitSync();
+      }
+    } catch {}
+  }
+  toJSON() {
+    const session = super.toJSON();
+    session.accessorType = "IndirectNThreadHostAccessor";
+    try {
+      const nt = this.nthread;
+      if (nt && typeof nt.threadId === "number") {
+        session.threadId = nt.threadId;
+      }
+      if (nt && nt.stubs) {
+        const stubs = {};
+        for (const [k, v] of Object.entries(nt.stubs)) {
+          if (v && typeof v.address === "bigint") {
+            stubs[k] = `0x${v.address.toString(16)}`;
+          }
+        }
+        if (Object.keys(stubs).length > 0) {
+          session.stubs = stubs;
+        }
+      }
+    } catch {}
+    return session;
+  }
+}
+var currentCandidate = new AsyncLocalStorage;
+
+class NThreadRaceAccessor extends RacingHostAccessor {
+  aborts = new Map;
+  constructor(pid, nthreadOptions = {}, root) {
+    super(pid, root);
+    this.target = this;
+    const threads = Thread.getThreads(pid);
+    if (threads.length === 0) {
+      throw new Error(`createAccessor: process ${pid} has no threads to redirect`);
+    }
+    const callerSignal = nthreadOptions.signal;
+    for (const t of threads) {
+      const controller = new AbortController;
+      if (callerSignal) {
+        if (callerSignal.aborted)
+          controller.abort(callerSignal.reason);
+        else
+          callerSignal.addEventListener("abort", () => controller.abort(callerSignal.reason), { once: true });
+      }
+      const nthread = new NThread(pid, t.tid, { ...nthreadOptions, signal: controller.signal }, this);
+      this.aborts.set(nthread, () => controller.abort());
+    }
+  }
+  startRacer(racer) {
+    return currentCandidate.run(racer, () => racer.init());
+  }
+  async call(func, ...args) {
+    if (this.target === this) {
+      const caller = currentCandidate.getStore();
+      if (caller)
+        return caller.call(func, ...args);
+    }
+    return super.call(func, ...args);
+  }
+  releaseLoser(racer, settled) {
+    this.aborts.get(racer)?.();
+    super.releaseLoser(racer, settled);
+  }
+  async onInit() {
+    const winner = await this.race();
+    this.target = winner;
+  }
+  onInitSync() {
+    throw new Error("NThreadRaceAccessor does not support initSync()");
+  }
+}
+// packages/accessors/src/accessors.ts
+import { Thread as Thread3, Module } from "bun-winapi";
+import { Kernel32Impl as Kernel32Impl2 } from "bun-xffi";
+import { CallThreadDiedError, NThread as NThread2 } from "bun-nthread";
+import { NShm } from "bun-nshm";
+import {
+  attachNJava as attachNJava2,
+  findNJava,
+  getNJava,
+  getReflection,
+  findReflection,
+  getJavaClass
+} from "bun-njava";
+
+// packages/accessors/src/stealth-java.ts
+import { Thread as Thread2 } from "bun-winapi";
+import { attachNJava } from "bun-njava";
+async function spawnStealthWorkerThread(bootstrapHost) {
+  const pid = bootstrapHost.processId;
+  const beforeThreads = new Set(Thread2.getThreads(pid).map((t) => t.tid));
+  const njava = await attachNJava(bootstrapHost);
+  const reflection = await njava.getReflection();
+  const functions = await njava.getFunctions();
+  const executorsClass = await reflection.getClass("java.util.concurrent.Executors");
+  const dtfMethod = await executorsClass.getMethod("defaultThreadFactory");
+  const threadFactory = await dtfMethod.call(0n);
+  const allExecMethods = await reflection.getAllReflectedMethods(executorsClass.classObj);
+  const newPoolMethod = allExecMethods.find((m) => m.name === "newSingleThreadScheduledExecutor" && m.paramTypes.length === 1) ?? allExecMethods.find((m) => m.name === "newSingleThreadScheduledExecutor");
+  const pool = newPoolMethod?.paramTypes.length === 1 ? await newPoolMethod.call(0n, threadFactory) : await newPoolMethod.call(0n);
+  const cdlClass = await reflection.getClass("java.util.concurrent.CountDownLatch");
+  const cdlCtor = await reflection.findConstructor(cdlClass.classObj, (p) => p.length === 1 && p[0] === "int");
+  const cdlInstance = await reflection.construct(cdlCtor, [0]);
+  const eventHandlerClass = await reflection.getClass("java.beans.EventHandler");
+  const ehCtor = await reflection.findConstructor(eventHandlerClass.classObj, (p) => p.length === 4 && p[0] === "java.lang.Object" && p[1] === "java.lang.String" && p[2] === "java.lang.String" && p[3] === "java.lang.String");
+  const handler = await reflection.construct(ehCtor, [
+    cdlInstance,
+    "countDown",
+    0n,
+    "run"
+  ]);
+  const proxyClass = await reflection.getClass("java.lang.reflect.Proxy");
+  const newProxyInstanceMethod = await proxyClass.getMethod("newProxyInstance");
+  const classLoaderClass = await reflection.getClass("java.lang.ClassLoader");
+  const getSysLoaderMethod = await classLoaderClass.getMethod("getSystemClassLoader");
+  const sysLoader = await getSysLoaderMethod.call(0n);
+  const classClass = await reflection.getClass("java.lang.Class");
+  const runnableClass = await reflection.getClass("java.lang.Runnable");
+  const interfacesArray = BigInt(await functions.NewObjectArray(1, classClass.classObj, runnableClass.classObj));
+  const runnable = await newProxyInstanceMethod.invokeRaw(0n, [
+    sysLoader,
+    interfacesArray,
+    handler
+  ]);
+  const timeUnitClass = await reflection.getClass("java.util.concurrent.TimeUnit");
+  const msField = await timeUnitClass.getField("MILLISECONDS");
+  const msUnit = await msField.get();
+  const poolClass = await reflection.getClass("java.util.concurrent.ScheduledExecutorService");
+  const scheduleMethod = await poolClass.getMethod("scheduleWithFixedDelay");
+  await scheduleMethod.invokeRaw(pool, [
+    runnable,
+    0n,
+    50n,
+    msUnit
+  ]);
+  const spawnDeadline = Date.now() + 5000;
+  let newTid;
+  while (Date.now() < spawnDeadline && !newTid) {
+    const afterThreads = Thread2.getThreads(pid);
+    const found = afterThreads.find((t) => !beforeThreads.has(t.tid));
+    if (found) {
+      newTid = found.tid;
+      break;
+    }
+    await Bun.sleep(20);
+  }
+  if (!newTid) {
+    throw new Error("spawnStealthWorkerThread: spawned worker thread did not appear in target process thread list");
+  }
+  return { osTid: newTid };
+}
+async function createStealthJavaAccessor(pid, options = {}) {
+  const { njava: _njavaOpt, ...passThroughOptions } = options;
+  const bootstrapHost = await createAccessor(pid, {
+    ...passThroughOptions,
+    njava: true
+  });
+  try {
+    const { osTid: workerTid } = await spawnStealthWorkerThread(bootstrapHost);
+    await bootstrapHost.deinit();
+    return await createAccessor(workerTid, {
+      ...passThroughOptions,
+      idType: "thread",
+      njava: true
+    });
+  } catch (err) {
+    await bootstrapHost.deinit().catch(() => {});
+    throw err;
+  }
+}
+
+// packages/accessors/src/accessors.ts
+var DEFAULT_ID_TYPE = "processAllThreadIds";
+function resolveFromThreadId(id) {
+  const entry = Thread3.getThreads(0).find((t) => t.tid === id);
+  if (!entry) {
+    throw new Error(`createAccessor: no thread with id ${id} found`);
+  }
+  return { pid: entry.ownerPid, threadId: id };
+}
+function resolveFromProcessId(id) {
+  const threadId = Thread3.getThreads(id)[0]?.tid;
+  if (threadId === undefined) {
+    throw new Error(`createAccessor: process ${id} has no threads to redirect`);
+  }
+  return { pid: id, threadId };
+}
+function resolveBaseAccessor(id, options) {
+  if (options.backend) {
+    return options.backend;
+  }
+  const Host = options.host ?? IndirectNThreadHostAccessor;
+  const idType = options.idType ?? DEFAULT_ID_TYPE;
+  if (idType === "processAllThreadIds") {
+    if (Host !== IndirectNThreadHostAccessor) {
+      throw new Error('createAccessor: idType "processAllThreadIds" is only supported ' + "with the default host (IndirectNThreadHostAccessor) -- there's " + "no generic way to race across an arbitrary host class's threads.");
+    }
+    return new IndirectNThreadHostAccessor(new NThreadRaceAccessor(id, options.hostOptions));
+  }
+  const { pid, threadId } = idType === "thread" ? resolveFromThreadId(id) : resolveFromProcessId(id);
+  return new Host(pid, threadId, options.hostOptions);
+}
+function createAccessorWithoutInit(id, options = {}) {
+  const base = resolveBaseAccessor(id, options);
+  base._options = options;
+  if (!options.sharedMemory) {
+    return base;
+  }
+  base.backend = new (options.sharedMemoryMiddleware ?? NShm)(base.backend, base, options.sharedMemoryOptions);
+  return base;
+}
+async function remoteGetModuleHandleA(accessor, name) {
+  const buf = Buffer.from(`${name}\x00`);
+  const ptr = await accessor.alloc(buf.length);
+  try {
+    await accessor.write(ptr, buf);
+    return BigInt(await accessor.call(Kernel32Impl2.GetModuleHandleA, ptr));
+  } finally {
+    await accessor.free(ptr).catch(() => {});
+  }
+}
+function isThreadDiedError(err) {
+  if (!(err instanceof Error))
+    return false;
+  return err instanceof CallThreadDiedError || err.name === "CallThreadDiedError" || err.constructor?.name === "CallThreadDiedError" || /Thread died/i.test(err.message);
+}
+async function createAccessor(idOrPath, options = {}) {
+  if (typeof idOrPath === "string") {
+    return await HostAccessor.load(idOrPath, options);
+  }
+  const id = idOrPath;
+  const initOne = async (targetId, opt) => {
+    const accessor = createAccessorWithoutInit(targetId, opt);
+    accessor._options = opt;
+    try {
+      await accessor.init();
+      const njavaOpt = opt.njava ?? "auto";
+      if (njavaOpt === true) {
+        await attachNJava2(accessor);
+      } else if (njavaOpt === "auto") {
+        try {
+          let hJvm = await remoteGetModuleHandleA(accessor, "jvm.dll");
+          if (hJvm === 0n) {
+            const modules = Module.getModules(accessor.processId);
+            const isJavaLauncher = modules.some((m) => /java(\.exe|w\.exe|\.dll)/i.test(m.name));
+            if (isJavaLauncher) {
+              const deadline = Date.now() + 1e4;
+              while (hJvm === 0n && Date.now() < deadline) {
+                await Bun.sleep(100);
+                hJvm = await remoteGetModuleHandleA(accessor, "jvm.dll");
+              }
+            }
+          }
+          if (hJvm !== 0n) {
+            await attachNJava2(accessor);
+          }
+        } catch (err) {
+          if (isThreadDiedError(err)) {
+            accessor.close();
+            throw err;
+          }
+        }
+      }
+      return accessor;
+    } catch (err) {
+      accessor.close();
+      throw err;
+    }
+  };
+  if (options.njava === "stealth") {
+    return await createStealthJavaAccessor(id, options);
+  }
+  if (options.backend || options.idType === "thread") {
+    return await initOne(id, options);
+  }
+  if (!options.idType) {
+    try {
+      const modules = Module.getModules(id);
+      const isJava = modules.some((m) => /java(\.exe|w\.exe|\.dll)/i.test(m.name));
+      if (isJava) {
+        const threads = Thread3.getThreads(id);
+        const candidateThreads = threads.length > 1 ? [...threads.slice(1), threads[0]] : threads;
+        for (const t of candidateThreads) {
+          try {
+            return await initOne(t.tid, {
+              ...options,
+              idType: "thread"
+            });
+          } catch {}
+        }
+      }
+    } catch {}
+  }
+  try {
+    return await initOne(id, options);
+  } catch (err) {
+    if (isThreadDiedError(err)) {
+      const threads = Thread3.getThreads(id);
+      for (const t of threads) {
+        try {
+          return await initOne(t.tid, {
+            ...options,
+            idType: "thread"
+          });
+        } catch {}
+      }
+    }
+    throw err;
+  }
+}
+var AGGRESSIVENESS_PRESETS = {
+  1: {
+    hostOptions: { timeoutMs: 20000, pollIntervalMs: 2 },
+    sharedMemory: false
+  },
+  2: {
+    hostOptions: { timeoutMs: 5000, pollIntervalMs: 2 },
+    sharedMemory: true
+  }
+};
+function createAccessorOptions(aggressiveness = 1) {
+  const preset = AGGRESSIVENESS_PRESETS[aggressiveness];
+  return {
+    hostOptions: { ...preset.hostOptions },
+    sharedMemory: preset.sharedMemory
+  };
+}
+async function restoreAccessorFromSession(session, overrideOptions = {}) {
+  const baseOptions = {
+    ...session.options,
+    ...overrideOptions
+  };
+  const nthreadLayer = session.pipeline?.find((p) => p.type === "NThread");
+  if (nthreadLayer?.state && nthreadLayer.state.threadId) {
+    try {
+      const testThread = Thread3.open(nthreadLayer.state.threadId);
+      const isAlive = testThread.isValid() && testThread.getExitCode() === 259;
+      testThread.close();
+      if (isAlive) {
+        const redirector = new RedirectorHostAccessor(session.processId);
+        const nthread = new NThread2(session.processId, nthreadLayer.state.threadId, baseOptions.hostOptions ?? {}, redirector);
+        nthread.resumeFromHibernation(nthreadLayer.state);
+        const accessor = new IndirectNThreadHostAccessor(nthread);
+        redirector.target = accessor;
+        const hasNShm = session.pipeline?.some((p) => p.type === "NShm") || baseOptions.sharedMemory;
+        if (hasNShm) {
+          accessor.backend = new (baseOptions.sharedMemoryMiddleware ?? NShm)(accessor.backend, accessor, baseOptions.sharedMemoryOptions);
+        }
+        await accessor.init();
+        const hasNJava = session.pipeline?.some((p) => p.type === "NJavaAccessor") || Boolean(baseOptions.njava);
+        if (hasNJava) {
+          await attachNJava2(accessor);
+        }
+        accessor._options = baseOptions;
+        if (session.metadata) {
+          for (const [key, value] of Object.entries(session.metadata)) {
+            accessor.setSessionMetadata(key, value);
+          }
+        }
+        return accessor;
+      }
+    } catch {}
+  }
+  let targetId = session.processId;
+  let useThread = false;
+  try {
+    const threads = Thread3.getThreads(session.processId);
+    if (threads.length === 0) {
+      throw new Error(`Cannot restore accessor: process ${session.processId} is not running (no threads found).`);
+    }
+    if (session.threadId !== undefined && threads.some((t) => t.tid === session.threadId)) {
+      targetId = session.threadId;
+      useThread = true;
+    }
+  } catch (err) {
+    if (err.message?.includes("Cannot restore accessor:")) {
+      throw err;
+    }
+  }
+  const finalOptions = {
+    ...baseOptions,
+    idType: useThread ? "thread" : baseOptions.idType ?? "processAllThreadIds"
+  };
+  const accessor = await createAccessor(targetId, finalOptions);
+  if (session.metadata) {
+    for (const [key, value] of Object.entries(session.metadata)) {
+      accessor.setSessionMetadata(key, value);
+    }
+  }
+  return accessor;
+}
+async function createAccessorFromFile(filePath, overrideOptions) {
+  return await HostAccessor.restoreFromFile(filePath, overrideOptions);
+}
+HostAccessor.registerRestorer("IndirectNThreadHostAccessor", async (session, overrideOptions) => {
+  return await restoreAccessorFromSession(session, overrideOptions);
+});
+HostAccessor.registerRestorer("default", async (session, overrideOptions) => {
+  return await restoreAccessorFromSession(session, overrideOptions);
+});
 export {
-  ThrowingMemoryAccessor,
-  ThrowingHostAccessor,
-  ScannerMiddleware,
-  RedirectorHostAccessor,
-  ProcessCacheAccessor,
-  MsvcrtDependentMiddlewareAccessor,
-  MemsetWriteAccessor,
-  MemcmpReadAccessor,
-  MarshallingCallableAccessor,
-  MachineCodePoolMiddleware,
-  IndirectCallRedirectorAccessor,
-  HostAccessor,
-  FileTransferWriteAccessor,
-  FileTransferReadAccessor,
+  BootstrapHostAccessor,
   CallRedirectorAccessor,
-  BootstrapHostAccessor
+  FileTransferReadAccessor,
+  FileTransferWriteAccessor,
+  HostAccessor,
+  IndirectCallRedirectorAccessor,
+  IndirectNThreadHostAccessor,
+  MachineCodePoolMiddleware,
+  MarshallingCallableAccessor,
+  MemcmpReadAccessor,
+  MemsetWriteAccessor,
+  MsvcrtDependentMiddlewareAccessor,
+  NThreadRaceAccessor,
+  ProcessCacheAccessor,
+  RacingHostAccessor,
+  RedirectorHostAccessor,
+  ScannerMiddleware,
+  ThrowingHostAccessor,
+  ThrowingMemoryAccessor,
+  attachNJava2 as attachNJava,
+  createAccessor,
+  createAccessorFromFile,
+  createAccessorOptions,
+  createAccessorWithoutInit,
+  createStealthJavaAccessor,
+  findNJava,
+  findReflection,
+  getJavaClass,
+  getNJava,
+  getReflection,
+  restoreAccessorFromSession,
+  spawnStealthWorkerThread
 };