@cursor/bdk 0.2.9 → 0.2.10

package/dist/filesystem.js

@@ -1,48 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
-    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-};
-var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
-    var i, p;
-    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
-    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
-};
 import { Buffer } from "node:buffer";
 import { mkdir, readdir, readFile, rm, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
@@ -58,7 +13,7 @@ import { isExcludedPath, listFilesFromPaths, mergeSortedByPath, statFromFilePath
  * `ListRepoPaths` from `/repo`. Smaller than Origin's 10k default
  * so a recursive listing does not materialize a huge response.
  */
-export const FILE_SYSTEM_SCAN_LIMIT = 1000;
+export const FILE_SYSTEM_SCAN_LIMIT = 1_000;
 export const FILE_SYSTEM_TOOL_NAMES = [
     "Read",
     "LS",
@@ -300,7 +255,7 @@ function compileGrepPattern(pattern, caseInsensitive, path = "/") {
     try {
         return new RegExp(pattern, caseInsensitive === true ? "i" : undefined);
     }
-    catch (_a) {
+    catch {
         throw new InvalidGrepPatternError(pattern, path);
     }
 }
@@ -319,34 +274,19 @@ function normalizeMaxResults(maxResults) {
     }
     return Math.max(0, Math.floor(maxResults));
 }
-function limitResults(source, maxResults) {
-    return __asyncGenerator(this, arguments, function* limitResults_1() {
-        var _a, e_1, _b, _c;
-        const cap = normalizeMaxResults(maxResults);
-        if (cap === 0) {
-            return yield __await(void 0);
-        }
-        let n = 0;
-        try {
-            for (var _d = true, source_1 = __asyncValues(source), source_1_1; source_1_1 = yield __await(source_1.next()), _a = source_1_1.done, !_a; _d = true) {
-                _c = source_1_1.value;
-                _d = false;
-                const item = _c;
-                yield yield __await(item);
-                n++;
-                if (cap !== undefined && n >= cap) {
-                    return yield __await(void 0);
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (!_d && !_a && (_b = source_1.return)) yield __await(_b.call(source_1));
-            }
-            finally { if (e_1) throw e_1.error; }
+async function* limitResults(source, maxResults) {
+    const cap = normalizeMaxResults(maxResults);
+    if (cap === 0) {
+        return;
+    }
+    let n = 0;
+    for await (const item of source) {
+        yield item;
+        n++;
+        if (cap !== undefined && n >= cap) {
+            return;
         }
-    });
+    }
 }
 function grepPushdownLimit(query, opts) {
     // Count and files_with_matches paginate after grouping by file.
@@ -374,65 +314,53 @@ function compareSearchResult(left, right) {
     }
     return left.path < right.path ? -1 : left.path > right.path ? 1 : 0;
 }
-export function collectGrepMatches(root, query, opts) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, e_2, _b, _c;
-        const matches = [];
-        const offset = opts.offset !== undefined && opts.offset > 0 ? opts.offset : 0;
-        const headLimit = opts.headLimit !== undefined && opts.headLimit > 0 ? opts.headLimit : undefined;
-        const skippedFiles = new Set();
-        const acceptedFiles = new Set();
-        let skippedItems = 0;
-        let takenItems = 0;
-        const pushdown = grepPushdownLimit(query, Object.assign({ outputMode: opts.outputMode, offset }, (opts.headLimit === undefined ? {} : { headLimit: opts.headLimit })));
-        const grepQuery = pushdown === undefined ? query : Object.assign(Object.assign({}, query), { maxResults: pushdown });
-        try {
-            for (var _d = true, _e = __asyncValues(root.grep(grepQuery)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                _c = _f.value;
-                _d = false;
-                const match = _c;
-                if (opts.outputMode === "content") {
-                    if (skippedItems < offset) {
-                        skippedItems++;
-                        continue;
-                    }
-                    matches.push(match);
-                    takenItems++;
-                    if (headLimit !== undefined && takenItems >= headLimit) {
-                        break;
-                    }
-                    continue;
-                }
-                if (skippedFiles.has(match.path)) {
-                    continue;
-                }
-                if (!acceptedFiles.has(match.path)) {
-                    if (skippedItems < offset) {
-                        skippedFiles.add(match.path);
-                        skippedItems++;
-                        continue;
-                    }
-                    if (headLimit !== undefined && takenItems >= headLimit) {
-                        break;
-                    }
-                    acceptedFiles.add(match.path);
-                    takenItems++;
-                }
-                matches.push(match);
+export async function collectGrepMatches(root, query, opts) {
+    const matches = [];
+    const offset = opts.offset !== undefined && opts.offset > 0 ? opts.offset : 0;
+    const headLimit = opts.headLimit !== undefined && opts.headLimit > 0 ? opts.headLimit : undefined;
+    const skippedFiles = new Set();
+    const acceptedFiles = new Set();
+    let skippedItems = 0;
+    let takenItems = 0;
+    const pushdown = grepPushdownLimit(query, {
+        outputMode: opts.outputMode,
+        offset,
+        ...(opts.headLimit === undefined ? {} : { headLimit: opts.headLimit }),
+    });
+    const grepQuery = pushdown === undefined ? query : { ...query, maxResults: pushdown };
+    for await (const match of root.grep(grepQuery)) {
+        if (opts.outputMode === "content") {
+            if (skippedItems < offset) {
+                skippedItems++;
+                continue;
             }
+            matches.push(match);
+            takenItems++;
+            if (headLimit !== undefined && takenItems >= headLimit) {
+                break;
+            }
+            continue;
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+        if (skippedFiles.has(match.path)) {
+            continue;
+        }
+        if (!acceptedFiles.has(match.path)) {
+            if (skippedItems < offset) {
+                skippedFiles.add(match.path);
+                skippedItems++;
+                continue;
             }
-            finally { if (e_2) throw e_2.error; }
+            if (headLimit !== undefined && takenItems >= headLimit) {
+                break;
+            }
+            acceptedFiles.add(match.path);
+            takenItems++;
         }
-        return matches;
-    });
+        matches.push(match);
+    }
+    return matches;
 }
 export function shapeGrepUnion(matches, outputMode) {
-    var _a;
     if (outputMode === "files_with_matches") {
         const files = [...new Set(matches.map(match => match.path))];
         return { type: "files", output: { files, count: files.length } };
@@ -440,7 +368,7 @@ export function shapeGrepUnion(matches, outputMode) {
     if (outputMode === "count") {
         const counts = new Map();
         for (const match of matches) {
-            counts.set(match.path, ((_a = counts.get(match.path)) !== null && _a !== void 0 ? _a : 0) + 1);
+            counts.set(match.path, (counts.get(match.path) ?? 0) + 1);
         }
         return {
             type: "count",
@@ -453,7 +381,13 @@ export function shapeGrepUnion(matches, outputMode) {
     return {
         type: "content",
         output: {
-            matches: matches.map(match => (Object.assign(Object.assign({ file: match.path, lineNumber: match.lineNumber, line: match.line }, (match.beforeContext === undefined ? {} : { beforeContext: match.beforeContext })), (match.afterContext === undefined ? {} : { afterContext: match.afterContext })))),
+            matches: matches.map(match => ({
+                file: match.path,
+                lineNumber: match.lineNumber,
+                line: match.line,
+                ...(match.beforeContext === undefined ? {} : { beforeContext: match.beforeContext }),
+                ...(match.afterContext === undefined ? {} : { afterContext: match.afterContext }),
+            })),
             totalMatches: matches.length,
         },
     };
@@ -528,28 +462,26 @@ export function virtualWorkspaceWritePath(relativePath) {
     }
     return dest;
 }
-export function writeWorkspaceFilesToRoot(root, files) {
-    return __awaiter(this, void 0, void 0, function* () {
-        for (const [relativePath, contents] of Object.entries(files)) {
-            // Refuse escapes, then write the sanitized relative dest so
-            // `localFileSystem` joins against cwd and `tempFs` still normalizes
-            // `a.txt` → `/a.txt`. Never forward an absolute host path.
-            const dest = virtualWorkspaceWritePath(relativePath);
-            const relativeDest = dest.replace(/^\//, "");
-            if (relativeDest === "") {
-                throw new FileSystemConfigError(`Refusing to write the virtual root: ${relativePath}`);
-            }
-            const fileText = typeof contents === "string"
-                ? contents
-                : Buffer.from(contents.data, "base64").toString("utf8");
-            try {
-                yield root.write(relativeDest, fileText);
-            }
-            catch (error) {
-                throw new FileSystemConfigError(`workspaceFiles failed to write ${relativePath}: ${error instanceof Error ? error.message : "write failed"}`);
-            }
+export async function writeWorkspaceFilesToRoot(root, files) {
+    for (const [relativePath, contents] of Object.entries(files)) {
+        // Refuse escapes, then write the sanitized relative dest so
+        // `localFileSystem` joins against cwd and `tempFs` still normalizes
+        // `a.txt` → `/a.txt`. Never forward an absolute host path.
+        const dest = virtualWorkspaceWritePath(relativePath);
+        const relativeDest = dest.replace(/^\//, "");
+        if (relativeDest === "") {
+            throw new FileSystemConfigError(`Refusing to write the virtual root: ${relativePath}`);
         }
-    });
+        const fileText = typeof contents === "string"
+            ? contents
+            : Buffer.from(contents.data, "base64").toString("utf8");
+        try {
+            await root.write(relativeDest, fileText);
+        }
+        catch (error) {
+            throw new FileSystemConfigError(`workspaceFiles failed to write ${relativePath}: ${error instanceof Error ? error.message : "write failed"}`);
+        }
+    }
 }
 function replaceLiteral(args) {
     if (args.replaceAll) {
@@ -607,22 +539,20 @@ function applyExactEdit(args) {
  * this helper's contract; FileSystem implementations do not
  * implement edit. Native StrReplace calls this.
  */
-export function strReplaceOnFileSystem(root, query) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const existing = yield root.read(query.path);
-        if (typeof existing !== "string") {
-            throw new EditError(query.path, `${query.path} is not text`);
-        }
-        const applied = applyExactEdit({
-            existing,
-            oldText: query.oldText,
-            newText: query.newText,
-            replaceAll: query.replaceAll === true,
-            path: query.path,
-        });
-        yield root.write(query.path, applied.contents);
-        return { occurrencesModified: applied.occurrencesModified };
+export async function strReplaceOnFileSystem(root, query) {
+    const existing = await root.read(query.path);
+    if (typeof existing !== "string") {
+        throw new EditError(query.path, `${query.path} is not text`);
+    }
+    const applied = applyExactEdit({
+        existing,
+        oldText: query.oldText,
+        newText: query.newText,
+        replaceAll: query.replaceAll === true,
+        path: query.path,
     });
+    await root.write(query.path, applied.contents);
+    return { occurrencesModified: applied.occurrencesModified };
 }
 /** Native Read offset/limit: 1-indexed, negative offset counts from the end. */
 export function sliceReadContent(content, offset, limit) {
@@ -631,14 +561,14 @@ export function sliceReadContent(content, offset, limit) {
     }
     const lines = content === "" ? [] : content.split("\n");
     const total = lines.length;
-    const effectiveOffset = offset !== null && offset !== void 0 ? offset : 1;
-    const effectiveLimit = limit !== null && limit !== void 0 ? limit : (effectiveOffset < 0 ? Math.abs(effectiveOffset) : total);
+    const effectiveOffset = offset ?? 1;
+    const effectiveLimit = limit ?? (effectiveOffset < 0 ? Math.abs(effectiveOffset) : total);
     const startIndex = effectiveOffset < 0 ? Math.max(0, total + effectiveOffset) : Math.max(0, effectiveOffset - 1);
     const endIndex = Math.min(total, startIndex + effectiveLimit);
     return lines.slice(startIndex, endIndex).join("\n");
 }
-function emptySearch(_query) { return __asyncGenerator(this, arguments, function* emptySearch_1() { }); }
-function emptyStream() { return __asyncGenerator(this, arguments, function* emptyStream_1() { }); }
+async function* emptySearch(_query) { }
+async function* emptyStream() { }
 /**
  * A FileSystem with no files. Use as an overlay leaf or a missing
  * catalog so a miss stays {@link FileNotFoundError} instead of
@@ -649,32 +579,22 @@ export function emptyFs() {
     return {
         list: () => emptyStream(),
         glob: () => emptyStream(),
-        grep(query) {
-            return __asyncGenerator(this, arguments, function* grep_1() {
-                compileGrepPattern(query.pattern, query.caseInsensitive, query.path === undefined || query.path === "" ? "/" : normalizeFsPath(query.path));
-                yield __await(yield* __asyncDelegator(__asyncValues(emptyStream())));
-            });
+        async *grep(query) {
+            compileGrepPattern(query.pattern, query.caseInsensitive, query.path === undefined || query.path === "" ? "/" : normalizeFsPath(query.path));
+            yield* emptyStream();
         },
         search: emptySearch,
-        stat(path) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return statFromFilePaths([], path);
-            });
+        async stat(path) {
+            return statFromFilePaths([], path);
         },
-        read(path) {
-            return __awaiter(this, void 0, void 0, function* () {
-                throw new FileNotFoundError(normalizeFsPath(path));
-            });
+        async read(path) {
+            throw new FileNotFoundError(normalizeFsPath(path));
         },
-        write(path) {
-            return __awaiter(this, void 0, void 0, function* () {
-                throw new ReadOnlyMountError(normalizeFsPath(path));
-            });
+        async write(path) {
+            throw new ReadOnlyMountError(normalizeFsPath(path));
         },
-        delete(path) {
-            return __awaiter(this, void 0, void 0, function* () {
-                throw new ReadOnlyMountError(normalizeFsPath(path));
-            });
+        async delete(path) {
+            throw new ReadOnlyMountError(normalizeFsPath(path));
         },
     };
 }
@@ -697,109 +617,84 @@ export function tempFs(files = {}) {
                 size: typeof content === "string" ? content.length : content.byteLength,
             })), prefix, options);
         },
-        stat(path) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return statFromFilePaths(store.keys(), path);
-            });
+        async stat(path) {
+            return statFromFilePaths(store.keys(), path);
         },
     };
     return {
         list(prefix, options) {
             return listed.list(prefix, options);
         },
-        stat(path) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return listed.stat(path);
-            });
+        async stat(path) {
+            return listed.stat(path);
         },
-        read(inputPath) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const path = normalizeFsPath(inputPath);
-                const content = store.get(path);
-                if (content === undefined) {
-                    throw new FileNotFoundError(path);
-                }
-                return content;
-            });
+        async read(inputPath) {
+            const path = normalizeFsPath(inputPath);
+            const content = store.get(path);
+            if (content === undefined) {
+                throw new FileNotFoundError(path);
+            }
+            return content;
         },
-        grep(query) {
-            return __asyncGenerator(this, arguments, function* grep_2() {
-                yield __await(yield* __asyncDelegator(__asyncValues(limitResults(uncapped(), query.maxResults))));
-                function uncapped() {
-                    return __asyncGenerator(this, arguments, function* uncapped_1() {
-                        var _a, e_3, _b, _c;
-                        const regex = compileGrepPattern(query.pattern, query.caseInsensitive, query.path === undefined || query.path === "" ? "/" : normalizeFsPath(query.path));
-                        const scope = query.path === undefined || query.path === "" ? "/" : normalizeFsPath(query.path);
-                        const exact = store.get(scope);
-                        if (scope !== "/" && exact !== undefined) {
-                            if (query.glob !== undefined &&
-                                !pathMatchesGlob(scope, scope, query.glob, {
-                                    matchBasename: true,
-                                })) {
-                                return yield __await(void 0);
-                            }
-                            if (isExcludedPath(scope, query.excludes)) {
-                                return yield __await(void 0);
-                            }
-                            yield __await(yield* __asyncDelegator(__asyncValues(grepFileContent({
-                                path: scope,
-                                content: fileSystemText(exact),
-                                regex,
-                            }))));
-                            return yield __await(void 0);
-                        }
-                        try {
-                            for (var _d = true, _e = __asyncValues(listed.list(scope === "/" ? undefined : scope, query.excludes === undefined ? undefined : { excludes: query.excludes })), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
-                                _c = _f.value;
-                                _d = false;
-                                const entry = _c;
-                                if (query.glob !== undefined &&
-                                    !pathMatchesGlob(entry.path, scope, query.glob, {
-                                        matchBasename: true,
-                                    })) {
-                                    continue;
-                                }
-                                const content = store.get(entry.path);
-                                if (content === undefined) {
-                                    continue;
-                                }
-                                yield __await(yield* __asyncDelegator(__asyncValues(grepFileContent({
-                                    path: entry.path,
-                                    content: fileSystemText(content),
-                                    regex,
-                                }))));
-                            }
-                        }
-                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                        finally {
-                            try {
-                                if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
-                            }
-                            finally { if (e_3) throw e_3.error; }
-                        }
+        async *grep(query) {
+            yield* limitResults(uncapped(), query.maxResults);
+            async function* uncapped() {
+                const regex = compileGrepPattern(query.pattern, query.caseInsensitive, query.path === undefined || query.path === "" ? "/" : normalizeFsPath(query.path));
+                const scope = query.path === undefined || query.path === "" ? "/" : normalizeFsPath(query.path);
+                const exact = store.get(scope);
+                if (scope !== "/" && exact !== undefined) {
+                    if (query.glob !== undefined &&
+                        !pathMatchesGlob(scope, scope, query.glob, {
+                            matchBasename: true,
+                        })) {
+                        return;
+                    }
+                    if (isExcludedPath(scope, query.excludes)) {
+                        return;
+                    }
+                    yield* grepFileContent({
+                        path: scope,
+                        content: fileSystemText(exact),
+                        regex,
                     });
+                    return;
                 }
-            });
+                for await (const entry of listed.list(scope === "/" ? undefined : scope, query.excludes === undefined ? undefined : { excludes: query.excludes })) {
+                    if (query.glob !== undefined &&
+                        !pathMatchesGlob(entry.path, scope, query.glob, {
+                            matchBasename: true,
+                        })) {
+                        continue;
+                    }
+                    const content = store.get(entry.path);
+                    if (content === undefined) {
+                        continue;
+                    }
+                    yield* grepFileContent({
+                        path: entry.path,
+                        content: fileSystemText(content),
+                        regex,
+                    });
+                }
+            }
         },
-        glob(pattern, dir, options) {
-            return __asyncGenerator(this, arguments, function* glob_1() {
-                const scope = dir === undefined || dir === "" ? "/" : normalizeFsPath(dir);
-                yield __await(yield* __asyncDelegator(__asyncValues(globFromList(listed.list(scope === "/" ? undefined : scope), Object.assign({ pattern, dir: scope }, ((options === null || options === void 0 ? void 0 : options.limit) === undefined ? {} : { limit: options.limit }))))));
+        async *glob(pattern, dir, options) {
+            const scope = dir === undefined || dir === "" ? "/" : normalizeFsPath(dir);
+            yield* globFromList(listed.list(scope === "/" ? undefined : scope), {
+                pattern,
+                dir: scope,
+                ...(options?.limit === undefined ? {} : { limit: options.limit }),
             });
         },
-        write(inputPath, contents) {
-            return __awaiter(this, void 0, void 0, function* () {
-                store.set(normalizeFsPath(inputPath), contents);
-            });
+        async write(inputPath, contents) {
+            store.set(normalizeFsPath(inputPath), contents);
         },
-        delete(inputPath) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const path = normalizeFsPath(inputPath);
-                if (!store.has(path)) {
-                    throw new FileNotFoundError(path);
-                }
-                store.delete(path);
-            });
+        async delete(inputPath) {
+            const path = normalizeFsPath(inputPath);
+            if (!store.has(path)) {
+                throw new FileNotFoundError(path);
+            }
+            store.delete(path);
         },
         search: emptySearch,
     };
@@ -813,48 +708,44 @@ function throwLocalReadError(error, filePath) {
 function skipWalkDir(name) {
     return name === ".git" || name === "node_modules";
 }
-function walkLocalFiles(rootDir) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const found = [];
-        const stack = [rootDir];
-        while (stack.length > 0) {
-            const current = stack.pop();
-            if (current === undefined) {
-                break;
-            }
-            let entries;
-            try {
-                entries = yield readdir(current, { withFileTypes: true });
-            }
-            catch (_a) {
-                continue;
-            }
-            for (const entry of entries) {
-                const full = path.join(current, entry.name);
-                // Same as the pre-root host walk and native LS/Glob/Grep: Dirent
-                // isDirectory/isFile do not follow links, so workspace `memory/`
-                // and other symlinks are not enumerated. Exact-path read/stat still
-                // follow.
-                if (entry.isDirectory()) {
-                    if (!skipWalkDir(entry.name)) {
-                        stack.push(full);
-                    }
-                }
-                else if (entry.isFile()) {
-                    found.push(full);
+async function walkLocalFiles(rootDir) {
+    const found = [];
+    const stack = [rootDir];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (current === undefined) {
+            break;
+        }
+        let entries;
+        try {
+            entries = await readdir(current, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const full = path.join(current, entry.name);
+            // Same as the pre-root host walk and native LS/Glob/Grep: Dirent
+            // isDirectory/isFile do not follow links, so workspace `memory/`
+            // and other symlinks are not enumerated. Exact-path read/stat still
+            // follow.
+            if (entry.isDirectory()) {
+                if (!skipWalkDir(entry.name)) {
+                    stack.push(full);
                 }
             }
+            else if (entry.isFile()) {
+                found.push(full);
+            }
         }
-        found.sort((left, right) => left.localeCompare(right));
-        return found;
-    });
+    }
+    found.sort((left, right) => left.localeCompare(right));
+    return found;
 }
-function listLocalFiles(rootDir) {
-    return __asyncGenerator(this, arguments, function* listLocalFiles_1() {
-        for (const filePath of yield __await(walkLocalFiles(rootDir))) {
-            yield yield __await({ path: filePath });
-        }
-    });
+async function* listLocalFiles(rootDir) {
+    for (const filePath of await walkLocalFiles(rootDir)) {
+        yield { path: filePath };
+    }
 }
 /**
  * Host-disk FileSystem. Relative paths resolve against `cwd`; absolute
@@ -867,128 +758,100 @@ export function localFileSystem(options) {
     const cwd = path.resolve(options.cwd);
     const resolvePath = (input) => path.isAbsolute(input) ? path.resolve(input) : path.resolve(cwd, input);
     return {
-        list(prefix, options) {
-            return __asyncGenerator(this, arguments, function* list_1() {
-                yield __await(yield* __asyncDelegator(__asyncValues(limitResults(uncapped(), options === null || options === void 0 ? void 0 : options.limit))));
-                function uncapped() {
-                    return __asyncGenerator(this, arguments, function* uncapped_2() {
-                        var _a, e_4, _b, _c;
-                        const dirPath = prefix === undefined || prefix === "" || prefix === "." ? cwd : resolvePath(prefix);
-                        try {
-                            for (var _d = true, _e = __asyncValues(listLocalFiles(dirPath)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
-                                _c = _f.value;
-                                _d = false;
-                                const entry = _c;
-                                if (!isExcludedPath(entry.path, options === null || options === void 0 ? void 0 : options.excludes)) {
-                                    yield yield __await(entry);
-                                }
-                            }
-                        }
-                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-                        finally {
-                            try {
-                                if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
-                            }
-                            finally { if (e_4) throw e_4.error; }
-                        }
-                    });
+        async *list(prefix, options) {
+            yield* limitResults(uncapped(), options?.limit);
+            async function* uncapped() {
+                const dirPath = prefix === undefined || prefix === "" || prefix === "." ? cwd : resolvePath(prefix);
+                for await (const entry of listLocalFiles(dirPath)) {
+                    if (!isExcludedPath(entry.path, options?.excludes)) {
+                        yield entry;
+                    }
                 }
-            });
+            }
         },
-        stat(probePath) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const filePath = resolvePath(probePath);
-                try {
-                    const info = yield stat(filePath);
-                    return { kind: info.isDirectory() ? "directory" : "file" };
-                }
-                catch (_a) {
-                    return { kind: "missing" };
+        async stat(probePath) {
+            const filePath = resolvePath(probePath);
+            try {
+                const info = await stat(filePath);
+                return { kind: info.isDirectory() ? "directory" : "file" };
+            }
+            catch {
+                return { kind: "missing" };
+            }
+        },
+        async read(inputPath) {
+            const filePath = resolvePath(inputPath);
+            try {
+                const bytes = await readFile(filePath);
+                if (detectImageMimeType(bytes, filePath) !== undefined) {
+                    return new Uint8Array(bytes);
                 }
-            });
+                return bytes.toString("utf8");
+            }
+            catch (error) {
+                throwLocalReadError(error, filePath);
+            }
         },
-        read(inputPath) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const filePath = resolvePath(inputPath);
+        async *grep(query) {
+            yield* limitResults(uncapped(), query.maxResults);
+            async function* uncapped() {
+                const searchRoot = resolvePath(query.path ?? cwd);
+                const regex = compileGrepPattern(query.pattern, query.caseInsensitive, searchRoot);
+                let filesToSearch;
                 try {
-                    const bytes = yield readFile(filePath);
-                    if (detectImageMimeType(bytes, filePath) !== undefined) {
-                        return new Uint8Array(bytes);
-                    }
-                    return bytes.toString("utf8");
+                    const info = await stat(searchRoot);
+                    filesToSearch = info.isFile() ? [searchRoot] : await walkLocalFiles(searchRoot);
                 }
                 catch (error) {
-                    throwLocalReadError(error, filePath);
+                    throwLocalReadError(error, searchRoot);
                 }
-            });
-        },
-        grep(query) {
-            return __asyncGenerator(this, arguments, function* grep_3() {
-                yield __await(yield* __asyncDelegator(__asyncValues(limitResults(uncapped(), query.maxResults))));
-                function uncapped() {
-                    return __asyncGenerator(this, arguments, function* uncapped_3() {
-                        var _a;
-                        const searchRoot = resolvePath((_a = query.path) !== null && _a !== void 0 ? _a : cwd);
-                        const regex = compileGrepPattern(query.pattern, query.caseInsensitive, searchRoot);
-                        let filesToSearch;
-                        try {
-                            const info = yield __await(stat(searchRoot));
-                            filesToSearch = info.isFile() ? [searchRoot] : yield __await(walkLocalFiles(searchRoot));
-                        }
-                        catch (error) {
-                            throwLocalReadError(error, searchRoot);
-                        }
-                        for (const filePath of filesToSearch) {
-                            if (query.glob !== undefined &&
-                                !pathMatchesGlob(filePath, searchRoot, query.glob, {
-                                    matchBasename: true,
-                                })) {
-                                continue;
-                            }
-                            if (isExcludedPath(filePath, query.excludes)) {
-                                continue;
-                            }
-                            let content;
-                            try {
-                                content = yield __await(readFile(filePath, "utf8"));
-                            }
-                            catch (_b) {
-                                continue;
-                            }
-                            yield __await(yield* __asyncDelegator(__asyncValues(grepFileContent({ path: filePath, content, regex }))));
-                        }
-                    });
+                for (const filePath of filesToSearch) {
+                    if (query.glob !== undefined &&
+                        !pathMatchesGlob(filePath, searchRoot, query.glob, {
+                            matchBasename: true,
+                        })) {
+                        continue;
+                    }
+                    if (isExcludedPath(filePath, query.excludes)) {
+                        continue;
+                    }
+                    let content;
+                    try {
+                        content = await readFile(filePath, "utf8");
+                    }
+                    catch {
+                        continue;
+                    }
+                    yield* grepFileContent({ path: filePath, content, regex });
                 }
-            });
+            }
         },
-        glob(pattern, dir, options) {
-            return __asyncGenerator(this, arguments, function* glob_2() {
-                const dirPath = dir === undefined || dir === "" || dir === "." ? cwd : resolvePath(dir);
-                yield __await(yield* __asyncDelegator(__asyncValues(globFromList(listLocalFiles(dirPath), Object.assign({ pattern, dir: dirPath }, ((options === null || options === void 0 ? void 0 : options.limit) === undefined ? {} : { limit: options.limit }))))));
+        async *glob(pattern, dir, options) {
+            const dirPath = dir === undefined || dir === "" || dir === "." ? cwd : resolvePath(dir);
+            yield* globFromList(listLocalFiles(dirPath), {
+                pattern,
+                dir: dirPath,
+                ...(options?.limit === undefined ? {} : { limit: options.limit }),
             });
         },
-        write(inputPath, contents) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const filePath = resolvePath(inputPath);
-                try {
-                    yield mkdir(path.dirname(filePath), { recursive: true });
-                    yield writeFile(filePath, contents, "utf8");
-                }
-                catch (error) {
-                    throw new WriteFailedError(filePath, fsErrorMessage(error, `write failed: ${filePath}`));
-                }
-            });
+        async write(inputPath, contents) {
+            const filePath = resolvePath(inputPath);
+            try {
+                await mkdir(path.dirname(filePath), { recursive: true });
+                await writeFile(filePath, contents, "utf8");
+            }
+            catch (error) {
+                throw new WriteFailedError(filePath, fsErrorMessage(error, `write failed: ${filePath}`));
+            }
         },
-        delete(inputPath) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const filePath = resolvePath(inputPath);
-                try {
-                    yield rm(filePath);
-                }
-                catch (error) {
-                    throwLocalReadError(error, filePath);
-                }
-            });
+        async delete(inputPath) {
+            const filePath = resolvePath(inputPath);
+            try {
+                await rm(filePath);
+            }
+            catch (error) {
+                throwLocalReadError(error, filePath);
+            }
         },
         search: emptySearch,
     };
@@ -1028,80 +891,35 @@ function toParentPath(path, prefix) {
     }
     return path.startsWith("/") ? `${prefix}${path}` : `${prefix}/${path}`;
 }
-function mapMountEntries(source, prefix) {
-    return __asyncGenerator(this, arguments, function* mapMountEntries_1() {
-        var _a, e_5, _b, _c;
-        try {
-            try {
-                for (var _d = true, source_2 = __asyncValues(source), source_2_1; source_2_1 = yield __await(source_2.next()), _a = source_2_1.done, !_a; _d = true) {
-                    _c = source_2_1.value;
-                    _d = false;
-                    const entry = _c;
-                    yield yield __await(Object.assign(Object.assign({}, entry), { path: toParentPath(entry.path, prefix) }));
-                }
-            }
-            catch (e_5_1) { e_5 = { error: e_5_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = source_2.return)) yield __await(_b.call(source_2));
-                }
-                finally { if (e_5) throw e_5.error; }
-            }
-        }
-        catch (error) {
-            throw remapPathError(error, prefix);
+async function* mapMountEntries(source, prefix) {
+    try {
+        for await (const entry of source) {
+            yield { ...entry, path: toParentPath(entry.path, prefix) };
         }
-    });
+    }
+    catch (error) {
+        throw remapPathError(error, prefix);
+    }
 }
-function mapMountGrep(source, prefix) {
-    return __asyncGenerator(this, arguments, function* mapMountGrep_1() {
-        var _a, e_6, _b, _c;
-        try {
-            try {
-                for (var _d = true, source_3 = __asyncValues(source), source_3_1; source_3_1 = yield __await(source_3.next()), _a = source_3_1.done, !_a; _d = true) {
-                    _c = source_3_1.value;
-                    _d = false;
-                    const hit = _c;
-                    yield yield __await(Object.assign(Object.assign({}, hit), { path: toParentPath(hit.path, prefix) }));
-                }
-            }
-            catch (e_6_1) { e_6 = { error: e_6_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = source_3.return)) yield __await(_b.call(source_3));
-                }
-                finally { if (e_6) throw e_6.error; }
-            }
-        }
-        catch (error) {
-            throw remapPathError(error, prefix);
+async function* mapMountGrep(source, prefix) {
+    try {
+        for await (const hit of source) {
+            yield { ...hit, path: toParentPath(hit.path, prefix) };
         }
-    });
+    }
+    catch (error) {
+        throw remapPathError(error, prefix);
+    }
 }
-function mapMountSearch(source, prefix) {
-    return __asyncGenerator(this, arguments, function* mapMountSearch_1() {
-        var _a, e_7, _b, _c;
-        try {
-            try {
-                for (var _d = true, source_4 = __asyncValues(source), source_4_1; source_4_1 = yield __await(source_4.next()), _a = source_4_1.done, !_a; _d = true) {
-                    _c = source_4_1.value;
-                    _d = false;
-                    const hit = _c;
-                    yield yield __await(Object.assign(Object.assign({}, hit), { path: toParentPath(hit.path, prefix) }));
-                }
-            }
-            catch (e_7_1) { e_7 = { error: e_7_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = source_4.return)) yield __await(_b.call(source_4));
-                }
-                finally { if (e_7) throw e_7.error; }
-            }
-        }
-        catch (error) {
-            throw remapPathError(error, prefix);
+async function* mapMountSearch(source, prefix) {
+    try {
+        for await (const hit of source) {
+            yield { ...hit, path: toParentPath(hit.path, prefix) };
         }
-    });
+    }
+    catch (error) {
+        throw remapPathError(error, prefix);
+    }
 }
 function childSearchQuery(query, prefix) {
     if (query.targetDirectories === undefined || query.targetDirectories.length === 0) {
@@ -1112,21 +930,21 @@ function childSearchQuery(query, prefix) {
         const normalized = normalizeFsPath(dir);
         // `/` is every mount, the same way grep at `/` fans out.
         if (normalized === "/") {
-            return Object.assign(Object.assign({}, query), { targetDirectories: undefined });
+            return { ...query, targetDirectories: undefined };
         }
         if (!pathHasSegmentPrefix({ path: normalized, prefix })) {
             continue;
         }
         const child = toChildPath(normalized, prefix);
         if (child === "/") {
-            return Object.assign(Object.assign({}, query), { targetDirectories: undefined });
+            return { ...query, targetDirectories: undefined };
         }
         dirs.push(child);
     }
     if (dirs.length === 0) {
         return undefined;
     }
-    return Object.assign(Object.assign({}, query), { targetDirectories: dirs });
+    return { ...query, targetDirectories: dirs };
 }
 /**
  * Longest-prefix compose, path-segment match. Every verb is
@@ -1159,161 +977,125 @@ export function unionFs(mounts) {
     const noMount = (path) => {
         throw new NoMountError(path);
     };
-    const forward = (path, run) => __awaiter(this, void 0, void 0, function* () {
+    const forward = async (path, run) => {
         const mount = longestMount(path, entries);
         if (mount === undefined) {
             return noMount(path);
         }
         const childPath = toChildPath(path, mount.prefix);
         try {
-            return yield run(mount.fs, childPath);
+            return await run(mount.fs, childPath);
         }
         catch (error) {
             throw remapPathError(error, mount.prefix);
         }
-    });
+    };
     const isRootPath = (value) => value === undefined || value === "" || value === "/";
     return {
-        list(prefix, options) {
-            return __asyncGenerator(this, arguments, function* list_2() {
-                yield __await(yield* __asyncDelegator(__asyncValues(limitResults(uncapped(), options === null || options === void 0 ? void 0 : options.limit))));
-                function uncapped() {
-                    return __asyncGenerator(this, arguments, function* uncapped_4() {
-                        if (isRootPath(prefix)) {
-                            yield __await(yield* __asyncDelegator(__asyncValues(mergeSortedByPath(entries.map(mount => mapMountEntries(mount.fs.list(undefined, options), mount.prefix)), { unique: true }))));
-                            return yield __await(void 0);
-                        }
-                        const path = normalizeFsPath(prefix !== null && prefix !== void 0 ? prefix : "/");
-                        const mount = longestMount(path, entries);
-                        if (mount === undefined) {
-                            return yield __await(void 0);
-                        }
-                        const childPath = toChildPath(path, mount.prefix);
-                        yield __await(yield* __asyncDelegator(__asyncValues(mapMountEntries(mount.fs.list(childPath === "/" ? undefined : childPath, options), mount.prefix))));
-                    });
-                }
-            });
-        },
-        stat(path) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const normalized = normalizeFsPath(path);
-                if (normalized === "/") {
-                    return { kind: "directory" };
+        async *list(prefix, options) {
+            yield* limitResults(uncapped(), options?.limit);
+            async function* uncapped() {
+                if (isRootPath(prefix)) {
+                    yield* mergeSortedByPath(entries.map(mount => mapMountEntries(mount.fs.list(undefined, options), mount.prefix)), { unique: true });
+                    return;
                 }
-                if (entries.some(entry => entry.prefix === normalized)) {
-                    return { kind: "directory" };
-                }
-                const mount = longestMount(normalized, entries);
+                const path = normalizeFsPath(prefix ?? "/");
+                const mount = longestMount(path, entries);
                 if (mount === undefined) {
-                    return { kind: "missing" };
+                    return;
                 }
-                return mount.fs.stat(toChildPath(normalized, mount.prefix));
-            });
+                const childPath = toChildPath(path, mount.prefix);
+                yield* mapMountEntries(mount.fs.list(childPath === "/" ? undefined : childPath, options), mount.prefix);
+            }
         },
-        read(path) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const normalized = normalizeFsPath(path);
-                return forward(normalized, (fs, childPath) => fs.read(childPath));
-            });
+        async stat(path) {
+            const normalized = normalizeFsPath(path);
+            if (normalized === "/") {
+                return { kind: "directory" };
+            }
+            if (entries.some(entry => entry.prefix === normalized)) {
+                return { kind: "directory" };
+            }
+            const mount = longestMount(normalized, entries);
+            if (mount === undefined) {
+                return { kind: "missing" };
+            }
+            return mount.fs.stat(toChildPath(normalized, mount.prefix));
         },
-        write(path, contents) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const normalized = normalizeFsPath(path);
-                return forward(normalized, (fs, childPath) => fs.write(childPath, contents));
-            });
+        async read(path) {
+            const normalized = normalizeFsPath(path);
+            return forward(normalized, (fs, childPath) => fs.read(childPath));
         },
-        delete(path) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const normalized = normalizeFsPath(path);
-                return forward(normalized, (fs, childPath) => fs.delete(childPath));
-            });
+        async write(path, contents) {
+            const normalized = normalizeFsPath(path);
+            return forward(normalized, (fs, childPath) => fs.write(childPath, contents));
         },
-        grep(query) {
-            return __asyncGenerator(this, arguments, function* grep_4() {
-                yield __await(yield* __asyncDelegator(__asyncValues(limitResults(uncapped(), query.maxResults))));
-                function uncapped() {
-                    return __asyncGenerator(this, arguments, function* uncapped_5() {
-                        const scope = query.path === undefined || query.path === "" ? "/" : normalizeFsPath(query.path);
-                        if (scope === "/") {
-                            yield __await(yield* __asyncDelegator(__asyncValues(mergeSorted(entries.map(mount => mapMountGrep(mount.fs.grep(Object.assign(Object.assign({}, query), { path: undefined })), mount.prefix)), { compare: compareGrepResult }))));
-                            return yield __await(void 0);
-                        }
-                        const mount = longestMount(scope, entries);
-                        if (mount === undefined) {
-                            return yield __await(void 0);
-                        }
-                        const childPath = toChildPath(scope, mount.prefix);
-                        yield __await(yield* __asyncDelegator(__asyncValues(mapMountGrep(mount.fs.grep(Object.assign(Object.assign({}, query), { path: childPath === "/" ? undefined : childPath })), mount.prefix))));
-                    });
-                }
-            });
+        async delete(path) {
+            const normalized = normalizeFsPath(path);
+            return forward(normalized, (fs, childPath) => fs.delete(childPath));
         },
-        search(query) {
-            return __asyncGenerator(this, arguments, function* search_1() {
-                yield __await(yield* __asyncDelegator(__asyncValues(limitResults(uncapped(), query.maxResults))));
-                function uncapped() {
-                    return __asyncGenerator(this, arguments, function* uncapped_6() {
-                        const sources = [];
-                        for (const mount of entries) {
-                            const childQuery = childSearchQuery(query, mount.prefix);
-                            if (childQuery === undefined) {
-                                continue;
-                            }
-                            sources.push(mapMountSearch(mount.fs.search(childQuery), mount.prefix));
-                        }
-                        yield __await(yield* __asyncDelegator(__asyncValues(mergeSorted(sources, { compare: compareSearchResult }))));
-                    });
+        async *grep(query) {
+            yield* limitResults(uncapped(), query.maxResults);
+            async function* uncapped() {
+                const scope = query.path === undefined || query.path === "" ? "/" : normalizeFsPath(query.path);
+                if (scope === "/") {
+                    yield* mergeSorted(entries.map(mount => mapMountGrep(mount.fs.grep({ ...query, path: undefined }), mount.prefix)), { compare: compareGrepResult });
+                    return;
                 }
-            });
-        },
-        glob(pattern, dir, options) {
-            return __asyncGenerator(this, arguments, function* glob_3() {
-                yield __await(yield* __asyncDelegator(__asyncValues(limitResults(uncapped(), options === null || options === void 0 ? void 0 : options.limit))));
-                function uncapped() {
-                    return __asyncGenerator(this, arguments, function* uncapped_7() {
-                        const scope = dir === undefined || dir === "" ? "/" : normalizeFsPath(dir);
-                        if (scope === "/") {
-                            yield __await(yield* __asyncDelegator(__asyncValues(mergeSortedByPath(entries.map(mount => mapMountEntries(mount.fs.glob(pattern, undefined, options), mount.prefix)), { unique: true }))));
-                            return yield __await(void 0);
-                        }
-                        const mount = longestMount(scope, entries);
-                        if (mount === undefined) {
-                            return yield __await(void 0);
-                        }
-                        const childPath = toChildPath(scope, mount.prefix);
-                        yield __await(yield* __asyncDelegator(__asyncValues(mapMountEntries(mount.fs.glob(pattern, childPath === "/" ? undefined : childPath, options), mount.prefix))));
-                    });
+                const mount = longestMount(scope, entries);
+                if (mount === undefined) {
+                    return;
                 }
-            });
+                const childPath = toChildPath(scope, mount.prefix);
+                yield* mapMountGrep(mount.fs.grep({
+                    ...query,
+                    path: childPath === "/" ? undefined : childPath,
+                }), mount.prefix);
+            }
         },
-    };
-}
-function collectLayerPaths(layer) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, e_8, _b, _c;
-        const paths = [];
-        try {
-            try {
-                for (var _d = true, _e = __asyncValues(layer.list()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const entry = _c;
-                    paths.push(entry.path);
+        async *search(query) {
+            yield* limitResults(uncapped(), query.maxResults);
+            async function* uncapped() {
+                const sources = [];
+                for (const mount of entries) {
+                    const childQuery = childSearchQuery(query, mount.prefix);
+                    if (childQuery === undefined) {
+                        continue;
+                    }
+                    sources.push(mapMountSearch(mount.fs.search(childQuery), mount.prefix));
                 }
+                yield* mergeSorted(sources, { compare: compareSearchResult });
             }
-            catch (e_8_1) { e_8 = { error: e_8_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+        },
+        async *glob(pattern, dir, options) {
+            yield* limitResults(uncapped(), options?.limit);
+            async function* uncapped() {
+                const scope = dir === undefined || dir === "" ? "/" : normalizeFsPath(dir);
+                if (scope === "/") {
+                    yield* mergeSortedByPath(entries.map(mount => mapMountEntries(mount.fs.glob(pattern, undefined, options), mount.prefix)), { unique: true });
+                    return;
                 }
-                finally { if (e_8) throw e_8.error; }
+                const mount = longestMount(scope, entries);
+                if (mount === undefined) {
+                    return;
+                }
+                const childPath = toChildPath(scope, mount.prefix);
+                yield* mapMountEntries(mount.fs.glob(pattern, childPath === "/" ? undefined : childPath, options), mount.prefix);
             }
+        },
+    };
+}
+async function collectLayerPaths(layer) {
+    const paths = [];
+    try {
+        for await (const entry of layer.list()) {
+            paths.push(entry.path);
         }
-        catch (_g) {
-            // A layer that cannot list also cannot own paths.
-        }
-        return paths;
-    });
+    }
+    catch {
+        // A layer that cannot list also cannot own paths.
+    }
+    return paths;
 }
 /**
  * Same-root overlay: earlier layers win. Read-only.
@@ -1326,41 +1108,27 @@ export function overlayFs(layers) {
     if (layers.length === 0) {
         throw new Error("overlayFs needs at least one layer.");
     }
-    const walkLayers = (collect) => __awaiter(this, void 0, void 0, function* () {
-        var _a, e_9, _b, _c;
+    const walkLayers = async (collect) => {
         const streams = [];
         let failure;
         let served = false;
         for (const layer of layers) {
             const collected = [];
             try {
-                try {
-                    for (var _d = true, _e = (e_9 = void 0, __asyncValues(yield collect(layer))), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                        _c = _f.value;
-                        _d = false;
-                        const entry = _c;
-                        collected.push(entry);
-                    }
-                }
-                catch (e_9_1) { e_9 = { error: e_9_1 }; }
-                finally {
-                    try {
-                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-                    }
-                    finally { if (e_9) throw e_9.error; }
+                for await (const entry of await collect(layer)) {
+                    collected.push(entry);
                 }
             }
             catch (error) {
-                failure !== null && failure !== void 0 ? failure : (failure = error);
+                failure ??= error;
                 continue;
             }
             served = true;
             streams.push(collected);
         }
         return { streams, failure, served };
-    });
-    const collectOverlayHits = (queryFn, rethrow) => __awaiter(this, void 0, void 0, function* () {
-        var _a, e_10, _b, _c;
+    };
+    const collectOverlayHits = async (queryFn, rethrow) => {
         const streams = [];
         const shadowed = new Set();
         let failure;
@@ -1368,34 +1136,22 @@ export function overlayFs(layers) {
         for (const layer of layers) {
             const collected = [];
             try {
-                try {
-                    for (var _d = true, _e = (e_10 = void 0, __asyncValues(queryFn(layer))), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                        _c = _f.value;
-                        _d = false;
-                        const hit = _c;
-                        if (!shadowed.has(hit.path)) {
-                            collected.push(hit);
-                        }
-                    }
-                }
-                catch (e_10_1) { e_10 = { error: e_10_1 }; }
-                finally {
-                    try {
-                        if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                for await (const hit of queryFn(layer)) {
+                    if (!shadowed.has(hit.path)) {
+                        collected.push(hit);
                     }
-                    finally { if (e_10) throw e_10.error; }
                 }
                 served = true;
             }
             catch (error) {
-                if ((rethrow === null || rethrow === void 0 ? void 0 : rethrow(error)) === true) {
+                if (rethrow?.(error) === true) {
                     throw error;
                 }
-                failure !== null && failure !== void 0 ? failure : (failure = error);
+                failure ??= error;
                 continue;
             }
             streams.push(collected);
-            for (const path of yield collectLayerPaths(layer)) {
+            for (const path of await collectLayerPaths(layer)) {
                 shadowed.add(path);
             }
         }
@@ -1403,91 +1159,75 @@ export function overlayFs(layers) {
             throw failure;
         }
         return streams;
-    });
+    };
     return {
-        list(prefix, options) {
-            return __asyncGenerator(this, arguments, function* list_3() {
-                const { streams, failure, served } = yield __await(walkLayers(layer => layer.list(prefix, options)));
-                if (!served && failure !== undefined) {
-                    throw failure;
-                }
-                yield __await(yield* __asyncDelegator(__asyncValues(limitResults(mergeSortedByPath(streams, { unique: true }), options === null || options === void 0 ? void 0 : options.limit))));
-            });
+        async *list(prefix, options) {
+            const { streams, failure, served } = await walkLayers(layer => layer.list(prefix, options));
+            if (!served && failure !== undefined) {
+                throw failure;
+            }
+            yield* limitResults(mergeSortedByPath(streams, { unique: true }), options?.limit);
         },
-        stat(path) {
-            return __awaiter(this, void 0, void 0, function* () {
-                let failure;
-                let sawMissing = false;
-                for (const layer of layers) {
-                    try {
-                        const info = yield layer.stat(path);
-                        if (info.kind !== "missing") {
-                            return info;
-                        }
-                        sawMissing = true;
-                    }
-                    catch (error) {
-                        failure !== null && failure !== void 0 ? failure : (failure = error);
+        async stat(path) {
+            let failure;
+            let sawMissing = false;
+            for (const layer of layers) {
+                try {
+                    const info = await layer.stat(path);
+                    if (info.kind !== "missing") {
+                        return info;
                     }
+                    sawMissing = true;
                 }
-                if (!sawMissing && failure !== undefined) {
-                    throw failure;
+                catch (error) {
+                    failure ??= error;
                 }
-                return { kind: "missing" };
-            });
+            }
+            if (!sawMissing && failure !== undefined) {
+                throw failure;
+            }
+            return { kind: "missing" };
         },
-        glob(pattern, dir, options) {
-            return __asyncGenerator(this, arguments, function* glob_4() {
-                const { streams, failure, served } = yield __await(walkLayers(layer => layer.glob(pattern, dir, options)));
-                if (!served && failure !== undefined) {
-                    throw failure;
-                }
-                yield __await(yield* __asyncDelegator(__asyncValues(limitResults(mergeSortedByPath(streams, { unique: true }), options === null || options === void 0 ? void 0 : options.limit))));
-            });
+        async *glob(pattern, dir, options) {
+            const { streams, failure, served } = await walkLayers(layer => layer.glob(pattern, dir, options));
+            if (!served && failure !== undefined) {
+                throw failure;
+            }
+            yield* limitResults(mergeSortedByPath(streams, { unique: true }), options?.limit);
         },
-        read(path) {
-            return __awaiter(this, void 0, void 0, function* () {
-                let failure;
-                for (const layer of layers) {
-                    try {
-                        return yield layer.read(path);
-                    }
-                    catch (error) {
-                        if (isFileNotFoundError(error)) {
-                            continue;
-                        }
-                        failure !== null && failure !== void 0 ? failure : (failure = error);
-                    }
+        async read(path) {
+            let failure;
+            for (const layer of layers) {
+                try {
+                    return await layer.read(path);
                 }
-                if (failure !== undefined) {
-                    throw failure;
+                catch (error) {
+                    if (isFileNotFoundError(error)) {
+                        continue;
+                    }
+                    failure ??= error;
                 }
-                throw new FileNotFoundError(path);
-            });
+            }
+            if (failure !== undefined) {
+                throw failure;
+            }
+            throw new FileNotFoundError(path);
         },
-        grep(query) {
-            return __asyncGenerator(this, arguments, function* grep_5() {
-                const { maxResults } = query, uncappedQuery = __rest(query, ["maxResults"]);
-                yield __await(yield* __asyncDelegator(__asyncValues(limitResults(mergeSorted(yield __await(collectOverlayHits(layer => layer.grep(uncappedQuery), error => isInvalidGrepPatternError(error))), { compare: compareGrepResult }), maxResults))));
-            });
+        async *grep(query) {
+            const { maxResults, ...uncappedQuery } = query;
+            yield* limitResults(mergeSorted(await collectOverlayHits(layer => layer.grep(uncappedQuery), error => isInvalidGrepPatternError(error)), { compare: compareGrepResult }), maxResults);
         },
-        write(path) {
-            return __awaiter(this, void 0, void 0, function* () {
-                throw new ReadOnlyMountError(path);
-            });
+        async write(path) {
+            throw new ReadOnlyMountError(path);
         },
-        delete(path) {
-            return __awaiter(this, void 0, void 0, function* () {
-                throw new ReadOnlyMountError(path);
-            });
+        async delete(path) {
+            throw new ReadOnlyMountError(path);
         },
-        search(query) {
-            return __asyncGenerator(this, arguments, function* search_2() {
-                const { maxResults } = query, uncappedQuery = __rest(query, ["maxResults"]);
-                yield __await(yield* __asyncDelegator(__asyncValues(limitResults(mergeSorted(yield __await(collectOverlayHits(layer => layer.search(uncappedQuery))), {
-                    compare: compareSearchResult,
-                }), maxResults))));
-            });
+        async *search(query) {
+            const { maxResults, ...uncappedQuery } = query;
+            yield* limitResults(mergeSorted(await collectOverlayHits(layer => layer.search(uncappedQuery)), {
+                compare: compareSearchResult,
+            }), maxResults);
         },
     };
 }
@@ -1512,41 +1252,37 @@ export function hostFs(files, scope) {
     const callOptions = { scope };
     const readEtags = new Map();
     const listed = {
-        list(prefix, options) {
-            return __asyncGenerator(this, arguments, function* list_4() {
-                const entries = yield __await(files.list(undefined, callOptions));
-                yield __await(yield* __asyncDelegator(__asyncValues(listFilesFromPaths(entries.map(entry => ({
-                    path: normalizeFsPath(entry.path),
-                    size: entry.size,
-                })), prefix, options))));
-            });
+        async *list(prefix, options) {
+            const entries = await files.list(undefined, callOptions);
+            yield* listFilesFromPaths(entries.map(entry => ({
+                path: normalizeFsPath(entry.path),
+                size: entry.size,
+            })), prefix, options);
         },
-        stat(path) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const entries = yield files.list(undefined, callOptions);
-                return statFromFilePaths(entries.map(entry => normalizeFsPath(entry.path)), path);
-            });
+        async stat(path) {
+            const entries = await files.list(undefined, callOptions);
+            return statFromFilePaths(entries.map(entry => normalizeFsPath(entry.path)), path);
         },
     };
-    const readText = (inputPath) => __awaiter(this, void 0, void 0, function* () {
+    const readText = async (inputPath) => {
         const path = normalizeFsPath(inputPath);
         const key = hostKey(path);
         if (key === "") {
             throw new FileNotFoundError(path);
         }
-        const [content, stat] = yield Promise.all([
+        const [content, stat] = await Promise.all([
             files.read(key, callOptions),
             files.stat(key, callOptions),
         ]);
         if (content === undefined) {
             throw new FileNotFoundError(path);
         }
-        if ((stat === null || stat === void 0 ? void 0 : stat.etag) !== undefined) {
+        if (stat?.etag !== undefined) {
             readEtags.set(key, stat.etag);
         }
         return content;
-    });
-    const writeHost = (inputPath, contents) => __awaiter(this, void 0, void 0, function* () {
+    };
+    const writeHost = async (inputPath, contents) => {
         const path = normalizeFsPath(inputPath);
         const key = hostKey(path);
         if (key === "") {
@@ -1555,10 +1291,15 @@ export function hostFs(files, scope) {
         try {
             if (files.capabilities.conflictDetection) {
                 const etag = readEtags.get(key);
-                yield files.write(key, contents, Object.assign(Object.assign({}, callOptions), (etag === undefined ? {} : { ifMatch: etag })));
+                await files.write(key, contents, {
+                    ...callOptions,
+                    // No cached etag: unconditional create/overwrite. After a
+                    // successful read or write, CAS on that etag.
+                    ...(etag === undefined ? {} : { ifMatch: etag }),
+                });
             }
             else {
-                yield files.write(key, contents, callOptions);
+                await files.write(key, contents, callOptions);
             }
         }
         catch (error) {
@@ -1567,132 +1308,92 @@ export function hostFs(files, scope) {
             }
             throw error;
         }
-        const stat = yield files.stat(key, callOptions);
-        if ((stat === null || stat === void 0 ? void 0 : stat.etag) !== undefined) {
+        const stat = await files.stat(key, callOptions);
+        if (stat?.etag !== undefined) {
             readEtags.set(key, stat.etag);
         }
         else {
             readEtags.delete(key);
         }
-    });
+    };
     return {
         list(prefix, options) {
             return listed.list(prefix, options);
         },
-        stat(path) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return listed.stat(path);
-            });
+        async stat(path) {
+            return listed.stat(path);
         },
-        read(path) {
-            return __awaiter(this, void 0, void 0, function* () {
-                return readText(path);
-            });
+        async read(path) {
+            return readText(path);
         },
-        grep(query) {
-            return __asyncGenerator(this, arguments, function* grep_6() {
-                yield __await(yield* __asyncDelegator(__asyncValues(limitResults(uncapped(), query.maxResults))));
-                function uncapped() {
-                    return __asyncGenerator(this, arguments, function* uncapped_8() {
-                        var _a, e_11, _b, _c;
-                        const scopePath = query.path === undefined || query.path === "" ? "/" : normalizeFsPath(query.path);
-                        const regex = compileGrepPattern(query.pattern, query.caseInsensitive, scopePath);
-                        const info = yield __await(listed.stat(scopePath));
-                        if (scopePath !== "/" && info.kind === "file") {
-                            if (query.glob !== undefined &&
-                                !pathMatchesGlob(scopePath, scopePath, query.glob, {
-                                    matchBasename: true,
-                                })) {
-                                return yield __await(void 0);
-                            }
-                            if (isExcludedPath(scopePath, query.excludes)) {
-                                return yield __await(void 0);
-                            }
-                            yield __await(yield* __asyncDelegator(__asyncValues(grepFileContent({
-                                path: scopePath,
-                                content: yield __await(readText(scopePath)),
-                                regex,
-                            }))));
-                            return yield __await(void 0);
-                        }
-                        try {
-                            for (var _d = true, _e = __asyncValues(listed.list(scopePath === "/" ? undefined : scopePath, query.excludes === undefined ? undefined : { excludes: query.excludes })), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
-                                _c = _f.value;
-                                _d = false;
-                                const entry = _c;
-                                if (query.glob !== undefined &&
-                                    !pathMatchesGlob(entry.path, scopePath, query.glob, {
-                                        matchBasename: true,
-                                    })) {
-                                    continue;
-                                }
-                                yield __await(yield* __asyncDelegator(__asyncValues(grepFileContent({
-                                    path: entry.path,
-                                    content: yield __await(readText(entry.path)),
-                                    regex,
-                                }))));
-                            }
-                        }
-                        catch (e_11_1) { e_11 = { error: e_11_1 }; }
-                        finally {
-                            try {
-                                if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
-                            }
-                            finally { if (e_11) throw e_11.error; }
-                        }
+        async *grep(query) {
+            yield* limitResults(uncapped(), query.maxResults);
+            async function* uncapped() {
+                const scopePath = query.path === undefined || query.path === "" ? "/" : normalizeFsPath(query.path);
+                const regex = compileGrepPattern(query.pattern, query.caseInsensitive, scopePath);
+                const info = await listed.stat(scopePath);
+                if (scopePath !== "/" && info.kind === "file") {
+                    if (query.glob !== undefined &&
+                        !pathMatchesGlob(scopePath, scopePath, query.glob, {
+                            matchBasename: true,
+                        })) {
+                        return;
+                    }
+                    if (isExcludedPath(scopePath, query.excludes)) {
+                        return;
+                    }
+                    yield* grepFileContent({
+                        path: scopePath,
+                        content: await readText(scopePath),
+                        regex,
                     });
+                    return;
                 }
-            });
+                for await (const entry of listed.list(scopePath === "/" ? undefined : scopePath, query.excludes === undefined ? undefined : { excludes: query.excludes })) {
+                    if (query.glob !== undefined &&
+                        !pathMatchesGlob(entry.path, scopePath, query.glob, {
+                            matchBasename: true,
+                        })) {
+                        continue;
+                    }
+                    yield* grepFileContent({
+                        path: entry.path,
+                        content: await readText(entry.path),
+                        regex,
+                    });
+                }
+            }
         },
-        glob(pattern, dir, options) {
-            return __asyncGenerator(this, arguments, function* glob_5() {
-                const dirPath = dir === undefined || dir === "" ? "/" : normalizeFsPath(dir);
-                yield __await(yield* __asyncDelegator(__asyncValues(globFromList(listed.list(dirPath === "/" ? undefined : dirPath), Object.assign({ pattern, dir: dirPath }, ((options === null || options === void 0 ? void 0 : options.limit) === undefined ? {} : { limit: options.limit }))))));
+        async *glob(pattern, dir, options) {
+            const dirPath = dir === undefined || dir === "" ? "/" : normalizeFsPath(dir);
+            yield* globFromList(listed.list(dirPath === "/" ? undefined : dirPath), {
+                pattern,
+                dir: dirPath,
+                ...(options?.limit === undefined ? {} : { limit: options.limit }),
             });
         },
-        write(inputPath, contents) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield writeHost(inputPath, contents);
-            });
+        async write(inputPath, contents) {
+            await writeHost(inputPath, contents);
         },
-        delete(inputPath) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const path = normalizeFsPath(inputPath);
-                const key = hostKey(path);
-                if (key === "" || !(yield files.exists(key, callOptions))) {
-                    throw new FileNotFoundError(path);
-                }
-                yield files.remove(key, callOptions);
-                readEtags.delete(key);
-            });
+        async delete(inputPath) {
+            const path = normalizeFsPath(inputPath);
+            const key = hostKey(path);
+            if (key === "" || !(await files.exists(key, callOptions))) {
+                throw new FileNotFoundError(path);
+            }
+            await files.remove(key, callOptions);
+            readEtags.delete(key);
         },
         search: emptySearch,
     };
 }
-function globFromList(source, options) {
-    return __asyncGenerator(this, arguments, function* globFromList_1() {
-        yield __await(yield* __asyncDelegator(__asyncValues(limitResults(uncapped(), options.limit))));
-        function uncapped() {
-            return __asyncGenerator(this, arguments, function* uncapped_9() {
-                var _a, e_12, _b, _c;
-                try {
-                    for (var _d = true, source_5 = __asyncValues(source), source_5_1; source_5_1 = yield __await(source_5.next()), _a = source_5_1.done, !_a; _d = true) {
-                        _c = source_5_1.value;
-                        _d = false;
-                        const entry = _c;
-                        if (pathMatchesGlob(entry.path, options.dir, options.pattern)) {
-                            yield yield __await(entry);
-                        }
-                    }
-                }
-                catch (e_12_1) { e_12 = { error: e_12_1 }; }
-                finally {
-                    try {
-                        if (!_d && !_a && (_b = source_5.return)) yield __await(_b.call(source_5));
-                    }
-                    finally { if (e_12) throw e_12.error; }
-                }
-            });
+async function* globFromList(source, options) {
+    yield* limitResults(uncapped(), options.limit);
+    async function* uncapped() {
+        for await (const entry of source) {
+            if (pathMatchesGlob(entry.path, options.dir, options.pattern)) {
+                yield entry;
+            }
         }
-    });
+    }
 }