@openclaw/openshell-sandbox 2026.9.4 → 2026.9.5

package/node_modules/@openclaw/fs-safe/dist/root-move-noreplace.d.ts

@@ -0,0 +1,14 @@
+import { type DenyMutationPolicy } from "./deny-mutations.js";
+import { type RootContext } from "./root-context.js";
+import { type MutationSymlinkPolicy } from "./root-symlink-policy.js";
+export declare function movePathNoReplaceNative(root: RootContext, params: {
+    assertBeforeMutation?: () => void;
+    denyMutations?: DenyMutationPolicy;
+    mutationSymlinks?: MutationSymlinkPolicy;
+}, paths: {
+    sourcePath: string;
+    sourceParentPath: string;
+    targetPath: string;
+    targetParentPath: string;
+}): Promise<void>;
+//# sourceMappingURL=root-move-noreplace.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/root-move-noreplace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-move-noreplace.d.ts","sourceRoot":"","sources":["../src/root-move-noreplace.ts"],"names":[],"mappings":"AAIA,OAAO,EAA2B,KAAK,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AASvF,OAAO,EAA4D,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAU/G,OAAO,EAA8B,KAAK,qBAAqB,EAAE,MAAM,0BAA0B,CAAC;AAqDlG,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE;IACN,oBAAoB,CAAC,EAAE,MAAM,IAAI,CAAC;IAClC,aAAa,CAAC,EAAE,kBAAkB,CAAC;IACnC,gBAAgB,CAAC,EAAE,qBAAqB,CAAC;CAC1C,EACD,KAAK,EAAE;IACL,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,GACA,OAAO,CAAC,IAAI,CAAC,CA0If"}

package/node_modules/@openclaw/fs-safe/dist/root-move-noreplace.js

@@ -0,0 +1,202 @@
+import fsSync, {} from "node:fs";
+import path from "node:path";
+import { assertAsyncDirectoryGuard, assertSyncDirectoryGuard } from "./directory-guard.js";
+import { FsSafeError } from "./errors.js";
+import { assertMutationNotDenied } from "./deny-mutations.js";
+import { closeNativeParentAdmission, openNativeParentAdmission, openNativeRootAdmission, } from "./native-parent-admission.js";
+import { getNativeBinding } from "./native.js";
+import { isNotFoundPathError } from "./path.js";
+import { assertRootIdentityCurrent, assertRootIdentityCurrentSync } from "./root-context.js";
+import { resolveRootPathSync } from "./root-path.js";
+import { admitPathInsideRoot } from "./root-boundary.js";
+import { fileNotFoundError, hardlinkedPathNotAllowedError, isAlreadyExistsError, normalizePinnedPathError, outsideWorkspaceError, } from "./root-errors.js";
+import { assertFinalSymlinkRejected } from "./root-symlink-policy.js";
+import { createSuppressedError } from "./suppressed-error.js";
+import { getFsSafeTestHooks } from "./test-hooks.js";
+function nativeParentRelativePath(rootReal, parentPath) {
+    const relative = path.relative(rootReal, parentPath);
+    if (relative === "" || relative === ".")
+        return "";
+    const firstSegment = relative.split(path.sep)[0];
+    if (firstSegment === ".." ||
+        path.isAbsolute(relative)) {
+        throw outsideWorkspaceError();
+    }
+    return relative.split(path.sep).join(path.posix.sep);
+}
+function admitMovePath(root, parent, basename) {
+    const admitted = admitPathInsideRoot({
+        rootPath: root.rootReal,
+        candidatePath: path.join(parent.guard.realPath, basename),
+        rootIdentity: root.rootIdentity,
+    });
+    if (!admitted)
+        throw outsideWorkspaceError();
+    return admitted.path;
+}
+function nativePrimitiveUnavailable(error) {
+    const code = error?.code;
+    return code === "ENOSYS" || code === "ENOTSUP" || code === "EOPNOTSUPP";
+}
+function normalizeMoveError(error) {
+    if (isNotFoundPathError(error)) {
+        return fileNotFoundError(error instanceof Error ? error : undefined);
+    }
+    if (nativePrimitiveUnavailable(error)) {
+        return new FsSafeError("helper-unavailable", "native no-replace move is unavailable", {
+            cause: error instanceof Error ? error : undefined,
+        });
+    }
+    return error;
+}
+function normalizeRenameNoReplaceError(error) {
+    if (error?.code === "EINVAL") {
+        return new FsSafeError("helper-unavailable", "native no-replace move is unavailable on this filesystem", {
+            cause: error instanceof Error ? error : undefined,
+        });
+    }
+    return normalizeMoveError(error);
+}
+export async function movePathNoReplaceNative(root, params, paths) {
+    try {
+        fsSync.lstatSync(paths.targetPath);
+        throw new FsSafeError("already-exists", "destination exists");
+    }
+    catch (error) {
+        if (error instanceof FsSafeError)
+            throw error;
+        if (!isNotFoundPathError(error))
+            throw error;
+        // Advisory fast rejection only. renameNoReplace owns the collision decision.
+    }
+    const binding = getNativeBinding();
+    if (!binding || typeof binding.renameNoReplace !== "function") {
+        throw new FsSafeError("helper-unavailable", "native no-replace move is unavailable");
+    }
+    const rootAdmission = await openNativeRootAdmission(binding, {
+        rootPath: root.rootReal,
+        rootIdentity: root.rootIdentity,
+        operation: "native move",
+    });
+    let sourceParent;
+    let targetParent;
+    let failed = false;
+    let operationError;
+    try {
+        const sourceParentRelativePath = nativeParentRelativePath(root.rootReal, paths.sourceParentPath);
+        sourceParent = await openNativeParentAdmission(binding, rootAdmission, sourceParentRelativePath);
+        const targetParentRelativePath = nativeParentRelativePath(root.rootReal, paths.targetParentPath);
+        targetParent = targetParentRelativePath === sourceParentRelativePath
+            ? sourceParent
+            : await openNativeParentAdmission(binding, rootAdmission, targetParentRelativePath);
+        const parentAdmissions = targetParent === sourceParent
+            ? [sourceParent]
+            : [sourceParent, targetParent];
+        await getFsSafeTestHooks()?.beforeRootFallbackMutation?.("move", paths.targetPath);
+        const admittedSourcePath = admitMovePath(root, sourceParent, path.basename(paths.sourcePath));
+        const admittedTargetPath = admitMovePath(root, targetParent, path.basename(paths.targetPath));
+        if (params.denyMutations) {
+            // Native admission can follow a newly introduced contained parent alias.
+            // Authorize the selected names, then recheck every retained directory.
+            await assertMutationNotDenied(admittedSourcePath, params.denyMutations, { protectAncestors: true });
+            await assertMutationNotDenied(admittedTargetPath, params.denyMutations, { protectAncestors: true });
+        }
+        await assertRootIdentityCurrent(root);
+        for (const admission of parentAdmissions)
+            assertSyncDirectoryGuard(admission.guard);
+        let sourceStat;
+        try {
+            sourceStat = fsSync.lstatSync(admittedSourcePath);
+        }
+        catch (error) {
+            throw normalizeMoveError(error);
+        }
+        if (sourceStat.isSymbolicLink()) {
+            throw new FsSafeError("symlink", "symlink not allowed");
+        }
+        if (sourceStat.isFile() && sourceStat.nlink > 1) {
+            throw hardlinkedPathNotAllowedError();
+        }
+        if (sourceStat.isDirectory()) {
+            throw new FsSafeError("invalid-path", "directory moves require overwrite: true");
+        }
+        assertFinalSymlinkRejected(admittedTargetPath, params.mutationSymlinks !== undefined);
+        params.assertBeforeMutation?.();
+        if (params.assertBeforeMutation || params.mutationSymlinks === "reject") {
+            // Do not carry directory freshness across the live authority callback.
+            assertRootIdentityCurrentSync(root);
+            if (params.mutationSymlinks === "reject") {
+                // Validate both full pre-native routes; selected canonical names have
+                // already erased any parent symlink followed during admission.
+                for (const absolutePath of [paths.sourcePath, paths.targetPath]) {
+                    resolveRootPathSync({
+                        absolutePath,
+                        rootPath: root.rootReal,
+                        rootCanonicalPath: root.rootReal,
+                        rootIdentity: root.rootIdentity,
+                        boundaryLabel: "root",
+                        rejectSymlinks: true,
+                        rejectFinalSymlink: true,
+                    });
+                }
+            }
+            for (const admission of parentAdmissions)
+                assertSyncDirectoryGuard(admission.guard);
+        }
+        try {
+            binding.renameNoReplace(sourceParent.fd, path.basename(paths.sourcePath), targetParent.fd, path.basename(paths.targetPath));
+        }
+        catch (error) {
+            if (isAlreadyExistsError(error) || error?.code === "ENOTEMPTY") {
+                throw new FsSafeError("already-exists", "destination exists", {
+                    cause: error instanceof Error ? error : undefined,
+                });
+            }
+            throw normalizeRenameNoReplaceError(error);
+        }
+        try {
+            for (const admission of parentAdmissions)
+                await assertAsyncDirectoryGuard(admission.guard);
+        }
+        catch (error) {
+            throw normalizePinnedPathError(error);
+        }
+    }
+    catch (error) {
+        failed = true;
+        operationError = normalizeMoveError(error);
+    }
+    const closeErrors = [];
+    const closedFds = new Set();
+    for (const admission of [targetParent, sourceParent]) {
+        if (!admission || closedFds.has(admission.fd))
+            continue;
+        closedFds.add(admission.fd);
+        try {
+            closeNativeParentAdmission(admission);
+        }
+        catch (error) {
+            closeErrors.push(error);
+        }
+    }
+    try {
+        await rootAdmission.root.close();
+    }
+    catch (error) {
+        closeErrors.push(error);
+    }
+    if (failed) {
+        if (closeErrors.length > 0) {
+            const closeError = closeErrors.length === 1
+                ? closeErrors[0]
+                : new AggregateError(closeErrors, "native move descriptor closes failed");
+            throw createSuppressedError(closeError, operationError, "native move and descriptor close failed");
+        }
+        throw operationError;
+    }
+    if (closeErrors.length === 1)
+        throw closeErrors[0];
+    if (closeErrors.length > 1) {
+        throw new AggregateError(closeErrors, "native move descriptor closes failed");
+    }
+}

package/node_modules/@openclaw/fs-safe/dist/root-move-preflight.d.ts

@@ -0,0 +1,8 @@
+import { type DenyMutationPolicy } from "./deny-mutations.js";
+import { type RootContext } from "./root-context.js";
+export declare function assertMoveMutationAllowed(root: RootContext, params: {
+    fromRelative: string;
+    toRelative: string;
+    denyMutations?: DenyMutationPolicy;
+}): Promise<void>;
+//# sourceMappingURL=root-move-preflight.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/root-move-preflight.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-move-preflight.d.ts","sourceRoot":"","sources":["../src/root-move-preflight.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,kBAAkB,EACxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAqB,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAExE,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE;IACN,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,kBAAkB,CAAC;CACpC,GACA,OAAO,CAAC,IAAI,CAAC,CAaf"}

package/node_modules/@openclaw/fs-safe/dist/root-move-preflight.js

@@ -0,0 +1,16 @@
+import { assertMutationNotDenied, } from "./deny-mutations.js";
+import { resolvePathInRoot } from "./root-context.js";
+export async function assertMoveMutationAllowed(root, params) {
+    // Keep this preflight separate from the pinned resolutions in movePathFallback:
+    // mutation denials must take precedence over source alias or identity failures.
+    const source = await resolvePathInRoot(root, params.fromRelative, {
+        aliasErrorCode: "path-alias",
+        allowFinalSymlink: true,
+    });
+    await assertMutationNotDenied(source.resolved, params.denyMutations, { protectAncestors: true });
+    const target = await resolvePathInRoot(root, params.toRelative, {
+        aliasErrorCode: "path-alias",
+        allowFinalSymlink: true,
+    });
+    await assertMutationNotDenied(target.resolved, params.denyMutations, { protectAncestors: true });
+}

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

@@ -0,0 +1,9 @@
+import { type RootPathObservationKind, type RootPathObservationReceipt } from "./root-path.js";
+import { type RootContext } from "./root-context.js";
+export type PinnedObservedPath = {
+    rootReal: string;
+    resolved: string;
+    receipt?: RootPathObservationReceipt;
+};
+export declare function resolvePinnedObservedPathInRoot(root: RootContext, relativePath: string, kind: RootPathObservationKind): Promise<PinnedObservedPath | undefined>;
+//# sourceMappingURL=root-observed-path.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"root-observed-path.d.ts","sourceRoot":"","sources":["../src/root-observed-path.ts"],"names":[],"mappings":"AAOA,OAAO,EAGL,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EAChC,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAIL,KAAK,WAAW,EACjB,MAAM,mBAAmB,CAAC;AAI3B,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,0BAA0B,CAAC;CACtC,CAAC;AAEF,wBAAsB,+BAA+B,CACnD,IAAI,EAAE,WAAW,EACjB,YAAY,EAAE,MAAM,EACpB,IAAI,EAAE,uBAAuB,GAC5B,OAAO,CAAC,kBAAkB,GAAG,SAAS,CAAC,CAgFzC"}

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

@@ -0,0 +1,95 @@
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import { getNativeDirectoryObservationBackend } from "./native-directory-observation.js";
+import { isNotFoundPathError } from "./path.js";
+import { PATH_ALIAS_POLICIES } from "./path-policy.js";
+import { admitPathInsideRoot } from "./root-boundary.js";
+import { assertRootPathObservationReceiptCurrent } from "./root-directory-list.js";
+import { RootPathObservationError, resolveRootPathWithObservation, } from "./root-path.js";
+import { createRootObservationGuard, ensureTrailingSep, expandRelativePathWithHome, } from "./root-context.js";
+import { fileNotFoundError, outsideWorkspaceError } from "./root-errors.js";
+import { getFsSafeTestHooks } from "./test-hooks.js";
+export async function resolvePinnedObservedPathInRoot(root, relativePath, kind) {
+    const rootGuard = await createRootObservationGuard(root);
+    if (!rootGuard)
+        return undefined;
+    // Race hooks exercise the established JavaScript observation points. Do not
+    // silently move those points into the native helper in test configurations.
+    const directoryObserver = getNativeDirectoryObservationBackend(getFsSafeTestHooks() === undefined);
+    const rootReal = root.rootReal;
+    let observed;
+    try {
+        const expandedPath = await expandRelativePathWithHome(relativePath);
+        const observationPath = process.platform === "win32"
+            ? expandedPath.replaceAll("/", path.sep)
+            : expandedPath;
+        observed = await resolveRootPathWithObservation({
+            absolutePath: path.isAbsolute(observationPath)
+                ? observationPath
+                : observationPath === ""
+                    ? rootReal
+                    : `${ensureTrailingSep(rootReal)}${observationPath}`,
+            rootPath: rootReal,
+            rootCanonicalPath: rootReal,
+            rootIdentity: root.rootIdentity,
+            boundaryLabel: "root",
+            policy: PATH_ALIAS_POLICIES.strict,
+        }, { kind, rootGuard, directoryObserver });
+    }
+    catch (error) {
+        if (error instanceof RootPathObservationError) {
+            if (error.parentReceipt) {
+                assertRootPathObservationReceiptCurrent(root, error.parentReceipt);
+                if (error.traversalFailure && !isNotFoundPathError(error.error)) {
+                    if (error.error instanceof FsSafeError && error.error.code === "symlink")
+                        throw error.error;
+                    throw new FsSafeError("path-alias", "path alias escape blocked", { cause: error.error });
+                }
+            }
+            if (isNotFoundPathError(error.error)) {
+                if (kind === "stat") {
+                    throw fileNotFoundError(error.error instanceof Error ? error.error : undefined);
+                }
+                throw new FsSafeError("not-found", "directory not found", {
+                    cause: error.error instanceof Error ? error.error : undefined,
+                });
+            }
+            throw error.error;
+        }
+        if (error instanceof FsSafeError && error.code === "symlink")
+            throw error;
+        throw new FsSafeError("path-alias", "path alias escape blocked", { cause: error });
+    }
+    const resolved = observed.resolved;
+    if (observed.receipt) {
+        // A receipt is emitted only for the straight traversal whose lexical and
+        // canonical cursors stayed identical and inside the checked boundary.
+        return {
+            rootReal: resolved.rootCanonicalPath,
+            resolved: resolved.canonicalPath,
+            receipt: observed.receipt,
+        };
+    }
+    const relativeResolved = path.relative(resolved.rootCanonicalPath, resolved.canonicalPath);
+    if (relativeResolved === "" || relativeResolved === ".") {
+        return {
+            rootReal: resolved.rootCanonicalPath,
+            resolved: resolved.canonicalPath,
+        };
+    }
+    const firstSegment = relativeResolved.split(path.sep)[0];
+    if (firstSegment === ".." || path.isAbsolute(relativeResolved)) {
+        throw outsideWorkspaceError();
+    }
+    const admittedCanonicalPath = admitPathInsideRoot({
+        rootPath: resolved.rootCanonicalPath,
+        candidatePath: resolved.canonicalPath,
+        rootIdentity: root.rootIdentity,
+    });
+    if (!admittedCanonicalPath)
+        throw outsideWorkspaceError();
+    return {
+        rootReal: resolved.rootCanonicalPath,
+        resolved: admittedCanonicalPath.path,
+    };
+}

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

@@ -0,0 +1,77 @@
+import type { DenyMutationPolicy } from "./deny-mutations.js";
+import type { RenameIdentityPolicy } from "./pinned-write.js";
+import type { MutationSymlinkPolicy, SymlinkPolicy } from "./root-symlink-policy.js";
+import type { CopyCloneMode } from "./copy-policy.js";
+import type { RootCopyPublicationReceipt } from "./copy-publication.js";
+import type { Root } from "./root-impl.js";
+export declare const DEFAULT_ROOT_MAX_BYTES: number;
+export type RootOptions = {
+    rootDir: string;
+    defaults?: RootDefaults;
+};
+export type HardlinkPolicy = "reject" | "allow";
+export type WritableOpenMode = "replace" | "append" | "update";
+export type RootDefaults = {
+    assertBeforeMutation?: () => void;
+    durable?: boolean;
+    hardlinks?: HardlinkPolicy;
+    maxBytes?: number;
+    mkdir?: boolean;
+    mode?: number;
+    denyMutations?: DenyMutationPolicy;
+    nonBlockingRead?: boolean;
+    renameIdentity?: RenameIdentityPolicy;
+    symlinks?: SymlinkPolicy;
+    mutationSymlinks?: MutationSymlinkPolicy;
+};
+export type RootReadOptions = Pick<RootDefaults, "hardlinks" | "maxBytes" | "nonBlockingRead" | "symlinks">;
+export type RootOpenOptions = Omit<RootReadOptions, "maxBytes">;
+export type RootWriteOptions = Pick<RootDefaults, "assertBeforeMutation" | "denyMutations" | "mutationSymlinks" | "durable" | "mkdir" | "mode" | "renameIdentity"> & {
+    encoding?: BufferEncoding;
+    overwrite?: boolean;
+};
+export type RootOpenWritableOptions = Pick<RootDefaults, "assertBeforeMutation" | "denyMutations" | "mutationSymlinks" | "mkdir" | "mode"> & {
+    writeMode?: WritableOpenMode;
+};
+export type RootCopyOptions = Pick<RootDefaults, "assertBeforeMutation" | "denyMutations" | "mutationSymlinks" | "durable" | "maxBytes" | "mkdir" | "mode"> & {
+    sourceHardlinks?: HardlinkPolicy;
+    overwrite?: boolean;
+    clone?: CopyCloneMode;
+    signal?: AbortSignal;
+    preserveSourceMode?: boolean;
+    onDestinationPublished?: (receipt: RootCopyPublicationReceipt) => void;
+};
+export type RootCopySource = string | {
+    root: Pick<Root, "open" | "stat">;
+    relativePath: string;
+};
+export type RootWriteJsonOptions = RootWriteOptions & {
+    replacer?: Parameters<typeof JSON.stringify>[1];
+    space?: Parameters<typeof JSON.stringify>[2];
+    trailingNewline?: boolean;
+};
+export type RootCreateOptions = Omit<RootWriteOptions, "overwrite">;
+export type RootCreateStreamOptions = Omit<RootCreateOptions, "encoding" | "renameIdentity"> & {
+    maxBytes?: number;
+    signal?: AbortSignal;
+};
+export type RootCreateJsonOptions = Omit<RootWriteJsonOptions, "overwrite">;
+export type RootAppendOptions = RootWriteOptions & {
+    prependNewlineIfNeeded?: boolean;
+};
+export type RootMoveOptions = Pick<RootDefaults, "assertBeforeMutation" | "denyMutations" | "mutationSymlinks"> & {
+    overwrite?: boolean;
+};
+export type RootRemoveOptions = Pick<RootDefaults, "assertBeforeMutation" | "denyMutations" | "mutationSymlinks"> & {
+    recursive?: boolean;
+    force?: boolean;
+    order?: "filesystem" | "sorted";
+    maxEntries?: number;
+    maxDepth?: number;
+    signal?: AbortSignal;
+};
+export type RootMkdirOptions = Pick<RootDefaults, "assertBeforeMutation" | "denyMutations" | "mutationSymlinks">;
+export type RootReadParams = Omit<RootReadOptions, "nonBlockingRead">;
+export declare function readDefaults(defaults: RootDefaults): RootReadParams;
+export declare function mergeReadOptions(defaults: RootDefaults, options: RootReadOptions): RootReadParams;
+//# sourceMappingURL=root-options.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"root-options.d.ts","sourceRoot":"","sources":["../src/root-options.ts"],"names":[],"mappings":"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"}

package/node_modules/@openclaw/fs-safe/dist/root-options.js

@@ -0,0 +1,18 @@
+import { normalizeMaxBytes } from "./byte-budget.js";
+export const DEFAULT_ROOT_MAX_BYTES = 16 * 1024 * 1024;
+export function readDefaults(defaults) {
+    return {
+        hardlinks: defaults.hardlinks,
+        maxBytes: normalizeMaxBytes(defaults.maxBytes, { defaultValue: DEFAULT_ROOT_MAX_BYTES }),
+        symlinks: defaults.symlinks,
+    };
+}
+export function mergeReadOptions(defaults, options) {
+    const merged = readDefaults(defaults);
+    if (options.hardlinks !== undefined)
+        merged.hardlinks = options.hardlinks;
+    merged.maxBytes = normalizeMaxBytes(options.maxBytes, { defaultValue: merged.maxBytes });
+    if (options.symlinks !== undefined)
+        merged.symlinks = options.symlinks;
+    return merged;
+}

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

@@ -0,0 +1,12 @@
+export declare function sanitizeRootPathError(error: unknown): unknown;
+export declare function pathEscapeError(params: {
+    boundaryLabel: string;
+    rootPath: string;
+    absolutePath: string;
+}): Error;
+export declare function symlinkEscapeError(params: {
+    boundaryLabel: string;
+    rootCanonicalPath: string;
+    symlinkPath: string;
+}): Error;
+//# sourceMappingURL=root-path-errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"root-path-errors.d.ts","sourceRoot":"","sources":["../src/root-path-errors.ts"],"names":[],"mappings":"AAEA,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAK7D;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE;IACtC,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;CACtB,GAAG,KAAK,CAIR;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE;IACzC,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,WAAW,EAAE,MAAM,CAAC;CACrB,GAAG,KAAK,CAIR"}

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

@@ -0,0 +1,13 @@
+import { formatErrorDetail, shortPath } from "./error-detail.js";
+export function sanitizeRootPathError(error) {
+    if (error instanceof Error) {
+        error.message = formatErrorDetail(error.message);
+    }
+    return error;
+}
+export function pathEscapeError(params) {
+    return new Error(`Path escapes ${params.boundaryLabel} (${shortPath(params.rootPath)}): ${shortPath(params.absolutePath)}`);
+}
+export function symlinkEscapeError(params) {
+    return new Error(`Symlink escapes ${params.boundaryLabel} (${shortPath(params.rootCanonicalPath)}): ${shortPath(params.symlinkPath)}`);
+}

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

@@ -1,3 +1,10 @@
+import { type RootBoundaryIdentity } from "./root-boundary.js";
+export declare function absolutePathWithRawSegments(candidate: string): string;
+export declare function rawPathRelativeToCanonicalRoot(candidate: string, rootCanonicalPath: string, options?: {
+    rejectSymlinks?: boolean;
+    rejectFinalSymlink?: boolean;
+    rootIdentity?: RootBoundaryIdentity;
+}): string | undefined;
 export declare function resolvePathViaExistingAncestor(targetPath: string): Promise<string>;
 export declare function resolvePathViaExistingAncestorSync(targetPath: string): string;
 //# sourceMappingURL=root-path-existing.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"root-path-existing.d.ts","sourceRoot":"","sources":["../src/root-path-existing.ts"],"names":[],"mappings":"AAoBA,wBAAsB,8BAA8B,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CA0BxF;AAED,wBAAgB,kCAAkC,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CA0B7E"}
+{"version":3,"file":"root-path-existing.d.ts","sourceRoot":"","sources":["../src/root-path-existing.ts"],"names":[],"mappings":"AAWA,OAAO,EAAuB,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAEpF,wBAAgB,2BAA2B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAarE;AAED,wBAAgB,8BAA8B,CAC5C,SAAS,EAAE,MAAM,EACjB,iBAAiB,EAAE,MAAM,EACzB,OAAO,GAAE;IACP,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,YAAY,CAAC,EAAE,oBAAoB,CAAC;CAChC,GACL,MAAM,GAAG,SAAS,CAqDpB;AAkBD,wBAAsB,8BAA8B,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAkCxF;AAED,wBAAgB,kCAAkC,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAqC7E"}