@openclaw/openshell-sandbox 2026.9.5 → 2026.9.7

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

@@ -0,0 +1,303 @@
+import fs, {} from "node:fs";
+import { FsSafeError } from "./errors.js";
+import { assertSynchronousCallbackResult } from "./mutation-authority.js";
+import { captureNativeFdClose } from "./native-binding.js";
+import { requireNativeBinding } from "./native.js";
+import { classifyNativeRenameFailure } from "./native-rename-outcome.js";
+import { assertStagedDirectoryCurrent, openStagedDirectory } from "./staged-directory.js";
+import { createStagedFileReceipt } from "./staged-file-settlement.js";
+const NOT_PUBLISHED = Object.freeze({ status: "not-published" });
+function basename(name) {
+    if (typeof name !== "string" || !name || name === "." || name === ".." ||
+        /[/\\:\u0000-\u001f\u007f-\u009f\u2028\u2029]/u.test(name)) {
+        throw new FsSafeError("invalid-path", "staged symlinks require a direct-child basename");
+    }
+}
+function failure(error, details) {
+    let code = "helper-failed";
+    try {
+        code = error instanceof FsSafeError ? error.code
+            : error?.code === "EEXIST" ? "already-exists" : "helper-failed";
+    }
+    catch {
+        // Uninspectable error metadata must not interrupt terminal settlement.
+    }
+    return new FsSafeError(code, `staged symlink ${details.phase} failed`, { cause: error, details });
+}
+function assertAuthority(assertion) {
+    assertSynchronousCallbackResult(assertion(), "assertBeforeMutation");
+}
+function expectedIdentity(stat, expected) {
+    return stat.isSymbolicLink() && stat.nlink === 1n &&
+        stat.dev === expected.dev && stat.ino === expected.ino &&
+        stat.uid === BigInt(expected.uid) && stat.gid === BigInt(expected.gid) &&
+        stat.ctimeNs === expected.ctimeNs;
+}
+class NativeStagedSymlink {
+    #publication = NOT_PUBLISHED;
+    #closed;
+    #removal;
+    #busy = false;
+    #receipt;
+    #binding;
+    #parentFd;
+    #linkFd;
+    #closeLink;
+    #assertion;
+    constructor(receipt, binding, parentFd, linkFd, closeLink, assertion) {
+        this.#receipt = receipt;
+        this.#binding = binding;
+        this.#parentFd = parentFd;
+        this.#linkFd = linkFd;
+        this.#closeLink = closeLink;
+        this.#assertion = assertion;
+    }
+    get receipt() { return this.#receipt; }
+    #idle() {
+        if (this.#busy)
+            throw new FsSafeError("helper-failed", "reentrant symlink operation");
+    }
+    #open() {
+        if (this.#closed)
+            throw new FsSafeError("helper-failed", "staged symlink is closed");
+    }
+    #matches(name) {
+        if (!this.#binding.stagedSymlinkMatches(this.#parentFd, name, this.#linkFd))
+            return false;
+        const stat = fs.fstatSync(this.#linkFd, { bigint: true });
+        const identity = this.#receipt.identity;
+        // ctime changes on rename; identity, ownership, mode and target do not.
+        return stat.dev === identity.dev && stat.ino === identity.ino &&
+            stat.uid === BigInt(identity.uid) && stat.gid === BigInt(identity.gid) &&
+            Number(stat.mode & 4095n) === identity.mode && stat.nlink === 1n &&
+            this.#binding.stagedSymlinkTarget(this.#parentFd, name, this.#linkFd) === this.#receipt.target;
+    }
+    #assertNamed(name) {
+        if (!this.#matches(name))
+            throw new FsSafeError("path-mismatch", "symlink no longer names the retained object");
+    }
+    #assertCurrent() {
+        this.#open();
+        if (this.#publication.status !== "not-published") {
+            throw new FsSafeError("helper-failed", "symlink publication has already been attempted");
+        }
+        assertStagedDirectoryCurrent(this.#receipt.directory);
+        this.#assertNamed(this.#receipt.temporaryBasename);
+    }
+    async assertCurrent() { this.#idle(); this.#assertCurrent(); }
+    async publish(name) {
+        this.#idle();
+        this.#busy = true;
+        try {
+            basename(name);
+            if (name === this.#receipt.temporaryBasename) {
+                throw new FsSafeError("invalid-path", "publication requires a distinct basename");
+            }
+            this.#assertCurrent();
+            assertAuthority(this.#assertion);
+            // A synchronous caller assertion can itself change either pathname.
+            this.#assertCurrent();
+            try {
+                this.#binding.publishStagedSymlink(this.#parentFd, this.#receipt.temporaryBasename, this.#linkFd, name);
+            }
+            catch (error) {
+                let outcome = "indeterminate";
+                try {
+                    outcome = classifyNativeRenameFailure(error);
+                }
+                catch {
+                    // Unreadable diagnostics cannot prove that the rename was uncommitted.
+                }
+                if (outcome === "indeterminate") {
+                    this.#publication = Object.freeze({ status: "indeterminate", basename: name, overwrite: false });
+                }
+                throw error;
+            }
+            const published = Object.freeze({
+                status: "published", staged: this.#receipt, basename: name, overwrite: false,
+            });
+            // Record dispatch success before any fallible post-observation.
+            this.#publication = published;
+            this.#assertNamed(name);
+            assertStagedDirectoryCurrent(this.#receipt.directory);
+            return published;
+        }
+        catch (error) {
+            throw failure(error, { phase: "publish", publication: this.#publication });
+        }
+        finally {
+            this.#busy = false;
+        }
+    }
+    #publishedName() {
+        this.#open();
+        if (this.#publication.status !== "published" || this.#removal) {
+            throw new FsSafeError("helper-failed", "no unsettled published symlink");
+        }
+        return this.#publication.basename;
+    }
+    async assertPublished() {
+        this.#idle();
+        const name = this.#publishedName();
+        assertStagedDirectoryCurrent(this.#receipt.directory);
+        this.#assertNamed(name);
+    }
+    #remove(name) {
+        try {
+            if (!this.#matches(name))
+                return "preserved";
+        }
+        catch (error) {
+            let missing = false;
+            try {
+                missing = error?.code === "ENOENT";
+            }
+            catch {
+                // Even a failed errno inspection must retain the original cause.
+            }
+            if (missing)
+                return "name-absent";
+            throw error;
+        }
+        assertAuthority(this.#assertion);
+        // Recheck after application code and immediately before guarded native unlink.
+        if (!this.#matches(name))
+            return "preserved";
+        return this.#binding.removeStagedSymlink(this.#parentFd, name, this.#linkFd);
+    }
+    async removePublished() {
+        this.#idle();
+        this.#open();
+        if (this.#removal) {
+            if (this.#removal.error)
+                throw this.#removal.error;
+            return this.#removal.receipt;
+        }
+        const name = this.#publishedName();
+        this.#busy = true;
+        try {
+            const receipt = this.#remove(name);
+            this.#removal = { receipt };
+            return receipt;
+        }
+        catch (error) {
+            const wrapped = failure(error, { phase: "remove-published", publication: this.#publication });
+            // A failed unlink is not safe to retry automatically.
+            this.#removal = { error: wrapped };
+            throw wrapped;
+        }
+        finally {
+            this.#busy = false;
+        }
+    }
+    async cleanup() {
+        this.#idle();
+        if (this.#closed) {
+            if (this.#closed.error)
+                throw this.#closed.error;
+            return this.#closed.receipt;
+        }
+        this.#busy = true;
+        let status = "not-needed";
+        const errors = [];
+        if (this.#publication.status === "indeterminate")
+            status = "preserved";
+        else if (this.#publication.status === "not-published") {
+            try {
+                status = this.#remove(this.#receipt.temporaryBasename);
+            }
+            catch (error) {
+                status = "failed";
+                errors.push(error);
+            }
+        }
+        let resources = "closed";
+        for (const close of [() => this.#closeLink(this.#linkFd), () => fs.closeSync(this.#parentFd)]) {
+            try {
+                close();
+            }
+            catch (error) {
+                resources = "close-failed";
+                errors.push(error);
+            }
+        }
+        const receipt = Object.freeze({
+            temporaryBasename: this.#receipt.temporaryBasename,
+            publication: this.#publication, status, resources,
+        });
+        const error = errors.length ? failure(errors.length === 1 ? errors[0] : new AggregateError(errors, "symlink settlement failed"), { phase: "cleanup", publication: this.#publication, cleanup: receipt }) : undefined;
+        this.#closed = { receipt, error };
+        this.#busy = false;
+        if (error)
+            throw error;
+        return receipt;
+    }
+    async [Symbol.asyncDispose]() {
+        const cleanup = await this.cleanup();
+        if (cleanup.status === "preserved") {
+            throw new FsSafeError("not-removable", "symlink settlement preserved an unverified entry", {
+                details: { phase: "cleanup", publication: this.#publication, cleanup },
+            });
+        }
+    }
+}
+/**
+ * Admit an existing staged symlink against caller-captured identity and retain
+ * its no-follow descriptor. Admission never creates, adopts by target, or unlinks.
+ */
+export async function retainSymlinkInDirectory(options) {
+    if (process.platform !== "linux" && process.platform !== "darwin") {
+        throw new FsSafeError("unsupported-platform", "retained symlinks require Linux or macOS");
+    }
+    const native = requireNativeBinding();
+    if ([
+        native.closeOwnedFd, native.openStagedSymlink, native.stagedSymlinkTarget,
+        native.stagedSymlinkMatches, native.publishStagedSymlink, native.removeStagedSymlink,
+    ].some((fn) => typeof fn !== "function")) {
+        throw new FsSafeError("helper-unavailable", "native retained symlink support is unavailable");
+    }
+    const binding = native;
+    const name = options.basename;
+    basename(name);
+    const expected = Object.freeze({ ...options.expected });
+    const assertion = options.assertBeforeMutation;
+    if (typeof assertion !== "function" || typeof expected.dev !== "bigint" ||
+        typeof expected.ino !== "bigint" || typeof expected.ctimeNs !== "bigint" ||
+        !Number.isSafeInteger(expected.uid) || expected.uid < 0 ||
+        !Number.isSafeInteger(expected.gid) || expected.gid < 0 ||
+        typeof expected.target !== "string" || !expected.target || expected.target.includes("\0")) {
+        throw new FsSafeError("invalid-path", "exact symlink identity, target and synchronous authority are required");
+    }
+    const closeLink = captureNativeFdClose(binding);
+    const parent = openStagedDirectory(options.directory);
+    let fd;
+    try {
+        fd = binding.openStagedSymlink(parent.fd, name);
+        const stat = fs.fstatSync(fd, { bigint: true });
+        if (!expectedIdentity(stat, expected) ||
+            binding.stagedSymlinkTarget(parent.fd, name, fd) !== expected.target) {
+            throw new FsSafeError("path-mismatch", "staged symlink does not match the supplied identity");
+        }
+        const receipt = Object.freeze({
+            ...createStagedFileReceipt(parent.receipt, name, stat), target: expected.target,
+        });
+        assertAuthority(assertion);
+        const owner = new NativeStagedSymlink(receipt, binding, parent.fd, fd, closeLink, assertion);
+        await owner.assertCurrent();
+        return owner;
+    }
+    catch (error) {
+        const errors = [error];
+        for (const close of [() => { if (fd !== undefined)
+                closeLink(fd); }, () => fs.closeSync(parent.fd)]) {
+            try {
+                close();
+            }
+            catch (closeError) {
+                errors.push(closeError);
+            }
+        }
+        // Until admission succeeds, the caller retains every namespace cleanup duty.
+        throw failure(errors.length === 1 ? error : new AggregateError(errors, "symlink admission and close failed"), { phase: "prepare", publication: NOT_PUBLISHED });
+    }
+}

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

@@ -11,4 +11,3 @@ export declare function getNativeBinding(): NativeBinding | undefined;
 export declare function requireNativeBinding(): NativeBinding;
 export declare function __setNativeLoaderForTest(loader: () => NativeBinding): void;
 export declare function __resetNativeLoaderForTest(): void;
-//# sourceMappingURL=native.d.ts.map

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

@@ -22,7 +22,7 @@ function isMuslFromReport() {
             return true;
     }
     catch {
-        // Continue with filesystem and ELF inspection.
+        // Continue with ELF and filesystem inspection.
     }
     return undefined;
 }
@@ -114,7 +114,7 @@ function isMuslFromElfInterpreter() {
 function isMusl() {
     if (process.platform !== "linux")
         return false;
-    for (const detector of [isMuslFromReport, isMuslFromFilesystem, isMuslFromElfInterpreter]) {
+    for (const detector of [isMuslFromReport, isMuslFromElfInterpreter, isMuslFromFilesystem]) {
         const result = detector();
         if (result !== undefined)
             return result;

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

@@ -5,4 +5,3 @@ export declare function recordExclusiveCreateFailure(error: unknown, filePath: s
 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>;
-//# sourceMappingURL=opened-file-failure.d.ts.map

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

@@ -13,4 +13,3 @@ export declare function resolveOpenedFileRealPathForFd(fd: number, handleStat: F
     realPath: string;
     stat: Stats | BigIntStats;
 }>;
-//# sourceMappingURL=opened-realpath.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/opened-realpath.js

@@ -5,9 +5,18 @@ import { openedPathResolutionError } from "./opened-file-failure.js";
 import { sameFileIdentity } from "./file-identity.js";
 import { isNotFoundPathError } from "./path.js";
 import { realpathSync } from "./realpath.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
 export async function resolveOpenedFileRealPathForHandle(handle, ioPath) {
-    const handleStat = fsSync.fstatSync(handle.fd);
-    return (await resolveOpenedFileRealPathForFd(handle.fd, handleStat, ioPath)).realPath;
+    const fd = handle.fd;
+    const identity = inspectFileIdentitySync(() => fsSync.fstatSync(fd, { bigint: true }));
+    const resolved = await resolveOpenedFileRealPathForFd(fd, identity, ioPath);
+    let first = resolved.stat;
+    inspectFileIdentitySync(() => {
+        const current = first ?? fsSync.statSync(resolved.realPath, { bigint: true });
+        first = undefined;
+        return current;
+    }, identity);
+    return resolved.realPath;
 }
 export async function resolveOpenedFileRealPathForFd(fd, handleStat, ioPath) {
     const statOptions = typeof handleStat.dev === "bigint" || typeof handleStat.ino === "bigint"

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

@@ -14,4 +14,3 @@ export type ExternalFileWriteResult<T = void> = {
     result: T;
 };
 export declare function writeExternalFileWithinRoot<T = void>(options: ExternalFileWriteOptions<T>): Promise<ExternalFileWriteResult<T>>;
-//# sourceMappingURL=output.d.ts.map

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

@@ -57,6 +57,10 @@ export async function writeExternalFileWithinRoot(options) {
     const requestedTargetPath = options.path;
     assertNoWindowsPathAlias(path.dirname(requestedTargetPath), "filesystem", "output target parent uses a Windows filesystem namespace alias");
     const producerIsolation = options.producerIsolation;
+    const write = options.write;
+    const mode = options.mode;
+    const staging = options.staging;
+    const fallbackFileName = options.fallbackFileName;
     const targetRoot = await root(rootDir);
     if (requestedTargetPath.length === 0) {
         throw new FsSafeError("invalid-path", "target path is required");
@@ -68,11 +72,11 @@ export async function writeExternalFileWithinRoot(options) {
         targetPath: requestedTargetPath,
     });
     assertFileTargetPath(rawTargetPath);
-    const targetPath = sanitizedTargetPath(rawTargetPath, options.fallbackFileName);
+    const targetPath = sanitizedTargetPath(rawTargetPath, fallbackFileName);
     assertNoWindowsPathAlias(targetPath, "filesystem", "output target uses a Windows filesystem namespace alias");
     const finalPath = await targetRoot.resolve(targetPath);
     assertNoWindowsPathAlias(finalPath, "filesystem", "output target uses a Windows filesystem namespace alias");
-    if (options.staging === "sibling") {
+    if (staging === "sibling") {
         const parentPath = path.dirname(targetPath);
         if (parentPath !== ".") {
             await targetRoot.mkdir(parentPath);
@@ -80,23 +84,23 @@ export async function writeExternalFileWithinRoot(options) {
         const siblingFinalPath = await targetRoot.resolve(targetPath);
         const result = await writeExternalFileViaSibling({
             finalPath: siblingFinalPath,
-            write: options.write,
+            write,
             producerIsolation,
-            fallbackFileName: options.fallbackFileName,
+            fallbackFileName,
             maxBytes,
-            mode: options.mode,
+            mode,
         });
         return { path: siblingFinalPath, result };
     }
     const staged = await tempFile({
         prefix: "fs-safe-output",
-        fileName: tempFileNameForTarget(targetPath, options.fallbackFileName),
+        fileName: tempFileNameForTarget(targetPath, fallbackFileName),
     });
     try {
-        const result = await options.write(staged.path);
+        const result = await Function.prototype.call.call(write, options, staged.path);
         await targetRoot.copyIn(targetPath, staged.path, {
             maxBytes,
-            mode: options.mode,
+            mode,
             mkdir: true,
             sourceHardlinks: "reject",
         });

package/node_modules/@openclaw/fs-safe/dist/overwrite-file-handle.d.ts

@@ -5,4 +5,3 @@ export type OverwriteFileHandleOptions = {
 };
 /** Overwrite a borrowed, non-append read/write handle with best-effort failure rollback. */
 export declare function overwriteFileHandle(handle: FileHandle, data: Uint8Array, options?: OverwriteFileHandleOptions): Promise<void>;
-//# sourceMappingURL=overwrite-file-handle.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/owner-dacl-batch-worker.js

@@ -0,0 +1,54 @@
+// One isolated process owns every native query in a batch, including stuck OS calls.
+import { FsSafeError } from "./errors.js";
+import { getNativeBinding } from "./native.js";
+import { configureFsSafeNative } from "./native-config.js";
+import { formatCaughtPermissionFailure } from "./permission-exec.js";
+import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
+const MAX_INPUT_BYTES = 16 * 1024 * 1024;
+async function inspectBatch() {
+    const mode = process.env.FS_SAFE_OWNER_DACL_BATCH_MODE;
+    if (mode !== "auto" && mode !== "require") {
+        throw new FsSafeError("helper-unavailable", "isolated Windows native inspection was not enabled");
+    }
+    configureFsSafeNative({ mode });
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of process.stdin) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bytes += buffer.byteLength;
+        if (bytes > MAX_INPUT_BYTES)
+            throw new Error("Windows security batch exceeded its input budget");
+        chunks.push(buffer);
+    }
+    const paths = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks)));
+    if (!Array.isArray(paths) || !paths.every(value => typeof value === "string" && value && !value.includes("\0"))) {
+        throw new Error("Windows security batch contains invalid paths");
+    }
+    for (const pathname of paths)
+        assertNoWindowsPathAlias(pathname);
+    const binding = getNativeBinding();
+    const inspect = binding?.readOwnerAndDacl;
+    if (!binding || typeof inspect !== "function") {
+        throw new FsSafeError("helper-unavailable", "isolated Windows native inspection is unavailable");
+    }
+    const result = [];
+    let outputBytes = Buffer.byteLength(JSON.stringify({ ok: true, result: [] }));
+    for (const pathname of paths) {
+        const row = { path: pathname, security: inspect.call(binding, pathname) };
+        outputBytes += Buffer.byteLength(JSON.stringify(row)) + (result.length ? 1 : 0);
+        if (outputBytes > MAX_INPUT_BYTES) {
+            throw new FsSafeError("too-large", "Windows security batch exceeded its output budget");
+        }
+        result.push(row);
+    }
+    return result;
+}
+try {
+    const result = await inspectBatch();
+    process.stdout.write(JSON.stringify({ ok: true, result }));
+}
+catch (error) {
+    const code = error && typeof error === "object" && "code" in error && typeof error.code === "string"
+        ? error.code : "EIO";
+    process.stdout.write(JSON.stringify({ ok: false, code, message: formatCaughtPermissionFailure(error) }));
+}

package/node_modules/@openclaw/fs-safe/dist/owner-dacl-batch.d.ts

@@ -0,0 +1,5 @@
+import { type OwnerAndDaclResult } from "./owner-dacl.js";
+/** Inspect an ordered batch outside the caller's event loop, without applying trust policy. */
+export declare function readOwnerAndDaclBatch(paths: readonly string[], options?: {
+    timeoutMs?: number;
+}): Promise<OwnerAndDaclResult[]>;

package/node_modules/@openclaw/fs-safe/dist/owner-dacl-batch.js

@@ -0,0 +1,64 @@
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import { getNativeBinding } from "./native.js";
+import { getFsSafeNativeConfig } from "./native-config.js";
+import { warnNativeFallback } from "./native-fallback-warning.js";
+import { projectOwnerAndDacl } from "./owner-dacl.js";
+import { anchorWindowsDriveRelativePath, assertNoWindowsPathAlias } from "./windows-path-alias.js";
+import { readWindowsSecurityFactsBatch, WINDOWS_SECURITY_BATCH_MAX_BYTES } from "./windows-security-command.js";
+const DEFAULT_BATCH_TIMEOUT_MS = 60_000;
+function snapshotPaths(paths) {
+    if (!Array.isArray(paths))
+        throw new TypeError("paths must be an array of path strings");
+    const length = paths.length;
+    const selected = [];
+    let bytes = 2;
+    for (let index = 0; index < length; index += 1) {
+        const value = paths[index];
+        if (!Object.hasOwn(paths, index) || typeof value !== "string" || !value || value.includes("\0")) {
+            throw new TypeError("paths must contain nonempty path strings without null bytes");
+        }
+        let captured = value;
+        if (process.platform === "win32") {
+            captured = anchorWindowsDriveRelativePath(value);
+            assertNoWindowsPathAlias(captured, "filesystem", "owner and DACL path uses a Windows filesystem namespace alias");
+            const root = path.win32.parse(captured).root;
+            // Anchor cwd-dependent paths without normalizing their physical . or .. suffix.
+            if (root.length <= 1 || !path.win32.isAbsolute(captured)) {
+                const base = path.win32.resolve(root || ".");
+                captured = `${base}${base.endsWith("\\") ? "" : "\\"}${captured.slice(root.length)}`;
+            }
+            assertNoWindowsPathAlias(captured, "filesystem", "owner and DACL path uses a Windows filesystem namespace alias");
+        }
+        bytes += Buffer.byteLength(JSON.stringify(captured), "utf8") + (index ? 1 : 0);
+        if (bytes > WINDOWS_SECURITY_BATCH_MAX_BYTES) {
+            throw new FsSafeError("too-large", "owner and DACL batch exceeds its input budget");
+        }
+        selected.push(captured);
+    }
+    return selected;
+}
+/** Inspect an ordered batch outside the caller's event loop, without applying trust policy. */
+export async function readOwnerAndDaclBatch(paths, options = {}) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_BATCH_TIMEOUT_MS;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2_147_483_647) {
+        throw new RangeError("timeoutMs must be a positive integer no greater than 2147483647");
+    }
+    const selected = snapshotPaths(paths);
+    if (process.platform !== "win32") {
+        return selected.map(() => ({ status: "unsupported-platform", platform: process.platform }));
+    }
+    if (selected.length === 0)
+        return [];
+    const config = getFsSafeNativeConfig();
+    const native = getNativeBinding();
+    const useNative = typeof native?.readOwnerAndDacl === "function";
+    if (!useNative) {
+        if (config.mode === "require") {
+            throw new FsSafeError("helper-unavailable", "Windows owner and DACL facts require an up-to-date native helper");
+        }
+        warnNativeFallback("windows-owner-dacl", "Windows owner and DACL inspection uses a slower built-in system command.");
+    }
+    const facts = await readWindowsSecurityFactsBatch(selected, { timeoutMs, native: useNative, mode: config.mode });
+    return facts.map(projectOwnerAndDacl);
+}

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

@@ -1,3 +1,4 @@
+import type { DescriptorFacts } from "./windows-security-facts.js";
 export type WindowsAceFlags = {
     raw: number;
     objectInherit: boolean;
@@ -28,4 +29,4 @@ export type OwnerAndDaclResult = {
     platform: NodeJS.Platform;
 };
 export declare function readOwnerAndDacl(targetPath: string): OwnerAndDaclResult;
-//# sourceMappingURL=owner-dacl.d.ts.map
+export declare function projectOwnerAndDacl(facts: DescriptorFacts): OwnerAndDaclResult;

package/node_modules/@openclaw/fs-safe/dist/owner-dacl.js

@@ -1,17 +1,26 @@
 import { FsSafeError } from "./errors.js";
 import { getNativeBinding } from "./native.js";
+import { getFsSafeNativeConfig } from "./native-config.js";
+import { warnNativeFallback } from "./native-fallback-warning.js";
 import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
+import { readWindowsSecurityFactsCommand } from "./windows-security-command.js";
 export function readOwnerAndDacl(targetPath) {
     if (process.platform !== "win32") {
         return { status: "unsupported-platform", platform: process.platform };
     }
     assertNoWindowsPathAlias(targetPath, "filesystem", "owner and DACL path uses a Windows filesystem namespace alias");
     const native = getNativeBinding();
-    if (!native) {
-        throw new FsSafeError("helper-unavailable", "Windows owner and DACL facts require the matching optional native platform package; " +
-            "install @openclaw/fs-safe with optional dependencies enabled on a supported platform and use FS_SAFE_NATIVE_MODE=auto or require");
+    const inspect = native?.readOwnerAndDacl;
+    if (typeof inspect !== "function") {
+        if (getFsSafeNativeConfig().mode === "require") {
+            throw new FsSafeError("helper-unavailable", "Windows owner and DACL facts require an up-to-date native helper");
+        }
+        warnNativeFallback("windows-owner-dacl", "Windows owner and DACL inspection uses a slower built-in system command.");
     }
-    const facts = native.readOwnerAndDacl(targetPath);
+    const facts = typeof inspect === "function" ? inspect.call(native, targetPath) : readWindowsSecurityFactsCommand(targetPath);
+    return projectOwnerAndDacl(facts);
+}
+export function projectOwnerAndDacl(facts) {
     return {
         status: "supported",
         ownerSid: facts.ownerSid,

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

@@ -4,4 +4,3 @@ export type ProbePathCaseOptions = {
 };
 /** Observe local ASCII case behavior; unknown observations never imply an operating-system default. */
 export declare function probePathCaseInsensitiveSync(targetPath: string, options?: ProbePathCaseOptions): boolean | undefined;
-//# sourceMappingURL=path-case.d.ts.map

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

@@ -22,4 +22,3 @@ export declare function assertNoHardlinkedFinalPath(params: {
     boundaryLabel: string;
     allowFinalHardlinkForUnlink?: boolean;
 }): Promise<void>;
-//# sourceMappingURL=path-policy.d.ts.map

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

@@ -4,4 +4,3 @@ export type ResolvedPathPrefix = {
     readonly unresolvedSegments: readonly string[];
 };
 export declare function resolvePathPrefixSync(input: string): ResolvedPathPrefix;
-//# sourceMappingURL=path-prefix.d.ts.map