@openclaw/openshell-sandbox 2026.9.4 → 2026.9.5

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

@@ -0,0 +1,74 @@
+import fs from "node:fs";
+import path from "node:path";
+import { FsSafeError } from "./errors.js";
+import { isNotFoundPathError } from "./path.js";
+import { admitPathInsideRoot } from "./root-boundary.js";
+import { withPinnedWriteRenameIdentityLock } from "./pinned-write.js";
+import { realpathSync } from "./realpath.js";
+import { serializePathWrite } from "./write-queue.js";
+function unsupportedSpelling() {
+    return new FsSafeError("path-alias", "Windows compatibility writes require lower-case ASCII destination components");
+}
+// The caller first applies the Root's ordinary path and mutation policies. This
+// extra admission rule is deliberately narrower than general Windows filenames:
+// the existing lock protocol has no portable case/Unicode equivalence key for a
+// missing name. Do not guess one, or switch keys when a placeholder appears.
+function effectiveDestination(rootPath, targetPath, rootIdentity) {
+    let effective;
+    try {
+        effective = realpathSync.native(targetPath);
+    }
+    catch (error) {
+        if (!isNotFoundPathError(error))
+            throw error;
+        let cursor = targetPath;
+        const missing = [];
+        for (;;) {
+            try {
+                fs.lstatSync(cursor);
+                break;
+            }
+            catch (error) {
+                if (!isNotFoundPathError(error) || cursor === rootPath)
+                    throw error;
+                const parent = path.dirname(cursor);
+                if (parent === cursor)
+                    throw error;
+                missing.unshift(path.basename(cursor));
+                cursor = parent;
+            }
+        }
+        // An existing dangling link must fail resolution, not become a missing
+        // lexical component. Keep the fallback bounded by the retained Root.
+        effective = path.join(realpathSync.native(cursor), ...missing);
+    }
+    const admitted = admitPathInsideRoot({ rootPath, candidatePath: effective, rootIdentity });
+    if (!admitted)
+        throw unsupportedSpelling();
+    const relative = admitted.relativePath;
+    if (!relative || !relative.split(path.sep).every(component => /^[a-z0-9._-]+$/.test(component) && !component.endsWith(".")))
+        throw unsupportedSpelling();
+    return admitted.path;
+}
+export function assertRootFallbackWritePath(expected, actual) {
+    if (expected !== undefined && actual !== expected) {
+        throw new FsSafeError("path-mismatch", "compatibility write destination changed after lock selection");
+    }
+}
+export async function withRootFallbackCompatibilityLock(params, run) {
+    const targetPath = effectiveDestination(params.rootPath, params.targetPath, params.rootIdentity);
+    const relativePath = path.relative(params.rootPath, targetPath).split(path.sep).join("/");
+    const assertCurrent = () => assertRootFallbackWritePath(targetPath, effectiveDestination(params.rootPath, targetPath, params.rootIdentity));
+    // Sidecars are reentrant within one manager; aliases also need the same local
+    // queue before acquisition. The outer Root queue uses the caller's spelling.
+    return await serializePathWrite(targetPath, async () => await withPinnedWriteRenameIdentityLock({
+        rootPath: params.rootPath, targetPath, relativeTargetPath: relativePath,
+    }, async () => {
+        // The guarded open resolves again under the lock; each mutation rechecks
+        // below. Lock selection is never reused as post-lock filesystem authority.
+        return await run({
+            targetPath, relativePath,
+            assertBeforeMutation: () => { params.assertBeforeMutation?.(); assertCurrent(); },
+        });
+    }));
+}

package/node_modules/@openclaw/fs-safe/dist/root-write-complete-parent.d.ts

@@ -0,0 +1,42 @@
+import type { BigIntStats } from "node:fs";
+import { type AsyncDirectoryGuard } from "./directory-guard.js";
+import type { RootContext } from "./root-context.js";
+import type { GuardedRootWriteTarget } from "./root-write-admission.js";
+type PreparedWriteTargetObservation = Readonly<{
+    exists: false;
+} | {
+    exists: true;
+    stat: BigIntStats;
+}>;
+/**
+ * Exact, operation-local evidence that an ordinary shared-JavaScript write
+ * already has a complete parent. Path selection consumes this instead of
+ * recapturing the same parent after a component walk.
+ */
+export type PreparedRootWriteParent = Readonly<{
+    operationTargetPath: string;
+    selectedTargetPath: string;
+    parentGuard: AsyncDirectoryGuard<BigIntStats>;
+    rootPath: string;
+    rootIdentity: Readonly<{
+        dev: bigint;
+        ino: bigint;
+    }>;
+    nativeMode: string;
+    target: PreparedWriteTargetObservation;
+}>;
+type SharedRootWriteTargetParams = Readonly<{
+    relativePath: string;
+    guardedTarget: GuardedRootWriteTarget;
+    mkdir?: boolean;
+    assertBeforeMutation?: () => void;
+}>;
+export type SharedRootWriteTarget = Readonly<{
+    targetPath: string;
+    mutationAdmission: GuardedRootWriteTarget["mutationAdmission"];
+    preparedParent?: PreparedRootWriteParent;
+}>;
+export declare function assertPreparedRootWriteParentCurrent(prepared: PreparedRootWriteParent, verifyTarget?: boolean): void;
+export declare function prepareSharedRootWriteTarget(root: RootContext, params: SharedRootWriteTargetParams): Promise<SharedRootWriteTarget>;
+export {};
+//# sourceMappingURL=root-write-complete-parent.d.ts.map

package/node_modules/@openclaw/fs-safe/dist/root-write-complete-parent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-write-complete-parent.d.ts","sourceRoot":"","sources":["../src/root-write-complete-parent.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,OAAO,EAIL,KAAK,mBAAmB,EACzB,MAAM,sBAAsB,CAAC;AAO9B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAKxE,KAAK,8BAA8B,GAAG,QAAQ,CAC1C;IAAE,MAAM,EAAE,KAAK,CAAA;CAAE,GACjB;IAAE,MAAM,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,WAAW,CAAA;CAAE,CACtC,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAAG,QAAQ,CAAC;IAC7C,mBAAmB,EAAE,MAAM,CAAC;IAC5B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,WAAW,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAAC;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,QAAQ,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACrD,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,8BAA8B,CAAC;CACxC,CAAC,CAAC;AAEH,KAAK,2BAA2B,GAAG,QAAQ,CAAC;IAC1C,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,sBAAsB,CAAC;IACtC,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,oBAAoB,CAAC,EAAE,MAAM,IAAI,CAAC;CACnC,CAAC,CAAC;AAEH,MAAM,MAAM,qBAAqB,GAAG,QAAQ,CAAC;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,sBAAsB,CAAC,mBAAmB,CAAC,CAAC;IAC/D,cAAc,CAAC,EAAE,uBAAuB,CAAC;CAC1C,CAAC,CAAC;AA2GH,wBAAgB,oCAAoC,CAClD,QAAQ,EAAE,uBAAuB,EACjC,YAAY,UAAQ,GACnB,IAAI,CAqBN;AAwCD,wBAAsB,4BAA4B,CAChD,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,2BAA2B,GAClC,OAAO,CAAC,qBAAqB,CAAC,CAqBhC"}

package/node_modules/@openclaw/fs-safe/dist/root-write-complete-parent.js

@@ -0,0 +1,195 @@
+import fsSync from "node:fs";
+import path from "node:path";
+import { assertDirectoryIdentitySync, createAsyncDirectoryGuard, inspectDirectoryIdentitySync, } from "./directory-guard.js";
+import { WINDOWS_RESERVED_DEVICE_NAMES } from "./device-path.js";
+import { FsSafeError } from "./errors.js";
+import { getFsSafeNativeConfig } from "./native-config.js";
+import { hasNodeErrorCode } from "./path.js";
+import { realpathSync } from "./realpath.js";
+import { admitPathInsideRoot } from "./root-boundary.js";
+import { prepareRootWriteTarget } from "./root-directory-creation.js";
+import { isSafePathSegment } from "./safe-path-segment.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+import { getFsSafeTestHooks } from "./test-hooks.js";
+function writeSelectionChanged(cause) {
+    return new FsSafeError("path-mismatch", "write target changed during operation", {
+        cause: cause instanceof Error ? cause : undefined,
+    });
+}
+function sameNormalizedPathSpelling(left, right) {
+    // Windows can expose case-sensitive directories, so normalize separators
+    // and roots without using path.relative's case-folding comparison.
+    return path.resolve(left) === path.resolve(right);
+}
+function windowsReservedDeviceSegment(segment) {
+    const extension = segment.indexOf(".");
+    const stem = segment.slice(0, extension < 0 ? segment.length : extension).toUpperCase();
+    return WINDOWS_RESERVED_DEVICE_NAMES.has(stem);
+}
+function ordinarySharedWriteRoute(root, relativePath, operationTargetPath) {
+    if (process.versions.bun || relativePath === "" || relativePath.startsWith("~") ||
+        relativePath.includes("\0") || path.isAbsolute(relativePath))
+        return false;
+    const separator = process.platform === "win32" ? "\\" : "/";
+    const alternateSeparator = process.platform === "win32" ? "/" : "\\";
+    if (relativePath.includes(alternateSeparator))
+        return false;
+    const segments = relativePath.split(separator);
+    if (segments.some((segment) => segment === "" || segment === "." || segment === ".." ||
+        (process.platform === "win32" &&
+            (!isSafePathSegment(segment, { allowDotPrefix: true }) ||
+                segment.endsWith(".") || segment.endsWith(" ") ||
+                windowsReservedDeviceSegment(segment)))))
+        return false;
+    const routed = path.resolve(root.rootReal, relativePath);
+    const admitted = admitPathInsideRoot({
+        rootPath: root.rootReal,
+        candidatePath: routed,
+        rootIdentity: root.rootIdentity,
+    });
+    return admitted?.admission === "exact" &&
+        sameNormalizedPathSpelling(admitted.path, routed) &&
+        sameNormalizedPathSpelling(routed, operationTargetPath);
+}
+// Preparation is optional evidence. An exact identity mismatch is conclusive
+// and remains fail-closed; every other probe failure must let the established
+// ordered component admission classify the same filesystem state.
+function deoptPreparationFailure(error) {
+    if (error instanceof FsSafeError && error.code === "path-mismatch")
+        throw error;
+    return undefined;
+}
+function capturePreparedTargetObservation(targetPath) {
+    let stat;
+    try {
+        stat = inspectFileIdentitySync(() => fsSync.lstatSync(targetPath, { bigint: true }));
+    }
+    catch (error) {
+        if (hasNodeErrorCode(error, "ENOENT"))
+            return Object.freeze({ exists: false });
+        return deoptPreparationFailure(error);
+    }
+    // Final aliases retain the established full component walk and selected-path
+    // admission. The shortcut is intentionally limited to an ordinary spelling.
+    if (stat.isSymbolicLink())
+        return undefined;
+    let realPath;
+    try {
+        realPath = realpathSync.native(targetPath);
+    }
+    catch (error) {
+        return deoptPreparationFailure(error);
+    }
+    if (!sameNormalizedPathSpelling(realPath, targetPath))
+        return undefined;
+    return Object.freeze({ exists: true, stat });
+}
+function samePreparedTargetFacts(left, right) {
+    return left.dev === right.dev && left.ino === right.ino && left.mode === right.mode &&
+        left.nlink === right.nlink;
+}
+function assertPreparedTargetCurrent(prepared) {
+    if (!prepared.target.exists) {
+        try {
+            fsSync.lstatSync(prepared.selectedTargetPath, { bigint: true });
+        }
+        catch (error) {
+            if (hasNodeErrorCode(error, "ENOENT"))
+                return;
+            throw writeSelectionChanged(error);
+        }
+        throw writeSelectionChanged();
+    }
+    try {
+        const current = inspectFileIdentitySync(() => fsSync.lstatSync(prepared.selectedTargetPath, { bigint: true }), prepared.target.stat);
+        if (current.isSymbolicLink() || !samePreparedTargetFacts(prepared.target.stat, current)) {
+            throw writeSelectionChanged();
+        }
+    }
+    catch (error) {
+        if (error instanceof FsSafeError && error.code === "path-mismatch")
+            throw error;
+        throw writeSelectionChanged(error);
+    }
+}
+export function assertPreparedRootWriteParentCurrent(prepared, verifyTarget = false) {
+    try {
+        if (getFsSafeNativeConfig().mode !== prepared.nativeMode)
+            throw writeSelectionChanged();
+        if (!sameNormalizedPathSpelling(prepared.parentGuard.dir, prepared.rootPath)) {
+            assertDirectoryIdentitySync(prepared.rootPath, prepared.rootIdentity);
+        }
+        else if (prepared.parentGuard.stat.dev !== prepared.rootIdentity.dev ||
+            prepared.parentGuard.stat.ino !== prepared.rootIdentity.ino) {
+            throw writeSelectionChanged();
+        }
+        const parent = inspectDirectoryIdentitySync(prepared.parentGuard.dir, prepared.parentGuard.stat);
+        if (parent.mode !== prepared.parentGuard.stat.mode ||
+            parent.nlink !== prepared.parentGuard.stat.nlink ||
+            !sameNormalizedPathSpelling(realpathSync.native(prepared.parentGuard.dir), prepared.parentGuard.realPath))
+            throw writeSelectionChanged();
+        if (verifyTarget)
+            assertPreparedTargetCurrent(prepared);
+    }
+    catch (error) {
+        if (error instanceof FsSafeError && error.code === "path-mismatch")
+            throw error;
+        throw writeSelectionChanged(error);
+    }
+}
+async function prepareCompleteRootWriteParent(root, guarded, relativePath) {
+    if (!guarded.mutationAdmission || !guarded.selectedTargetAdmission ||
+        typeof root.rootIdentity.dev !== "bigint" || typeof root.rootIdentity.ino !== "bigint" ||
+        !ordinarySharedWriteRoute(root, relativePath, guarded.targetPath) ||
+        !sameNormalizedPathSpelling(guarded.resolvedPath.resolved, guarded.targetPath))
+        return undefined;
+    const parentPath = path.dirname(guarded.targetPath);
+    const admittedParent = admitPathInsideRoot({
+        rootPath: root.rootReal,
+        candidatePath: parentPath,
+        rootIdentity: root.rootIdentity,
+    });
+    if (admittedParent?.admission !== "exact" ||
+        !sameNormalizedPathSpelling(admittedParent.path, parentPath))
+        return undefined;
+    let parentGuard;
+    try {
+        parentGuard = await createAsyncDirectoryGuard(parentPath, { bigint: true });
+    }
+    catch (error) {
+        return deoptPreparationFailure(error);
+    }
+    if (!sameNormalizedPathSpelling(parentGuard.dir, parentPath) ||
+        !sameNormalizedPathSpelling(parentGuard.realPath, parentPath))
+        return undefined;
+    const target = capturePreparedTargetObservation(guarded.targetPath);
+    if (!target)
+        return undefined;
+    return Object.freeze({
+        operationTargetPath: guarded.targetPath,
+        selectedTargetPath: guarded.targetPath,
+        parentGuard,
+        rootPath: root.rootReal,
+        rootIdentity: Object.freeze({ dev: root.rootIdentity.dev, ino: root.rootIdentity.ino }),
+        nativeMode: getFsSafeNativeConfig().mode,
+        target,
+    });
+}
+export async function prepareSharedRootWriteTarget(root, params) {
+    const { guardedTarget } = params;
+    const resolvedPath = guardedTarget.resolvedPath.resolved;
+    const mutationAdmission = guardedTarget.mutationAdmission;
+    const beforeParentAdmission = mutationAdmission
+        ? getFsSafeTestHooks()?.beforePinnedWriteParentAdmission
+        : undefined;
+    if (mutationAdmission)
+        await beforeParentAdmission?.(resolvedPath);
+    const preparedParent = params.mkdir !== false &&
+        params.assertBeforeMutation === undefined && beforeParentAdmission === undefined
+        ? await prepareCompleteRootWriteParent(root, guardedTarget, params.relativePath)
+        : undefined;
+    const targetPath = params.mkdir === false
+        ? guardedTarget.targetPath
+        : preparedParent?.selectedTargetPath ?? await prepareRootWriteTarget(root, resolvedPath, params.assertBeforeMutation, mutationAdmission);
+    return { targetPath, mutationAdmission, preparedParent };
+}

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

@@ -1,6 +1,8 @@
+import { type RootBoundaryIdentity } from "./root-boundary.js";
 export declare function inheritWriteTargetMode(params: {
     targetPath: string;
     rootWithSep: string;
+    rootIdentity?: RootBoundaryIdentity;
     requestedMode?: number;
 }): Promise<number>;
 //# sourceMappingURL=root-write-mode.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"root-write-mode.d.ts","sourceRoot":"","sources":["../src/root-write-mode.ts"],"names":[],"mappings":"AAUA,wBAAsB,sBAAsB,CAAC,MAAM,EAAE;IACnD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,OAAO,CAAC,MAAM,CAAC,CAwClB"}
+{"version":3,"file":"root-write-mode.d.ts","sourceRoot":"","sources":["../src/root-write-mode.ts"],"names":[],"mappings":"AAQA,OAAO,EAAuB,KAAK,oBAAoB,EAAE,MAAM,oBAAoB,CAAC;AAGpF,wBAAsB,sBAAsB,CAAC,MAAM,EAAE;IACnD,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,oBAAoB,CAAC;IACpC,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,GAAG,OAAO,CAAC,MAAM,CAAC,CAkDlB"}

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

@@ -1,31 +1,36 @@
 import fsSync from "node:fs";
 import fs from "node:fs/promises";
 import { FsSafeError } from "./errors.js";
-import { sameFileIdentity } from "./file-identity.js";
-import { isNotFoundPathError, isPathInside } from "./path.js";
+import { isNotFoundPathError } from "./path.js";
 import { resolveReadOpenFlags } from "./read-open-flags.js";
+import { realpathSync } from "./realpath.js";
 import { hardlinkedPathNotAllowedError, outsideWorkspaceError } from "./root-errors.js";
 import { inspectFileIdentity } from "./strict-file-identity.js";
+import { admitPathInsideRoot } from "./root-boundary.js";
 // The caller has already resolved and guarded this write target.
 export async function inheritWriteTargetMode(params) {
     try {
-        const existing = await inspectFileIdentity(() => fsSync.lstatSync(params.targetPath, { bigint: true }));
+        const admittedTarget = admitPathInsideRoot({
+            rootPath: params.rootWithSep,
+            candidatePath: params.targetPath,
+            rootIdentity: params.rootIdentity,
+        });
+        if (!admittedTarget)
+            throw outsideWorkspaceError();
+        const targetPath = admittedTarget.path;
+        const existing = await inspectFileIdentity(() => fsSync.lstatSync(targetPath, { bigint: true }));
         if (existing.isSymbolicLink())
             throw new FsSafeError("path-alias", "path alias escape blocked");
         if (!existing.isFile())
             throw new FsSafeError("not-file", "not a file");
         if (existing.nlink > 1n)
             throw hardlinkedPathNotAllowedError();
-        if (!isPathInside(params.rootWithSep, params.targetPath))
-            throw outsideWorkspaceError();
         // Preserve read-open admission of the pre-existing destination. access(2)
         // is not equivalent: it ignores ACLs on Windows and capabilities on Linux.
-        const handle = await fs.open(params.targetPath, resolveReadOpenFlags());
+        const handle = await fs.open(targetPath, resolveReadOpenFlags());
         try {
             // Bind admission to the inode whose metadata is inherited.
-            if (!sameFileIdentity(fsSync.fstatSync(handle.fd, { bigint: true }), existing)) {
-                throw new FsSafeError("path-mismatch", "write target changed during mode inheritance");
-            }
+            await inspectFileIdentity(() => fsSync.fstatSync(handle.fd, { bigint: true }), existing);
         }
         finally {
             await handle.close().catch(() => undefined);
@@ -33,9 +38,15 @@ export async function inheritWriteTargetMode(params) {
         try {
             // A parent can change after guarded resolution. Do not inherit metadata
             // from an outside inode, even if the parent is restored before publication.
-            const realPath = fsSync.realpathSync.native(params.targetPath);
-            if (!isPathInside(params.rootWithSep, realPath))
+            const observedRealPath = realpathSync.native(targetPath);
+            const admittedRealPath = admitPathInsideRoot({
+                rootPath: params.rootWithSep,
+                candidatePath: observedRealPath,
+                rootIdentity: params.rootIdentity,
+            });
+            if (!admittedRealPath)
                 throw outsideWorkspaceError();
+            const realPath = admittedRealPath.path;
             await inspectFileIdentity(async () => {
                 const current = fsSync.statSync(realPath, { bigint: true });
                 if (!current.isFile())

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

@@ -0,0 +1,24 @@
+import { type BigIntStats } from "node:fs";
+import type { FileHandle } from "node:fs/promises";
+import type { AnyAsyncDirectoryGuard } from "./directory-guard.js";
+import type { RootContext } from "./root-context.js";
+import type { RootWriteOptions } from "./root-options.js";
+export declare function finishRootFallbackWrite(params: {
+    root: RootContext;
+    targetPath: string;
+    handle: FileHandle;
+    identity: BigIntStats;
+    parentGuard: AnyAsyncDirectoryGuard;
+    mode: number;
+    options: RootWriteOptions & {
+        data: string | Buffer;
+    };
+    openForCompatibility: () => Promise<{
+        opened: {
+            handle: FileHandle;
+        };
+        identity: BigIntStats;
+    }>;
+    onVerificationFailure: (error: unknown) => void;
+}): Promise<void>;
+//# sourceMappingURL=root-write-publication.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"root-write-publication.d.ts","sourceRoot":"","sources":["../src/root-write-publication.ts"],"names":[],"mappings":"AAAA,OAAe,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAGnD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAKnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAK1D,wBAAsB,uBAAuB,CAAC,MAAM,EAAE;IACpD,IAAI,EAAE,WAAW,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,EAAE,WAAW,CAAC;IACtB,WAAW,EAAE,sBAAsB,CAAC;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,gBAAgB,GAAG;QAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;IACtD,oBAAoB,EAAE,MAAM,OAAO,CAAC;QAAE,MAAM,EAAE;YAAE,MAAM,EAAE,UAAU,CAAA;SAAE,CAAC;QAAC,QAAQ,EAAE,WAAW,CAAA;KAAE,CAAC,CAAC;IAC/F,qBAAqB,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACjD,GAAG,OAAO,CAAC,IAAI,CAAC,CAoEhB"}

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

@@ -0,0 +1,85 @@
+import fsSync, {} from "node:fs";
+import path from "node:path";
+import { readFileHandleBounded } from "./bounded-read.js";
+import { syncDirectoryBestEffort } from "./directory-durability.js";
+import { FsSafeError } from "./errors.js";
+import { sameFileIdentityForCleanup, sha256Hex } from "./file-identity.js";
+import { cleanupPinnedFilePath } from "./replace-file-temp-owner.js";
+import { verifyAtomicWriteResult } from "./root-write-verification.js";
+// Compatibility callers hold the lock throughout this operation. The caller
+// owns the original write handle; this helper owns a content-verified reopen.
+export async function finishRootFallbackWrite(params) {
+    let handle = params.handle;
+    let identity = params.identity;
+    let accepted;
+    const compatibility = params.options.renameIdentity === "verify-content-with-lock";
+    const verify = async () => {
+        try {
+            await verifyAtomicWriteResult({
+                root: params.root, targetPath: params.targetPath, fd: handle.fd,
+                expectedIdentity: identity, parentGuard: params.parentGuard,
+            });
+        }
+        catch (error) {
+            params.onVerificationFailure(error);
+            throw error;
+        }
+    };
+    try {
+        if (compatibility) {
+            const current = fsSync.lstatSync(params.targetPath, { bigint: true });
+            if (current.isSymbolicLink() || !current.isFile()) {
+                throw new FsSafeError("path-mismatch", "fallback target changed during write");
+            }
+            if (process.platform === "win32" && (current.dev === 0n || current.ino === 0n)) {
+                // Opaque pathname stats are not evidence of rename identity drift. The
+                // strict verifier can reopen against the retained descriptor's exact
+                // identity without reading bytes; a different object must still fail.
+                await verify();
+            }
+            else if (!sameFileIdentityForCleanup(current, identity)) {
+                const opened = await params.openForCompatibility();
+                accepted = handle = opened.opened.handle;
+                identity = opened.identity;
+                // Admit the destination under the retained Root and parent before any
+                // read, chmod, or sync; the original temp no longer proves its identity.
+                await verify();
+                const data = params.options.data;
+                const expectedBytes = typeof data === "string"
+                    ? Buffer.byteLength(data, params.options.encoding ?? "utf8") : data.byteLength;
+                const content = await readFileHandleBounded(handle, expectedBytes).catch((error) => {
+                    if (error instanceof FsSafeError && error.code === "too-large") {
+                        throw new FsSafeError("path-mismatch", "fallback target changed during write", { cause: error });
+                    }
+                    throw error;
+                });
+                if (sha256Hex(content) !== sha256Hex(data, params.options.encoding)) {
+                    throw new FsSafeError("path-mismatch", "fallback target changed during write");
+                }
+                await verify();
+            }
+        }
+        // Final mode belongs to the accepted object, including on rename-unstable
+        // filesystems; never chmod the old temp and assume its mode was transferred.
+        try {
+            await handle.chmod(params.mode);
+        }
+        catch (error) {
+            await cleanupPinnedFilePath({
+                pathname: params.targetPath, handle, identity, parentGuard: params.parentGuard,
+            });
+            throw error;
+        }
+        if (params.options.durable !== false)
+            await handle.sync();
+        await verify();
+        if (params.options.durable !== false) {
+            await syncDirectoryBestEffort(path.dirname(params.targetPath));
+            if (compatibility)
+                await verify();
+        }
+    }
+    finally {
+        await accepted?.close().catch(() => undefined);
+    }
+}

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

@@ -1 +1 @@
-{"version":3,"file":"root-write-verification.d.ts","sourceRoot":"","sources":["../src/root-write-verification.ts"],"names":[],"mappings":"AAEA,OAAO,EAA6B,KAAK,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAK9F,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAEhE,OAAO,EAA6B,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGhF,wBAAsB,uBAAuB,CAAC,MAAM,EAAE;IACpD,IAAI,EAAE,WAAW,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,gBAAgB,EAAE,sBAAsB,CAAC;IACzC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,sBAAsB,CAAC;CACrC,GAAG,OAAO,CAAC,IAAI,CAAC,CAqFhB"}
+{"version":3,"file":"root-write-verification.d.ts","sourceRoot":"","sources":["../src/root-write-verification.ts"],"names":[],"mappings":"AAEA,OAAO,EAA6B,KAAK,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAK9F,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAC;AAEhE,OAAO,EAA6B,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIhF,wBAAsB,uBAAuB,CAAC,MAAM,EAAE;IACpD,IAAI,EAAE,WAAW,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,gBAAgB,EAAE,sBAAsB,CAAC;IACzC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,sBAAsB,CAAC;CACrC,GAAG,OAAO,CAAC,IAAI,CAAC,CAgGhB"}

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

@@ -4,10 +4,11 @@ import { assertAsyncDirectoryGuard } from "./directory-guard.js";
 import { FsSafeError } from "./errors.js";
 import { sameFileIdentity } from "./file-identity.js";
 import { resolveOpenedFileRealPathForFd } from "./opened-realpath.js";
-import { assertNoUnsafeDeviceReadPath, hasNodeErrorCode, isNotFoundPathError, isPathInside, isSymlinkOpenError } from "./path.js";
+import { assertNoUnsafeDeviceReadPath, hasNodeErrorCode, isNotFoundPathError, isSymlinkOpenError } from "./path.js";
 import { resolveReadOpenFlags } from "./read-open-flags.js";
 import { assertRootIdentityCurrent } from "./root-context.js";
 import { fileNotFoundError, hardlinkedPathNotAllowedError, outsideWorkspaceError } from "./root-errors.js";
+import { admitPathInsideRoot } from "./root-boundary.js";
 export async function verifyAtomicWriteResult(params) {
     let needsPathOpen = false;
     const assertFile = (stat) => {
@@ -47,9 +48,15 @@ export async function verifyAtomicWriteResult(params) {
         // This descriptor remains owned by the writer, even when final mode forbids opens.
         const stat = assertDescriptor();
         assertPath(fsSync.lstatSync(params.targetPath, { bigint: true }));
-        const { realPath } = await resolveOpenedFileRealPathForFd(params.fd, stat, params.targetPath);
-        assertPath(fsSync.statSync(realPath, { bigint: true }));
-        if (!isPathInside(params.root.rootWithSep, realPath)) {
+        const { realPath, stat: resolvedStat } = await resolveOpenedFileRealPathForFd(params.fd, stat, params.targetPath);
+        // Consume the resolver's observation only in this pass; the checks after
+        // the directory guards must still sample the current path and descriptor.
+        assertPath(resolvedStat);
+        if (!admitPathInsideRoot({
+            rootPath: params.root.rootReal,
+            candidatePath: realPath,
+            rootIdentity: params.root.rootIdentity,
+        })) {
             throw outsideWorkspaceError();
         }
         await assertAsyncDirectoryGuard(params.parentGuard);
@@ -74,9 +81,13 @@ export async function verifyAtomicWriteResult(params) {
             try {
                 const reopenedStat = assertDescriptor(opened.fd);
                 assertPath(fsSync.lstatSync(params.targetPath, { bigint: true }));
-                const { realPath: reopenedPath } = await resolveOpenedFileRealPathForFd(opened.fd, reopenedStat, params.targetPath);
-                assertPath(fsSync.statSync(reopenedPath, { bigint: true }));
-                if (!isPathInside(params.root.rootWithSep, reopenedPath)) {
+                const { realPath: reopenedPath, stat: reopenedPathStat } = await resolveOpenedFileRealPathForFd(opened.fd, reopenedStat, params.targetPath);
+                assertPath(reopenedPathStat);
+                if (!admitPathInsideRoot({
+                    rootPath: params.root.rootReal,
+                    candidatePath: reopenedPath,
+                    rootIdentity: params.root.rootIdentity,
+                })) {
                     throw outsideWorkspaceError();
                 }
                 await assertAsyncDirectoryGuard(params.parentGuard);

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

@@ -1,4 +1,7 @@
-export { DEFAULT_ROOT_MAX_BYTES, openLocalFileSafely, readLocalFileSafely, resolveOpenedFileRealPathForHandle, root, type DenyMutationPolicy, type HardlinkPolicy, type RenameIdentityPolicy, type OpenResult, type ReadResult, type Root, type RootAppendOptions, type RootCopyOptions, type RootCreateJsonOptions, type RootCreateOptions, type RootDefaults, type RootMkdirOptions, type RootMoveOptions, type RootOpenOptions, type RootOpenWritableOptions, type RootOptions, type RootReadOptions, type RootRemoveOptions, type RootWriteJsonOptions, type RootWriteOptions, type SymlinkPolicy, type WritableOpenMode, type WritableOpenResult, } from "./root-impl.js";
+export { DEFAULT_ROOT_MAX_BYTES, openLocalFileSafely, readLocalFileSafely, resolveOpenedFileRealPathForHandle, root, type DenyMutationPolicy, type HardlinkPolicy, type MutationSymlinkPolicy, type RenameIdentityPolicy, type OpenResult, type ReadResult, type Root, type RootAppendOptions, type RootCopyOptions, type RootCopySource, type RootCreateJsonOptions, type RootCreateOptions, type RootCreateStreamOptions, type RootDefaults, type RootMkdirOptions, type RootMoveOptions, type RootOpenOptions, type RootOpenWritableOptions, type RootOptions, type RootReadOptions, type RootRemoveOptions, type RootWriteJsonOptions, type RootWriteOptions, type SymlinkPolicy, type WritableOpenMode, type WritableOpenResult, } from "./root-impl.js";
+export type { RootCopyPublicationReceipt } from "./copy-publication.js";
+export type { CopyCloneMode } from "./copy-policy.js";
+export type { RootEntriesOptions } from "./root-entries.js";
 export type { ContainmentGuarantee } from "./containment.js";
 export type { RootWalkDataEntry, RootWalkDataEntryKind, RootWalkDirectoryErrorBehavior, RootWalkEntry, RootWalkEntryFilter, RootWalkEntryFilterResult, RootWalkEntryKind, RootWalkLimitBehavior, RootWalkOptions, RootWalkSymlinkPolicy, } from "./root-walk.js";
 //# sourceMappingURL=root.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"root.d.ts","sourceRoot":"","sources":["../src/root.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,EACnB,kCAAkC,EAClC,IAAI,EACJ,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,IAAI,EACT,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,GACxB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,YAAY,EACV,iBAAiB,EACjB,qBAAqB,EACrB,8BAA8B,EAC9B,aAAa,EACb,mBAAmB,EACnB,yBAAyB,EACzB,iBAAiB,EACjB,qBAAqB,EACrB,eAAe,EACf,qBAAqB,GACtB,MAAM,gBAAgB,CAAC"}
+{"version":3,"file":"root.d.ts","sourceRoot":"","sources":["../src/root.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,mBAAmB,EACnB,mBAAmB,EACnB,kCAAkC,EAClC,IAAI,EACJ,KAAK,kBAAkB,EACvB,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,KAAK,oBAAoB,EACzB,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,IAAI,EACT,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,uBAAuB,EAC5B,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,WAAW,EAChB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EACzB,KAAK,gBAAgB,EACrB,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,GACxB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EAAE,0BAA0B,EAAE,MAAM,uBAAuB,CAAC;AACxE,YAAY,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AACtD,YAAY,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC5D,YAAY,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC7D,YAAY,EACV,iBAAiB,EACjB,qBAAqB,EACrB,8BAA8B,EAC9B,aAAa,EACb,mBAAmB,EACnB,yBAAyB,EACzB,iBAAiB,EACjB,qBAAqB,EACrB,eAAe,EACf,qBAAqB,GACtB,MAAM,gBAAgB,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"safe-path-segment.d.ts","sourceRoot":"","sources":["../src/safe-path-segment.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,sBAAsB,GAAG;IACnC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAKtF;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAUrD;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAaT;AAED,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,sBAA2B,GACnC,MAAM,CAUR;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,sBAA2B,GACnC,MAAM,CAWR;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,sBAA2B,GACnC,MAAM,CAeR"}
+{"version":3,"file":"safe-path-segment.d.ts","sourceRoot":"","sources":["../src/safe-path-segment.ts"],"names":[],"mappings":"AAWA,MAAM,MAAM,sBAAsB,GAAG;IACnC,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,wBAAgB,iCAAiC,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAKtF;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAUrD;AAED,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAaT;AAED,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,sBAA2B,GACnC,MAAM,CAUR;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE,sBAA2B,GACnC,MAAM,CAWR;AAED,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,sBAA2B,GACnC,MAAM,CAeR"}

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

@@ -4,12 +4,14 @@ const SAFE_DOT_PREFIX_PATH_SEGMENT_PATTERN = /^[A-Za-z0-9._-]+$/;
 // Windows treats "C:name" as relative to the drive's current directory even
 // though path.win32.isAbsolute() reports false.
 const DRIVE_RELATIVE_PREFIX = /^[A-Za-z]:(?![\\/])/;
+// A forward slash ends the segment, so "C:/file" still contains the "C:" segment.
+const DRIVE_RELATIVE_SEGMENT = /(?:^|\/)[A-Za-z]:(?!\\)/;
 const HYPHEN_CHAR_CODE = 0x2d;
 export function isDriveRelativePath(value) {
     return DRIVE_RELATIVE_PREFIX.test(value);
 }
 export function assertNoDriveRelativePathSegments(value, label) {
-    if (value.split("/").some(isDriveRelativePath)) {
+    if (DRIVE_RELATIVE_SEGMENT.test(value)) {
         throw new FsSafeError("invalid-path", `${label} must not contain a drive letter`);
     }
     return value;

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

@@ -11,6 +11,7 @@ type SecretFileWriteParams = {
     content: string | Uint8Array;
     mode?: number;
     dirMode?: number;
+    durable?: boolean;
 };
 export declare function prepareSecretFileWrite(params: Omit<SecretFileWriteParams, "content">): Promise<{
     mode: number;

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

@@ -1 +1 @@
-{"version":3,"file":"secret-file.d.ts","sourceRoot":"","sources":["../src/secret-file.ts"],"names":[],"mappings":"AAAA,OAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAK/C,OAAO,EAAkF,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAUhJ,OAAO,EAML,KAAK,qBAAqB,EAC3B,MAAM,yBAAyB,CAAC;AAIjC,eAAO,MAAM,uBAAuB,MAAQ,CAAC;AAC7C,eAAO,MAAM,wBAAwB,MAAQ,CAAC;AAE9C,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,qBAA0B,GAClC,MAAM,CAkER;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,qBAA0B,GAClC,MAAM,GAAG,SAAS,CAUpB;AA8JD,KAAK,qBAAqB,GAAG;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAYF,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,IAAI,CAAC,qBAAqB,EAAE,SAAS,CAAC,GAC7C,OAAO,CAAC;IACT,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAAC;IAC5C,WAAW,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAAC;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC,CAuBD;AAuDD,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAKxF;AAED,wBAAsB,sBAAsB,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAezF"}
+{"version":3,"file":"secret-file.d.ts","sourceRoot":"","sources":["../src/secret-file.ts"],"names":[],"mappings":"AAAA,OAAW,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAM/C,OAAO,EAAkF,KAAK,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAUhJ,OAAO,EAML,KAAK,qBAAqB,EAC3B,MAAM,yBAAyB,CAAC;AAQjC,eAAO,MAAM,uBAAuB,MAAQ,CAAC;AAC7C,eAAO,MAAM,wBAAwB,MAAQ,CAAC;AAE9C,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,qBAA0B,GAClC,MAAM,CAmER;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAC5B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,qBAA0B,GAClC,MAAM,GAAG,SAAS,CAUpB;AA8JD,KAAK,qBAAqB,GAAG;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,GAAG,UAAU,CAAC;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB,CAAC;AA+BF,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,IAAI,CAAC,qBAAqB,EAAE,SAAS,CAAC,GAC7C,OAAO,CAAC;IACT,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAAC;IAC5C,WAAW,EAAE,mBAAmB,CAAC,WAAW,CAAC,CAAC;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC,CAgCD;AAwDD,wBAAsB,qBAAqB,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAUxF;AAED,wBAAsB,sBAAsB,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAoBzF"}