@openclaw/openshell-sandbox 2026.9.4 → 2026.9.5

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

@@ -11,6 +11,7 @@ import { resolveReadOpenFlags } from "./read-open-flags.js";
 import { assertNoSymlinkParents, assertNoSymlinkParentsSync } from "./symlink-parents.js";
 import { getFsSafeTestHooks } from "./test-hooks.js";
 import { isNonRegularWriteOpenError, isNonRegularWriteOpenErrorSync, resolveNonblockingWriteFlag, } from "./write-open-flags.js";
+import { assertNoWindowsPathAlias, resolvePathPreservingWindowsRoot, } from "./windows-path-alias.js";
 export function resolveRegularFileAppendFlags(constants = fsSync.constants) {
     const noFollow = constants.O_NOFOLLOW;
     return (constants.O_CREAT |
@@ -29,6 +30,7 @@ function translateBoundedReadOverflow(error, filePath, maxBytes) {
     throw error;
 }
 export async function statRegularFile(filePath) {
+    assertNoWindowsPathAlias(filePath, "filesystem", "file path uses a Windows filesystem namespace alias");
     let stat;
     try {
         stat = fsSync.lstatSync(filePath);
@@ -45,6 +47,7 @@ export async function statRegularFile(filePath) {
     return { missing: false, stat };
 }
 export function statRegularFileSync(filePath) {
+    assertNoWindowsPathAlias(filePath, "filesystem", "file path uses a Windows filesystem namespace alias");
     let stat;
     try {
         stat = fsSync.lstatSync(filePath);
@@ -62,22 +65,24 @@ export function statRegularFileSync(filePath) {
 }
 export async function readRegularFile(params) {
     const maxBytes = normalizeMaxBytes(params.maxBytes);
-    assertNoUnsafeDeviceReadPath(params.filePath);
+    const filePath = params.filePath;
+    assertNoWindowsPathAlias(filePath, "filesystem", "file path uses a Windows filesystem namespace alias");
+    assertNoUnsafeDeviceReadPath(filePath);
     const before = await inspectFileIdentity(async () => {
-        const stat = fsSync.lstatSync(params.filePath, { bigint: true });
-        assertRegularReadStat(stat, params.filePath, true);
+        const stat = fsSync.lstatSync(filePath, { bigint: true });
+        assertRegularReadStat(stat, filePath, true);
         return stat;
-    }).catch((error) => throwReadPreviewError(error, params.filePath));
+    }).catch((error) => throwReadPreviewError(error, filePath));
     if (maxBytes !== undefined && before.size > maxBytes) {
-        throw regularFileTooLargeError(params.filePath, maxBytes);
+        throw regularFileTooLargeError(filePath, maxBytes);
     }
     let handle;
     try {
-        handle = await fs.open(params.filePath, resolveReadOpenFlags());
+        handle = await fs.open(filePath, resolveReadOpenFlags());
     }
     catch (err) {
         if (isNotFoundPathError(err)) {
-            throw new FsSafeError("path-mismatch", `File changed during read: ${params.filePath}`);
+            throw new FsSafeError("path-mismatch", `File changed during read: ${filePath}`);
         }
         throw err;
     }
@@ -85,24 +90,24 @@ export async function readRegularFile(params) {
         const stat = fsSync.fstatSync(handle.fd);
         const identity = await inspectFileIdentity(async () => {
             const exact = fsSync.fstatSync(handle.fd, { bigint: true });
-            assertRegularReadStat(exact, params.filePath);
+            assertRegularReadStat(exact, filePath);
             return exact;
         }, before);
         try {
             await inspectFileIdentity(async () => {
-                const current = fsSync.lstatSync(params.filePath, { bigint: true });
-                assertRegularReadStat(current, params.filePath);
+                const current = fsSync.lstatSync(filePath, { bigint: true });
+                assertRegularReadStat(current, filePath);
                 return current;
             }, identity);
         }
         catch (err) {
             if (isNotFoundPathError(err)) {
-                throw new FsSafeError("path-mismatch", `File changed during read: ${params.filePath}`);
+                throw new FsSafeError("path-mismatch", `File changed during read: ${filePath}`);
             }
             throw err;
         }
         if (maxBytes !== undefined && stat.size > maxBytes) {
-            throw regularFileTooLargeError(params.filePath, maxBytes);
+            throw regularFileTooLargeError(filePath, maxBytes);
         }
         // With a byte cap, avoid readFile(): a raced file growth would allocate
         // the oversized content before the post-read check could reject it.
@@ -115,7 +120,7 @@ export async function readRegularFile(params) {
         }
         catch (error) {
             if (maxBytes !== undefined) {
-                translateBoundedReadOverflow(error, params.filePath, maxBytes);
+                translateBoundedReadOverflow(error, filePath, maxBytes);
             }
             throw error;
         }
@@ -178,35 +183,37 @@ function readOpenedRegularFileSync(params) {
 }
 export function readRegularFileSync(params) {
     const maxBytes = normalizeMaxBytes(params.maxBytes);
-    assertNoUnsafeDeviceReadPath(params.filePath);
+    const filePath = params.filePath;
+    assertNoWindowsPathAlias(filePath, "filesystem", "file path uses a Windows filesystem namespace alias");
+    assertNoUnsafeDeviceReadPath(filePath);
     let before;
     try {
         before = inspectFileIdentitySync(() => {
-            const stat = fsSync.lstatSync(params.filePath, { bigint: true });
-            assertRegularReadStat(stat, params.filePath, true);
+            const stat = fsSync.lstatSync(filePath, { bigint: true });
+            assertRegularReadStat(stat, filePath, true);
             return stat;
         });
     }
     catch (error) {
-        throwReadPreviewError(error, params.filePath);
+        throwReadPreviewError(error, filePath);
     }
     if (maxBytes !== undefined && before.size > maxBytes) {
-        throw regularFileTooLargeError(params.filePath, maxBytes);
+        throw regularFileTooLargeError(filePath, maxBytes);
     }
     let fd;
     try {
-        fd = fsSync.openSync(params.filePath, resolveReadOpenFlags());
+        fd = fsSync.openSync(filePath, resolveReadOpenFlags());
     }
     catch (error) {
         if (isNotFoundPathError(error)) {
-            throw new FsSafeError("path-mismatch", `File changed during read: ${params.filePath}`);
+            throw new FsSafeError("path-mismatch", `File changed during read: ${filePath}`);
         }
         throw error;
     }
     try {
         return readOpenedRegularFileSync({
             fd,
-            filePath: params.filePath,
+            filePath,
             preOpenStat: before,
             maxBytes,
         });
@@ -231,8 +238,10 @@ function throwAppendIdentityError(error, filePath) {
     throw error;
 }
 export async function appendRegularFile(options) {
+    const filePath = options.filePath;
+    assertNoWindowsPathAlias(filePath, "filesystem", "file path uses a Windows filesystem namespace alias");
     if (options.rejectSymlinkParents === true) {
-        const resolvedDir = path.resolve(path.dirname(options.filePath));
+        const resolvedDir = resolvePathPreservingWindowsRoot(path.dirname(filePath));
         await assertNoSymlinkParents({
             rootDir: path.parse(resolvedDir).root,
             targetPath: resolvedDir,
@@ -245,12 +254,12 @@ export async function appendRegularFile(options) {
     let preOpenStat;
     try {
         preOpenStat = await inspectFileIdentity(async () => {
-            const stat = fsSync.lstatSync(options.filePath, { bigint: true });
+            const stat = fsSync.lstatSync(filePath, { bigint: true });
             if (stat.isSymbolicLink()) {
-                throw new Error(`Refusing to append through symlink: ${options.filePath}`);
+                throw new Error(`Refusing to append through symlink: ${filePath}`);
             }
             if (!stat.isFile()) {
-                throw new Error(`Refusing to append to non-file: ${options.filePath}`);
+                throw new Error(`Refusing to append to non-file: ${filePath}`);
             }
             return stat;
         });
@@ -266,15 +275,15 @@ export async function appendRegularFile(options) {
         Number(preOpenStat?.size ?? 0n) + contentBytes > options.maxFileBytes) {
         return;
     }
-    await getFsSafeTestHooks()?.beforeRegularFileAppendOpen?.(options.filePath);
+    await getFsSafeTestHooks()?.beforeRegularFileAppendOpen?.(filePath);
     const flags = resolveRegularFileAppendFlags();
     let handle;
     try {
-        handle = await fs.open(options.filePath, flags, options.mode ?? 0o600);
+        handle = await fs.open(filePath, flags, options.mode ?? 0o600);
     }
     catch (error) {
-        if (await isNonRegularWriteOpenError(error, options.filePath, flags)) {
-            throw new Error(`Refusing to append to non-file: ${options.filePath}`);
+        if (await isNonRegularWriteOpenError(error, filePath, flags)) {
+            throw new Error(`Refusing to append to non-file: ${filePath}`);
         }
         throw error;
     }
@@ -283,17 +292,17 @@ export async function appendRegularFile(options) {
         try {
             identity = await inspectFileIdentity(async () => {
                 const stat = fsSync.fstatSync(handle.fd, { bigint: true });
-                assertRegularAppendStat(stat, options.filePath);
+                assertRegularAppendStat(stat, filePath);
                 return stat;
             }, preOpenStat);
             await inspectFileIdentity(async () => {
-                const current = fsSync.lstatSync(options.filePath, { bigint: true });
-                assertRegularAppendStat(current, options.filePath);
+                const current = fsSync.lstatSync(filePath, { bigint: true });
+                assertRegularAppendStat(current, filePath);
                 return current;
             }, identity);
         }
         catch (error) {
-            throwAppendIdentityError(error, options.filePath);
+            throwAppendIdentityError(error, filePath);
         }
         if (options.maxFileBytes !== undefined &&
             Number(identity.size) + contentBytes > options.maxFileBytes) {
@@ -311,8 +320,10 @@ export async function appendRegularFile(options) {
     }
 }
 export function appendRegularFileSync(options) {
+    const filePath = options.filePath;
+    assertNoWindowsPathAlias(filePath, "filesystem", "file path uses a Windows filesystem namespace alias");
     if (options.rejectSymlinkParents === true) {
-        const resolvedDir = path.resolve(path.dirname(options.filePath));
+        const resolvedDir = resolvePathPreservingWindowsRoot(path.dirname(filePath));
         assertNoSymlinkParentsSync({
             rootDir: path.parse(resolvedDir).root,
             targetPath: resolvedDir,
@@ -325,12 +336,12 @@ export function appendRegularFileSync(options) {
     let preOpenStat;
     try {
         preOpenStat = inspectFileIdentitySync(() => {
-            const stat = fsSync.lstatSync(options.filePath, { bigint: true });
+            const stat = fsSync.lstatSync(filePath, { bigint: true });
             if (stat.isSymbolicLink()) {
-                throw new Error(`Refusing to append through symlink: ${options.filePath}`);
+                throw new Error(`Refusing to append through symlink: ${filePath}`);
             }
             if (!stat.isFile()) {
-                throw new Error(`Refusing to append to non-file: ${options.filePath}`);
+                throw new Error(`Refusing to append to non-file: ${filePath}`);
             }
             return stat;
         });
@@ -346,15 +357,15 @@ export function appendRegularFileSync(options) {
         Number(preOpenStat?.size ?? 0n) + contentBuffer.byteLength > options.maxFileBytes) {
         return;
     }
-    getFsSafeTestHooks()?.beforeRegularFileAppendOpenSync?.(options.filePath);
+    getFsSafeTestHooks()?.beforeRegularFileAppendOpenSync?.(filePath);
     const flags = resolveRegularFileAppendFlags();
     let fd;
     try {
-        fd = fsSync.openSync(options.filePath, flags, options.mode ?? 0o600);
+        fd = fsSync.openSync(filePath, flags, options.mode ?? 0o600);
     }
     catch (error) {
-        if (isNonRegularWriteOpenErrorSync(error, options.filePath, flags)) {
-            throw new Error(`Refusing to append to non-file: ${options.filePath}`);
+        if (isNonRegularWriteOpenErrorSync(error, filePath, flags)) {
+            throw new Error(`Refusing to append to non-file: ${filePath}`);
         }
         throw error;
     }
@@ -363,17 +374,17 @@ export function appendRegularFileSync(options) {
         try {
             identity = inspectFileIdentitySync(() => {
                 const stat = fsSync.fstatSync(fd, { bigint: true });
-                assertRegularAppendStat(stat, options.filePath);
+                assertRegularAppendStat(stat, filePath);
                 return stat;
             }, preOpenStat);
             inspectFileIdentitySync(() => {
-                const current = fsSync.lstatSync(options.filePath, { bigint: true });
-                assertRegularAppendStat(current, options.filePath);
+                const current = fsSync.lstatSync(filePath, { bigint: true });
+                assertRegularAppendStat(current, filePath);
                 return current;
             }, identity);
         }
         catch (error) {
-            throwAppendIdentityError(error, options.filePath);
+            throwAppendIdentityError(error, filePath);
         }
         if (options.maxFileBytes !== undefined &&
             Number(identity.size) + contentBuffer.byteLength > options.maxFileBytes) {

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

@@ -1 +1 @@
-{"version":3,"file":"replace-directory.d.ts","sourceRoot":"","sources":["../src/replace-directory.ts"],"names":[],"mappings":"AAOA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,IAAI,CAAC,CAKf"}
+{"version":3,"file":"replace-directory.d.ts","sourceRoot":"","sources":["../src/replace-directory.ts"],"names":[],"mappings":"AAUA,MAAM,MAAM,6BAA6B,GAAG;IAC1C,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,IAAI,CAAC,CAiBf"}

package/node_modules/@openclaw/fs-safe/dist/replace-directory.js

@@ -2,21 +2,29 @@ import { randomUUID } from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
 import { guardedRename, guardedRm } from "./guarded-mutation.js";
+import { recursiveMkdirPath } from "./recursive-mkdir-path.js";
 import { assertSafePathPrefix } from "./safe-path-segment.js";
+import { admitStandalonePublicationPath } from "./standalone-publication-path.js";
 import { serializePathWrite } from "./write-queue.js";
+import { assertNoWindowsPathAlias } from "./windows-path-alias.js";
 export async function replaceDirectoryAtomic(options) {
-    const targetDir = path.resolve(options.targetDir);
+    const stagedDirInput = admitStandalonePublicationPath(options.stagedDir, "staged directory uses a Windows filesystem namespace alias");
+    const targetDirInput = admitStandalonePublicationPath(options.targetDir, "target directory uses a Windows filesystem namespace alias");
+    const stagedDir = path.resolve(stagedDirInput);
+    const targetDir = path.resolve(targetDirInput);
+    assertNoWindowsPathAlias(stagedDir, "filesystem", "staged directory uses a Windows filesystem namespace alias");
+    assertNoWindowsPathAlias(targetDir, "filesystem", "target directory uses a Windows filesystem namespace alias");
+    const backupPrefixInput = options.backupPrefix;
     await serializePathWrite(targetDir, async () => {
-        await replaceDirectoryAtomicUnserialized(options, targetDir);
+        await replaceDirectoryAtomicUnserialized(stagedDir, targetDir, backupPrefixInput);
     });
 }
-async function replaceDirectoryAtomicUnserialized(options, targetDir) {
-    const stagedDir = path.resolve(options.stagedDir);
+async function replaceDirectoryAtomicUnserialized(stagedDir, targetDir, backupPrefixInput) {
     const parentDir = path.dirname(targetDir);
-    const backupPrefix = assertSafePathPrefix(options.backupPrefix ?? ".fs-safe-dir-backup-", { label: "atomic directory backup prefix" });
+    const backupPrefix = assertSafePathPrefix(backupPrefixInput ?? ".fs-safe-dir-backup-", { label: "atomic directory backup prefix" });
     const backupDir = path.join(parentDir, `${backupPrefix}${process.pid}-${randomUUID()}`);
     let backupCreated = false;
-    await fs.mkdir(parentDir, { recursive: true });
+    await fs.mkdir(recursiveMkdirPath(parentDir), { recursive: true });
     try {
         await guardedRename({ from: targetDir, to: backupDir });
         backupCreated = true;

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

@@ -1 +1 @@
-{"version":3,"file":"replace-file-copy-fallback.d.ts","sourceRoot":"","sources":["../src/replace-file-copy-fallback.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,EAAE,EAAE,KAAK,WAAW,EAAc,MAAM,SAAS,CAAC;AAO/D,MAAM,MAAM,oCAAoC,GAAG,QAAQ,CAAC;AAC5D,MAAM,MAAM,oCAAoC,GAAG,kBAAkB,GAAG,MAAM,CAAC;AAC/E,MAAM,MAAM,+BAA+B,GAAG,UAAU,GAAG,gBAAgB,CAAC;AAC5E,MAAM,MAAM,sCAAsC,GAAG;IACnD,OAAO,EAAE,+BAA+B,CAAC;CAC1C,CAAC;AAEF,KAAK,eAAe,GAAG;IACrB,KAAK,EAAE,cAAc,kBAAkB,EAAE,KAAK,CAAC;IAC/C,IAAI,EAAE,cAAc,kBAAkB,EAAE,IAAI,CAAC;IAC7C,EAAE,EAAE,cAAc,kBAAkB,EAAE,EAAE,CAAC;IACzC,MAAM,EAAE,cAAc,kBAAkB,EAAE,MAAM,CAAC;CAClD,CAAC;AAEF,KAAK,cAAc,GAAG,IAAI,CACxB,OAAO,MAAM,EACX,WAAW,GACX,WAAW,GACX,WAAW,GACX,eAAe,GACf,WAAW,GACX,UAAU,GACV,UAAU,GACV,QAAQ,GACR,YAAY,GACZ,WAAW,CACd,CAAC;AAuFF,wBAAsB,+BAA+B,CACnD,QAAQ,EAAE,eAAe,EACzB,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,oCAAoC,GAC5C,OAAO,CAAC,IAAI,CAAC,CAqBf;AAED,wBAAgB,mCAAmC,CACjD,QAAQ,EAAE,cAAc,EACxB,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,oCAAoC,GAC5C,IAAI,CAwBN;AAmID,wBAAsB,mBAAmB,CAAC,MAAM,EAAE;IAChD,QAAQ,EAAE,eAAe,CAAC;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB,CAAC,EAAE,oCAAoC,CAAC;IAC5D,OAAO,EAAE,oCAAoC,CAAC;IAC9C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,sBAAsB,CAAC,EAAE,WAAW,CAAC;IACrC,IAAI,EAAE,OAAO,CAAC;CACf,GAAG,OAAO,CAAC,IAAI,CAAC,CAwDhB;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE;IAC9C,QAAQ,EAAE,cAAc,CAAC;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB,CAAC,EAAE,oCAAoC,CAAC;IAC5D,OAAO,EAAE,oCAAoC,CAAC;IAC9C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,sBAAsB,CAAC,EAAE,WAAW,CAAC;IACrC,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAChD,IAAI,EAAE,OAAO,CAAC;CACf,GAAG,IAAI,CAkEP"}
+{"version":3,"file":"replace-file-copy-fallback.d.ts","sourceRoot":"","sources":["../src/replace-file-copy-fallback.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,EAAE,EAAE,KAAK,WAAW,EAAc,MAAM,SAAS,CAAC;AAQ/D,MAAM,MAAM,oCAAoC,GAAG,QAAQ,CAAC;AAC5D,MAAM,MAAM,oCAAoC,GAAG,kBAAkB,GAAG,MAAM,CAAC;AAC/E,MAAM,MAAM,+BAA+B,GAAG,UAAU,GAAG,gBAAgB,CAAC;AAC5E,MAAM,MAAM,sCAAsC,GAAG;IACnD,OAAO,EAAE,+BAA+B,CAAC;CAC1C,CAAC;AAEF,KAAK,eAAe,GAAG;IACrB,KAAK,EAAE,cAAc,kBAAkB,EAAE,KAAK,CAAC;IAC/C,IAAI,EAAE,cAAc,kBAAkB,EAAE,IAAI,CAAC;IAC7C,EAAE,EAAE,cAAc,kBAAkB,EAAE,EAAE,CAAC;IACzC,MAAM,EAAE,cAAc,kBAAkB,EAAE,MAAM,CAAC;CAClD,CAAC;AAEF,KAAK,cAAc,GAAG,IAAI,CACxB,OAAO,MAAM,EACX,WAAW,GACX,WAAW,GACX,WAAW,GACX,eAAe,GACf,WAAW,GACX,UAAU,GACV,UAAU,GACV,QAAQ,GACR,YAAY,GACZ,WAAW,CACd,CAAC;AAyFF,wBAAsB,+BAA+B,CACnD,QAAQ,EAAE,eAAe,EACzB,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,oCAAoC,GAC5C,OAAO,CAAC,IAAI,CAAC,CAwBf;AAED,wBAAgB,mCAAmC,CACjD,QAAQ,EAAE,cAAc,EACxB,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,oCAAoC,GAC5C,IAAI,CAwBN;AA+HD,wBAAsB,mBAAmB,CAAC,MAAM,EAAE;IAChD,QAAQ,EAAE,eAAe,CAAC;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB,CAAC,EAAE,oCAAoC,CAAC;IAC5D,OAAO,EAAE,oCAAoC,CAAC;IAC9C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,sBAAsB,CAAC,EAAE,WAAW,CAAC;IACrC,IAAI,EAAE,OAAO,CAAC;CACf,GAAG,OAAO,CAAC,IAAI,CAAC,CA4DhB;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE;IAC9C,QAAQ,EAAE,cAAc,CAAC;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB,CAAC,EAAE,oCAAoC,CAAC;IAC5D,OAAO,EAAE,oCAAoC,CAAC;IAC9C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,sBAAsB,CAAC,EAAE,WAAW,CAAC;IACrC,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAChD,IAAI,EAAE,OAAO,CAAC;CACf,GAAG,IAAI,CAkEP"}

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

@@ -1,4 +1,6 @@
 import syncFs, {} from "node:fs";
+import fs, {} from "node:fs/promises";
+import { readBoundedAsync, readBoundedSync } from "./bounded-read.js";
 import { FsSafeError } from "./errors.js";
 import { sameFileIdentity } from "./file-identity.js";
 import { readOwnedCopySource, readOwnedCopySourceSync } from "./replace-file-copy-source.js";
@@ -8,7 +10,6 @@ const NOFOLLOW = SUPPORTS_NOFOLLOW ? syncFs.constants.O_NOFOLLOW : 0;
 const OPEN_READ_FLAGS = resolveReadOpenFlags();
 const OPEN_READ_WRITE_FLAGS = syncFs.constants.O_RDWR | NOFOLLOW;
 const OPEN_WRITE_EXCLUSIVE_FLAGS = syncFs.constants.O_WRONLY | syncFs.constants.O_CREAT | syncFs.constants.O_EXCL | NOFOLLOW;
-const READ_CHUNK_BYTES = 64 * 1024;
 function notFound(error) {
     return error.code === "ENOENT";
 }
@@ -27,11 +28,15 @@ function assertPinnedDestination(pathname, opened, dest, hardlinks) {
     }
 }
 async function openPinnedDestination(fsModule, dest, hardlinks) {
-    const preview = await fsModule.lstat(dest).catch((error) => {
+    let preview;
+    try {
+        preview = fsModule === fs ? syncFs.lstatSync(dest) : await fsModule.lstat(dest);
+    }
+    catch (error) {
         if (notFound(error))
             return null;
         throw error;
-    });
+    }
     if (!preview)
         return null;
     if (preview.isSymbolicLink()) {
@@ -39,8 +44,8 @@ async function openPinnedDestination(fsModule, dest, hardlinks) {
     }
     const handle = await fsModule.open(dest, OPEN_READ_WRITE_FLAGS);
     try {
-        const opened = await handle.stat();
-        const current = await fsModule.lstat(dest);
+        const opened = fsModule === fs ? syncFs.fstatSync(handle.fd) : await handle.stat();
+        const current = fsModule === fs ? syncFs.lstatSync(dest) : await fsModule.lstat(dest);
         assertPinnedDestination(current, opened, dest, hardlinks);
         return { handle, stat: opened };
     }
@@ -76,17 +81,21 @@ function openPinnedDestinationSync(fsModule, dest, hardlinks) {
 export async function assertDestinationHardlinkPolicy(fsModule, dest, policy) {
     if (policy !== "reject")
         return;
-    const preview = await fsModule.lstat(dest).catch((error) => {
+    let preview;
+    try {
+        preview = fsModule === fs ? syncFs.lstatSync(dest) : await fsModule.lstat(dest);
+    }
+    catch (error) {
         if (notFound(error))
-            return null;
+            return;
         throw error;
-    });
+    }
     if (!preview || preview.isSymbolicLink() || !preview.isFile())
         return;
     const handle = await fsModule.open(dest, OPEN_READ_FLAGS);
     try {
-        const opened = await handle.stat();
-        const current = await fsModule.lstat(dest);
+        const opened = fsModule === fs ? syncFs.fstatSync(handle.fd) : await handle.stat();
+        const current = fsModule === fs ? syncFs.lstatSync(dest) : await fsModule.lstat(dest);
         if (current.isSymbolicLink() || !current.isFile() || !sameFileIdentity(current, opened)) {
             throw new FsSafeError("path-mismatch", `Atomic replace destination changed while opening: ${dest}`);
         }
@@ -127,37 +136,27 @@ export function assertDestinationHardlinkPolicySync(fsModule, dest, policy) {
         fsModule.closeSync(fd);
     }
 }
-async function readBounded(handle, maxBytes) {
-    const chunks = [];
+function restoreReadOptions(stat, maxBytes) {
+    return {
+        initialSize: Number.isSafeInteger(stat.size) && stat.size >= 0 ? stat.size : undefined,
+        createLimitError: () => new FsSafeError("too-large", `Atomic replace restore snapshot exceeds maxRestoreBytes (${maxBytes})`),
+    };
+}
+async function readRestoreSnapshot(handle, maxBytes, stat) {
     let position = 0;
-    while (position <= maxBytes) {
-        const buffer = Buffer.allocUnsafe(Math.min(READ_CHUNK_BYTES, maxBytes - position + 1));
-        const { bytesRead } = await handle.read(buffer, 0, buffer.length, position);
-        if (bytesRead === 0)
-            break;
+    return await readBoundedAsync(maxBytes, async (buffer, length) => {
+        const { bytesRead } = await handle.read(buffer, 0, length, position);
         position += bytesRead;
-        if (position > maxBytes) {
-            throw new FsSafeError("too-large", `Atomic replace restore snapshot exceeds maxRestoreBytes (${maxBytes})`);
-        }
-        chunks.push(buffer.subarray(0, bytesRead));
-    }
-    return Buffer.concat(chunks, position);
+        return bytesRead;
+    }, restoreReadOptions(stat, maxBytes));
 }
-function readBoundedSync(fsModule, fd, maxBytes) {
-    const chunks = [];
+function readRestoreSnapshotSync(fsModule, fd, maxBytes, stat) {
     let position = 0;
-    while (position <= maxBytes) {
-        const buffer = Buffer.allocUnsafe(Math.min(READ_CHUNK_BYTES, maxBytes - position + 1));
-        const bytesRead = fsModule.readSync(fd, buffer, 0, buffer.length, position);
-        if (bytesRead === 0)
-            break;
+    return readBoundedSync(maxBytes, (buffer, length) => {
+        const bytesRead = fsModule.readSync(fd, buffer, 0, length, position);
         position += bytesRead;
-        if (position > maxBytes) {
-            throw new FsSafeError("too-large", `Atomic replace restore snapshot exceeds maxRestoreBytes (${maxBytes})`);
-        }
-        chunks.push(buffer.subarray(0, bytesRead));
-    }
-    return Buffer.concat(chunks, position);
+        return bytesRead;
+    }, restoreReadOptions(stat, maxBytes));
 }
 async function writeAll(handle, data) {
     await handle.truncate(0);
@@ -191,9 +190,10 @@ function restoreFailure(writeError, cleanup, restoreError) {
         ? `Atomic copy fallback failed; original destination restored: ${primary.message}`
         : `Atomic copy fallback failed and original restoration failed: ${primary.message}`, { cause, details });
 }
-async function replacePinnedWithRestore(handle, replacement, maxRestoreBytes, replacementMode) {
-    const originalMode = (await handle.stat()).mode;
-    const original = await readBounded(handle, maxRestoreBytes);
+async function replacePinnedWithRestore(fsModule, handle, replacement, maxRestoreBytes, replacementMode) {
+    const originalStat = fsModule === fs ? syncFs.fstatSync(handle.fd) : await handle.stat();
+    const originalMode = originalStat.mode;
+    const original = await readRestoreSnapshot(handle, maxRestoreBytes, originalStat);
     try {
         await writeAll(handle, replacement);
         await handle.chmod(replacementMode);
@@ -215,8 +215,9 @@ async function replacePinnedWithRestore(handle, replacement, maxRestoreBytes, re
     }
 }
 function replacePinnedWithRestoreSync(fsModule, fd, replacement, maxRestoreBytes, replacementMode, fchmodSync) {
-    const originalMode = fsModule.fstatSync(fd).mode;
-    const original = readBoundedSync(fsModule, fd, maxRestoreBytes);
+    const originalStat = fsModule.fstatSync(fd);
+    const originalMode = originalStat.mode;
+    const original = readRestoreSnapshotSync(fsModule, fd, maxRestoreBytes, originalStat);
     try {
         writeAllSync(fsModule, fd, replacement);
         fchmodSync?.(fd, replacementMode);
@@ -250,15 +251,19 @@ export async function copyFallbackReplace(params) {
             const pinned = await openPinnedDestination(params.fsModule, params.dest, params.destinationHardlinks);
             if (pinned) {
                 destHandle = pinned.handle;
-                await replacePinnedWithRestore(destHandle, replacement, params.maxRestoreBytes, source.mode);
+                await replacePinnedWithRestore(params.fsModule, destHandle, replacement, params.maxRestoreBytes, source.mode);
             }
         }
         if (!destHandle) {
-            const destStat = await params.fsModule.lstat(params.dest).catch((error) => {
-                if (notFound(error))
-                    return null;
-                throw error;
-            });
+            let destStat = null;
+            try {
+                destStat = params.fsModule === fs
+                    ? syncFs.lstatSync(params.dest) : await params.fsModule.lstat(params.dest);
+            }
+            catch (error) {
+                if (!notFound(error))
+                    throw error;
+            }
             if (destStat?.isSymbolicLink()) {
                 throw new FsSafeError("symlink", `Refusing copy fallback through symlink destination: ${params.dest}`);
             }

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

@@ -1 +1 @@
-{"version":3,"file":"replace-file-copy-source.d.ts","sourceRoot":"","sources":["../src/replace-file-copy-source.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,EAAE,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAOnD,KAAK,qBAAqB,GAAG,IAAI,CAAC,cAAc,kBAAkB,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC,CAAC;AACvF,KAAK,oBAAoB,GAAG,IAAI,CAC9B,OAAO,MAAM,EACb,WAAW,GAAG,WAAW,GAAG,WAAW,GAAG,UAAU,GAAG,UAAU,CAClE,CAAC;AA0DF,wBAAsB,mBAAmB,CAAC,MAAM,EAAE;IAChD,QAAQ,EAAE,qBAAqB,CAAC;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,gBAAgB,CAAC,EAAE,WAAW,CAAC;CAChC,GAAG,OAAO,CAAC;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CA0BjD;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE;IAC9C,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,gBAAgB,CAAC,EAAE,WAAW,CAAC;CAChC,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CA8BxC"}
+{"version":3,"file":"replace-file-copy-source.d.ts","sourceRoot":"","sources":["../src/replace-file-copy-source.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,EAAE,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AAQnD,KAAK,qBAAqB,GAAG,IAAI,CAAC,cAAc,kBAAkB,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC,CAAC;AACvF,KAAK,oBAAoB,GAAG,IAAI,CAC9B,OAAO,MAAM,EACb,WAAW,GAAG,WAAW,GAAG,WAAW,GAAG,UAAU,GAAG,UAAU,CAClE,CAAC;AAqDF,wBAAsB,mBAAmB,CAAC,MAAM,EAAE;IAChD,QAAQ,EAAE,qBAAqB,CAAC;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,gBAAgB,CAAC,EAAE,WAAW,CAAC;CAChC,GAAG,OAAO,CAAC;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CA8BjD;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE;IAC9C,QAAQ,EAAE,oBAAoB,CAAC;IAC/B,GAAG,EAAE,MAAM,CAAC;IACZ,gBAAgB,CAAC,EAAE,WAAW,CAAC;CAChC,GAAG;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CA8BxC"}

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

@@ -1,10 +1,11 @@
 import syncFs, {} from "node:fs";
+import fs, {} from "node:fs/promises";
+import { readBoundedSync } from "./bounded-read.js";
 import { resolveReadOpenFlags } from "./read-open-flags.js";
 import { FsSafeError } from "./errors.js";
 import { sameFileIdentity } from "./file-identity.js";
 import { inspectFileIdentity, inspectFileIdentitySync } from "./strict-file-identity.js";
 const OPEN_READ_FLAGS = resolveReadOpenFlags();
-const READ_CHUNK_BYTES = 64 * 1024;
 function assertSourcePreview(source, src) {
     if (source.isSymbolicLink()) {
         throw new FsSafeError("symlink", `Refusing copy fallback from non-file source: ${src}`);
@@ -43,29 +44,28 @@ function openSourceSync(fsModule, src) {
         throw error;
     }
 }
-function readAllSync(fsModule, fd) {
-    const chunks = [];
+function readAllSync(fsModule, fd, size) {
     let position = 0;
-    while (true) {
-        const buffer = Buffer.allocUnsafe(READ_CHUNK_BYTES);
-        const bytesRead = fsModule.readSync(fd, buffer, 0, buffer.length, position);
-        if (bytesRead === 0)
-            break;
+    return readBoundedSync(Infinity, (buffer, length) => {
+        const bytesRead = fsModule.readSync(fd, buffer, 0, length, position);
         position += bytesRead;
-        chunks.push(buffer.subarray(0, bytesRead));
-    }
-    return Buffer.concat(chunks, position);
+        return bytesRead;
+    }, { initialSize: Number.isSafeInteger(size) && size >= 0 ? size : undefined });
 }
 export async function readOwnedCopySource(params) {
-    assertSourcePreview(await params.fsModule.lstat(params.src), params.src);
+    assertSourcePreview(params.fsModule === fs
+        ? syncFs.lstatSync(params.src) : await params.fsModule.lstat(params.src), params.src);
     const handle = await openSource(params.fsModule, params.src);
     try {
         if (params.expectedIdentity) {
-            const exact = await inspectFileIdentity(() => handle.stat({ bigint: true }), params.expectedIdentity);
-            await inspectFileIdentity(() => params.fsModule.lstat(params.src, { bigint: true }), exact);
+            const exact = await inspectFileIdentity(() => params.fsModule === fs
+                ? syncFs.fstatSync(handle.fd, { bigint: true }) : handle.stat({ bigint: true }), params.expectedIdentity);
+            await inspectFileIdentity(() => params.fsModule === fs
+                ? syncFs.lstatSync(params.src, { bigint: true }) : params.fsModule.lstat(params.src, { bigint: true }), exact);
         }
-        const opened = await handle.stat();
-        const current = await params.fsModule.lstat(params.src);
+        const opened = params.fsModule === fs ? syncFs.fstatSync(handle.fd) : await handle.stat();
+        const current = params.fsModule === fs
+            ? syncFs.lstatSync(params.src) : await params.fsModule.lstat(params.src);
         if (!opened.isFile() || current.isSymbolicLink() || !sameFileIdentity(opened, current)) {
             throw new FsSafeError("path-mismatch", `Copy fallback source changed while opening: ${params.src}`);
         }
@@ -94,7 +94,7 @@ export function readOwnedCopySourceSync(params) {
         if (opened.nlink !== 1) {
             throw new FsSafeError("hardlink", `Hardlinked copy fallback source not allowed: ${params.src}`);
         }
-        return { replacement: readAllSync(params.fsModule, fd), mode: opened.mode };
+        return { replacement: readAllSync(params.fsModule, fd, opened.size), mode: opened.mode };
     }
     finally {
         try {

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

@@ -0,0 +1,3 @@
+import type { Stats } from "node:fs";
+export declare function inheritedRegularFileMode(stat: Stats): number;
+//# sourceMappingURL=replace-file-mode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"replace-file-mode.d.ts","sourceRoot":"","sources":["../src/replace-file-mode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGrC,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,KAAK,GAAG,MAAM,CAQ5D"}

package/node_modules/@openclaw/fs-safe/dist/replace-file-mode.js

@@ -0,0 +1,10 @@
+import { FsSafeError } from "./errors.js";
+export function inheritedRegularFileMode(stat) {
+    if (stat.isSymbolicLink()) {
+        throw new FsSafeError("symlink", "atomic replace destination must not be a symbolic link");
+    }
+    if (!stat.isFile()) {
+        throw new FsSafeError("not-file", "atomic replace destination must be a regular file");
+    }
+    return stat.mode & 0o777;
+}

package/node_modules/@openclaw/fs-safe/dist/replace-file-temp-owner.d.ts

@@ -3,6 +3,7 @@ import fs, { type FileHandle } from "node:fs/promises";
 import { type AnyAsyncDirectoryGuard } from "./directory-guard.js";
 type AsyncOwnerFileSystem = Pick<typeof fs, "lstat" | "open" | "unlink">;
 type SyncOwnerFileSystem = Pick<typeof syncFs, "closeSync" | "fstatSync" | "lstatSync" | "openSync" | "readFileSync" | "unlinkSync">;
+export declare function removePathIfIdentityUnchanged(targetPath: string, identity: Pick<BigIntStats, "dev" | "ino">): Promise<void>;
 export declare function cleanupPinnedFilePath(params: {
     pathname: string;
     handle: FileHandle;

package/node_modules/@openclaw/fs-safe/dist/replace-file-temp-owner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"replace-file-temp-owner.d.ts","sourceRoot":"","sources":["../src/replace-file-temp-owner.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,EAAE,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,EAAE,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAA6B,KAAK,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAO9F,KAAK,oBAAoB,GAAG,IAAI,CAAC,OAAO,EAAE,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC,CAAC;AACzE,KAAK,mBAAmB,GAAG,IAAI,CAC7B,OAAO,MAAM,EACb,WAAW,GAAG,WAAW,GAAG,WAAW,GAAG,UAAU,GAAG,cAAc,GAAG,YAAY,CACrF,CAAC;AAgEF,wBAAsB,qBAAqB,CAAC,MAAM,EAAE;IAClD,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,WAAW,EAAE,sBAAsB,CAAC;CACrC,GAAG,OAAO,CAAC,IAAI,CAAC,CAuBhB;AA+BD,qBAAa,oBAAoB;;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAM1B,YAAY,QAAQ,EAAE,MAAM,EAG3B;IAED,KAAK,IAAI,IAAI,CAEZ;IAED,QAAQ,CAAC,UAAU,aAAc,WAAW,KAAG,IAAI,CAGjD;IAEF,KAAK,CAAC,IAAI,EAAE;QAAE,MAAM,EAAE,UAAU,CAAC;QAAC,QAAQ,EAAE,WAAW,CAAA;KAAE,GAAG,IAAI,CAG/D;IAED,IAAI,QAAQ,IAAI,WAAW,CAG1B;IAEK,aAAa,CAAC,QAAQ,EAAE,oBAAoB,EAAE,QAAQ,SAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAoB3F;IAEK,eAAe,CACnB,QAAQ,EAAE,oBAAoB,EAC9B,QAAQ,EAAE,MAAM,EAChB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,IAAI,CAAC,CA4Cf;IAED,WAAW,IAAI,IAAI,CAGlB;IAEK,MAAM,CAAC,MAAM,EAAE;QACnB,QAAQ,EAAE,oBAAoB,CAAC;QAC/B,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,mBAAmB,EAAE,OAAO,CAAC;KAC9B,GAAG,OAAO,CAAC,IAAI,CAAC,CA8BhB;CACF;AAED,qBAAa,mBAAmB;;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAM1B,YAAY,QAAQ,EAAE,MAAM,EAG3B;IAED,KAAK,IAAI,IAAI,CAEZ;IAED,QAAQ,CAAC,UAAU,aAAc,WAAW,KAAG,IAAI,CAGjD;IAEF,KAAK,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,WAAW,CAAA;KAAE,GAAG,IAAI,CAGvD;IAED,IAAI,QAAQ,IAAI,WAAW,CAG1B;IAED,aAAa,CAAC,QAAQ,EAAE,mBAAmB,EAAE,QAAQ,SAAgB,GAAG,IAAI,CAkB3E;IAED,eAAe,CACb,QAAQ,EAAE,mBAAmB,EAC7B,QAAQ,EAAE,MAAM,EAChB,YAAY,CAAC,EAAE,MAAM,GACpB,IAAI,CAgDN;IAED,WAAW,IAAI,IAAI,CAGlB;IAED,MAAM,CAAC,MAAM,EAAE;QACb,QAAQ,EAAE,mBAAmB,CAAC;QAC9B,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,mBAAmB,EAAE,OAAO,CAAC;KAC9B,GAAG,IAAI,CAgCP;CACF"}
+{"version":3,"file":"replace-file-temp-owner.d.ts","sourceRoot":"","sources":["../src/replace-file-temp-owner.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,EAAE,EAAE,KAAK,WAAW,EAAE,MAAM,SAAS,CAAC;AACnD,OAAO,EAAE,EAAE,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEvD,OAAO,EAAwD,KAAK,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAQzH,KAAK,oBAAoB,GAAG,IAAI,CAAC,OAAO,EAAE,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAC,CAAC;AACzE,KAAK,mBAAmB,GAAG,IAAI,CAC7B,OAAO,MAAM,EACb,WAAW,GAAG,WAAW,GAAG,WAAW,GAAG,UAAU,GAAG,cAAc,GAAG,YAAY,CACrF,CAAC;AAIF,wBAAsB,6BAA6B,CACjD,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,IAAI,CAAC,WAAW,EAAE,KAAK,GAAG,KAAK,CAAC,GACzC,OAAO,CAAC,IAAI,CAAC,CAOf;AA8DD,wBAAsB,qBAAqB,CAAC,MAAM,EAAE;IAClD,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,UAAU,CAAC;IACnB,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,WAAW,EAAE,sBAAsB,CAAC;CACrC,GAAG,OAAO,CAAC,IAAI,CAAC,CAuBhB;AA+BD,qBAAa,oBAAoB;;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAM1B,YAAY,QAAQ,EAAE,MAAM,EAG3B;IAED,KAAK,IAAI,IAAI,CAEZ;IAED,QAAQ,CAAC,UAAU,aAAc,WAAW,KAAG,IAAI,CAGjD;IAEF,KAAK,CAAC,IAAI,EAAE;QAAE,MAAM,EAAE,UAAU,CAAC;QAAC,QAAQ,EAAE,WAAW,CAAA;KAAE,GAAG,IAAI,CAG/D;IAED,IAAI,QAAQ,IAAI,WAAW,CAG1B;IAEK,aAAa,CAAC,QAAQ,EAAE,oBAAoB,EAAE,QAAQ,SAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAoB3F;IAEK,eAAe,CACnB,QAAQ,EAAE,oBAAoB,EAC9B,QAAQ,EAAE,MAAM,EAChB,YAAY,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,IAAI,CAAC,CA4Cf;IAED,WAAW,IAAI,IAAI,CAGlB;IAEK,MAAM,CAAC,MAAM,EAAE;QACnB,QAAQ,EAAE,oBAAoB,CAAC;QAC/B,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,mBAAmB,EAAE,OAAO,CAAC;KAC9B,GAAG,OAAO,CAAC,IAAI,CAAC,CA8BhB;CACF;AAED,qBAAa,mBAAmB;;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAM1B,YAAY,QAAQ,EAAE,MAAM,EAG3B;IAED,KAAK,IAAI,IAAI,CAEZ;IAED,QAAQ,CAAC,UAAU,aAAc,WAAW,KAAG,IAAI,CAGjD;IAEF,KAAK,CAAC,IAAI,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,WAAW,CAAA;KAAE,GAAG,IAAI,CAGvD;IAED,IAAI,QAAQ,IAAI,WAAW,CAG1B;IAED,aAAa,CAAC,QAAQ,EAAE,mBAAmB,EAAE,QAAQ,SAAgB,GAAG,IAAI,CAkB3E;IAED,eAAe,CACb,QAAQ,EAAE,mBAAmB,EAC7B,QAAQ,EAAE,MAAM,EAChB,YAAY,CAAC,EAAE,MAAM,GACpB,IAAI,CAkDN;IAED,WAAW,IAAI,IAAI,CAGlB;IAED,MAAM,CAAC,MAAM,EAAE;QACb,QAAQ,EAAE,mBAAmB,CAAC;QAC9B,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,mBAAmB,EAAE,OAAO,CAAC;KAC9B,GAAG,IAAI,CAkCP;CACF"}