@openclaw/openshell-sandbox 2026.9.3 → 2026.9.5

package/node_modules/@openclaw/fs-safe/dist/copy-tree-portable.js

@@ -0,0 +1,222 @@
+import { setMaxListeners } from "node:events";
+import fs from "node:fs";
+import fsp, {} from "node:fs/promises";
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import { assertStagedDirectoryCurrent, exactIdentityMatches, openStagedDirectory, } from "./staged-directory.js";
+function timestampSeconds(nanoseconds) {
+    // Dates discard sub-millisecond precision; negative numbers mean "now" in
+    // Node's utimes API. Numeric strings retain fractional, pre-epoch timestamps.
+    return String(Number(nanoseconds / 1000000000n) + Number(nanoseconds % 1000000000n) / 1e9);
+}
+/** Byte-copy adapter for the shared immutable-source, caller-owned namespace contract. */
+export async function copyOwnedTree(source, destination, options) {
+    options.signal?.throwIfAborted();
+    const cancellation = new AbortController();
+    const signal = cancellation.signal;
+    setMaxListeners(options.concurrency, signal);
+    const abort = () => cancellation.abort(options.signal?.reason);
+    options.signal?.addEventListener("abort", abort, { once: true });
+    const pending = new Set();
+    const finishing = new Set();
+    const buffers = [];
+    async function schedule(operation, children) {
+        signal.throwIfAborted();
+        const task = operation()
+            .catch((error) => {
+            cancellation.abort(error);
+        })
+            .finally(() => {
+            pending.delete(task);
+            children.delete(task);
+        });
+        pending.add(task);
+        children.add(task);
+        if (pending.size >= options.concurrency)
+            await Promise.race(pending);
+        signal.throwIfAborted();
+    }
+    async function copyFile(from, to, stat) {
+        const input = await fsp.open(from, fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW | fs.constants.O_NONBLOCK);
+        let output;
+        try {
+            const opened = await input.stat({ bigint: true });
+            if (!opened.isFile() || !exactIdentityMatches(stat, opened)) {
+                throw new FsSafeError("path-mismatch", "copy source changed while opening");
+            }
+            output = await fsp.open(to, "wx", 0o600);
+            if (options.copyFileContents) {
+                // napi-rs owns onabort. Each admitted file gets a separate signal so
+                // concurrent native copies cannot replace one another's cancellation.
+                const fileCancellation = new AbortController();
+                const abortFile = () => fileCancellation.abort();
+                signal.addEventListener("abort", abortFile, { once: true });
+                try {
+                    signal.throwIfAborted();
+                    await options.copyFileContents(input.fd, output.fd, fileCancellation.signal);
+                }
+                finally {
+                    signal.removeEventListener("abort", abortFile);
+                }
+            }
+            else {
+                const buffer = buffers.pop() ??
+                    Buffer.allocUnsafe(process.platform === "win32" ? 1024 * 1024 : 128 * 1024);
+                try {
+                    let position = 0;
+                    while (true) {
+                        signal?.throwIfAborted();
+                        const { bytesRead } = await input.read(buffer, 0, buffer.length, position);
+                        if (bytesRead === 0)
+                            break;
+                        let written = 0;
+                        while (written < bytesRead) {
+                            signal?.throwIfAborted();
+                            const { bytesWritten } = await output.write(buffer, written, bytesRead - written, position + written);
+                            if (bytesWritten === 0)
+                                throw new Error("copy write made no progress");
+                            written += bytesWritten;
+                        }
+                        position += bytesRead;
+                    }
+                }
+                finally {
+                    buffers.push(buffer);
+                }
+            }
+            signal.throwIfAborted();
+            if (process.platform !== "win32")
+                await output.chmod(Number(stat.mode & 4095n));
+            await output.utimes(timestampSeconds(stat.atimeNs), timestampSeconds(stat.mtimeNs));
+        }
+        catch (error) {
+            cancellation.abort(error);
+            throw error;
+        }
+        finally {
+            try {
+                await output?.close();
+            }
+            finally {
+                await input.close();
+            }
+        }
+    }
+    async function copyDirectory(from, to, parentChildren) {
+        signal?.throwIfAborted();
+        const stat = await fsp.lstat(from, { bigint: true });
+        // Exclusive admission prevents merging a pre-existing directory, including
+        // any destination left by an unsuccessful native clone.
+        await fsp.mkdir(to, { mode: 0o700 });
+        const target = openStagedDirectory(to);
+        const children = new Set();
+        let original;
+        try {
+            original = openStagedDirectory(from);
+            if (!exactIdentityMatches(stat, original.receipt.identity)) {
+                throw new FsSafeError("path-mismatch", "copy source directory changed while opening");
+            }
+            for (const entry of await fsp.readdir(from, { withFileTypes: true })) {
+                signal?.throwIfAborted();
+                assertStagedDirectoryCurrent(target.receipt);
+                assertStagedDirectoryCurrent(original.receipt);
+                const childSource = path.join(from, entry.name);
+                const childTarget = path.join(to, entry.name);
+                const child = await fsp.lstat(childSource, { bigint: true });
+                if (child.isDirectory()) {
+                    await copyDirectory(childSource, childTarget, children);
+                }
+                else if (child.isFile()) {
+                    await schedule(() => copyFile(childSource, childTarget, child), children);
+                }
+                else if (child.isSymbolicLink()) {
+                    const link = process.platform === "win32"
+                        ? await fsp.readlink(childSource)
+                        : await fsp.readlink(childSource, { encoding: "buffer" });
+                    let type;
+                    if (process.platform === "win32") {
+                        // Older Node releases infer link type from the destination, where a
+                        // relative directory target may not exist yet. Inspect the source.
+                        // lstat does not expose the Windows link's directory attribute, so
+                        // an unresolved source cannot be recreated with a proven type.
+                        try {
+                            type = (await fsp.stat(childSource)).isDirectory() ? "dir" : "file";
+                        }
+                        catch (error) {
+                            if (error instanceof Error &&
+                                "code" in error &&
+                                (error.code === "ENOENT" || error.code === "ENOTDIR" || error.code === "ELOOP")) {
+                                throw new FsSafeError("unsupported-platform", "byte copying cannot determine the type of an unresolved Windows symbolic link", { cause: error });
+                            }
+                            throw error;
+                        }
+                    }
+                    signal?.throwIfAborted();
+                    await fsp.symlink(link, childTarget, type);
+                }
+                else {
+                    throw new FsSafeError("not-file", "tree copying does not support special files");
+                }
+            }
+        }
+        catch (error) {
+            cancellation.abort(error);
+            throw error;
+        }
+        finally {
+            // Traversal can advance into siblings while this directory's own files
+            // settle. Children retain their parents and finish metadata bottom-up.
+            const completion = (async () => {
+                try {
+                    await Promise.all(children);
+                    signal.throwIfAborted();
+                    if (original) {
+                        assertStagedDirectoryCurrent(original.receipt);
+                        assertStagedDirectoryCurrent(target.receipt);
+                        if (process.platform !== "win32")
+                            fs.fchmodSync(target.fd, Number(stat.mode & 4095n));
+                        await fsp.utimes(to, timestampSeconds(stat.atimeNs), timestampSeconds(stat.mtimeNs));
+                        assertStagedDirectoryCurrent(target.receipt);
+                    }
+                }
+                finally {
+                    try {
+                        if (original)
+                            fs.closeSync(original.fd);
+                    }
+                    finally {
+                        fs.closeSync(target.fd);
+                    }
+                }
+            })()
+                .catch((error) => {
+                cancellation.abort(error);
+            })
+                .finally(() => {
+                finishing.delete(completion);
+                parentChildren?.delete(completion);
+            });
+            finishing.add(completion);
+            parentChildren?.add(completion);
+            // Bound traversed-but-unsettled directories as well as file workers;
+            // ancestors stay open along the current traversal path.
+            if (finishing.size >= options.concurrency)
+                await Promise.race(finishing);
+        }
+        signal.throwIfAborted();
+    }
+    try {
+        await copyDirectory(source.receipt.realPath, destination);
+        await Promise.all(finishing);
+        signal.throwIfAborted();
+    }
+    catch (error) {
+        await Promise.all(finishing);
+        options.signal?.throwIfAborted();
+        throw error;
+    }
+    finally {
+        await Promise.all(finishing);
+        options.signal?.removeEventListener("abort", abort);
+    }
+}

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

@@ -0,0 +1,16 @@
+import { type CopyCloneMode } from "./copy-policy.js";
+export { readCloneFileMetadata, type CloneFileMetadata } from "./clone-metadata.js";
+export type { CopyCloneMode } from "./copy-policy.js";
+export type TreeCloneBackend = "apfs" | "btrfs" | "refs" | "xfs" | "zfs";
+export type CopyTreeOptions = {
+    clone?: CopyCloneMode;
+    signal?: AbortSignal;
+    concurrency?: number;
+};
+/** Inspect an existing real directory without creating probe files. */
+export declare function probeTreeClone(parentPath: string): TreeCloneBackend | undefined;
+/** Create an empty clone source: a Btrfs subvolume or an ordinary supported directory. */
+export declare function createCloneSource(destination: string, options?: Pick<CopyTreeOptions, "signal">): Promise<void>;
+/** Copy an immutable, caller-owned tree, preferring native cloning unless configured otherwise. */
+export declare function copyTree(source: string, destination: string, options?: CopyTreeOptions): Promise<void>;
+//# sourceMappingURL=copy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"copy.d.ts","sourceRoot":"","sources":["../src/copy.ts"],"names":[],"mappings":"AAGA,OAAO,EAAwB,KAAK,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAK5E,OAAO,EAAE,qBAAqB,EAAE,KAAK,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACpF,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAEtD,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,CAAC;AACzE,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,CAAC,EAAE,aAAa,CAAC;IACtB,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,uEAAuE;AACvE,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAS/E;AAED,0FAA0F;AAC1F,wBAAsB,iBAAiB,CACrC,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAM,GAC5C,OAAO,CAAC,IAAI,CAAC,CAEf;AAED,mGAAmG;AACnG,wBAAsB,QAAQ,CAC5B,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,IAAI,CAAC,CAIf"}

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

@@ -0,0 +1,125 @@
+import fs from "node:fs";
+import path from "node:path";
+import { assertAbsolutePathInput } from "./absolute-path.js";
+import { resolveCopyCloneMode } from "./copy-policy.js";
+import { copyOwnedTree } from "./copy-tree-portable.js";
+import { FsSafeError } from "./errors.js";
+import { getNativeBinding, requireNativeBinding } from "./native.js";
+import { assertStagedDirectoryCurrent, openStagedDirectory } from "./staged-directory.js";
+export { readCloneFileMetadata } from "./clone-metadata.js";
+/** Inspect an existing real directory without creating probe files. */
+export function probeTreeClone(parentPath) {
+    const native = getNativeBinding();
+    if (!native)
+        return undefined;
+    const parent = openStagedDirectory(assertAbsolutePathInput(parentPath));
+    try {
+        return native.probeTreeClone(parent.fd) ?? undefined;
+    }
+    finally {
+        fs.closeSync(parent.fd);
+    }
+}
+/** Create an empty clone source: a Btrfs subvolume or an ordinary supported directory. */
+export async function createCloneSource(destination, options = {}) {
+    await materializeTree(undefined, destination, options, "always");
+}
+/** Copy an immutable, caller-owned tree, preferring native cloning unless configured otherwise. */
+export async function copyTree(source, destination, options = {}) {
+    options.signal?.throwIfAborted();
+    const policy = resolveCopyCloneMode(options.clone, "auto");
+    await materializeTree(source, destination, options, policy);
+}
+function cloneUnavailable(error) {
+    if (error instanceof FsSafeError && error.code === "unsupported-platform")
+        return true;
+    if (!(error instanceof Error) || !("code" in error))
+        return false;
+    // ENOTSUP also describes unsupported contents (for example named streams).
+    // Only capability failures may select a byte copy, never lossy source errors.
+    return error.code === "CLONE_UNAVAILABLE" || error.code === "EXDEV" || error.code === "ENOSYS";
+}
+async function materializeTree(source, destination, options, policy) {
+    options.signal?.throwIfAborted();
+    const concurrency = options.concurrency ?? 16;
+    if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > 32) {
+        throw new FsSafeError("invalid-path", "clone concurrency must be an integer between 1 and 32");
+    }
+    const native = policy === "always"
+        ? requireNativeBinding()
+        : policy === "auto"
+            ? getNativeBinding()
+            : undefined;
+    const target = assertAbsolutePathInput(destination);
+    const name = path.basename(target);
+    if (!name)
+        throw new FsSafeError("invalid-path", "clone destination must name a child directory");
+    const parent = openStagedDirectory(path.dirname(target));
+    let original;
+    try {
+        const supported = native?.probeTreeClone(parent.fd);
+        if (!supported && policy === "always") {
+            throw new FsSafeError("unsupported-platform", "destination filesystem does not support tree cloning");
+        }
+        if (source !== undefined) {
+            original = openStagedDirectory(assertAbsolutePathInput(source));
+            const relative = path.relative(original.receipt.realPath, path.join(parent.receipt.realPath, name));
+            if (relative === "" ||
+                (!path.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path.sep}`))) {
+                throw new FsSafeError("invalid-path", "clone destination must be outside the source tree");
+            }
+            assertStagedDirectoryCurrent(original.receipt);
+        }
+        assertStagedDirectoryCurrent(parent.receipt);
+        options.signal?.throwIfAborted();
+        let cloned = false;
+        // napi-rs uses the supplied signal's onabort property. Give it a private
+        // signal so caller handlers and other admitted native operations stay intact.
+        const cancellation = options.signal && supported ? new AbortController() : undefined;
+        const abort = () => cancellation?.abort();
+        options.signal?.addEventListener("abort", abort, { once: true });
+        try {
+            if (native && supported) {
+                await native.cloneTree(original?.fd ?? null, parent.fd, name, concurrency, cancellation?.signal);
+                cloned = true;
+            }
+        }
+        catch (error) {
+            options.signal?.throwIfAborted();
+            if (policy !== "auto" || !cloneUnavailable(error)) {
+                if (error instanceof Error && "code" in error && error.code === "CLONE_UNAVAILABLE") {
+                    throw new FsSafeError("unsupported-platform", error.message, { cause: error });
+                }
+                throw error;
+            }
+        }
+        finally {
+            options.signal?.removeEventListener("abort", abort);
+        }
+        options.signal?.throwIfAborted();
+        assertStagedDirectoryCurrent(parent.receipt);
+        if (original)
+            assertStagedDirectoryCurrent(original.receipt);
+        if (!cloned && original) {
+            await copyOwnedTree(original, target, {
+                signal: options.signal,
+                concurrency: options.concurrency ?? (process.platform === "win32" ? 4 : 1),
+                copyFileContents: process.platform === "win32" || process.platform === "linux"
+                    ? native?.copyFileContents
+                    : undefined,
+            });
+            options.signal?.throwIfAborted();
+            assertStagedDirectoryCurrent(parent.receipt);
+            assertStagedDirectoryCurrent(original.receipt);
+        }
+    }
+    finally {
+        try {
+            if (original)
+                fs.closeSync(original.fd);
+        }
+        finally {
+            fs.closeSync(parent.fd);
+        }
+    }
+}

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

@@ -0,0 +1,4 @@
+import type { NativeDarwinAclFacts } from "./native-binding.js";
+/** Internal descriptor facts only; callers own identity, lifetime, and ACL policy. */
+export declare function inspectDarwinAcl(fd: number): NativeDarwinAclFacts;
+//# sourceMappingURL=darwin-acl.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/darwin-acl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"darwin-acl.d.ts","sourceRoot":"","sources":["../src/darwin-acl.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAGhE,sFAAsF;AACtF,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,oBAAoB,CAmBjE"}

package/node_modules/@openclaw/fs-safe/dist/darwin-acl.js

@@ -0,0 +1,24 @@
+import { FsSafeError } from "./errors.js";
+import { getNativeBinding } from "./native.js";
+/** Internal descriptor facts only; callers own identity, lifetime, and ACL policy. */
+export function inspectDarwinAcl(fd) {
+    if (!Number.isInteger(fd) || fd < 0 || fd > 0x7fff_ffff) {
+        throw new FsSafeError("permission-unverified", "Darwin ACL inspection requires a valid descriptor");
+    }
+    const native = getNativeBinding();
+    if (typeof native?.inspectDarwinAcl !== "function") {
+        throw new FsSafeError("helper-unavailable", "Darwin ACL inspection requires the matching native capability");
+    }
+    let facts;
+    try {
+        facts = native.inspectDarwinAcl(fd);
+    }
+    catch (cause) {
+        throw new FsSafeError("permission-unverified", "Darwin descriptor ACL could not be inspected", { cause });
+    }
+    const state = facts && typeof facts === "object" && "state" in facts ? facts.state : undefined;
+    if (state !== "absent" && state !== "empty" && state !== "present") {
+        throw new FsSafeError("permission-unverified", "Darwin ACL inspection returned invalid facts");
+    }
+    return { state };
+}

package/node_modules/@openclaw/fs-safe/dist/deny-mutations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"deny-mutations.d.ts","sourceRoot":"","sources":["../src/deny-mutations.ts"],"names":[],"mappings":"AAKA,wBAAsB,8BAA8B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAI1F;AAMD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9B,CAAC;AAEF,KAAK,wBAAwB,GAAG;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAqBF,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,kBAAkB,GAAG,SAAS,EACtC,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,IAAI,CAAC,CAiCf;AAED,wBAAgB,yBAAyB,CACvC,aAAa,EAAE,kBAAkB,GAAG,SAAS,EAC7C,UAAU,EAAE,kBAAkB,GAAG,SAAS,GACzC,kBAAkB,GAAG,SAAS,CAWhC"}
+{"version":3,"file":"deny-mutations.d.ts","sourceRoot":"","sources":["../src/deny-mutations.ts"],"names":[],"mappings":"AASA,wBAAsB,8BAA8B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAQ1F;AAMD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,QAAQ,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9B,CAAC;AAEF,KAAK,wBAAwB,GAAG;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AAsBF,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,kBAAkB,GAAG,SAAS,EACtC,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,IAAI,CAAC,CAiCf;AAED,wBAAgB,yBAAyB,CACvC,aAAa,EAAE,kBAAkB,GAAG,SAAS,EAC7C,UAAU,EAAE,kBAAkB,GAAG,SAAS,GACzC,kBAAkB,GAAG,SAAS,CAWhC"}

package/node_modules/@openclaw/fs-safe/dist/deny-mutations.js

@@ -2,10 +2,15 @@ import path from "node:path";
 import { FsSafeError } from "./errors.js";
 import { assertNoNulPathInput, isPathInside } from "./path.js";
 import { resolvePathViaExistingAncestor } from "./root-path-existing.js";
+import { assertNoWindowsPathAlias, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
 export async function resolveMutationComparablePaths(rawPath) {
     assertNoNulPathInput(rawPath, "path contains a NUL byte");
-    const resolved = path.resolve(rawPath);
-    return new Set([resolved, await resolvePathViaExistingAncestor(resolved)]);
+    assertNoWindowsPathAlias(rawPath, "filesystem", "mutation path uses a Windows filesystem namespace alias");
+    const resolved = resolvePathPreservingWindowsRoot(rawPath);
+    assertNoWindowsPathAlias(resolved, "filesystem", "mutation path uses a Windows filesystem namespace alias");
+    const canonical = await resolvePathViaExistingAncestor(resolved);
+    assertNoWindowsPathAlias(canonical, "filesystem", "mutation path uses a Windows filesystem namespace alias");
+    return new Set([resolved, canonical]);
 }
 function isSamePath(left, right) {
     return isPathInside(left, right) && isPathInside(right, left);
@@ -20,6 +25,7 @@ function policyPathEntries(entries) {
             throw new FsSafeError("invalid-path", "deny mutation paths must be non-empty");
         }
         assertNoNulPathInput(entry, "deny mutation path contains a NUL byte");
+        assertNoWindowsPathAlias(entry, "filesystem", "deny mutation path uses a Windows filesystem namespace alias");
         if (!path.isAbsolute(entry)) {
             throw new FsSafeError("invalid-path", "deny mutation paths must be absolute");
         }

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

@@ -1 +1 @@
-{"version":3,"file":"device-path.d.ts","sourceRoot":"","sources":["../src/device-path.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,0BAA0B,GAClC,cAAc,GACd,UAAU,GACV,gBAAgB,CAAC;AAErB,MAAM,MAAM,yBAAyB,GAAG;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,0BAA0B,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG;IACxC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;CAC5B,CAAC;AAcF,eAAO,MAAM,6BAA6B,EAAE,WAAW,CAAC,MAAM,CAgC5D,CAAC;AAsEH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEjE;AAcD,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,2BAAgC,GACxC,yBAAyB,GAAG,SAAS,CAWvC;AAED,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,2BAA2B,GACpC,OAAO,CAET;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,2BAA2B,GACpC,IAAI,CAON"}
+{"version":3,"file":"device-path.d.ts","sourceRoot":"","sources":["../src/device-path.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,0BAA0B,GAClC,cAAc,GACd,UAAU,GACV,gBAAgB,CAAC;AAErB,MAAM,MAAM,yBAAyB,GAAG;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,0BAA0B,CAAC;CACpC,CAAC;AAEF,MAAM,MAAM,2BAA2B,GAAG;IACxC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC,QAAQ,CAAC;CAC5B,CAAC;AAcF,eAAO,MAAM,6BAA6B,EAAE,WAAW,CAAC,MAAM,CAgC5D,CAAC;AA2EH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEjE;AAcD,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,2BAAgC,GACxC,yBAAyB,GAAG,SAAS,CAWvC;AAED,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,2BAA2B,GACpC,OAAO,CAET;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,2BAA2B,GACpC,IAAI,CAON"}

package/node_modules/@openclaw/fs-safe/dist/device-path.js

@@ -96,9 +96,11 @@ function matchPosixDeviceReadPath(filePath, cwd) {
 }
 function normalizeWindowsDeviceBaseName(filePath) {
     const normalized = trimTrailingWindowsSeparators(filePath.replace(/\//g, "\\"));
-    const lastSegment = normalized.split("\\").filter(Boolean).at(-1) ?? normalized;
-    const withoutStream = lastSegment.split(":")[0] ?? lastSegment;
-    const stem = withoutStream.split(".")[0] ?? withoutStream;
+    const start = normalized.lastIndexOf("\\") + 1;
+    const stream = normalized.indexOf(":", start);
+    const extension = normalized.indexOf(".", start);
+    const end = Math.min(stream < 0 ? normalized.length : stream, extension < 0 ? normalized.length : extension);
+    const stem = normalized.slice(start, end);
     return trimTrailingWindowsIgnoredChars(stem).toUpperCase();
 }
 export function isWindowsReservedDeviceName(name) {

package/node_modules/@openclaw/fs-safe/dist/directory-durability.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"directory-durability.d.ts","sourceRoot":"","sources":["../src/directory-durability.ts"],"names":[],"mappings":"AAAA,OAAe,EAAE,KAAK,KAAK,EAAE,MAAM,SAAS,CAAC;AAM7C,OAAO,EAAoB,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE7E,MAAM,MAAM,oBAAoB,GAC5B;IAAE,MAAM,EAAE,QAAQ,CAAA;CAAE,GACpB;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,KAAK,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,gBAAgB,GAAG;IACvD,UAAU,EAAE,oBAAoB,GAAG;QAAE,MAAM,EAAE,YAAY,CAAA;KAAE,CAAC;CAC7D,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;IACnC,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,IAAI,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACtC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG;IAC1C,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wBAAwB,CAAC,EAAE,gBAAgB,CAAC;IAC5C,MAAM,CAAC,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnD,CAAC;AAgKF,wBAAsB,YAAY,CAChC,SAAS,EAAE,MAAM,GAAG,gBAAgB,EACpC,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/B,OAAO,CAAC,eAAe,CAAC,CAa1B;AAED,wBAAsB,aAAa,CACjC,SAAS,EAAE,MAAM,GAAG,gBAAgB,EACpC,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/B,OAAO,CAAC,oBAAoB,CAAC,CAmB/B;AAED,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,GAAG,gBAAgB,EACpC,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/B,oBAAoB,CAuCtB;AAED,wBAAsB,uBAAuB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAElF;AAED,wBAAgB,2BAA2B,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAMvE;AAuBD,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,uBAAuB,CAAC,CA8ElC"}
+{"version":3,"file":"directory-durability.d.ts","sourceRoot":"","sources":["../src/directory-durability.ts"],"names":[],"mappings":"AAAA,OAAe,EAAE,KAAK,KAAK,EAAE,MAAM,SAAS,CAAC;AAM7C,OAAO,EAAoB,KAAK,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAI7E,MAAM,MAAM,oBAAoB,GAC5B;IAAE,MAAM,EAAE,QAAQ,CAAA;CAAE,GACpB;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAE7C,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,KAAK,CAAC;CACjB,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,gBAAgB,GAAG;IACvD,UAAU,EAAE,oBAAoB,GAAG;QAAE,MAAM,EAAE,YAAY,CAAA;KAAE,CAAC;CAC7D,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,OAAO,EAAE,gBAAgB,CAAC;IACnC,aAAa,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,IAAI,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACtC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,6BAA6B,GAAG;IAC1C,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,wBAAwB,CAAC,EAAE,gBAAgB,CAAC;IAC5C,MAAM,CAAC,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACnD,CAAC;AAwOF,wBAAsB,YAAY,CAChC,SAAS,EAAE,MAAM,GAAG,gBAAgB,EACpC,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/B,OAAO,CAAC,eAAe,CAAC,CAe1B;AAED,wBAAsB,aAAa,CACjC,SAAS,EAAE,MAAM,GAAG,gBAAgB,EACpC,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/B,OAAO,CAAC,oBAAoB,CAAC,CAqB/B;AAED,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,GAAG,gBAAgB,EACpC,OAAO,GAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/B,oBAAoB,CAyCtB;AAED,wBAAsB,uBAAuB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAElF;AAED,wBAAgB,2BAA2B,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,CAMvE;AAiCD,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,uBAAuB,CAAC,CA2FlC"}