@muhkoo/connect 0.13.0-alpha.0 → 0.13.2-alpha.0

package/dist/server/index.js

@@ -3235,7 +3235,7 @@ function base64UrlDecode(s) {
  * expect (and isn't serving a stale cached bundle). Keep this in sync with
  * `package.json` `version`.
  */
-const VERSION = "0.13.0-alpha.0";
+const VERSION = "0.13.2-alpha.0";
 
 /**
  * `HttpClient` — the one place the unified {@link Client} talks to the
@@ -11914,6 +11914,32 @@ function escapeLiteral(s) {
  * repeat.
  */
 const MAX_DEPTH = 64;
+/**
+ * How many directories `walk` lists at once.
+ *
+ * Enough to hide per-request latency on a wide tree; low enough that a big
+ * project does not open a request per directory. Browsers cap concurrency per
+ * origin anyway, so a larger number mostly moves the queue.
+ */
+const WALK_CONCURRENCY = 8;
+/**
+ * `Promise.all` with a ceiling, preserving input order.
+ *
+ * Results are written back BY INDEX rather than pushed as they settle, so the
+ * output order matches the input regardless of which finishes first — which is
+ * what lets `walk` parallelise without changing what it returns.
+ */
+async function mapLimit(items, limit, fn) {
+    if (items.length <= 1)
+        return items.length ? [await fn(items[0])] : [];
+    const out = new Array(items.length);
+    let next = 0;
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, async () => {
+        for (let i = next++; i < items.length; i = next++)
+            out[i] = await fn(items[i]);
+    }));
+    return out;
+}
 const DEFAULT_HISTORY_LIMIT = 20;
 class VfsNamespace {
     deps;
@@ -12072,34 +12098,40 @@ class VfsNamespace {
      * one fetch per directory. Fine for a project, wrong as a default.
      */
     async walk(path = ".") {
-        const out = [];
-        // Guard against a tree that is not one.
-        //
-        // `visit` recurses on a PATH, re-resolved from the root each time, so a
-        // record whose entry points back at an ancestor - or, before names were
-        // validated, an entry simply named ".." - recurses forever and grows
-        // `out` without bound. Nothing in the format prevents that, and `mount`
-        // calls this on every sync pass.
+        /**
+         * Sibling directories are listed CONCURRENTLY.
+         *
+         * Each `list` is a round trip for one directory record, and walking them
+         * one after another cost the sum of those latencies: measured against a
+         * real project, the walk alone was 1–2.1s before a single file had been
+         * read. Directories are independent, so there was never a reason to
+         * queue them.
+         *
+         * Order is preserved exactly. Each entry maps to its own slice of the
+         * result and the slices are concatenated in listing order, so the output
+         * is identical to the depth-first version — callers and tests that
+         * depend on it are unaffected, and only the timing changes.
+         */
         const seen = new Set();
         const visit = async (dirPath, depth) => {
             if (depth > MAX_DEPTH) {
                 this.warn(`stopping at ${dirPath}: deeper than ${MAX_DEPTH} levels`);
-                return;
+                return [];
             }
+            // Claimed BEFORE the first await, so two concurrent visits to the
+            // same directory cannot both get past this. A record whose entry
+            // points back at an ancestor would otherwise recurse forever, and
+            // nothing in the format prevents one.
             if (seen.has(dirPath)) {
                 this.warn(`stopping at ${dirPath}: already visited (the tree contains a cycle)`);
-                return;
+                return [];
             }
             seen.add(dirPath);
-            for (const entry of await this.list(dirPath)) {
-                if (entry.kind === "dir")
-                    await visit(entry.path, depth + 1);
-                else
-                    out.push(entry.path);
-            }
+            const entries = await this.list(dirPath);
+            const slices = await mapLimit(entries, WALK_CONCURRENCY, async (entry) => entry.kind === "dir" ? visit(entry.path, depth + 1) : [entry.path]);
+            return slices.flat();
         };
-        await visit(this.resolve(path), 0);
-        return out;
+        return visit(this.resolve(path), 0);
     }
     async readFile(path) {
         const entry = await this.expectFile(path);