@vibe-agent-toolkit/utils 0.1.42 → 0.2.0-rc.1

package/dist/fs-utils.d.ts

@@ -1,6 +1,34 @@
 /**
  * Filesystem utilities
  */
+/**
+ * What one path looked like the first time this run asked.
+ *
+ * The two fields are deliberately NOT collapsed into a single `stat` result:
+ * they record the outcome of `existsSync` and of `statSync` *separately*,
+ * because callers distinguish three states and only two of them are "the stat
+ * worked". See {@link FsLookupCache.probe}.
+ */
+export interface PathProbe {
+    /** `existsSync` — follows symlinks, so a dangling link reads as absent. */
+    readonly exists: boolean;
+    /**
+     * `statSync().isDirectory()`.
+     *
+     * `null` means *no answer*, which happens two ways: the path is absent, or
+     * it exists and `statSync` threw anyway (a permission change or a delete
+     * between the two calls). Callers that must tell those apart read
+     * {@link PathProbe.exists} alongside it.
+     */
+    readonly isDirectory: boolean | null;
+}
+/** How many probes a {@link FsLookupCache} answered, and how many cost syscalls. */
+export interface PathProbeStats {
+    /** Probe calls received. */
+    readonly probes: number;
+    /** Probes that were not already memoized, i.e. that hit the filesystem. */
+    readonly misses: number;
+}
 /**
  * Per-run memo for the two filesystem lookups that validation repeats on values
  * which are constant for the whole run: `realpath` of roots, and `readdir` of the
@@ -17,20 +45,122 @@
  * arbitrarily long ago. The intended lifetime is one instance per validation run,
  * constructed as a local and collected with the run.
  *
+ * Fill first, then judge. The loop holds no `await`, because every listing the
+ * loop could have needed was already taken:
+ *
  * @example
  * ```typescript
  * const fsCache = new FsLookupCache();          // one per run
- * for (const link of links) {
- *   await verifyCaseSensitiveFilename(link.target, fsCache);
+ * const targets = links.map((link) => link.target);
+ * const siblingNames = await fillSiblingNames(targets, fsCache);  // all the I/O, once
+ * for (const target of targets) {
+ *   classifyFilenameCaseFrom(siblingNames, target);               // pure — no syscall
  * }
  * ```
  */
 export declare class FsLookupCache {
     #private;
     /**
-     * Canonical path for `targetPath`, falling back to `safePath.resolve()` when the
-     * path does not exist or cannot be resolved (a non-existent file has no realpath,
-     * and callers comparing paths still need an answer).
+     * Probe counters, for tests and `--debug` output.
+     *
+     * A memo whose tests never assert its hit count is theatre: every assertion
+     * about *values* still passes when the memo is disabled, because an
+     * always-miss cache returns the same answers — only more slowly. This is the
+     * one observable that dies when the memo does.
+     */
+    get probeStats(): PathProbeStats;
+    /**
+     * Does this path exist, and is it a directory — asked once per run.
+     *
+     * **Both syscalls are preserved, in order, exactly as an uncached caller
+     * would make them.** `existsSync` then `statSync` is not the same as one
+     * `statSync`: the pair distinguishes "absent" from "present but unstattable",
+     * and the link walker's classifier branches differently on each. Collapsing
+     * them would be a behaviour change wearing the shape of an optimization, so
+     * this method deduplicates the pair rather than replacing it.
+     *
+     * Synchronous, unlike this class's other two lookups, because its caller (the
+     * skill link-graph walker) is synchronous throughout. One oracle answering
+     * both shapes beats a second class that differs only in colour.
+     *
+     * @param targetPath - Path to probe
+     * @returns The recorded existence/kind pair
+     */
+    probe(targetPath: string): PathProbe;
+    /**
+     * Canonical path for `targetPath`. A path that cannot be canonicalized is
+     * answered from its **deepest existing ancestor** — that ancestor's realpath
+     * with the missing remainder re-appended — because a non-existent file has no
+     * realpath and callers comparing paths still need an answer.
+     *
+     * ⚠️ **The fallback must stay in the same NAMESPACE as the success path, which
+     * a lexical `safePath.resolve()` is not.** The only consumer of this column
+     * compares one canonical path against another (`isWithinProject` /
+     * `isWithinProjectFrom`), so an answer resolved lexically is being compared
+     * against an answer resolved through symlinks. Where the root traverses a
+     * symlink — macOS `/tmp → /private/tmp`, bind mounts, a worktree under a
+     * symlinked path — the two spellings differ and the comparison is nonsense.
+     * Measured truth table for `isWithinProject(file, root)` under a `link → real`
+     * root, before the walk:
+     *
+     * ```text
+     * existing file, symlinked root : true
+     * MISSING  file, symlinked root : false  ← lexical fallback, wrong namespace
+     * MISSING  file, plain root     : true
+     * symlink inside pointing out   : false  (correct either way)
+     * ```
+     *
+     * The middle row is user-visible: a merely BROKEN root-absolute markdown link
+     * was reported as *escaping the project*. The walk fixes it without widening
+     * containment, because the ancestor is exactly where an escaping symlink
+     * lives — a missing file behind a directory link that points outside still
+     * canonicalizes outside.
+     *
+     * The recursion goes through `this.realpath(parent)`, not a private helper, so
+     * ancestors land in the same memo and share in-flight promises. A missing
+     * file's parent directory is almost always already cached, so the common case
+     * costs no extra syscall. **The fixpoint guard is mandatory**: `path.dirname`
+     * is idempotent at a root (`'/'` on posix, `'C:/'` for a drive, `'//server/share/'`
+     * for a UNC share), so without it the walk never terminates.
+     *
+     * Errno is deliberately not inspected. EACCES on an existing file and ELOOP on
+     * a symlink cycle land in the same catch as ENOENT, and for all three the
+     * ancestor's namespace is a strictly better answer than the lexical one.
+     *
+     * ⚠️ **`promisify(nodeFs.realpath)` — NOT `fs/promises.realpath`. Node ships two
+     * different realpaths and they do not agree.** `fs.realpathSync` and the
+     * `fs.realpath` *callback* form run Node's own JS implementation: an
+     * lstat/readlink walk that preserves the casing you asked for. `fs/promises.realpath`
+     * and `fs.realpath.native` call `uv_fs_realpath` (`realpath(3)` /
+     * `GetFinalPathNameByHandleW`), which reports the casing **on disk**. On a
+     * case-insensitive filesystem — macOS and Windows — those are different strings,
+     * and this column feeds *synchronous* judges that previously called
+     * `fs.realpathSync` themselves. A column that does not match `realpathSync` byte
+     * for byte flips containment verdicts and emits findings the un-refactored code
+     * does not. Measured, Node v24.13.1 / darwin, disk holding `<B>/Sub/Target.TXT`,
+     * asked for `<B>/sub/target.txt`:
+     *
+     * ```text
+     * realpathSync           : <B>/sub/target.txt   ← the contract
+     * promisify(fs.realpath) : <B>/sub/target.txt   ✅ matches (this call)
+     * fs/promises.realpath   : <B>/Sub/Target.TXT   ❌ on-disk casing
+     * fs.realpath.native     : <B>/Sub/Target.TXT   ❌ on-disk casing
+     * ```
+     *
+     * They also disagree on `''`, where the sync form resolves to the cwd and the
+     * native form throws `ENOENT`. **Do not "modernize" this back to `fs/promises`** —
+     * it reads tidier and silently changes output. `packages/utils/test/fs-utils.test.ts`
+     * → *"answers a mis-cased path exactly as realpathSync does, not as the native
+     * resolver does"* pins the equivalence (and skips itself on a case-sensitive
+     * filesystem, where the two routes cannot be told apart).
+     *
+     * `promisify` is applied **per call, on the default object**, not once at module
+     * scope: an eagerly captured function bypasses any `vi.spyOn(nodeFs, 'realpath')`
+     * installed after import, so this method's I/O would count zero — indistinguishable
+     * from performing none. (`fs.realpath` carries no `util.promisify.custom`, so this
+     * promisification really does get the JS implementation; it is verified, not
+     * assumed — see *"routes canonicalization through the node:fs default object"*.)
+     * The wrapper is allocated only on a cache MISS, i.e. once per actual syscall.
      *
      * @param targetPath - Path to canonicalize
      * @returns Canonical path with forward slashes on every platform
@@ -57,39 +187,268 @@ export declare class FsLookupCache {
  */
 export declare function copyDirectory(src: string, dest: string): Promise<void>;
 /**
- * Verify that a file exists with the exact case-sensitive filename.
+ * The one fact on disk that a case-sensitivity question turns on: what the
+ * parent directory actually contains, paired with the name being asked about.
+ *
+ * A row, not an answer — {@link classifyFilenameCase} turns it into a verdict.
+ * Splitting the two is what lets the verdict be tested against listings that no
+ * filesystem will hand you on demand, entry ORDER in particular.
+ */
+export interface SiblingNames {
+    /**
+     * Basename being asked about, i.e. `path.basename(filePath)` — **verbatim, in
+     * whatever Unicode normalization form the path carries**. Nothing folds it on
+     * the way in; {@link classifyFilenameCase} owns every comparison rule there is.
+     */
+    readonly expectedName: string;
+    /**
+     * The parent directory's entry names **exactly as `readdir` returned them**,
+     * or `null` when it could not be read. Raw, unfolded bytes — which is what
+     * makes "this link only resolves after normalization" a question the judge can
+     * still answer. See {@link classifyFilenameCase}.
+     *
+     * `null` is not `[]` — an unreadable or absent directory versus a readable
+     * empty one. {@link classifyFilenameCase} deliberately collapses them (both
+     * are "no such entry"), but the distinction is kept in the row because it is
+     * a *fact*, and the judge that wants it — a check that says "the directory
+     * itself is missing" rather than "the file is missing" — cannot recover it
+     * once the fill has thrown it away.
+     */
+    readonly names: readonly string[] | null;
+}
+/**
+ * The materialized listing column: parent directory → that directory's entry
+ * names, or `null` when it could not be read.
+ *
+ * `null` carries exactly the meaning {@link SiblingNames.names} documents — an
+ * unreadable or absent directory, which is *not* the same fact as a readable
+ * empty one (`[]`), even though {@link classifyFilenameCase} collapses the two
+ * into one verdict.
  *
- * On case-insensitive filesystems (Windows, macOS), a file might be found even if
- * the case doesn't match. This function checks that the actual filename on disk
- * matches the requested path exactly (case-sensitive).
+ * A *missing key* is a third thing again, and never a legal input to judgement:
+ * see {@link siblingNamesFrom}.
+ */
+export type SiblingNamesTable = ReadonlyMap<string, readonly string[] | null>;
+/**
+ * List the parent directory of every path in `filePaths` — the only place I/O is
+ * legal for this fact, and the pass that must run *before* any judging.
  *
- * Answering requires listing the target's parent directory. Callers checking many
- * paths (every link in a corpus) hit the same handful of directories over and over,
- * so the listing comes from a caller-supplied {@link FsLookupCache}.
+ * ⚠️ **It takes FILE paths, not directory paths, deliberately.** It derives each
+ * parent with `path.dirname` itself, so exactly one function in the system owns
+ * the key derivation and a caller cannot construct a key that
+ * {@link siblingNamesFrom} then misses. Do not "simplify" this to take
+ * directories: that hands the derivation back to every call site and reopens the
+ * silent-miss class this shape closes.
  *
- * The cache parameter is **required rather than defaulted on purpose**: a default
- * would let an unmigrated call site silently keep the un-memoized behaviour, which
- * is a no-op wearing the shape of a fix. `new FsLookupCache()` per call reproduces
- * the old behaviour exactly, so migrating is mechanical — but it has to be a
- * decision someone made.
+ * Distinct parents are listed **concurrently**: the shape this replaced asked one
+ * link at a time at judgement time, which serialised every `readdir` behind the
+ * previous link's `await`. De-duplication is by parent, so N files in one
+ * directory cost one listing; the listing itself goes through
+ * {@link FsLookupCache.readdir}, which memoizes and shares in-flight promises
+ * across fills.
  *
- * @param filePath - Absolute path to the file to verify
+ * @param filePaths - File paths whose parent directories should be listed
  * @param fsCache - Per-run lookup cache (one instance per validation run)
- * @returns Object with exists flag and actual filename (or null if not found)
+ * @returns The filled table; empty input yields an empty table with no syscalls
+ */
+export declare function fillSiblingNames(filePaths: Iterable<string>, fsCache: FsLookupCache): Promise<SiblingNamesTable>;
+/**
+ * Read the row for `filePath` out of an already-filled table. Pure.
  *
- * @example
- * ```typescript
- * // On case-insensitive filesystem with file "README.md"
- * const fsCache = new FsLookupCache();
- * const result1 = await verifyCaseSensitiveFilename('/project/README.md', fsCache);
- * // { exists: true, actualName: 'README.md' }
+ * **A miss throws rather than degrading to `names: null`.** The fill set is
+ * derived from exactly the paths the judge will be asked about, so a missing
+ * parent is a programming error — a path judged that nobody filled. The `null`
+ * fallback would answer it as "the directory is unreadable", which reports every
+ * file under that directory as *missing*: a wrong answer wearing the shape of a
+ * graceful degradation, and one no test of the verdict would catch.
  *
- * const result2 = await verifyCaseSensitiveFilename('/project/readme.md', fsCache);
- * // { exists: false, actualName: 'README.md' } - case mismatch!
- * ```
+ * Internal on purpose — {@link classifyFilenameCaseFrom} is the public judge.
+ *
+ * @param table - Table filled by {@link fillSiblingNames}
+ * @param filePath - Path being asked about
+ * @returns The row: the expected basename plus the parent's entries
+ * @throws If `table` holds no entry for the path's parent directory
+ */
+export declare function siblingNamesFrom(table: SiblingNamesTable, filePath: string): SiblingNames;
+/**
+ * Which pass of {@link classifyFilenameCase} produced the answer.
+ *
+ * The three that are not `absent` are ordered by how faithfully the asked-for
+ * spelling matches disk, and every consumer that reports to a human needs the
+ * distinction: only `exact` opens on every filesystem.
  */
-export declare function verifyCaseSensitiveFilename(filePath: string, fsCache: FsLookupCache): Promise<{
+export type FilenameMatch = 
+/** The asked-for name and a directory entry are the same bytes. Opens anywhere. */
+'exact'
+/**
+ * They are different bytes that are equal after Unicode NFC folding — the same
+ * visible filename in two normalization forms. Opens on macOS/APFS and
+ * Windows; **does not open on a byte-exact filesystem** (Linux/ext4, i.e. CI
+ * and most deploy targets), where the two forms simply name different files.
+ */
+ | 'normalized'
+/** They differ by letter case (after folding). Opens only on a case-insensitive filesystem. */
+ | 'case_mismatch'
+/** Nothing in the listing matches, or the directory could not be read. */
+ | 'absent';
+/** What {@link classifyFilenameCase} decided about one asked-for filename. */
+export interface FilenameCaseVerdict {
+    /**
+     * Whether the name resolves to an entry at all — `true` for both `exact` and
+     * `normalized`, i.e. exactly where the author's own machine opens the file.
+     * Derivable from {@link FilenameCaseVerdict.match}; kept because "does this
+     * path resolve" is the question most callers are actually asking.
+     */
     exists: boolean;
+    /**
+     * The entry actually on disk, **verbatim as `readdir` returned it**, or
+     * `null` when nothing matched. Raw rather than folded on purpose: this is the
+     * string a caller suggests writing, and a folded reconstruction of an NFD
+     * entry is a spelling that does not open the file on Linux.
+     */
     actualName: string | null;
-}>;
+    /** Which pass matched. See {@link FilenameMatch}. */
+    match: FilenameMatch;
+}
+/**
+ * Decide whether `row.expectedName` names a real entry, and how faithfully.
+ *
+ * Pure: no filesystem, no cache, no path parsing — it reads only the columns it
+ * is handed, which is what makes hand-written listings a legitimate test input.
+ * Both columns arrive **raw**, exactly as `readdir` and `path.basename` produced
+ * them; this function owns every comparison rule, so nothing upstream can
+ * disagree with it about what "the same filename" means.
+ *
+ * **Three passes, strictly in this order, first match wins — the order IS the
+ * contract**, because each pass accepts a strictly weaker notion of sameness and
+ * a weaker pass reached first would mislabel a file that is genuinely there:
+ *
+ * 1. **byte-exact** `entry === expectedName`. On a case-insensitive filesystem a
+ *    listing can hold both `readme.md` and `README.md`, in either order; asking
+ *    for `README.md` must report it present regardless of which one `readdir`
+ *    happened to return first. Same argument, one form weaker, for pass 2.
+ * 2. **NFC-folded** `toNfc(entry) === toNfc(expectedName)`. `é` has two encodings
+ *    (NFC `U+00E9` vs NFD `e` + `U+0301`) that are `!==` and that case-folding
+ *    does not reconcile, so without this pass an accented file that plainly
+ *    exists was reported flatly *missing* — not even a case-mismatch hint, since
+ *    that needs pass 3 to match (ledger entry D7).
+ * 3. **case-insensitive, on the folded forms.** Folding first is required, not
+ *    tidy: `toLowerCase()` does not reconcile NFC against NFD, so a name that
+ *    differs in *both* case and normalization falls out as `absent` and the
+ *    author loses the suggestion.
+ *
+ * ⚠️ **Passes 1 and 2 are not the same verdict, and collapsing them is a
+ * silently-wrong answer rather than a lost nicety.** The fix for D7 originally
+ * folded both sides *before* comparing, which repaired the false "missing" on
+ * macOS/APFS — and over-corrected into the opposite error on Linux/ext4, where
+ * the filesystem is byte-exact: a markdown link spelling a filename NFD while
+ * disk holds NFC genuinely 404s there, and the folded judge answered "exists,
+ * exact match, no issue". `match` is what keeps both facts: the link resolves
+ * (so it must not be reported broken), *and* it resolves only by folding (so a
+ * caller can warn). {@link classifyFilenameCaseFrom}'s consumer in
+ * `@vibe-agent-toolkit/resources` turns `'normalized'` into
+ * `LINK_NORMALIZATION_MISMATCH`.
+ *
+ * **Folding is deferred to the miss path, and that is a real saving.** Pass 1
+ * calls `toNfc` zero times, so a corpus whose links all resolve byte-exactly —
+ * every pure-ASCII corpus, i.e. nearly all of them — normalizes nothing at all.
+ * The older shape folded every entry of every directory in the fill,
+ * unconditionally.
+ *
+ * @param row - The listing row, read out of a filled table by {@link siblingNamesFrom}
+ * @returns The verdict: whether it resolves, the entry really on disk, and which pass matched
+ */
+export declare function classifyFilenameCase(row: SiblingNames): FilenameCaseVerdict;
+/**
+ * Judge `filePath` against an already-filled {@link SiblingNamesTable}.
+ *
+ * This is the judging half of the two-pass shape: {@link fillSiblingNames} does
+ * every listing first, then this runs over as many paths as you like with no
+ * interleaved I/O.
+ *
+ * **The signature is not what keeps this free of I/O — a test is.** `fs-utils.ts`
+ * imports `node:fs` and `node:fs/promises` at module scope, so this function's
+ * module reaches the filesystem freely; taking no {@link FsLookupCache} and no
+ * `fs` parameter constrains a future edit not at all, which could call
+ * `nodeFs.statSync` on the next line and still typecheck. What actually holds the
+ * property is `packages/utils/test/fs-utils.test.ts` →
+ * *"judges from a filled table, reaching neither readdir nor the sync stat pair"*:
+ * it spies `fs.readdir`, `nodeFs.existsSync` and `nodeFs.statSync` on the very
+ * default objects this module imports, drives a positive control through each so
+ * a zero cannot mean "the instrument never attached", and asserts the counts do
+ * not move across judgement. If a future check needs another fact about the parent
+ * directory, widen the *table* rather than reaching for `fs` here — and expect
+ * that test, not this signature, to be what stops you.
+ *
+ * @param table - Table filled by {@link fillSiblingNames}
+ * @param filePath - Absolute path to judge
+ * @returns The verdict — see {@link FilenameCaseVerdict}
+ * @throws If `table` holds no entry for the path's parent directory — see
+ *   {@link siblingNamesFrom}
+ */
+export declare function classifyFilenameCaseFrom(table: SiblingNamesTable, filePath: string): FilenameCaseVerdict;
+/**
+ * The materialized realpath column: path → its canonical path.
+ *
+ * Every filled row is a string — never `null`, never `undefined`.
+ * {@link FsLookupCache.realpath} answers a path it cannot canonicalize from that
+ * path's deepest existing ancestor rather than failing, because a path that does
+ * not exist has no realpath and a caller comparing paths still needs an answer.
+ * That fallback IS the contract, and it is what lets `undefined` out of this map
+ * mean exactly one thing: *absent key*. See {@link realpathFrom}.
+ */
+export type RealpathTable = ReadonlyMap<string, string>;
+/**
+ * Canonicalize every path in `paths` — the only place I/O is legal for this
+ * fact, and the pass that must run *before* any judging.
+ *
+ * ⚠️ **Rows are keyed by the input path string exactly as given** — not a
+ * dirname, not a re-resolved form. {@link realpathFrom} looks that same string
+ * up, so any normalization applied here and not there is a silent miss (a loud
+ * one, in fact: the judge throws). Contrast {@link fillSiblingNames}, which keys
+ * by `path.dirname` *because* many files share one listing; here the answer is
+ * per path, so the path is the key.
+ *
+ * Distinct paths are canonicalized **concurrently**: the shape this replaces
+ * asked one path at a time at judgement time, which serialised every `realpath`
+ * behind the previous path's `await`. De-duplication is by path, so the same
+ * path passed N times costs one syscall; the call itself goes through
+ * {@link FsLookupCache.realpath}, which memoizes and shares in-flight promises
+ * across fills.
+ *
+ * @param paths - Paths to canonicalize
+ * @param fsCache - Per-run lookup cache (one instance per validation run)
+ * @returns The filled table; empty input yields an empty table with no syscalls
+ */
+export declare function fillRealpaths(paths: Iterable<string>, fsCache: FsLookupCache): Promise<RealpathTable>;
+/**
+ * Read the canonical path for `filePath` out of an already-filled table. Pure.
+ *
+ * **A miss throws rather than degrading to a recomputed realpath.** The fill set
+ * is derived from exactly the paths the judge will be asked about, so a missing
+ * key is a programming error — a path judged that nobody filled. Recomputing it
+ * would answer *correctly* and silently reintroduce the per-path syscall this
+ * column exists to remove: a regression no test of the verdict could catch,
+ * because the verdict would be identical, only slower.
+ *
+ * Public, unlike {@link siblingNamesFrom}: a sibling-names row is not yet an
+ * answer (it still needs {@link classifyFilenameCase}), whereas here the row IS
+ * the answer — so this lookup is itself the judge for this column, and there is
+ * nothing left to keep internal.
+ *
+ * **The signature is not what keeps this free of I/O — a test is.** As with
+ * {@link classifyFilenameCaseFrom}, this module imports `node:fs` and
+ * `node:fs/promises` at module scope, so withholding a {@link FsLookupCache} from
+ * the parameter list prevents nothing. The guard is
+ * `packages/utils/test/fs-utils.test.ts` → *"judges from a filled table, reaching
+ * neither the async nor the sync realpath"*, which spies `nodeFs.realpath` and
+ * `nodeFs.realpathSync` on the module default objects, proves both instruments
+ * attached with a positive control, and asserts zero calls across judgement.
+ *
+ * @param table - Table filled by {@link fillRealpaths}
+ * @param filePath - Path being asked about, as it was handed to the fill
+ * @returns The canonical path, with forward slashes on every platform
+ * @throws If `table` holds no row for `filePath`
+ */
+export declare function realpathFrom(table: RealpathTable, filePath: string): string;
 //# sourceMappingURL=fs-utils.d.ts.map

package/dist/fs-utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fs-utils.d.ts","sourceRoot":"","sources":["../src/fs-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,aAAa;;IAOxB;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAe7C;;;;;;;OAOG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC;CASnD;AAED;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAgB5E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAsB,2BAA2B,CAC/C,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAgCzD"}
+{"version":3,"file":"fs-utils.d.ts","sourceRoot":"","sources":["../src/fs-utils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAmBH;;;;;;;GAOG;AACH,MAAM,WAAW,SAAS;IACxB,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB;;;;;;;OAOG;IACH,QAAQ,CAAC,WAAW,EAAE,OAAO,GAAG,IAAI,CAAC;CACtC;AAED,oFAAoF;AACpF,MAAM,WAAW,cAAc;IAC7B,4BAA4B;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,2EAA2E;IAC3E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,aAAa;;IAcxB;;;;;;;OAOG;IACH,IAAI,UAAU,IAAI,cAAc,CAE/B;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS;IAyBpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6EG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAyC7C;;;;;;;OAOG;IACH,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,GAAG,IAAI,CAAC;CASnD;AAED;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAgB5E;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;CAC1C;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC,CAAC;AAE9E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,EAC3B,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,iBAAiB,CAAC,CA8B5B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,CAiBzF;AAED;;;;;;GAMG;AACH,MAAM,MAAM,aAAa;AACvB,mFAAmF;AACjF,OAAO;AACT;;;;;GAKG;GACD,YAAY;AACd,+FAA+F;GAC7F,eAAe;AACjB,0EAA0E;GACxE,QAAQ,CAAC;AAEb,8EAA8E;AAC9E,MAAM,WAAW,mBAAmB;IAClC;;;;;OAKG;IACH,MAAM,EAAE,OAAO,CAAC;IAChB;;;;;OAKG;IACH,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,qDAAqD;IACrD,KAAK,EAAE,aAAa,CAAC;CACtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,YAAY,GAAG,mBAAmB,CAoC3E;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,iBAAiB,EACxB,QAAQ,EAAE,MAAM,GACf,mBAAmB,CAErB;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,EACvB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,aAAa,CAAC,CAWxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAa3E"}