exoproc-accessors 0.1.0 → 0.6.2

package/dist/middleware-accessor.js

@@ -2,7 +2,8 @@ import { randomUUID } from 'crypto';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
-import { NativeMemory, normalizeType, resolveAddress, alignUp, computeNearAllocRange, freeRegionCandidate, AllocNearRangeError, Kernel32Impl, MsvcrtImpl, MsvcrtLibrary, MemoryBasicInformation, PROCESSENTRY32W_SIZE, MemoryState, MemoryProtection, MemoryFreeType, ToolhelpSnapshotFlag, ProcessAccess, DEFAULT_MACHINECODE_ALIGNMENT, memmem, memmem1, memmem2, memmem4, memmem8, memmemWithoutBuffer, Pattern, Scanner, verifyCoreModules, verifyCoreModulesSync, isModuleLoadedInProcess, isModuleLoadedInProcessSync, MiddlewareAccessor, InittableMiddlewareAccessor, isMiddlewareAccessor, } from 'bun-xffi';
+import { NativeMemory, normalizeType, resolveAddress, alignUp, computeNearAllocRange, freeRegionCandidate, AllocNearRangeError, Kernel32Impl, MsvcrtImpl, MsvcrtLibrary, MemoryBasicInformation, PROCESSENTRY32W_SIZE, MemoryState, MemoryProtection, MemoryFreeType, ToolhelpSnapshotFlag, ProcessAccess, DEFAULT_MACHINECODE_ALIGNMENT, memmem, memmem1, memmem2, memmem4, memmem8, memmemWithoutBuffer, Pattern, Scanner, verifyCoreModules, verifyCoreModulesSync, isModuleLoadedInProcess, isModuleLoadedInProcessSync, MiddlewareAccessor, InittableMiddlewareAccessor, isInittableAccessor, HostAccessor, } from 'bun-xffi';
+export { HostAccessor };
 export class MsvcrtDependentMiddlewareAccessor extends InittableMiddlewareAccessor {
     async onInit() {
         if (this.isLocal)
@@ -23,34 +24,6 @@ export class MsvcrtDependentMiddlewareAccessor extends InittableMiddlewareAccess
         }
     }
 }
-/**
- * HostAccessor is a base class that automatically initializes all nested InittableMiddlewareAccessors
- * in the backend decorator chain.
- */
-export 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() {
-        // No-op. Chain initialization is automatically propagated by init().
-    }
-    onInitSync() {
-        // No-op. Chain initialization is automatically propagated by initSync().
-    }
-}
 /**
  * A HostAccessor that forwards all operations to a dynamically changeable target HostAccessor.
  * This is useful for resolving circular dependencies in middleware chains where the root
@@ -77,7 +50,15 @@ export class RedirectorHostAccessor extends HostAccessor {
     _target;
     constructor(processId, root) {
         super(new ThrowingMemoryAccessor(processId), root);
-        this._target = new ThrowingHostAccessor(processId, this.root);
+        // Deliberately self-rooted (no `root` arg) rather than `this.root`: this
+        // placeholder is never a real candidate, but constructing it with the
+        // outer `root` would still run through `MiddlewareAccessor`'s
+        // constructor -- which unconditionally calls `root.registerChild(this)`
+        // -- and register the placeholder itself as a racer on a
+        // `RacingHostAccessor` root. Since it always throws and never does real
+        // work, it would "win" the race instantly, before any genuine candidate
+        // could land.
+        this._target = new ThrowingHostAccessor(processId);
     }
     get target() {
         return this._target;
@@ -232,10 +213,126 @@ export class RedirectorHostAccessor extends HostAccessor {
     async onInit() {
         // No-op. The target is initialized separately.
     }
+    /**
+     * Mirrors the `close()` override above for the async lifecycle: every op
+     * (read/write/call/...) routes to `target` once it's no longer `this`, so
+     * `deinit()` must too. Without this, the inherited `deinitNext()` (from
+     * `InittableMiddlewareAccessor`) walks `this.backend` -- which for a
+     * subclass like `NThreadRaceAccessor` stays pointed at its own
+     * placeholder `ThrowingMemoryAccessor` forever (only `target` ever gets
+     * reassigned to the winner, per `RedirectorHostAccessor`'s whole design;
+     * see its class doc comment) -- so the real accessor `target` resolved to
+     * would never actually get deinited, leaving its underlying resource
+     * (e.g. a hijacked thread) permanently stuck.
+     *
+     * Deliberately excludes `t === this.root`: `BootstrapHostAccessor.onInit()`
+     * itself resolves `target` to `this.root` once its own backend has landed
+     * -- that's a hand-off back to whatever *contains* this accessor (e.g. a
+     * per-candidate `BootstrapHostAccessor` inside `NThreadRaceAccessor`
+     * resolves to the race accessor itself), not a distinct resource this
+     * accessor now owns. Cascading `deinit()` there would tear down the
+     * container (and everything else riding on it, e.g. the actual race
+     * winner) from a single losing candidate's own cleanup.
+     */
+    async onDeinit() {
+        const t = this.getTarget();
+        if (t !== this && t !== this.root && isInittableAccessor(t)) {
+            await t.deinit();
+        }
+    }
     onInitSync() {
         // No-op. The target is initialized separately.
     }
 }
+/**
+ * A minimal `RedirectorHostAccessor` mixin meant to be *extended*, not used
+ * directly -- its only job is giving a subclass (e.g. `NThreadRaceAccessor`)
+ * two things for free: automatic candidate collection, and a `race()` helper
+ * to actually run the race once the subclass's own `onInit()` decides it's
+ * time. `target` (inherited) is left for the subclass to set to the winner
+ * however makes sense for it -- this class never touches it itself.
+ *
+ * Candidates are never added explicitly -- every `MiddlewareAccessor`'s
+ * constructor calls `root.registerChild(this)` (a no-op on every other
+ * `IHostAccessor`; see its doc comment), so simply constructing a candidate
+ * with a `RacingHostAccessor` (sub)instance as its `root` is enough to enter
+ * it into the race.
+ *
+ * Deliberately knows nothing about *why* a caller is racing candidates -- no
+ * `NThread`, no `AbortController`, no timeout, no `AsyncLocalStorage`; a
+ * caller that needs to cancel the losers does so itself, by extending this
+ * class and overriding `releaseLoser`, and a caller whose candidates need
+ * per-candidate context threaded through their own `init()` (e.g.
+ * `NThreadRaceAccessor`, whose candidates all share one root and need
+ * `root.call()` to resolve back to *this specific* candidate while racing)
+ * does so by overriding `startRacer` -- kept as a single, narrow extension
+ * point instead of baking any particular mechanism (like
+ * `AsyncLocalStorage`) into this generic base.
+ */
+export class RacingHostAccessor extends RedirectorHostAccessor {
+    racers = [];
+    registerChild(child) {
+        // Can fire before our own field initializers run: RedirectorHostAccessor's
+        // constructor builds a placeholder `new ThrowingHostAccessor(processId,
+        // this.root)`, and `this.root` is this very instance (self-rooted, still
+        // mid-construction) when nothing else was passed as `root` -- `this.racers`
+        // isn't assigned yet at that point. Harmless to skip: real candidates
+        // always register later, from a subclass's own constructor body, which
+        // only runs after every `super()` call (and therefore every field
+        // initializer) has completed.
+        if (!this.racers || !isInittableAccessor(child))
+            return;
+        this.racers.push(child);
+    }
+    /**
+     * Launches one racer's `init()`. Overridable so a subclass can wrap the
+     * call with its own per-candidate context (see `NThreadRaceAccessor`,
+     * which threads an `AsyncLocalStorage` context through this so its shared
+     * root's `call()` can resolve back to whichever candidate is currently
+     * bootstrapping) without this base class needing to know why.
+     */
+    startRacer(racer) {
+        return racer.init();
+    }
+    /**
+     * Races every registered racer's `init()` and returns whichever settles
+     * first; every other racer gets {@link releaseLoser}'d. Doesn't touch
+     * `target` itself -- callers (a subclass's own `onInit()` override)
+     * decide what to do with the winner.
+     */
+    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;
+    }
+    /**
+     * Called once per losing racer, right after a winner is picked. Default:
+     * deinit it once (if) its own `init()` eventually settles -- `deinit()` is
+     * a no-op for one that never finished or that already failed. Subclasses
+     * (e.g. `NThreadRaceAccessor`) can override this to *also* cancel an
+     * in-flight racer immediately, instead of only cleaning up after the fact.
+     */
+    releaseLoser(racer, settled) {
+        settled.then(() => racer.deinit().catch(() => { })).catch(() => { });
+    }
+}
 /**
  * BootstrapHostAccessor is a specialized RedirectorHostAccessor designed to resolve circular dependencies
  * during the initialization of decorator/middleware chains.
@@ -263,7 +360,7 @@ export class BootstrapHostAccessor extends RedirectorHostAccessor {
  */
 export 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}`);
@@ -271,7 +368,7 @@ export 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}`);
@@ -503,31 +600,66 @@ export 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 it's standard READWRITE memory without a specific requested address, use malloc for maximum redirection!
         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}`);
+            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 {
+                // Fallback to VirtualAlloc if msvcrt.dll malloc is not available in target process
             }
-            const allocatedAddr = Number(result);
-            this.mallocs.set(allocatedAddr, size);
-            return allocatedAddr;
         }
-        // Otherwise, fall back to VirtualAlloc (e.g. for executable memory blocks)
+        // Otherwise, fall back to VirtualAlloc (e.g. for executable memory blocks or if msvcrt not loaded)
         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}`);
+            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 {
+                // Fallback to VirtualAlloc if msvcrt.dll malloc is not available in target process
             }
-            const allocatedAddr = Number(result);
-            this.mallocs.set(allocatedAddr, size);
-            return allocatedAddr;
         }
         return super.allocSync(size, address, protection, allocationType);
     }
@@ -596,19 +728,43 @@ export class IndirectCallRedirectorAccessor extends CallRedirectorAccessor {
 export class MarshallingCallableAccessor extends MiddlewareAccessor {
     /**
      * Shared by call()/callSync() -- pure decision of "does this argument need
-     * marshalling to a remote buffer, and if so, what bytes", with no I/O.
-     * Returns `null` for args that pass through unmodified.
+     * marshalling to a remote buffer, and if so, what bytes and whether to copy
+     * remote modifications back to the caller's buffer/struct after the call".
      */
-    static bufferToMarshal(type, val) {
+    static marshalInfo(funcName, type, val) {
         const normType = normalizeType(type);
         if (normType === 'cstring' && typeof val === 'string') {
-            return Buffer.from(val + '\0', 'utf8');
-        }
-        else if (normType === 'cwstring' && typeof val === 'string') {
-            return Buffer.from(val + '\0', 'utf16le');
+            return { buf: Buffer.from(val + '\0', 'utf8') };
+        }
+        if (normType === 'cwstring' && typeof val === 'string') {
+            return { buf: Buffer.from(val + '\0', '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 + '\0', isAnsi ? 'utf8' : 'utf16le'),
+                };
+            }
         }
-        else if (val && typeof val === 'object' && Buffer.isBuffer(val)) {
-            return val;
+        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;
     }
@@ -617,16 +773,43 @@ export 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 {
+                        // ignore write-back errors
+                    }
+                }
+            }
+            return result;
         }
         finally {
             for (const alloc of tempAllocations) {
@@ -644,16 +827,43 @@ export 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 {
+                        // ignore write-back errors
+                    }
+                }
+            }
+            return result;
         }
         finally {
             for (const alloc of tempAllocations) {
@@ -1161,33 +1371,41 @@ export class FileTransferReadAccessor extends MsvcrtDependentMiddlewareAccessor
         if (this.isInitializing || !this.tempFilePath) {
             return super.readAfterInit(address, size, offset);
         }
-        await this.ensureOpen();
-        const targetAddr = resolveAddress(address) + offset;
-        // Rewind so we overwrite from the start, dump target memory into the
-        // file, then flush so the local read below sees the fresh bytes.
-        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);
-        // The file may still carry trailing bytes from a larger previous
-        // transfer, so take only the `size` bytes we just wrote.
-        return fs.readFileSync(this.tempFilePath).subarray(0, size);
+        try {
+            await this.ensureOpen();
+            const targetAddr = resolveAddress(address) + offset;
+            // Rewind so we overwrite from the start, dump target memory into the
+            // file, then flush so the local read below sees the fresh bytes.
+            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 {
+            // Fall through to backend read on any CRT staging or file lock failure
+        }
+        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})`);
+        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 {
+            // Fall through to backend read on any CRT staging or file lock failure
         }
-        this.backend.callSync(MsvcrtImpl.fflush, this.hFile);
-        return fs.readFileSync(this.tempFilePath).subarray(0, size);
+        return super.readAfterInitSync(address, size, offset);
     }
 }
 /**
@@ -1307,17 +1525,22 @@ export class FileTransferWriteAccessor extends MsvcrtDependentMiddlewareAccessor
         }
         const targetAddr = resolveAddress(address) + offset;
         const buffer = data instanceof Buffer ? data : Buffer.from(data);
-        // Put the payload in the file (local, truncating write) BEFORE opening so
-        // fopen("rb") sees a valid file, then rewind the shared FILE* so fread
-        // re-reads the freshly written bytes from offset 0.
-        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 {
+            // Put the payload in the file (local, truncating write) BEFORE opening so
+            // fopen("rb") sees a valid file, then rewind the shared FILE* so fread
+            // re-reads the freshly written bytes from offset 0.
+            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 {
+            // Fall through to backend write on any CRT staging or file lock failure
+        }
+        return super.writeAfterInit(address, data, offset);
     }
     writeAfterInitSync(address, data, offset = 0) {
         if (this.isInitializingSync || !this.tempFilePath) {
@@ -1325,14 +1548,19 @@ export 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 {
+            // Fall through to backend write on any CRT staging or file lock failure
+        }
+        return super.writeAfterInitSync(address, data, offset);
     }
 }
 /**