@openclaw/signal 2026.9.4 → 2026.9.6

package/node_modules/@openclaw/fs-safe/dist/native-staged-file.js

@@ -0,0 +1,442 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { assertDarwinCreationAcl, assertPrivateCreationFile } from "./creation-boundary.js";
+import { requireNativeBinding } from "./native.js";
+import { syncFileBestEffortSync } from "./file-sync.js";
+import { randomUUID } from "node:crypto";
+import fs, {} from "node:fs";
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import { assertSynchronousCallbackResult, MutationAuthorityError } from "./mutation-authority.js";
+import { captureNativeFdClose } from "./native-binding.js";
+import { writePinnedInput } from "./pinned-write-input.js";
+import { assertNativeCopyCompleted, createNativeCopyFile } from "./copy-file-input.js";
+import { assertStagedDirectoryCurrent, openStagedDirectory } from "./staged-directory.js";
+import { assertFinalSymlinkRejected } from "./root-symlink-policy.js";
+import { classifyNativeRenameFailure } from "./native-rename-outcome.js";
+import { createStagedFileReceipt, stagedFileFailure as failure } from "./staged-file-settlement.js";
+export function assertNativeStaging(binding) {
+    if ([
+        binding.closeOwnedFd,
+        binding.createStagedFile,
+        binding.stagedFileMatches,
+        binding.removeStagedFile,
+        binding.renameReplace,
+        binding.renameNoReplace,
+    ].some((fn) => typeof fn !== "function")) {
+        throw new FsSafeError("helper-unavailable", "native retained-directory staging is unavailable");
+    }
+}
+function assertBasename(name, portable) {
+    if (!name || name === "." || name === ".." || name.includes("/") || name.includes("\0") ||
+        (portable && /[\\:\u0000-\u001f\u007f-\u009f\u2028\u2029]/u.test(name))) {
+        throw new FsSafeError("invalid-path", "publication requires one direct-child basename");
+    }
+}
+const NOT_PUBLISHED = Object.freeze({ status: "not-published" });
+class NativeStagedFile {
+    #owner;
+    #closeFd;
+    #assertBeforeMutation;
+    #private;
+    #verifyMode;
+    #state = { status: "open", publication: NOT_PUBLISHED };
+    #receipt;
+    #rejectFinalSymlink = false;
+    constructor(owner) {
+        const name = owner.name ?? `.fs-safe-${randomUUID()}.tmp`;
+        assertBasename(name, owner.portableNames !== false);
+        this.#closeFd = captureNativeFdClose(owner.binding);
+        this.#owner = { ...owner, name };
+        this.#assertBeforeMutation = owner.assertBeforeMutation;
+        this.#private = owner.permissionPolicy === "private-creation";
+        this.#verifyMode = owner.permissionPolicy !== undefined;
+    }
+    // Public staging supplies a Node parent; pinned writes supply a native parent.
+    // The supplied closer owns parentFd even on construction or preparation failure.
+    static async create(owner, input, maxBytes) {
+        let staged;
+        try {
+            staged = new NativeStagedFile(owner);
+        }
+        catch (error) {
+            try {
+                owner.closeParentFd(owner.parentFd);
+            }
+            catch (closeError) {
+                throw new AggregateError([error, closeError], "staged owner construction and close failed");
+            }
+            throw error;
+        }
+        await staged.#prepare(input, maxBytes);
+        return staged;
+    }
+    static async write(binding, parentFd, closeParentFd, directory, params, parentGuard) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const exclusive = params.overwrite === false && params.input.kind === "buffer" && params.input.stageBeforePublish === false;
+            // This owner never escapes. Only the internal verifier borrows its fd;
+            // public descriptor methods remain await-free and cannot race disposal.
+            const staged = __addDisposableResource(env_1, await NativeStagedFile.create({
+                binding, parentFd, closeParentFd, directory, mode: params.mode, sync: params.sync,
+                // Public staging uses portable names; existing POSIX writes accept literal names.
+                portableNames: false, assertBeforeMutation: params.assertBeforeMutation,
+                name: exclusive ? params.basename : undefined, strictFileSync: params.strictFileSync,
+                permissionPolicy: params.private ? "private-creation" : params.verifyPosixMode === true ? "mode-only" : undefined,
+            }, params.input, params.maxBytes), true);
+            staged.#rejectFinalSymlink = params.rejectFinalSymlink === true;
+            if (params.input.kind === "file")
+                await params.input.verifySource();
+            if (exclusive) {
+                staged.#assertCurrent();
+                params.assertBeforeMutation?.();
+                if (staged.#verifyMode)
+                    staged.#assertCurrent();
+            }
+            const published = exclusive
+                ? staged.#completePublication(params.basename, false, params.onPublished)
+                : await staged.publish(params.basename, { overwrite: params.overwrite !== false }, params.onPublished);
+            const identity = published.staged.identity;
+            try {
+                await params.verifyPublished?.(staged.#file(), identity, parentGuard);
+            }
+            catch (error) {
+                if (params.overwrite === false && params.input.kind !== "file" && params.input.stageBeforePublish === true) {
+                    throw failure(error, { phase: "publish", publication: published });
+                }
+                throw error;
+            }
+            return { dev: identity.dev, ino: identity.ino };
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
+        }
+    }
+    get receipt() {
+        if (!this.#receipt) {
+            throw new FsSafeError("helper-failed", "staged file preparation is incomplete");
+        }
+        return this.#receipt;
+    }
+    #open() {
+        if (this.#state.status === "closed") {
+            throw new FsSafeError("helper-failed", "staged file is closed");
+        }
+        return this.#state;
+    }
+    #file() {
+        const state = this.#open();
+        if (state.fileFd === undefined) {
+            throw new FsSafeError("helper-failed", "staged file has not been created");
+        }
+        return state.fileFd;
+    }
+    #assertNamed(name, expectedMode) {
+        const fd = this.#file();
+        const stat = this.#owner.binding.stagedFileMatches(this.#owner.parentFd, name, fd)
+            ? fs.fstatSync(fd, { bigint: true }) : undefined;
+        if (!stat || stat.nlink !== 1n) {
+            throw new FsSafeError("path-mismatch", "staged entry no longer names the exclusive created file");
+        }
+        this.#assertPermissions(fd, stat, expectedMode);
+        return Number(stat.mode & 4095n);
+    }
+    #assertCurrent() {
+        if (this.#open().publication.status !== "not-published") {
+            throw new FsSafeError("helper-failed", "staged file publication has already been attempted");
+        }
+        assertStagedDirectoryCurrent(this.#owner.directory);
+        this.#assertNamed(this.#owner.name, 0o600);
+    }
+    #assertPermissions(fd, stat, expectedMode) {
+        if (this.#private)
+            assertPrivateCreationFile(stat, fd);
+        if (this.#verifyMode && Number(stat.mode & 4095n) !== expectedMode) {
+            throw new FsSafeError("insecure-permissions", "filesystem did not enforce the staged file mode");
+        }
+    }
+    #assertStagePermissions(fd) {
+        this.#assertPermissions(fd, fs.fstatSync(fd, { bigint: true }), 0o600);
+    }
+    async #prepare(input, maxBytes) {
+        try {
+            const mode = this.#owner.mode;
+            if (!Number.isInteger(mode) || mode < 0 || mode > 0o7777) {
+                throw new FsSafeError("invalid-path", "invalid staged file mode");
+            }
+            const fileSignal = input.kind === "file" && this.#verifyMode ? input.signal : undefined;
+            if (input.kind === "file" && this.#verifyMode) {
+                fileSignal?.throwIfAborted();
+                if (input.clone === "always") {
+                    throw new FsSafeError("helper-unavailable", "required cloning cannot verify staged permissions before copying");
+                }
+            }
+            assertStagedDirectoryCurrent(this.#owner.directory);
+            // The exclusive open performs no fallible post-open checks. Store its fd
+            // before every subsequent operation, including the first metadata read.
+            const state = this.#open();
+            if (this.#private)
+                assertDarwinCreationAcl(this.#owner.parentFd, "file");
+            this.#assertBeforeMutation?.();
+            if (this.#private)
+                assertDarwinCreationAcl(this.#owner.parentFd, "file");
+            // Native copying populates its new file before returning its descriptor.
+            const copied = input.kind === "file" && !this.#verifyMode
+                ? await createNativeCopyFile(this.#owner.binding, input, this.#owner.parentFd, this.#owner.name, maxBytes, false)
+                : undefined;
+            state.fileFd = copied?.fd;
+            if (state.fileFd === undefined) {
+                this.#assertBeforeMutation?.();
+                if (this.#private)
+                    assertDarwinCreationAcl(this.#owner.parentFd, "file");
+                state.fileFd = this.#owner.binding.createStagedFile(this.#owner.parentFd, this.#owner.name);
+            }
+            const fd = state.fileFd;
+            if (input.kind === "file")
+                assertNativeCopyCompleted(input, copied);
+            const assertBeforeChmod = this.#assertBeforeMutation;
+            const beforeChmodResult = assertBeforeChmod?.();
+            if (this.#private) {
+                assertSynchronousCallbackResult(beforeChmodResult, "assertBeforeMutation");
+                assertPrivateCreationFile(fs.fstatSync(fd, { bigint: true }), fd);
+            }
+            fs.fchmodSync(fd, 0o600);
+            // Some filesystems report successful chmod without enforcing its mode.
+            if (this.#verifyMode)
+                this.#assertStagePermissions(fd);
+            const assertBeforeMutation = this.#verifyMode ? () => {
+                assertSynchronousCallbackResult(this.#assertBeforeMutation?.(), "assertBeforeMutation");
+                fileSignal?.throwIfAborted();
+                this.#assertStagePermissions(fd);
+            } : this.#assertBeforeMutation;
+            if (!copied)
+                await writePinnedInput(fd, input, maxBytes, assertBeforeMutation);
+            if (this.#verifyMode)
+                this.#assertStagePermissions(fd);
+            if (this.#owner.sync !== false) {
+                if (this.#owner.strictFileSync)
+                    fs.fsyncSync(fd);
+                else
+                    syncFileBestEffortSync(fd);
+            }
+            const stat = fs.fstatSync(fd, { bigint: true });
+            this.#receipt = createStagedFileReceipt(this.#owner.directory, this.#owner.name, stat);
+            this.#assertCurrent();
+        }
+        catch (error) {
+            const { receipt: cleanup, error: cleanupError } = this.#finalize();
+            if (cleanupError) {
+                throw failure(new AggregateError([error, cleanupError], "preparation and cleanup failed"), { phase: "prepare", publication: cleanup.publication, cleanup });
+            }
+            if (cleanup.status === "preserved") {
+                throw failure(error, { phase: "prepare", publication: cleanup.publication, cleanup });
+            }
+            throw error;
+        }
+    }
+    // Keep public descriptor work await-free: each call completes its mutations
+    // before the next invocation, including closure and cached cleanup failures.
+    async assertCurrent() {
+        this.#assertCurrent();
+    }
+    async publish(basename, options, onPublished) {
+        const overwrite = options?.overwrite;
+        try {
+            const state = this.#open();
+            assertBasename(basename, this.#owner.portableNames !== false);
+            if (basename === this.#owner.name || typeof overwrite !== "boolean") {
+                throw new FsSafeError("invalid-path", "publication needs a distinct basename and explicit overwrite policy");
+            }
+            this.#assertCurrent();
+            assertFinalSymlinkRejected(path.join(this.#owner.directory.realPath, basename), this.#rejectFinalSymlink);
+            this.#assertBeforeMutation?.();
+            if (this.#assertBeforeMutation) {
+                this.#assertCurrent();
+                assertFinalSymlinkRejected(path.join(this.#owner.directory.realPath, basename), this.#rejectFinalSymlink);
+            }
+            try {
+                if (overwrite) {
+                    this.#owner.binding.renameReplace(this.#owner.parentFd, this.#owner.name, this.#owner.parentFd, basename);
+                }
+                else {
+                    this.#owner.binding.renameNoReplace(this.#owner.parentFd, this.#owner.name, this.#owner.parentFd, basename);
+                }
+            }
+            catch (error) {
+                // Only explicit pre-dispatch provenance can rule out a committed rename.
+                if (classifyNativeRenameFailure(error) === "indeterminate") {
+                    state.publication = Object.freeze({ status: "indeterminate", basename, overwrite });
+                }
+                throw error;
+            }
+            return this.#completePublication(basename, overwrite, onPublished);
+        }
+        catch (error) {
+            if (error instanceof MutationAuthorityError)
+                throw error;
+            // Closure rejects further use, not the recorded outcome of an earlier publication.
+            const publication = this.#state.status === "closed"
+                ? this.#state.receipt.publication
+                : this.#state.publication;
+            throw failure(error, { phase: "publish", publication });
+        }
+    }
+    #completePublication(basename, overwrite, onPublished) {
+        // Record complete content before fallible post-publication verification.
+        const receipt = Object.freeze({ status: "published", staged: this.receipt, basename, overwrite });
+        this.#open().publication = receipt;
+        onPublished?.(receipt.staged.identity);
+        const stagedMode = this.#assertNamed(basename, 0o600);
+        assertStagedDirectoryCurrent(this.#owner.directory);
+        // Keep contents private until the name passes its identity fence. Mode
+        // changes use the owned fd, including for final mode 000.
+        const fd = this.#file();
+        if (this.#owner.mode !== 0o600 || stagedMode !== 0o600)
+            fs.fchmodSync(fd, this.#owner.mode);
+        // Content was synced during preparation. A lost chmod leaves 0600, no wider
+        // than modes retaining owner rw; restrictive modes still need a durable correction.
+        if (this.#owner.sync !== false && ((this.#owner.mode & 0o600) !== 0o600 || (stagedMode & ~this.#owner.mode) !== 0)) {
+            if (this.#owner.strictFileSync)
+                fs.fsyncSync(fd);
+            else
+                syncFileBestEffortSync(fd);
+        }
+        if (this.#owner.sync !== false)
+            syncFileBestEffortSync(this.#owner.parentFd);
+        this.#assertNamed(basename, this.#owner.mode);
+        assertStagedDirectoryCurrent(this.#owner.directory);
+        return receipt;
+    }
+    #finalize() {
+        if (this.#state.status === "closed") {
+            return this.#state;
+        }
+        const state = this.#state;
+        let outcome = "not-needed";
+        const errors = [];
+        if (state.publication.status === "indeterminate") {
+            outcome = "preserved";
+        }
+        else if (state.publication.status === "not-published" && state.fileFd !== undefined) {
+            try {
+                outcome = this.#owner.binding.removeStagedFile(this.#owner.parentFd, this.#owner.name, state.fileFd);
+            }
+            catch (error) {
+                outcome = "failed";
+                errors.push(error);
+            }
+        }
+        let resources = "closed";
+        for (const [fd, closeFd] of [
+            [state.fileFd, this.#closeFd],
+            [this.#owner.parentFd, this.#owner.closeParentFd],
+        ]) {
+            if (fd === undefined) {
+                continue;
+            }
+            try {
+                closeFd(fd);
+            }
+            catch (error) {
+                resources = "close-failed";
+                errors.push(error);
+            }
+        }
+        const receipt = Object.freeze({
+            temporaryBasename: this.#owner.name,
+            publication: state.publication,
+            status: outcome,
+            resources,
+        });
+        const error = errors.length ? failure(errors.length === 1 ? errors[0] : new AggregateError(errors, "staged cleanup failed"), { phase: "cleanup", publication: state.publication, cleanup: receipt }) : undefined;
+        this.#state = { status: "closed", receipt, error };
+        return this.#state;
+    }
+    async cleanup() {
+        const closed = this.#finalize();
+        if (closed.error) {
+            throw closed.error;
+        }
+        return closed.receipt;
+    }
+    async [Symbol.asyncDispose]() {
+        const cleanup = await this.cleanup();
+        if (cleanup.status === "preserved") {
+            throw new FsSafeError("not-removable", "staged cleanup preserved an unverified entry", {
+                details: { phase: "cleanup", publication: cleanup.publication, cleanup },
+            });
+        }
+    }
+}
+export const createNativeStage = NativeStagedFile.create;
+export const writeNativeStage = NativeStagedFile.write;
+export async function stageFileInDirectory(options) {
+    if (process.platform !== "linux" && process.platform !== "darwin") {
+        throw new FsSafeError("unsupported-platform", "retained-directory staging requires Linux or macOS");
+    }
+    const binding = requireNativeBinding();
+    assertNativeStaging(binding);
+    const input = { kind: "buffer", data: Buffer.from(options.content) };
+    const mode = options.mode ?? 0o600;
+    const parent = openStagedDirectory(options.directory);
+    return await createNativeStage({
+        binding, parentFd: parent.fd, closeParentFd: fs.closeSync,
+        directory: parent.receipt, mode, permissionPolicy: "mode-only",
+    }, input);
+}

package/node_modules/@openclaw/fs-safe/dist/native.d.ts

@@ -0,0 +1,13 @@
+import { type NativeBinding } from "./native-binding.js";
+export type { NativeBinding } from "./native-binding.js";
+export declare function __loadBundledNativeForTest(): NativeBinding;
+export declare function __nativeLoaderDetectorsForTest(): {
+    report: boolean | undefined;
+    filesystem: boolean | undefined;
+    elfInterpreter: boolean | undefined;
+};
+export declare function __nativeTargetForTest(platform: NodeJS.Platform, arch: string, musl?: boolean): string | undefined;
+export declare function getNativeBinding(): NativeBinding | undefined;
+export declare function requireNativeBinding(): NativeBinding;
+export declare function __setNativeLoaderForTest(loader: () => NativeBinding): void;
+export declare function __resetNativeLoaderForTest(): void;

package/node_modules/@openclaw/fs-safe/dist/native.js

@@ -0,0 +1,209 @@
+import { closeSync, openSync, readSync, readdirSync, } from "node:fs";
+import { createRequire } from "node:module";
+import { FsSafeError } from "./errors.js";
+import { captureNativeFdClose } from "./native-binding.js";
+import { getFsSafeNativeConfig } from "./native-config.js";
+const require = createRequire(import.meta.url);
+let binding;
+let loadError;
+let attempted = false;
+let loadBinding = loadBundledBinding;
+function isMuslFilename(file) {
+    return file.includes("libc.musl-") || file.includes("ld-musl-");
+}
+function isMuslFromReport() {
+    try {
+        if (!process.report || typeof process.report.getReport !== "function")
+            return undefined;
+        const report = process.report.getReport();
+        if (report.header?.glibcVersionRuntime)
+            return false;
+        if (report.sharedObjects?.some(isMuslFilename))
+            return true;
+    }
+    catch {
+        // Continue with ELF and filesystem inspection.
+    }
+    return undefined;
+}
+function isMuslFromFilesystem() {
+    for (const directory of ["/lib", "/usr/lib"]) {
+        try {
+            if (readdirSync(directory).some(isMuslFilename))
+                return true;
+        }
+        catch {
+            // A missing or unreadable conventional library directory is inconclusive.
+        }
+    }
+    return undefined;
+}
+function readUInt(buffer, offset, bytes, littleEndian) {
+    if (offset < 0 || offset + bytes > buffer.length)
+        return undefined;
+    if (bytes === 2)
+        return littleEndian ? buffer.readUInt16LE(offset) : buffer.readUInt16BE(offset);
+    if (bytes === 4)
+        return littleEndian ? buffer.readUInt32LE(offset) : buffer.readUInt32BE(offset);
+    const value = littleEndian ? buffer.readBigUInt64LE(offset) : buffer.readBigUInt64BE(offset);
+    return value <= BigInt(Number.MAX_SAFE_INTEGER) ? Number(value) : undefined;
+}
+function isMuslFromElfInterpreter() {
+    let fd;
+    try {
+        fd = openSync(process.execPath, "r");
+        const header = Buffer.alloc(64);
+        if (readSync(fd, header, 0, header.length, 0) < 52)
+            return undefined;
+        if (!header.subarray(0, 4).equals(Buffer.from([0x7f, 0x45, 0x4c, 0x46])))
+            return undefined;
+        const elfClass = header[4];
+        const dataEncoding = header[5];
+        if ((elfClass !== 1 && elfClass !== 2) || (dataEncoding !== 1 && dataEncoding !== 2)) {
+            return undefined;
+        }
+        const littleEndian = dataEncoding === 1;
+        const is64Bit = elfClass === 2;
+        const tableOffset = readUInt(header, is64Bit ? 32 : 28, is64Bit ? 8 : 4, littleEndian);
+        const entrySize = readUInt(header, is64Bit ? 54 : 42, 2, littleEndian);
+        const entryCount = readUInt(header, is64Bit ? 56 : 44, 2, littleEndian);
+        if (tableOffset === undefined ||
+            entrySize === undefined ||
+            entryCount === undefined ||
+            entrySize < (is64Bit ? 56 : 32) ||
+            entryCount > 1024) {
+            return undefined;
+        }
+        const programHeader = Buffer.alloc(entrySize);
+        for (let index = 0; index < entryCount; index += 1) {
+            const offset = tableOffset + index * entrySize;
+            if (readSync(fd, programHeader, 0, entrySize, offset) !== entrySize)
+                return undefined;
+            if (readUInt(programHeader, 0, 4, littleEndian) !== 3)
+                continue;
+            const interpreterOffset = readUInt(programHeader, is64Bit ? 8 : 4, is64Bit ? 8 : 4, littleEndian);
+            const interpreterSize = readUInt(programHeader, is64Bit ? 32 : 16, is64Bit ? 8 : 4, littleEndian);
+            if (interpreterOffset === undefined ||
+                interpreterSize === undefined ||
+                interpreterSize < 1 ||
+                interpreterSize > 4096) {
+                return undefined;
+            }
+            const interpreter = Buffer.alloc(interpreterSize);
+            if (readSync(fd, interpreter, 0, interpreterSize, interpreterOffset) !== interpreterSize) {
+                return undefined;
+            }
+            return isMuslFilename(interpreter.toString("utf8"));
+        }
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (fd !== undefined) {
+            try {
+                closeSync(fd);
+            }
+            catch {
+                // Best-effort detection must never turn close failure into import failure.
+            }
+        }
+    }
+    return undefined;
+}
+function isMusl() {
+    if (process.platform !== "linux")
+        return false;
+    for (const detector of [isMuslFromReport, isMuslFromElfInterpreter, isMuslFromFilesystem]) {
+        const result = detector();
+        if (result !== undefined)
+            return result;
+    }
+    // Unknown Linux libc: try the glibc binary and let its require fail normally.
+    return false;
+}
+function targetFor(platform, arch, musl) {
+    if (platform === "win32" && arch === "x64")
+        return "win32-x64-msvc";
+    if (platform === "darwin" && arch === "x64")
+        return "darwin-x64";
+    if (platform === "darwin" && arch === "arm64")
+        return "darwin-arm64";
+    if (platform === "linux" && (arch === "x64" || arch === "arm64")) {
+        return `linux-${arch}-${musl ? "musl" : "gnu"}`;
+    }
+    return undefined;
+}
+function bundledTarget() {
+    return targetFor(process.platform, process.arch, isMusl());
+}
+function nativePackageForTarget(target) {
+    return `@openclaw/fs-safe-${target}`;
+}
+function loadBundledBinding() {
+    const target = bundledTarget();
+    if (!target) {
+        throw new Error(`Unsupported OS or architecture: ${process.platform}-${process.arch}`);
+    }
+    const loaded = require(nativePackageForTarget(target));
+    captureNativeFdClose(loaded);
+    return loaded;
+}
+export function __loadBundledNativeForTest() {
+    return loadBundledBinding();
+}
+export function __nativeLoaderDetectorsForTest() {
+    return {
+        report: isMuslFromReport(),
+        filesystem: isMuslFromFilesystem(),
+        elfInterpreter: isMuslFromElfInterpreter(),
+    };
+}
+export function __nativeTargetForTest(platform, arch, musl = false) {
+    return targetFor(platform, arch, musl);
+}
+export function getNativeBinding() {
+    const { mode } = getFsSafeNativeConfig();
+    if (mode === "off")
+        return undefined;
+    if (!attempted) {
+        attempted = true;
+        try {
+            const loaded = loadBinding();
+            captureNativeFdClose(loaded);
+            binding = loaded;
+        }
+        catch (error) {
+            loadError = error;
+        }
+    }
+    if (binding)
+        return binding;
+    if (mode === "require") {
+        throw new FsSafeError("helper-unavailable", "native fs-safe helper is unavailable", {
+            cause: loadError,
+        });
+    }
+    return undefined;
+}
+export function requireNativeBinding() {
+    const native = getNativeBinding();
+    if (!native) {
+        throw new FsSafeError("helper-unavailable", "native fs-safe helper is unavailable", {
+            cause: loadError,
+        });
+    }
+    return native;
+}
+export function __setNativeLoaderForTest(loader) {
+    binding = undefined;
+    loadError = undefined;
+    attempted = false;
+    loadBinding = loader;
+}
+export function __resetNativeLoaderForTest() {
+    binding = undefined;
+    loadError = undefined;
+    attempted = false;
+    loadBinding = loadBundledBinding;
+}

package/node_modules/@openclaw/fs-safe/dist/opened-file-failure.d.ts

@@ -0,0 +1,7 @@
+import { type BigIntStats } from "node:fs";
+import type { FileHandle } from "node:fs/promises";
+export declare function recordFileOpenFailure(error: unknown, filePath: string): never;
+export declare function recordExclusiveCreateFailure(error: unknown, filePath: string): never;
+export declare function openedPathResolutionError(error?: Error): Error;
+export declare function recordPreOpenFileChange(error: unknown, handle: FileHandle, filePath: string, before: BigIntStats | undefined, opened: BigIntStats | undefined): Promise<void>;
+export declare function recordOpenedFileFailure(error: unknown, handle: FileHandle, filePath: string, identity: BigIntStats): Promise<void>;