@openclaw/fs-safe 0.9.0 → 0.11.0

package/dist/root-paths.js

@@ -5,6 +5,7 @@ import { formatErrorDetail } from "./error-detail.js";
 import { FsSafeError } from "./errors.js";
 import { assertNoNulPathInput, hasNodeErrorCode, isNodeError, isNotFoundPathError, isPathInside, isPathRelativeEscape, } from "./path.js";
 import { root as openRoot } from "./root.js";
+import { realpathSync } from "./realpath.js";
 function invalidPath(scopeLabel) {
     return {
         ok: false,
@@ -12,12 +13,15 @@ function invalidPath(scopeLabel) {
     };
 }
 function pathStaysWithinRoot(rootDir, candidatePath) {
+    if (process.platform !== "win32") {
+        return candidatePath !== rootDir && isPathInside(rootDir, candidatePath);
+    }
     const relative = path.relative(rootDir, candidatePath);
     return Boolean(relative) && !isPathRelativeEscape(relative);
 }
 async function resolveRealPathIfExists(targetPath) {
     try {
-        return fsSync.realpathSync.native(targetPath);
+        return realpathSync.native(targetPath);
     }
     catch {
         return undefined;
@@ -29,7 +33,7 @@ async function resolveTrustedRootRealPath(rootDir) {
         if (!rootLstat.isDirectory() || rootLstat.isSymbolicLink()) {
             return undefined;
         }
-        return fsSync.realpathSync.native(rootDir);
+        return realpathSync.native(rootDir);
     }
     catch {
         return undefined;
@@ -50,7 +54,7 @@ async function validateCanonicalPathWithinRoot(params) {
         if (params.expect === "file" && candidateLstat.nlink > 1) {
             return "invalid";
         }
-        const candidateRealPath = fsSync.realpathSync.native(params.candidatePath);
+        const candidateRealPath = realpathSync.native(params.candidatePath);
         return isPathInside(params.rootRealPath, candidateRealPath) ? "ok" : "invalid";
     }
     catch (err) {
@@ -169,9 +173,9 @@ export async function ensureDirectoryWithinRoot(params) {
             return invalidPath(scopeLabel);
         }
         await assertNoSymlinkSegments({ rootDir, targetPath, scopeLabel });
-        const rootReal = fsSync.realpathSync.native(rootDir);
+        const rootReal = realpathSync.native(rootDir);
         const nearestExistingPath = await resolveNearestExistingPath(targetPath);
-        const nearestExistingReal = fsSync.realpathSync.native(nearestExistingPath);
+        const nearestExistingReal = realpathSync.native(nearestExistingPath);
         if (!isPathInside(rootReal, nearestExistingReal)) {
             return invalidPath(scopeLabel);
         }
@@ -202,12 +206,12 @@ export async function ensureDirectoryWithinRoot(params) {
                     }
                 }
             }
-            const currentReal = fsSync.realpathSync.native(current);
+            const currentReal = realpathSync.native(current);
             if (!isPathInside(rootReal, currentReal)) {
                 return invalidPath(scopeLabel);
             }
         }
-        const targetReal = fsSync.realpathSync.native(targetPath);
+        const targetReal = realpathSync.native(targetPath);
         if (!isPathInside(rootReal, targetReal)) {
             return invalidPath(scopeLabel);
         }
@@ -309,7 +313,7 @@ async function resolveCheckedPathsWithinRoot(params, allowMissingFallback) {
             return lexicalPathResult;
         }
         try {
-            const resolvedExistingPath = fsSync.realpathSync.native(raw);
+            const resolvedExistingPath = realpathSync.native(raw);
             const relativePath = path.relative(rootRealPath, resolvedExistingPath);
             if (!isInRoot(relativePath)) {
                 return lexicalPathResult;
@@ -351,7 +355,7 @@ async function resolveCheckedPathsWithinRoot(params, allowMissingFallback) {
                         scopeLabel: params.scopeLabel,
                     });
                     const existingPath = await resolveNearestExistingPath(pathResult.fallbackPath);
-                    const existingRealPath = fsSync.realpathSync.native(existingPath);
+                    const existingRealPath = realpathSync.native(existingPath);
                     if (!isPathInside(rootRealPath, existingRealPath)) {
                         return invalidPath(params.scopeLabel);
                     }

package/dist/root-remove.d.ts

@@ -0,0 +1,5 @@
+import { type RootContext } from "./root-context.js";
+import type { RootRemoveOptions } from "./root-options.js";
+export declare function validateRemoveOptions(options: RootRemoveOptions): void;
+export declare function removePathInRootFallback(root: RootContext, targetPath: string, options: RootRemoveOptions): Promise<void>;
+//# sourceMappingURL=root-remove.d.ts.map

package/dist/root-remove.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-remove.d.ts","sourceRoot":"","sources":["../src/root-remove.ts"],"names":[],"mappings":"AAeA,OAAO,EAA6B,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAS3D,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,iBAAiB,GAAG,IAAI,CAgBtE;AA0CD,wBAAsB,wBAAwB,CAC5C,IAAI,EAAE,WAAW,EACjB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,IAAI,CAAC,CA6Lf"}

package/dist/root-remove.js

@@ -0,0 +1,286 @@
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { assertAsyncDirectoryGuard, assertSyncDirectoryGuard, createAsyncDirectoryGuard, } from "./directory-guard.js";
+import { assertMutationNotDenied } from "./deny-mutations.js";
+import { FsSafeError } from "./errors.js";
+import { sameFileIdentityForCleanup } from "./file-identity.js";
+import { MutationAuthorityError } from "./mutation-authority.js";
+import { isNotFoundPathError, isPathInside } from "./path.js";
+import { assertRootIdentityCurrent } from "./root-context.js";
+import { normalizeRemoveGuardError, normalizeRemovePathError, rootPathChangedError } from "./root-errors.js";
+import { assertFinalSymlinkRejected } from "./root-symlink-policy.js";
+import { inspectFileIdentitySync } from "./strict-file-identity.js";
+import { createSuppressedError } from "./suppressed-error.js";
+import { getFsSafeTestHooks } from "./test-hooks.js";
+const DEFAULT_MAX_ENTRIES = 100_000;
+const DEFAULT_MAX_DEPTH = 64;
+export function validateRemoveOptions(options) {
+    if (options.order !== undefined && options.order !== "filesystem" && options.order !== "sorted") {
+        throw new TypeError("remove order must be filesystem or sorted");
+    }
+    for (const key of ["maxEntries", "maxDepth"]) {
+        const value = options[key];
+        if (value !== undefined && value !== Number.POSITIVE_INFINITY && (!Number.isSafeInteger(value) || value < 0)) {
+            throw new RangeError(`${key} must be a non-negative safe integer`);
+        }
+    }
+    if (!options.recursive && (options.maxEntries !== undefined || options.maxDepth !== undefined)) {
+        throw new TypeError("remove budgets require recursive: true");
+    }
+    if (!options.recursive && options.order !== undefined) {
+        throw new TypeError("remove order requires recursive: true");
+    }
+}
+function assertNotAborted(signal) {
+    try {
+        signal?.throwIfAborted();
+    }
+    catch (error) {
+        // Preserve arbitrary abort reasons through Root's filesystem error mapping.
+        throw new MutationAuthorityError(error);
+    }
+}
+async function removeOne(root, targetPath, options) {
+    let guard;
+    try {
+        guard = await createAsyncDirectoryGuard(path.dirname(targetPath));
+    }
+    catch (error) {
+        if (options.force && isNotFoundPathError(error)) {
+            await assertRootIdentityCurrent(root);
+            assertNotAborted(options.signal);
+            return;
+        }
+        throw normalizeRemoveGuardError(error);
+    }
+    try {
+        await getFsSafeTestHooks()?.beforeRootFallbackMutation?.("remove", targetPath);
+        await assertAsyncDirectoryGuard(guard);
+    }
+    catch (error) {
+        throw normalizeRemoveGuardError(error);
+    }
+    try {
+        const isDirectory = fsSync.lstatSync(targetPath).isDirectory();
+        assertFinalSymlinkRejected(targetPath, options.mutationSymlinks !== undefined);
+        assertNotAborted(options.signal);
+        options.assertBeforeMutation?.();
+        await (isDirectory ? fs.rmdir(targetPath) : fs.unlink(targetPath));
+    }
+    catch (error) {
+        if (!(options.force && isNotFoundPathError(error)))
+            throw normalizeRemovePathError(error);
+    }
+    await assertAsyncDirectoryGuard(guard).catch(error => { throw normalizeRemoveGuardError(error); });
+    assertNotAborted(options.signal);
+}
+export async function removePathInRootFallback(root, targetPath, options) {
+    assertNotAborted(options.signal);
+    if (!options.recursive) {
+        await removeOne(root, targetPath, options);
+        return;
+    }
+    const maxEntries = options.maxEntries ?? DEFAULT_MAX_ENTRIES;
+    const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+    const details = (target, phase) => ({
+        operation: "remove",
+        phase,
+        relativePath: path.relative(targetPath, target),
+    });
+    let examined = 0;
+    const rootGuard = await createAsyncDirectoryGuard(root.rootReal, { bigint: true });
+    if (!sameFileIdentityForCleanup(rootGuard.stat, root.rootIdentity))
+        throw rootPathChangedError();
+    const guards = [rootGuard];
+    let ancestor = root.rootReal;
+    const parentRelative = path.relative(root.rootReal, path.dirname(targetPath));
+    for (const segment of parentRelative.split(path.sep).filter(Boolean)) {
+        ancestor = path.join(ancestor, segment);
+        let guard;
+        try {
+            guard = await createAsyncDirectoryGuard(ancestor, { bigint: true });
+        }
+        catch (error) {
+            if (isNotFoundPathError(error)) {
+                assertCurrent();
+                assertNotAborted(options.signal);
+                if (options.force)
+                    return;
+            }
+            throw normalizeRemoveGuardError(error);
+        }
+        if (!isPathInside(guard.realPath, ancestor) || !isPathInside(ancestor, guard.realPath)) {
+            throw new FsSafeError("path-mismatch", "removal ancestor changed during operation");
+        }
+        guards.push(guard);
+    }
+    function assertCurrent() {
+        for (const guard of guards) {
+            try {
+                assertSyncDirectoryGuard(guard);
+            }
+            catch (error) {
+                // force tolerates a vanished leaf, never a lost traversal boundary.
+                throw new FsSafeError("path-mismatch", "removal ancestor changed during operation", { cause: error });
+            }
+        }
+    }
+    const inspect = (target, expected) => {
+        assertCurrent();
+        try {
+            return inspectFileIdentitySync(() => fsSync.lstatSync(target, { bigint: true }), expected);
+        }
+        catch (error) {
+            if (options.force && isNotFoundPathError(error))
+                return;
+            throw normalizeRemovePathError(error, details(target, expected ? "remove" : "inspect"));
+        }
+    };
+    async function visit(target, depth, entryCounted = false) {
+        assertNotAborted(options.signal);
+        if ((!entryCounted && examined >= maxEntries) || depth > maxDepth) {
+            throw new FsSafeError("too-large", "recursive removal budget exceeded", {
+                details: details(target, "inspect"),
+            });
+        }
+        if (!entryCounted)
+            examined += 1;
+        await assertMutationNotDenied(target, options.denyMutations, { protectAncestors: true });
+        assertNotAborted(options.signal);
+        const initial = inspect(target);
+        if (!initial)
+            return;
+        assertFinalSymlinkRejected(target, options.mutationSymlinks !== undefined, details(target, "inspect"));
+        if (initial.isDirectory()) {
+            let directoryGuard;
+            try {
+                directoryGuard = await createAsyncDirectoryGuard(target, { bigint: true });
+            }
+            catch (error) {
+                assertCurrent();
+                assertNotAborted(options.signal);
+                if (options.force && isNotFoundPathError(error))
+                    return;
+                throw normalizeRemovePathError(error, details(target, "inspect"));
+            }
+            if (!isPathInside(directoryGuard.realPath, target) || !isPathInside(target, directoryGuard.realPath) ||
+                !sameFileIdentityForCleanup(directoryGuard.stat, initial)) {
+                throw new FsSafeError("path-mismatch", "removal directory changed during operation");
+            }
+            guards.push(directoryGuard);
+            try {
+                assertCurrent();
+                assertNotAborted(options.signal);
+                const handle = await fs.opendir(target, { bufferSize: 1 }).catch(error => {
+                    if (options.force && isNotFoundPathError(error)) {
+                        assertNotAborted(options.signal);
+                        return undefined;
+                    }
+                    throw normalizeRemovePathError(error, details(target, "enumerate"));
+                });
+                if (handle) {
+                    let failed = false;
+                    let operationError;
+                    try {
+                        let names = options.order === "sorted" ? [] : undefined;
+                        if (names && maxEntries === Infinity) {
+                            assertCurrent();
+                            assertNotAborted(options.signal);
+                            const snapshot = await fs.readdir(target).catch(error => {
+                                if (options.force && isNotFoundPathError(error))
+                                    return undefined;
+                                throw normalizeRemovePathError(error, details(target, "enumerate"));
+                            });
+                            assertNotAborted(options.signal);
+                            if (snapshot) {
+                                assertCurrent();
+                                names = snapshot;
+                                examined += names.length;
+                            }
+                        }
+                        else {
+                            while (true) {
+                                assertCurrent();
+                                assertNotAborted(options.signal);
+                                const entry = await handle.read().catch(error => {
+                                    if (options.force && isNotFoundPathError(error))
+                                        return undefined;
+                                    throw normalizeRemovePathError(error, details(target, "enumerate"));
+                                });
+                                if (entry === undefined) {
+                                    assertNotAborted(options.signal);
+                                    if (names)
+                                        names.length = 0;
+                                    break;
+                                }
+                                assertCurrent();
+                                assertNotAborted(options.signal);
+                                if (!entry)
+                                    break;
+                                if (names) {
+                                    if (examined >= maxEntries) {
+                                        throw new FsSafeError("too-large", "recursive removal budget exceeded", {
+                                            details: details(path.join(target, entry.name), "enumerate"),
+                                        });
+                                    }
+                                    examined += 1;
+                                    names.push(entry.name);
+                                }
+                                else {
+                                    await visit(path.join(target, entry.name), depth + 1);
+                                }
+                            }
+                        }
+                        if (names) {
+                            for (const name of names.sort()) {
+                                await visit(path.join(target, name), depth + 1, true);
+                            }
+                        }
+                    }
+                    catch (error) {
+                        failed = true;
+                        operationError = error instanceof MutationAuthorityError ? error.rejection : error;
+                        throw error;
+                    }
+                    finally {
+                        try {
+                            // Close before rmdir, including on Windows and after revocation.
+                            await handle.close();
+                        }
+                        catch (error) {
+                            const closeError = normalizeRemovePathError(error, details(target, "enumerate"));
+                            if (failed)
+                                throw createSuppressedError(closeError, operationError, "recursive removal and close both failed");
+                            throw closeError;
+                        }
+                    }
+                }
+            }
+            finally {
+                guards.pop();
+            }
+        }
+        // A tolerated missing-directory observation still rechecks its target and ancestors.
+        await getFsSafeTestHooks()?.beforeRootFallbackMutation?.("remove", target);
+        await assertMutationNotDenied(target, options.denyMutations, { protectAncestors: true });
+        assertNotAborted(options.signal);
+        if (!inspect(target, initial))
+            return;
+        assertFinalSymlinkRejected(target, options.mutationSymlinks !== undefined, details(target, "remove"));
+        assertNotAborted(options.signal);
+        options.assertBeforeMutation?.();
+        try {
+            await (initial.isDirectory() ? fs.rmdir(target) : fs.unlink(target));
+        }
+        catch (error) {
+            if (!(options.force && isNotFoundPathError(error))) {
+                throw normalizeRemovePathError(error, details(target, "remove"));
+            }
+        }
+        assertCurrent();
+        assertNotAborted(options.signal);
+    }
+    await assertRootIdentityCurrent(root);
+    await visit(targetPath, 0);
+}

package/dist/root-symlink-policy.d.ts

@@ -0,0 +1,14 @@
+import { type FsSafeErrorDetails } from "./errors.js";
+export type SymlinkPolicy = "reject" | "follow-within-root" | "follow-parents-within-root";
+export type MutationSymlinkPolicy = "reject" | "follow-parents-within-root";
+export declare function readSymlinkResolution(symlinks: SymlinkPolicy | undefined): {
+    rejectSymlinks: boolean;
+    rejectFinalSymlink: boolean;
+};
+export declare function mutationSymlinkResolution(symlinks: MutationSymlinkPolicy | undefined): {
+    rejectSymlinks: boolean;
+    rejectFinalSymlink: boolean;
+    resolveCanonical: boolean;
+};
+export declare function assertFinalSymlinkRejected(targetPath: string, reject: boolean | undefined, details?: FsSafeErrorDetails): void;
+//# sourceMappingURL=root-symlink-policy.d.ts.map

package/dist/root-symlink-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-symlink-policy.d.ts","sourceRoot":"","sources":["../src/root-symlink-policy.ts"],"names":[],"mappings":"AACA,OAAO,EAAe,KAAK,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAGnE,MAAM,MAAM,aAAa,GAAG,QAAQ,GAAG,oBAAoB,GAAG,4BAA4B,CAAC;AAC3F,MAAM,MAAM,qBAAqB,GAAG,QAAQ,GAAG,4BAA4B,CAAC;AAE5E,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,aAAa,GAAG,SAAS;IAErE,cAAc;IACd,kBAAkB;EAErB;AAED,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,qBAAqB,GAAG,SAAS;IAKjF,cAAc;IACd,kBAAkB;IAClB,gBAAgB;EAEnB;AAID,wBAAgB,0BAA0B,CACxC,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,OAAO,GAAG,SAAS,EAC3B,OAAO,CAAC,EAAE,kBAAkB,GAC3B,IAAI,CASN"}

package/dist/root-symlink-policy.js

@@ -0,0 +1,34 @@
+import fs from "node:fs";
+import { FsSafeError } from "./errors.js";
+import { isNotFoundPathError } from "./path.js";
+export function readSymlinkResolution(symlinks) {
+    return {
+        rejectSymlinks: symlinks !== "follow-within-root" && symlinks !== "follow-parents-within-root",
+        rejectFinalSymlink: symlinks === "follow-parents-within-root",
+    };
+}
+export function mutationSymlinkResolution(symlinks) {
+    if (symlinks !== undefined && symlinks !== "reject" && symlinks !== "follow-parents-within-root") {
+        throw new RangeError("mutationSymlinks must be reject or follow-parents-within-root");
+    }
+    return {
+        rejectSymlinks: symlinks === "reject",
+        rejectFinalSymlink: symlinks !== undefined,
+        resolveCanonical: symlinks !== undefined,
+    };
+}
+// Call after parent fences and immediately before the mutation. This is a
+// final-component check, not an atomic conditional rename against another process.
+export function assertFinalSymlinkRejected(targetPath, reject, details) {
+    if (!reject)
+        return;
+    try {
+        if (fs.lstatSync(targetPath).isSymbolicLink()) {
+            throw new FsSafeError("symlink", "final symlink not allowed", { details });
+        }
+    }
+    catch (error) {
+        if (!isNotFoundPathError(error))
+            throw error;
+    }
+}

package/dist/root-walk.d.ts

@@ -1,4 +1,5 @@
-import type { DirEntry } from "./types.js";
+import type { RootDirectoryListing, RootDirectoryListingOptions } from "./root-directory-list.js";
+import type { PathStat } from "./types.js";
 export type RootWalkSymlinkPolicy = "skip" | "follow-within-root";
 export type RootWalkLimitBehavior = "truncate" | "throw";
 export type RootWalkDirectoryErrorBehavior = "throw" | "skip-and-report";
@@ -24,6 +25,7 @@ export type RootWalkEntryFilter = (entry: RootWalkDataEntry) => RootWalkEntryFil
 export type RootWalkOptions = {
     maxDepth?: number;
     maxEntries?: number;
+    order?: "sorted" | "filesystem";
     symlinkPolicy: RootWalkSymlinkPolicy;
     signal?: AbortSignal;
     limitBehavior?: RootWalkLimitBehavior;
@@ -32,9 +34,8 @@ export type RootWalkOptions = {
 };
 type RootWalkCapability = {
     rootReal: string;
-    list(relativePath: string, options: {
-        withFileTypes: true;
-    }): Promise<DirEntry[]>;
+    stat(relativePath: string): Promise<PathStat>;
+    list(relativePath: string, options: RootDirectoryListingOptions): Promise<RootDirectoryListing>;
 };
 export declare function walkRoot(root: RootWalkCapability, relativePath: string, options: RootWalkOptions): AsyncGenerator<RootWalkEntry>;
 export {};

package/dist/root-walk.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"root-walk.d.ts","sourceRoot":"","sources":["../src/root-walk.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,oBAAoB,CAAC;AAClE,MAAM,MAAM,qBAAqB,GAAG,UAAU,GAAG,OAAO,CAAC;AACzD,MAAM,MAAM,8BAA8B,GAAG,OAAO,GAAG,iBAAiB,CAAC;AACzE,MAAM,MAAM,yBAAyB,GAAG,SAAS,GAAG,MAAM,GAAG,cAAc,CAAC;AAC5E,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,WAAW,GAAG,OAAO,CAAC;AACnE,MAAM,MAAM,iBAAiB,GAAG,qBAAqB,GAAG,iBAAiB,GAAG,WAAW,CAAC;AAExF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,qBAAqB,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,aAAa,GACrB,iBAAiB,GACjB;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE,GACpD;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,CAAC,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAE/E,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE,iBAAiB,KAAK,yBAAyB,CAAC;AAE1F,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,qBAAqB,CAAC;IACrC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,aAAa,CAAC,EAAE,qBAAqB,CAAC;IACtC,WAAW,CAAC,EAAE,mBAAmB,CAAC;IAClC,gBAAgB,CAAC,EAAE,8BAA8B,CAAC;CACnD,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE;QAAE,aAAa,EAAE,IAAI,CAAA;KAAE,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC;CACnF,CAAC;AAqBF,wBAAuB,QAAQ,CAC7B,IAAI,EAAE,kBAAkB,EACxB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,eAAe,GACvB,cAAc,CAAC,aAAa,CAAC,CAyH/B"}
+{"version":3,"file":"root-walk.d.ts","sourceRoot":"","sources":["../src/root-walk.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,oBAAoB,EAAE,2BAA2B,EAAE,MAAM,0BAA0B,CAAC;AAClG,OAAO,KAAK,EAAY,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGrD,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,oBAAoB,CAAC;AAClE,MAAM,MAAM,qBAAqB,GAAG,UAAU,GAAG,OAAO,CAAC;AACzD,MAAM,MAAM,8BAA8B,GAAG,OAAO,GAAG,iBAAiB,CAAC;AACzE,MAAM,MAAM,yBAAyB,GAAG,SAAS,GAAG,MAAM,GAAG,cAAc,CAAC;AAC5E,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,WAAW,GAAG,OAAO,CAAC;AACnE,MAAM,MAAM,iBAAiB,GAAG,qBAAqB,GAAG,iBAAiB,GAAG,WAAW,CAAC;AAExF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,qBAAqB,CAAC;IAC5B,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,MAAM,MAAM,aAAa,GACrB,iBAAiB,GACjB;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,CAAC,CAAA;CAAE,GACpD;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAC;IAAC,IAAI,EAAE,CAAC,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAAC;AAE/E,MAAM,MAAM,mBAAmB,GAAG,CAAC,KAAK,EAAE,iBAAiB,KAAK,yBAAyB,CAAC;AAE1F,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,QAAQ,GAAG,YAAY,CAAC;IAChC,aAAa,EAAE,qBAAqB,CAAC;IACrC,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB,aAAa,CAAC,EAAE,qBAAqB,CAAC;IACtC,WAAW,CAAC,EAAE,mBAAmB,CAAC;IAClC,gBAAgB,CAAC,EAAE,8BAA8B,CAAC;CACnD,CAAC;AAEF,KAAK,kBAAkB,GAAG;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAC9C,IAAI,CACF,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,oBAAoB,CAAC,CAAC;CAClC,CAAC;AAqBF,wBAAuB,QAAQ,CAC7B,IAAI,EAAE,kBAAkB,EACxB,YAAY,EAAE,MAAM,EACpB,OAAO,EAAE,eAAe,GACvB,cAAc,CAAC,aAAa,CAAC,CAqK/B"}