@reventlessdev/reventless-gwt 1.0.0-alpha.75 → 1.0.0-alpha.77

package/src/JestBind.res

@@ -60,7 +60,7 @@ let testPromise = (
 ) =>
   if Collector.isActive() {
     let location = Collector.captureLocation(1)
-    Collector.push(~slice?, ~location?, name, body)
+    Collector.push(~slice?, ~location?, ~timeout?, name, body)
   } else {
     switch timeout {
     | Some(t) =>

package/src/JestBind.res.mjs

@@ -35,7 +35,7 @@ function todo(label) {
 function test(slice, name, body) {
   if (Collector$ReventlessGwt.isActive()) {
     let location = Collector$ReventlessGwt.captureLocation(1);
-    return Collector$ReventlessGwt.push(slice, location, name, () => Promise.resolve(body()));
+    return Collector$ReventlessGwt.push(slice, location, undefined, name, () => Promise.resolve(body()));
   }
   globalThis.test(name, () => assertOutcome(slice, body()));
 }
@@ -50,7 +50,7 @@ function testPromise(slice, name, timeout, body) {
     return;
   }
   let location = Collector$ReventlessGwt.captureLocation(1);
-  Collector$ReventlessGwt.push(slice, location, name, body);
+  Collector$ReventlessGwt.push(slice, location, timeout, name, body);
 }
 
 export {

package/src/LocalHost.res

@@ -55,23 +55,11 @@ type pluginExports = {"Make": platform => builtPlugin}
 //    plugin keys match the names the framework itself bakes into Plugin.res. ──
 
 // "@scope/my-catalog" → "MyCatalog", "online-shop" → "OnlineShop".
-let packageNameToPluginName = (packageName: string): string => {
-  let base = switch packageName->String.split("/") {
-  | [_scope, local] => local
-  | [local] => local
-  | parts => parts->Array.getUnsafe(parts->Array.length - 1)
-  }
-  base
-  ->String.split("-")
-  ->Array.flatMap(part => part->String.split("_"))
-  ->Array.map(word =>
-    word === ""
-      ? ""
-      : word->String.slice(~start=0, ~end=1)->String.toUpperCase ++
-          word->String.slice(~start=1, ~end=word->String.length)
-  )
-  ->Array.join("")
-}
+// Single-sourced with the plugin generator (spec's `Config`) via
+// `Reventless.PluginName` so the two can't drift — a drift silently breaks
+// graph plugin keys (see the module for the full rationale). Re-exported here
+// under the historical name the tests already pin.
+let packageNameToPluginName = Reventless.PluginName.fromPackageName
 
 let strField = (json, key) =>
   json->JSON.Decode.object->Option.flatMap(d => d->Dict.get(key))->Option.flatMap(JSON.Decode.string)
@@ -82,19 +70,15 @@ let readJson = path =>
   }
 
 // plugin.json `name` → else PascalCase(package.json `name`) → else "Plugin".
+// The precedence itself lives in `Reventless.PluginName.resolve`; this only
+// reads the two raw fields with the local node bindings.
 let derivePluginName = (~pluginSrcDir: string): string => {
   let pluginJson = join(pluginSrcDir, "plugin.json")
-  let fromPluginJson =
+  let pluginJsonName =
     existsSync(pluginJson) ? readJson(pluginJson)->Option.flatMap(j => strField(j, "name")) : None
-  switch fromPluginJson {
-  | Some(name) => name
-  | None =>
-    let pkgJson = join(dirname(pluginSrcDir), "package.json")
-    readJson(pkgJson)
-    ->Option.flatMap(j => strField(j, "name"))
-    ->Option.map(packageNameToPluginName)
-    ->Option.getOr("Plugin")
-  }
+  let packageJsonName =
+    readJson(join(dirname(pluginSrcDir), "package.json"))->Option.flatMap(j => strField(j, "name"))
+  Reventless.PluginName.resolve(~pluginJsonName, ~packageJsonName)
 }
 
 // Given workspace package dirs (e.g. from PackageScan), keep those that carry a

package/src/LocalHost.res.mjs

@@ -7,6 +7,7 @@ import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Nodemodule from "node:module";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as PluginName$Reventless from "@reventlessdev/reventless-spec/src/components/PluginName.res.mjs";
 
 let dynamicImport = ((u) => import(u));
 
@@ -19,34 +20,6 @@ function bustedUrl(absolutePath) {
   return Nodeurl.pathToFileURL(absolutePath).href + "?t=" + counter.contents.toString();
 }
 
-function packageNameToPluginName(packageName) {
-  let parts = packageName.split("/");
-  let len = parts.length;
-  let base;
-  if (len >= 3) {
-    base = parts[parts.length - 1 | 0];
-  } else {
-    switch (len) {
-      case 0 :
-        base = parts[parts.length - 1 | 0];
-        break;
-      case 1 :
-        base = parts[0];
-        break;
-      case 2 :
-        base = parts[1];
-        break;
-    }
-  }
-  return base.split("-").flatMap(part => part.split("_")).map(word => {
-    if (word === "") {
-      return "";
-    } else {
-      return word.slice(0, 1).toUpperCase() + word.slice(1, word.length);
-    }
-  }).join("");
-}
-
 function strField(json, key) {
   return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), d => d[key]), Stdlib_JSON.Decode.string);
 }
@@ -61,12 +34,9 @@ function readJson(path) {
 
 function derivePluginName(pluginSrcDir) {
   let pluginJson = Nodepath.join(pluginSrcDir, "plugin.json");
-  let fromPluginJson = Nodefs.existsSync(pluginJson) ? Stdlib_Option.flatMap(readJson(pluginJson), j => strField(j, "name")) : undefined;
-  if (fromPluginJson !== undefined) {
-    return fromPluginJson;
-  }
-  let pkgJson = Nodepath.join(Nodepath.dirname(pluginSrcDir), "package.json");
-  return Stdlib_Option.getOr(Stdlib_Option.map(Stdlib_Option.flatMap(readJson(pkgJson), j => strField(j, "name")), packageNameToPluginName), "Plugin");
+  let pluginJsonName = Nodefs.existsSync(pluginJson) ? Stdlib_Option.flatMap(readJson(pluginJson), j => strField(j, "name")) : undefined;
+  let packageJsonName = Stdlib_Option.flatMap(readJson(Nodepath.join(Nodepath.dirname(pluginSrcDir), "package.json")), j => strField(j, "name"));
+  return PluginName$Reventless.resolve(pluginJsonName, packageJsonName);
 }
 
 function discover(packageDirs) {
@@ -111,6 +81,8 @@ async function loadGraph(platformModulePath, plugins) {
   };
 }
 
+let packageNameToPluginName = PluginName$Reventless.fromPackageName;
+
 export {
   dynamicImport,
   counter,

package/src/MismatchRender.res

@@ -0,0 +1,72 @@
+// Single source for rendering an `Outcome.mismatch`'s expected/actual/extras
+// into RenderRescript strings. The Human and TAP formatters previously each held
+// a full 10-arm switch over the mismatch that computed *identical* rendered
+// values (`RenderRescript.render*`, the `Error()`/`Ok()` wrapping, the Todo
+// `(id, value)` pairs) and differed only in framing — aligned `label: value`
+// lines vs YAML `key: "escaped"` lines. This normalizes the value-rendering once;
+// each formatter interprets the `field` list with its own framing.
+//
+// NOT used by JUnit (renders via the older JSON-based `Outcome.format`) nor
+// FormatterJson/VsCode (they consume the raw JSON values to build a structured
+// `{type, payload, rendered}` + `fieldDiff` payload).
+
+// One rendered piece of a mismatch. The constructor carries the *already
+// rendered* string (unescaped — Human uses it raw, TAP yaml-escapes it), except
+// the structural markers `ExpectedNoEvents` (Human prints a literal line; TAP
+// omits it) and `Stack` (Human appends it raw; TAP labels it as a yaml field).
+type field =
+  | Expected(string)
+  | Actual(string)
+  | Key(string)
+  | ExpectedNoEvents
+  | Error(string)
+  | Stack(string)
+
+type normalized = {
+  kind: string,
+  fields: array<field>,
+}
+
+let render = RenderRescript.render
+let renderMany = RenderRescript.renderMany
+let renderOption = RenderRescript.renderOption
+
+let normalize = (m: Outcome.mismatch): normalized => {
+  let fields = switch m {
+  | EventsMismatch({expected, actual}) => [Expected(renderMany(expected)), Actual(renderMany(actual))]
+  | ErrorMismatch({expected, actual, actualEvents}) => [
+      Expected(`Error(${render(expected)})`),
+      Actual(
+        switch actual {
+        | Some(v) => `Error(${render(v)})`
+        | None => `Ok(${renderMany(actualEvents)})`
+        },
+      ),
+    ]
+  | StateMismatch({key, expected, actual}) => [
+      Key(key),
+      Expected(renderOption(expected)),
+      Actual(renderOption(actual)),
+    ]
+  | NoEventExpected({actual}) => [ExpectedNoEvents, Actual(renderMany(actual))]
+  | TodoMismatch({expected, actual}) =>
+    let fmt = (arr: array<(string, JSON.t)>) =>
+      "[" ++ arr->Array.map(((id, v)) => `(${id}, ${render(v)})`)->Array.join(", ") ++ "]"
+    [Expected(fmt(expected)), Actual(fmt(actual))]
+  | AppendConditionMismatch({expected, actual}) => [
+      Expected(render(expected)),
+      Actual(render(actual)),
+    ]
+  | TranslateError({expected, actual}) => [
+      Expected(expected),
+      Actual(actual->Option.getOr("(none)")),
+    ]
+  | QueryRowsMismatch({expected, actual}) => [Expected(renderMany(expected)), Actual(renderMany(actual))]
+  | PublishedActionsMismatch({expected, actual}) => [
+      Expected(renderMany(expected)),
+      Actual(renderMany(actual)),
+    ]
+  | Throw({error, stack}) => [Error(error), Stack(stack)]
+  }
+  {kind: Outcome.kindName(m), fields}
+}

package/src/MismatchRender.res.mjs

@@ -0,0 +1,127 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
+import * as RenderRescript$ReventlessGwt from "./RenderRescript.res.mjs";
+
+function normalize(m) {
+  let fields;
+  switch (m.TAG) {
+    case "ErrorMismatch" :
+      let actual = m.actual;
+      fields = [
+        {
+          TAG: "Expected",
+          _0: `Error(` + RenderRescript$ReventlessGwt.render(undefined, m.expected) + `)`
+        },
+        {
+          TAG: "Actual",
+          _0: actual !== undefined ? `Error(` + RenderRescript$ReventlessGwt.render(undefined, actual) + `)` : `Ok(` + RenderRescript$ReventlessGwt.renderMany(m.actualEvents) + `)`
+        }
+      ];
+      break;
+    case "StateMismatch" :
+      fields = [
+        {
+          TAG: "Key",
+          _0: m.key
+        },
+        {
+          TAG: "Expected",
+          _0: RenderRescript$ReventlessGwt.renderOption(m.expected)
+        },
+        {
+          TAG: "Actual",
+          _0: RenderRescript$ReventlessGwt.renderOption(m.actual)
+        }
+      ];
+      break;
+    case "NoEventExpected" :
+      fields = [
+        "ExpectedNoEvents",
+        {
+          TAG: "Actual",
+          _0: RenderRescript$ReventlessGwt.renderMany(m.actual)
+        }
+      ];
+      break;
+    case "TodoMismatch" :
+      let fmt = arr => "[" + arr.map(param => `(` + param[0] + `, ` + RenderRescript$ReventlessGwt.render(undefined, param[1]) + `)`).join(", ") + "]";
+      fields = [
+        {
+          TAG: "Expected",
+          _0: fmt(m.expected)
+        },
+        {
+          TAG: "Actual",
+          _0: fmt(m.actual)
+        }
+      ];
+      break;
+    case "AppendConditionMismatch" :
+      fields = [
+        {
+          TAG: "Expected",
+          _0: RenderRescript$ReventlessGwt.render(undefined, m.expected)
+        },
+        {
+          TAG: "Actual",
+          _0: RenderRescript$ReventlessGwt.render(undefined, m.actual)
+        }
+      ];
+      break;
+    case "TranslateError" :
+      fields = [
+        {
+          TAG: "Expected",
+          _0: m.expected
+        },
+        {
+          TAG: "Actual",
+          _0: Stdlib_Option.getOr(m.actual, "(none)")
+        }
+      ];
+      break;
+    case "Throw" :
+      fields = [
+        {
+          TAG: "Error",
+          _0: m.error
+        },
+        {
+          TAG: "Stack",
+          _0: m.stack
+        }
+      ];
+      break;
+    default:
+      fields = [
+        {
+          TAG: "Expected",
+          _0: RenderRescript$ReventlessGwt.renderMany(m.expected)
+        },
+        {
+          TAG: "Actual",
+          _0: RenderRescript$ReventlessGwt.renderMany(m.actual)
+        }
+      ];
+  }
+  return {
+    kind: Outcome$ReventlessGwt.kindName(m),
+    fields: fields
+  };
+}
+
+let render = RenderRescript$ReventlessGwt.render;
+
+let renderMany = RenderRescript$ReventlessGwt.renderMany;
+
+let renderOption = RenderRescript$ReventlessGwt.renderOption;
+
+export {
+  render,
+  renderMany,
+  renderOption,
+  normalize,
+}
+/* No side effect */

package/src/Outcome.res

@@ -95,67 +95,3 @@ let format = (m: mismatch) =>
       )}`
   | Throw({error, stack}) => `Throw: ${error}\n${stack}`
   }
-
-// Structured JSON payload per §3.3 of the analysis.
-// Closed schema — consumers switch on the `kind` discriminator.
-// Stage 7 enriches with `rendered` strings and `fieldDiff`.
-let toJson = (m: mismatch): JSON.t => {
-  let obj = Dict.make()
-  obj->Dict.set("kind", JSON.Encode.string(kindName(m)))
-  let jsonArr = arr => JSON.Encode.array(arr)
-  let optJson = o => o->Option.getOr(JSON.Encode.null)
-  switch m {
-  | EventsMismatch({expected, actual}) => {
-      obj->Dict.set("expected", jsonArr(expected))
-      obj->Dict.set("actual", jsonArr(actual))
-    }
-  | ErrorMismatch({expected, actual, actualEvents}) => {
-      obj->Dict.set("expected", expected)
-      obj->Dict.set("actual", optJson(actual))
-      obj->Dict.set("actualEvents", jsonArr(actualEvents))
-    }
-  | StateMismatch({key, expected, actual}) => {
-      obj->Dict.set("key", JSON.Encode.string(key))
-      obj->Dict.set("expected", optJson(expected))
-      obj->Dict.set("actual", optJson(actual))
-    }
-  | NoEventExpected({actual}) => obj->Dict.set("actual", jsonArr(actual))
-  | TodoMismatch({expected, actual}) => {
-      let pairArr = pairs =>
-        pairs
-        ->Array.map(((id, v)) => {
-          let d = Dict.make()
-          d->Dict.set("id", JSON.Encode.string(id))
-          d->Dict.set("value", v)
-          JSON.Encode.object(d)
-        })
-        ->jsonArr
-      obj->Dict.set("expected", pairArr(expected))
-      obj->Dict.set("actual", pairArr(actual))
-    }
-  | AppendConditionMismatch({expected, actual}) => {
-      obj->Dict.set("expected", expected)
-      obj->Dict.set("actual", actual)
-    }
-  | TranslateError({expected, actual}) => {
-      obj->Dict.set("expected", JSON.Encode.string(expected))
-      obj->Dict.set(
-        "actual",
-        actual->Option.mapOr(JSON.Encode.null, JSON.Encode.string),
-      )
-    }
-  | QueryRowsMismatch({expected, actual}) => {
-      obj->Dict.set("expected", jsonArr(expected))
-      obj->Dict.set("actual", jsonArr(actual))
-    }
-  | PublishedActionsMismatch({expected, actual}) => {
-      obj->Dict.set("expected", jsonArr(expected))
-      obj->Dict.set("actual", jsonArr(actual))
-    }
-  | Throw({error, stack}) => {
-      obj->Dict.set("error", JSON.Encode.string(error))
-      obj->Dict.set("stack", JSON.Encode.string(stack))
-    }
-  }
-  JSON.Encode.object(obj)
-}

package/src/Outcome.res.mjs

@@ -76,52 +76,6 @@ function format(m) {
   }
 }
 
-function toJson(m) {
-  let obj = {};
-  obj["kind"] = kindName(m);
-  switch (m.TAG) {
-    case "ErrorMismatch" :
-      obj["expected"] = m.expected;
-      obj["actual"] = Stdlib_Option.getOr(m.actual, null);
-      obj["actualEvents"] = m.actualEvents;
-      break;
-    case "StateMismatch" :
-      obj["key"] = m.key;
-      obj["expected"] = Stdlib_Option.getOr(m.expected, null);
-      obj["actual"] = Stdlib_Option.getOr(m.actual, null);
-      break;
-    case "NoEventExpected" :
-      obj["actual"] = m.actual;
-      break;
-    case "TodoMismatch" :
-      let pairArr = pairs => pairs.map(param => {
-        let d = {};
-        d["id"] = param[0];
-        d["value"] = param[1];
-        return d;
-      });
-      obj["expected"] = pairArr(m.expected);
-      obj["actual"] = pairArr(m.actual);
-      break;
-    case "TranslateError" :
-      obj["expected"] = m.expected;
-      obj["actual"] = Stdlib_Option.mapOr(m.actual, null, prim => prim);
-      break;
-    case "EventsMismatch" :
-    case "AppendConditionMismatch" :
-    case "QueryRowsMismatch" :
-    case "PublishedActionsMismatch" :
-      obj["expected"] = m.expected;
-      obj["actual"] = m.actual;
-      break;
-    case "Throw" :
-      obj["error"] = m.error;
-      obj["stack"] = m.stack;
-      break;
-  }
-  return obj;
-}
-
 let pass = {
   TAG: "Ok",
   _0: undefined
@@ -135,6 +89,5 @@ export {
   stringifyOptJson,
   stringifyJsonArray,
   format,
-  toJson,
 }
 /* No side effect */

package/src/PlatformRunner.res

@@ -60,6 +60,9 @@ let openEphemeral = (): promise<(netServer, int)> =>
     s->_listen(0, "127.0.0.1", () => resolve((s, (s->_address)["port"])))
   })
 
+let closeServer = (s: netServer): promise<unit> =>
+  Promise.make((resolve, _reject) => s->_close(() => resolve()))
+
 // Hold all n open while collecting ports so they're guaranteed distinct, then
 // release them just before the child binds.
 let allocFreePorts = async (n: int): array<int> => {
@@ -70,7 +73,10 @@ let allocFreePorts = async (n: int): array<int> => {
     servers->Array.push(s)
     ports->Array.push(p)
   }
-  servers->Array.forEach(s => s->_close(() => ()))
+  // Await every close so the ports are actually released before the child binds
+  // them. Closing fire-and-forget returned the ports while the sockets were
+  // still bound, racing the child's bind into EADDRINUSE.
+  let _ = await Promise.all(servers->Array.map(closeServer))
   ports
 }
 
@@ -150,11 +156,26 @@ let run = async (
       }
     ChildProcess.onStdoutLine(proc, handle)
     ChildProcess.onStderrLine(proc, handle)
-    ChildProcess.onClose(proc, code => callbacks.onStop(code))
 
-    // Keep the process alive until cancelled — like runWatch, returning here would
-    // let the bin wrapper process.exit and tear down the child immediately.
-    await Promise.make((resolve, _reject) => Cancellation.onCancel(() => resolve()))
-    0
+    // Keep the parent alive until either the operator cancels or the child exits.
+    // The previous shape awaited cancellation *forever* and always returned 0, so
+    // a crashed platform child left a zombie parent that reported success. Resolve
+    // on child close (or a spawn error) too, and surface the child's exit code.
+    let exitCode = ref(0)
+    await Promise.make((resolve, _reject) => {
+      Cancellation.onCancel(() => resolve())
+      ChildProcess.onError(proc, msg => {
+        callbacks.onLog("platform spawn error: " ++ msg)
+        callbacks.onStop(None)
+        exitCode := 1
+        resolve()
+      })
+      ChildProcess.onClose(proc, code => {
+        callbacks.onStop(code)
+        exitCode := code->Option.getOr(0)
+        resolve()
+      })
+    })
+    exitCode.contents
   }
 }

package/src/PlatformRunner.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Nodenet from "node:net";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Cancellation$ReventlessGwt from "./Cancellation.res.mjs";
 import * as ChildProcess$ReventlessGwt from "./ChildProcess.res.mjs";
 import * as PlatformScan$ReventlessGwt from "./PlatformScan.res.mjs";
@@ -44,6 +45,12 @@ function openEphemeral() {
   });
 }
 
+function closeServer(s) {
+  return new Promise((resolve, _reject) => {
+    s.close(() => resolve());
+  });
+}
+
 async function allocFreePorts(n) {
   let servers = [];
   let ports = [];
@@ -52,9 +59,7 @@ async function allocFreePorts(n) {
     servers.push(match[0]);
     ports.push(match[1]);
   }
-  servers.forEach(s => {
-    s.close(() => {});
-  });
+  await Promise.all(servers.map(closeServer));
   return ports;
 }
 
@@ -136,9 +141,24 @@ async function run(roots, backend, fixedPortsOpt, callbacks) {
     };
     ChildProcess$ReventlessGwt.onStdoutLine(proc, handle);
     ChildProcess$ReventlessGwt.onStderrLine(proc, handle);
-    ChildProcess$ReventlessGwt.onClose(proc, code => callbacks.onStop(code));
-    await new Promise((resolve, _reject) => Cancellation$ReventlessGwt.onCancel(() => resolve()));
-    return 0;
+    let exitCode = {
+      contents: 0
+    };
+    await new Promise((resolve, _reject) => {
+      Cancellation$ReventlessGwt.onCancel(() => resolve());
+      ChildProcess$ReventlessGwt.onError(proc, msg => {
+        callbacks.onLog("platform spawn error: " + msg);
+        callbacks.onStop(undefined);
+        exitCode.contents = 1;
+        resolve();
+      });
+      ChildProcess$ReventlessGwt.onClose(proc, code => {
+        callbacks.onStop(code);
+        exitCode.contents = Stdlib_Option.getOr(code, 0);
+        resolve();
+      });
+    });
+    return exitCode.contents;
   }
   callbacks.onLog("no reventless-local platform package (src/Main.res.mjs + @reventlessdev/reventless-local) found under: " + roots.join(", "));
   return 1;
@@ -148,6 +168,7 @@ export {
   tapSentinel,
   classifyLine,
   openEphemeral,
+  closeServer,
   allocFreePorts,
   fixedPlatformPorts,
   run,

package/src/PlatformScan.res

@@ -105,16 +105,20 @@ let inspectDir = (dir: string): option<platformPkg> => {
 // declaration order preserved). Prunes node_modules/lib/.git like Discovery.
 let rec walk = async (dir: string, acc: array<platformPkg>): array<platformPkg> => {
   switch inspectDir(dir) {
-  | Some(pkg) => acc->Array.push(pkg) // a platform package — record, don't descend into its src
-  | None => ()
-  }
-  let entries = try await _readdir(dir, {withFileTypes: true}) catch {
-  | _ => []
-  }
-  for i in 0 to entries->Array.length - 1 {
-    let entry = entries->Array.getUnsafe(i)
-    if entry._isDirectory() && !Array.includes(ignoreNames, entry.name) {
-      let _ = await walk(join(dir, entry.name), acc)
+  // A platform package — record it and stop: descending into its own subtree
+  // (src/, generated code, nested workspace copies) can only waste I/O or turn
+  // up spurious inner matches. This is what the "don't descend" comment always
+  // intended; the recursion below used to run regardless.
+  | Some(pkg) => acc->Array.push(pkg)
+  | None =>
+    let entries = try await _readdir(dir, {withFileTypes: true}) catch {
+    | _ => []
+    }
+    for i in 0 to entries->Array.length - 1 {
+      let entry = entries->Array.getUnsafe(i)
+      if entry._isDirectory() && !Array.includes(ignoreNames, entry.name) {
+        let _ = await walk(join(dir, entry.name), acc)
+      }
     }
   }
   acc

package/src/PlatformScan.res.mjs

@@ -83,19 +83,20 @@ async function walk(dir, acc) {
   let pkg = inspectDir(dir);
   if (pkg !== undefined) {
     acc.push(pkg);
-  }
-  let entries;
-  try {
-    entries = await Promises.readdir(dir, {
-      withFileTypes: true
-    });
-  } catch (exn) {
-    entries = [];
-  }
-  for (let i = 0, i_finish = entries.length; i < i_finish; ++i) {
-    let entry = entries[i];
-    if (entry.isDirectory() && !ignoreNames.includes(entry.name)) {
-      await walk(Nodepath.join(dir, entry.name), acc);
+  } else {
+    let entries;
+    try {
+      entries = await Promises.readdir(dir, {
+        withFileTypes: true
+      });
+    } catch (exn) {
+      entries = [];
+    }
+    for (let i = 0, i_finish = entries.length; i < i_finish; ++i) {
+      let entry = entries[i];
+      if (entry.isDirectory() && !ignoreNames.includes(entry.name)) {
+        await walk(Nodepath.join(dir, entry.name), acc);
+      }
     }
   }
   return acc;