@reventlessdev/reventless-gwt 1.0.0-alpha.100

package/src/Cli.res.mjs

@@ -0,0 +1,952 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Nodepath from "node:path";
+import * as Nodecrypto from "node:crypto";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_object from "@rescript/runtime/lib/es6/Primitive_object.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Watch$ReventlessGwt from "./Watch.res.mjs";
+import * as Nodeworker_threads from "node:worker_threads";
+import * as Loader$ReventlessGwt from "./Loader.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Worker$ReventlessGwt from "./Worker.res.mjs";
+import * as Outcome$ReventlessGwt from "./Outcome.res.mjs";
+import * as Collector$ReventlessGwt from "./Collector.res.mjs";
+import * as Discovery$ReventlessGwt from "./Discovery.res.mjs";
+import * as LocalHost$ReventlessGwt from "./LocalHost.res.mjs";
+import * as DomainGraph$ReventlessGwt from "./DomainGraph.res.mjs";
+import * as PackageScan$ReventlessGwt from "./PackageScan.res.mjs";
+import * as RunnerTypes$ReventlessGwt from "./RunnerTypes.res.mjs";
+import * as Cancellation$ReventlessGwt from "./Cancellation.res.mjs";
+import * as FormatterTap$ReventlessGwt from "./FormatterTap.res.mjs";
+import * as PlatformScan$ReventlessGwt from "./PlatformScan.res.mjs";
+import * as WatcherProbe$ReventlessGwt from "./WatcherProbe.res.mjs";
+import * as ComponentScan$ReventlessGwt from "./ComponentScan.res.mjs";
+import * as FormatterJson$ReventlessGwt from "./FormatterJson.res.mjs";
+import * as DomainDeadCode$ReventlessGwt from "./DomainDeadCode.res.mjs";
+import * as FormatterHuman$ReventlessGwt from "./FormatterHuman.res.mjs";
+import * as FormatterJunit$ReventlessGwt from "./FormatterJunit.res.mjs";
+import * as PlatformRunner$ReventlessGwt from "./PlatformRunner.res.mjs";
+import * as ProcessManager$ReventlessGwt from "./ProcessManager.res.mjs";
+import * as BuildClassifier$ReventlessGwt from "./BuildClassifier.res.mjs";
+import * as FormatterVsCode$ReventlessGwt from "./FormatterVsCode.res.mjs";
+import * as Platform_ComponentDefinitionsApi$ReventlessCore from "@reventlessdev/reventless-core/src/admin/Platform_ComponentDefinitionsApi.res.mjs";
+
+let toolVersion = "0.1.0";
+
+function sha256(s) {
+  return Nodecrypto.createHash("sha256").update(s).digest("hex");
+}
+
+let lastDomainHash = {
+  contents: undefined
+};
+
+let dateNowIso = (() => new Date().toISOString());
+
+function parseFormat(s) {
+  switch (s) {
+    case "human" :
+      return {
+        TAG: "Ok",
+        _0: "Human"
+      };
+    case "json" :
+      return {
+        TAG: "Ok",
+        _0: "Json"
+      };
+    case "junit" :
+      return {
+        TAG: "Ok",
+        _0: "Junit"
+      };
+    case "tap" :
+      return {
+        TAG: "Ok",
+        _0: "Tap"
+      };
+    case "vscode" :
+      return {
+        TAG: "Ok",
+        _0: "VsCode"
+      };
+    default:
+      return {
+        TAG: "Error",
+        _0: "Unknown --format value: " + s
+      };
+  }
+}
+
+function defaultRoots() {
+  return ["."];
+}
+
+function help() {
+  return `reventless-dev — Reventless dev CLI: GWT runner, domain graph, components, platform runner
+
+USAGE:
+  reventless-dev run [--format=<fmt>] [--filter=<id>] [--stream] [--watch] [path...]
+  reventless-dev discover [--format=vscode] [path...]
+  reventless-dev watch [--format=<fmt>] [--filter=<id>] [path...]
+  reventless-dev platform [--format=vscode] [--backend=<b>] [--ui-ports] [path...]
+  reventless-dev platform --list [path...]
+
+FORMATS:
+  human   ANSI-coloured terminal output (default)
+  json    Structured JSON envelope (--stream for NDJSON)
+  tap     TAP 14 with YAML diagnostics
+  junit   JUnit XML (single batch)
+  vscode  NDJSON event stream for the VS Code Testing API
+
+FLAGS:
+  --filter <id>         Restrict execution to tests whose id contains <id>.
+                        Repeatable.
+  --stream              NDJSON streaming (json/vscode)
+  --watch               Re-run on file change
+  --schema-version <v>  Pin a JSON schema version for stable AI prompts
+  --backend <b>         platform: storage backend for the spawned local platform
+                        ("memory" default, or "sqlite:<path>[?reset]")
+  --ui-ports            platform: pin the platform to the fixed default ports
+                        (4000/4001/3001/3002) instead of ephemeral ones, so the
+                        host-shell UI's Vite proxy can reach it
+  --list                platform: list launchable platform packages as NDJSON
+                        ({name, dir} per line) and exit
+  --help                Show this help and exit
+
+Exit code is 1 if any test failed, 0 otherwise.
+`;
+}
+
+function parseArgv(argv) {
+  let slice = argv.slice(2, argv.length);
+  let subcommand = "Run";
+  let format = "Human";
+  let stream = false;
+  let watch = false;
+  let filters = [];
+  let schemaVersion;
+  let roots = [];
+  let backend = "memory";
+  let uiPorts = false;
+  let listPlatforms = false;
+  let error;
+  let showHelp = false;
+  let i = 0;
+  let len = slice.length;
+  if (len > 0) {
+    let first = slice[0];
+    switch (first) {
+      case "--help" :
+      case "-h" :
+        showHelp = true;
+        break;
+      case "discover" :
+        subcommand = "Discover";
+        format = "VsCode";
+        i = 1;
+        break;
+      case "platform" :
+        subcommand = "Platform";
+        i = 1;
+        break;
+      case "run" :
+        subcommand = "Run";
+        i = 1;
+        break;
+      case "watch" :
+        subcommand = "Watch";
+        watch = true;
+        i = 1;
+        break;
+    }
+  }
+  while (i < len && error === undefined && !showHelp) {
+    let arg = slice[i];
+    if (arg === "--help" || arg === "-h") {
+      showHelp = true;
+    } else if (arg.startsWith("--format=")) {
+      let v = arg.slice(9, arg.length);
+      let f = parseFormat(v);
+      if (f.TAG === "Ok") {
+        format = f._0;
+      } else {
+        error = f._0;
+      }
+    } else if (arg === "--format" && (i + 1 | 0) < len) {
+      let v$1 = slice[i + 1 | 0];
+      let f$1 = parseFormat(v$1);
+      if (f$1.TAG === "Ok") {
+        format = f$1._0;
+      } else {
+        error = f$1._0;
+      }
+      i = i + 1 | 0;
+    } else if (arg.startsWith("--filter=")) {
+      let v$2 = arg.slice(9, arg.length);
+      filters = filters.concat([v$2]);
+    } else if (arg === "--filter" && (i + 1 | 0) < len) {
+      let v$3 = slice[i + 1 | 0];
+      filters = filters.concat([v$3]);
+      i = i + 1 | 0;
+    } else if (arg === "--stream") {
+      stream = true;
+    } else if (arg === "--watch") {
+      watch = true;
+    } else if (arg.startsWith("--schema-version=")) {
+      let v$4 = arg.slice(17, arg.length);
+      schemaVersion = v$4;
+    } else if (arg.startsWith("--backend=")) {
+      backend = arg.slice(10, arg.length);
+    } else if (arg === "--backend" && (i + 1 | 0) < len) {
+      backend = slice[i + 1 | 0];
+      i = i + 1 | 0;
+    } else if (arg === "--ui-ports") {
+      uiPorts = true;
+    } else if (arg === "--list") {
+      listPlatforms = true;
+    } else if (arg.startsWith("--")) {
+      error = "Unknown flag: " + arg;
+    } else {
+      roots = roots.concat([arg]);
+    }
+    i = i + 1 | 0;
+  };
+  if (showHelp) {
+    return {
+      TAG: "Error",
+      _0: `reventless-dev — Reventless dev CLI: GWT runner, domain graph, components, platform runner
+
+USAGE:
+  reventless-dev run [--format=<fmt>] [--filter=<id>] [--stream] [--watch] [path...]
+  reventless-dev discover [--format=vscode] [path...]
+  reventless-dev watch [--format=<fmt>] [--filter=<id>] [path...]
+  reventless-dev platform [--format=vscode] [--backend=<b>] [--ui-ports] [path...]
+  reventless-dev platform --list [path...]
+
+FORMATS:
+  human   ANSI-coloured terminal output (default)
+  json    Structured JSON envelope (--stream for NDJSON)
+  tap     TAP 14 with YAML diagnostics
+  junit   JUnit XML (single batch)
+  vscode  NDJSON event stream for the VS Code Testing API
+
+FLAGS:
+  --filter <id>         Restrict execution to tests whose id contains <id>.
+                        Repeatable.
+  --stream              NDJSON streaming (json/vscode)
+  --watch               Re-run on file change
+  --schema-version <v>  Pin a JSON schema version for stable AI prompts
+  --backend <b>         platform: storage backend for the spawned local platform
+                        ("memory" default, or "sqlite:<path>[?reset]")
+  --ui-ports            platform: pin the platform to the fixed default ports
+                        (4000/4001/3001/3002) instead of ephemeral ones, so the
+                        host-shell UI's Vite proxy can reach it
+  --list                platform: list launchable platform packages as NDJSON
+                        ({name, dir} per line) and exit
+  --help                Show this help and exit
+
+Exit code is 1 if any test failed, 0 otherwise.
+`
+    };
+  }
+  let e = error;
+  if (e !== undefined) {
+    return {
+      TAG: "Error",
+      _0: e + "\n\n" + `reventless-dev — Reventless dev CLI: GWT runner, domain graph, components, platform runner
+
+USAGE:
+  reventless-dev run [--format=<fmt>] [--filter=<id>] [--stream] [--watch] [path...]
+  reventless-dev discover [--format=vscode] [path...]
+  reventless-dev watch [--format=<fmt>] [--filter=<id>] [path...]
+  reventless-dev platform [--format=vscode] [--backend=<b>] [--ui-ports] [path...]
+  reventless-dev platform --list [path...]
+
+FORMATS:
+  human   ANSI-coloured terminal output (default)
+  json    Structured JSON envelope (--stream for NDJSON)
+  tap     TAP 14 with YAML diagnostics
+  junit   JUnit XML (single batch)
+  vscode  NDJSON event stream for the VS Code Testing API
+
+FLAGS:
+  --filter <id>         Restrict execution to tests whose id contains <id>.
+                        Repeatable.
+  --stream              NDJSON streaming (json/vscode)
+  --watch               Re-run on file change
+  --schema-version <v>  Pin a JSON schema version for stable AI prompts
+  --backend <b>         platform: storage backend for the spawned local platform
+                        ("memory" default, or "sqlite:<path>[?reset]")
+  --ui-ports            platform: pin the platform to the fixed default ports
+                        (4000/4001/3001/3002) instead of ephemeral ones, so the
+                        host-shell UI's Vite proxy can reach it
+  --list                platform: list launchable platform packages as NDJSON
+                        ({name, dir} per line) and exit
+  --help                Show this help and exit
+
+Exit code is 1 if any test failed, 0 otherwise.
+`
+    };
+  } else {
+    return {
+      TAG: "Ok",
+      _0: {
+        subcommand: subcommand,
+        format: format,
+        stream: stream,
+        watch: watch,
+        filters: filters,
+        schemaVersion: schemaVersion,
+        roots: roots.length === 0 ? ["."] : roots,
+        backend: backend,
+        uiPorts: uiPorts,
+        listPlatforms: listPlatforms,
+        toolVersion: toolVersion,
+        paths: undefined
+      }
+    };
+  }
+}
+
+function passesFilter(id, filters) {
+  if (filters.length === 0) {
+    return true;
+  } else {
+    return filters.some(f => id.includes(f));
+  }
+}
+
+let exnMessage = (function(e) {
+  if (e == null) return "unknown error"
+  if (typeof e === "string") return e
+  if (typeof e.message === "string" && e.message.length) return e.message
+  if (typeof e.RE_EXN_ID === "string") {
+    var id = e.RE_EXN_ID
+    var tag = id.lastIndexOf(".") >= 0 ? id.slice(id.lastIndexOf(".") + 1) : id
+    return (typeof e._1 === "string" && e._1.length) ? e._1 : tag
+  }
+  return "unknown error"
+});
+
+function raceWithTimeout(body, ms) {
+  let handleRef = {
+    contents: undefined
+  };
+  let timeout = new Promise((resolve, _reject) => {
+    handleRef.contents = Primitive_option.some(setTimeout(() => resolve(Outcome$ReventlessGwt.fail({
+      TAG: "Throw",
+      error: `timed out after ` + ms.toString() + `ms`,
+      stack: ""
+    })), ms));
+  });
+  return Promise.race([
+    body(),
+    timeout
+  ]).then(o => {
+    let h = handleRef.contents;
+    if (h !== undefined) {
+      clearTimeout(Primitive_option.valFromOption(h));
+    }
+    return Promise.resolve(o);
+  });
+}
+
+async function runEntry(entry) {
+  let start = performance.now();
+  let status = "Pass";
+  let mismatch;
+  let match = entry.status;
+  let exit = 0;
+  switch (match) {
+    case "Skipped" :
+      status = "Skip";
+      break;
+    case "Runnable" :
+    case "Only" :
+      exit = 1;
+      break;
+  }
+  if (exit === 1) {
+    try {
+      let deadline = Stdlib_Option.getOr(entry.timeout, 5000);
+      let outcome = await raceWithTimeout(entry.body, deadline);
+      if (outcome.TAG === "Ok") {
+        status = "Pass";
+      } else {
+        status = "Fail";
+        mismatch = outcome._0;
+      }
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      status = "Fail";
+      let err = exnMessage(exn);
+      let stack = ((e => (e && e.stack) || ""))(exn);
+      mismatch = {
+        TAG: "Throw",
+        error: err,
+        stack: stack
+      };
+    }
+  }
+  let durationMs = performance.now() - start;
+  return {
+    id: entry.id,
+    name: entry.name,
+    describePath: entry.describePath,
+    status: status,
+    durationMs: durationMs,
+    location: entry.location,
+    slice: entry.slice,
+    mismatch: mismatch,
+    skipReason: entry.status === "Skipped" ? "skipped at source" : undefined
+  };
+}
+
+async function loadAndCollect(path) {
+  Collector$ReventlessGwt.activate();
+  Collector$ReventlessGwt.setCurrentFile(path);
+  try {
+    await Loader$ReventlessGwt.loadFile(path);
+  } catch (raw_exn) {
+    let exn = Primitive_exceptions.internalToException(raw_exn);
+    let msg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "import failed");
+    Collector$ReventlessGwt.push(undefined, undefined, undefined, `<file-load-error>`, () => Promise.resolve(Outcome$ReventlessGwt.fail({
+      TAG: "Throw",
+      error: "Failed to load " + path + ": " + msg,
+      stack: ""
+    })));
+  }
+  let entries = Collector$ReventlessGwt.drain();
+  Collector$ReventlessGwt.deactivate();
+  return entries;
+}
+
+async function runFiles(opts, paths, onFileFinished, onTestStart, onTestFinished) {
+  let startedAt = dateNowIso();
+  let startTime = performance.now();
+  let files = [];
+  for (let i = 0, i_finish = paths.length; i < i_finish; ++i) {
+    let path = paths[i];
+    if (!Cancellation$ReventlessGwt.isCancelled()) {
+      let entries = await loadAndCollect(path);
+      let onlyActive = Collector$ReventlessGwt.hasOnly.contents;
+      let selected = entries.filter(e => {
+        let keepByOnly = onlyActive ? e.status === "Only" : true;
+        let qualifiedId = path + "::" + e.id;
+        let keepByFilter = passesFilter(e.id, opts.filters) || passesFilter(qualifiedId, opts.filters);
+        if (keepByOnly) {
+          return keepByFilter;
+        } else {
+          return false;
+        }
+      });
+      let tests = [];
+      for (let j = 0, j_finish = selected.length; j < j_finish; ++j) {
+        if (Cancellation$ReventlessGwt.isCancelled()) {
+          let e = selected[j];
+          let r_id = e.id;
+          let r_name = e.name;
+          let r_describePath = e.describePath;
+          let r_location = e.location;
+          let r_slice = e.slice;
+          let r_skipReason = "cancelled";
+          let r = {
+            id: r_id,
+            name: r_name,
+            describePath: r_describePath,
+            status: "Skip",
+            durationMs: 0.0,
+            location: r_location,
+            slice: r_slice,
+            mismatch: undefined,
+            skipReason: r_skipReason
+          };
+          tests.push(r);
+          if (onTestFinished !== undefined) {
+            onTestFinished(path, r);
+          }
+        } else {
+          let entry = selected[j];
+          if (onTestStart !== undefined) {
+            onTestStart(path, entry);
+          }
+          let r$1 = await runEntry(entry);
+          tests.push(r$1);
+          if (onTestFinished !== undefined) {
+            onTestFinished(path, r$1);
+          }
+        }
+      }
+      let fr = {
+        path: path,
+        tests: tests
+      };
+      files.push(fr);
+      if (onFileFinished !== undefined) {
+        onFileFinished(fr);
+      }
+    }
+  }
+  let durationMs = performance.now() - startTime;
+  let summary = RunnerTypes$ReventlessGwt.summaryOf(files, durationMs, startedAt);
+  return {
+    summary: summary,
+    files: files
+  };
+}
+
+function emitResult(opts, r) {
+  let match = opts.format;
+  switch (match) {
+    case "Human" :
+      return FormatterHuman$ReventlessGwt.emit(r);
+    case "Json" :
+      if (opts.stream) {
+        return FormatterJson$ReventlessGwt.streamRunEnd(r);
+      } else {
+        return FormatterJson$ReventlessGwt.emit(r, opts.toolVersion, opts.schemaVersion);
+      }
+    case "Tap" :
+      return FormatterTap$ReventlessGwt.emit(r);
+    case "Junit" :
+      return FormatterJunit$ReventlessGwt.emit(r);
+    case "VsCode" :
+      return FormatterVsCode$ReventlessGwt.runEnd(r.summary);
+  }
+}
+
+function mergeScope(a, b) {
+  if (typeof a !== "object") {
+    return "RunAll";
+  }
+  if (typeof b !== "object") {
+    return "RunAll";
+  }
+  let seen = {};
+  let union = [];
+  a._0.concat(b._0).forEach(d => {
+    let match = seen[d];
+    if (match !== undefined) {
+      return;
+    } else {
+      seen[d] = true;
+      union.push(d);
+      return;
+    }
+  });
+  return {
+    TAG: "RunPackages",
+    _0: union
+  };
+}
+
+function pathUnderDir(path, dir) {
+  return path.startsWith(dir.endsWith("/") ? dir : dir + "/");
+}
+
+function scopeSubset(scope, allPaths) {
+  if (typeof scope !== "object") {
+    return allPaths;
+  }
+  let dirs = scope._0;
+  return allPaths.filter(p => dirs.some(d => pathUnderDir(p, d)));
+}
+
+async function runOnce(opts) {
+  let p = opts.paths;
+  let paths = p !== undefined ? p : await Discovery$ReventlessGwt.discover(opts.roots);
+  if (opts.format === "Json" && opts.stream) {
+    FormatterJson$ReventlessGwt.streamRunStart(opts.toolVersion, dateNowIso(), opts.schemaVersion);
+  }
+  let match = opts.format;
+  let match$1 = opts.stream;
+  let onFileFinished;
+  onFileFinished = match === "Json" && match$1 ? f => {
+      f.tests.forEach(FormatterJson$ReventlessGwt.streamTest);
+      FormatterJson$ReventlessGwt.streamFileFinished(f);
+    } : undefined;
+  let onTestStart = opts.format === "VsCode" ? (path, e) => FormatterVsCode$ReventlessGwt.testStart(path + "::" + e.id) : undefined;
+  let onTestFinished = opts.format === "VsCode" ? (path, t) => {
+      let id = path + "::" + t.id;
+      let match = t.status;
+      switch (match) {
+        case "Pass" :
+          return FormatterVsCode$ReventlessGwt.testPass(id, t.durationMs);
+        case "Fail" :
+          return FormatterVsCode$ReventlessGwt.testFail(t, id);
+        case "Skip" :
+          return FormatterVsCode$ReventlessGwt.testSkip(id, Stdlib_Option.getOr(t.skipReason, "skipped"));
+      }
+    } : undefined;
+  if (opts.format === "Json" && opts.stream) {
+    paths.forEach(FormatterJson$ReventlessGwt.streamFileStart);
+  } else if (opts.format === "VsCode") {
+    FormatterVsCode$ReventlessGwt.runStart(0, opts.filters);
+  }
+  let result = await runFiles(opts, paths, onFileFinished, onTestStart, onTestFinished);
+  emitResult(opts, result);
+  if (result.summary.failed > 0) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+async function emitDomainAnalysis(pkgs) {
+  let plugins = LocalHost$ReventlessGwt.discover(pkgs.map(p => p.dir));
+  if (plugins.length === 0) {
+    return;
+  }
+  let platformModulePath = LocalHost$ReventlessGwt.resolveLocalPlatform(plugins[0].packageDir);
+  if (platformModulePath === undefined) {
+    return;
+  }
+  try {
+    let loaded = await LocalHost$ReventlessGwt.loadGraph(platformModulePath, plugins);
+    let definitions = loaded.structures.map(param => Platform_ComponentDefinitionsApi$ReventlessCore.encodePluginStructureEntry(param[0], param[1]));
+    let fingerprint = sha256(JSON.stringify(definitions));
+    if (Primitive_object.notequal(lastDomainHash.contents, fingerprint)) {
+      lastDomainHash.contents = fingerprint;
+      FormatterVsCode$ReventlessGwt.deadCode(DomainDeadCode$ReventlessGwt.analyze(loaded.structures));
+      FormatterVsCode$ReventlessGwt.graph(DomainGraph$ReventlessGwt.build(loaded.structures));
+      return FormatterVsCode$ReventlessGwt.definitions(definitions);
+    } else {
+      return;
+    }
+  } catch (exn) {
+    return;
+  }
+}
+
+async function emitDiscovery(paths) {
+  FormatterVsCode$ReventlessGwt.discoverStart();
+  let fileTests = [];
+  for (let i = 0, i_finish = paths.length; i < i_finish; ++i) {
+    let path = paths[i];
+    let entries = await loadAndCollect(path);
+    let tests = entries.map(e => ({
+      id: e.id,
+      name: e.name,
+      describePath: e.describePath,
+      status: "Skip",
+      durationMs: 0.0,
+      location: e.location,
+      slice: e.slice,
+      mismatch: undefined,
+      skipReason: undefined
+    }));
+    fileTests.push([
+      path,
+      tests
+    ]);
+  }
+  FormatterVsCode$ReventlessGwt.emitDiscoveryItems(fileTests);
+  let total = Stdlib_Array.reduce(fileTests, 0, (a, param) => a + param[1].length | 0);
+  let pkgs = PackageScan$ReventlessGwt.scan(paths);
+  FormatterVsCode$ReventlessGwt.packages(pkgs);
+  let comps = await ComponentScan$ReventlessGwt.scan(pkgs.map(p => p.dir));
+  FormatterVsCode$ReventlessGwt.components(comps);
+  FormatterVsCode$ReventlessGwt.discoverEnd(total);
+  return await emitDomainAnalysis(pkgs);
+}
+
+async function runDiscover(opts) {
+  let paths = await Discovery$ReventlessGwt.discover(opts.roots);
+  await emitDiscovery(paths);
+  return 0;
+}
+
+function startBuildWatchers(paths) {
+  Cancellation$ReventlessGwt.onCancel(ProcessManager$ReventlessGwt.killAll);
+  PackageScan$ReventlessGwt.scan(paths).forEach(pkg => {
+    if (WatcherProbe$ReventlessGwt.hasLiveWatcher(pkg.dir)) {
+      return FormatterVsCode$ReventlessGwt.buildExternal(pkg.dir);
+    }
+    let feed = BuildClassifier$ReventlessGwt.make(undefined, {
+      onStart: () => FormatterVsCode$ReventlessGwt.buildStart(pkg.dir),
+      onOk: ms => FormatterVsCode$ReventlessGwt.buildOk(pkg.dir, ms),
+      onFail: msg => FormatterVsCode$ReventlessGwt.buildFail(pkg.dir, msg)
+    });
+    ProcessManager$ReventlessGwt.spawnWatcher(pkg, (_dir, line) => feed(line));
+  });
+}
+
+async function runWatch(opts) {
+  let roots = opts.roots;
+  let discoveredPaths = {
+    contents: []
+  };
+  if (opts.format === "VsCode") {
+    let paths = await Discovery$ReventlessGwt.discover(roots);
+    discoveredPaths.contents = paths;
+    await emitDiscovery(paths);
+    startBuildWatchers(paths);
+  }
+  let currentWorker = {
+    contents: undefined
+  };
+  Cancellation$ReventlessGwt.onCancel(() => {
+    let w = currentWorker.contents;
+    if (w !== undefined) {
+      Primitive_option.valFromOption(w).terminate();
+      return;
+    }
+  });
+  let runInWorker = paths => new Promise((resolve, _reject) => {
+    let w = new Nodeworker_threads.Worker(Worker$ReventlessGwt.runWorkerUrl, {
+      workerData: {
+        subcommand: opts.subcommand,
+        format: opts.format,
+        stream: opts.stream,
+        watch: opts.watch,
+        filters: opts.filters,
+        schemaVersion: opts.schemaVersion,
+        roots: opts.roots,
+        backend: opts.backend,
+        uiPorts: opts.uiPorts,
+        listPlatforms: opts.listPlatforms,
+        toolVersion: opts.toolVersion,
+        paths: paths
+      }
+    });
+    currentWorker.contents = Primitive_option.some(w);
+    let settled = {
+      contents: false
+    };
+    let settle = () => {
+      if (!settled.contents) {
+        settled.contents = true;
+        currentWorker.contents = undefined;
+        return resolve();
+      }
+    };
+    w.on("exit", _code => settle());
+    w.on("error", e => {
+      console.error("gwt run worker error:", e);
+      settle();
+    });
+  });
+  let pathsForScope = scope => {
+    if (opts.format === "VsCode") {
+      return scopeSubset(scope, discoveredPaths.contents);
+    }
+  };
+  let runInProgress = {
+    contents: false
+  };
+  let pendingScope = {
+    contents: undefined
+  };
+  let requestRun = async scope => {
+    if (runInProgress.contents) {
+      let s = pendingScope.contents;
+      pendingScope.contents = s !== undefined ? mergeScope(s, scope) : scope;
+      return;
+    }
+    runInProgress.contents = true;
+    await runInWorker(pathsForScope(scope));
+    let drain = async () => {
+      let next = pendingScope.contents;
+      if (next !== undefined) {
+        pendingScope.contents = undefined;
+        await runInWorker(pathsForScope(next));
+        return await drain();
+      } else {
+        runInProgress.contents = false;
+        return;
+      }
+    };
+    return await drain();
+  };
+  await requestRun("RunAll");
+  let rediscoverAndRun = async () => {
+    if (opts.format === "VsCode") {
+      discoveredPaths.contents = await Discovery$ReventlessGwt.discover(roots);
+    }
+    await requestRun("RunAll");
+  };
+  let rebuilding = {};
+  let refreshDiscovery = async () => {
+    let paths = await Discovery$ReventlessGwt.discover(roots);
+    discoveredPaths.contents = paths;
+    await emitDiscovery(paths);
+    startBuildWatchers(paths);
+    await requestRun("RunAll");
+  };
+  let affectedScope = path => {
+    if (opts.format !== "VsCode") {
+      return "RunAll";
+    }
+    let abs = Nodepath.resolve(path);
+    let pkg = PackageScan$ReventlessGwt.findOwning(Nodepath.dirname(abs));
+    if (pkg !== undefined && discoveredPaths.contents.some(p => pathUnderDir(p, pkg.dir))) {
+      return {
+        TAG: "RunPackages",
+        _0: [pkg.dir]
+      };
+    } else {
+      return "RunAll";
+    }
+  };
+  Watch$ReventlessGwt.start(roots, (event, path) => {
+    if (opts.format === "VsCode" && Watch$ReventlessGwt.isStructuralSource(event, path)) {
+      let pkg = PackageScan$ReventlessGwt.findOwning(path);
+      if (pkg !== undefined) {
+        if (Stdlib_Option.getOr(rebuilding[pkg.dir], false)) {
+          return;
+        }
+        rebuilding[pkg.dir] = true;
+        let t0 = Date.now();
+        FormatterVsCode$ReventlessGwt.buildStart(pkg.dir);
+        let sawError = {
+          contents: false
+        };
+        let feed = BuildClassifier$ReventlessGwt.make(undefined, {
+          onStart: () => {},
+          onOk: _ms => {},
+          onFail: msg => {
+            sawError.contents = true;
+            FormatterVsCode$ReventlessGwt.buildFail(pkg.dir, msg);
+          }
+        });
+        return ProcessManager$ReventlessGwt.cleanRebuild(pkg, (_dir, line) => feed(line), ok => {
+          rebuilding[pkg.dir] = false;
+          if (ok) {
+            FormatterVsCode$ReventlessGwt.buildOk(pkg.dir, Date.now() - t0);
+          } else if (!sawError.contents) {
+            FormatterVsCode$ReventlessGwt.buildFail(pkg.dir, "clean rebuild failed");
+          }
+          rediscoverAndRun();
+        });
+      }
+      requestRun("RunAll");
+      return;
+    } else {
+      if (opts.format === "VsCode" && event === "Add" && path.endsWith(".res")) {
+        refreshDiscovery();
+      } else {
+        requestRun(affectedScope(path));
+      }
+      return;
+    }
+  });
+  await new Promise((resolve, _reject) => Cancellation$ReventlessGwt.onCancel(() => resolve()));
+  return 0;
+}
+
+async function runPlatform(opts) {
+  let callbacks = opts.format === "VsCode" ? ({
+      onStart: FormatterVsCode$ReventlessGwt.platformStart,
+      onReady: FormatterVsCode$ReventlessGwt.platformReady,
+      onDomainEvent: FormatterVsCode$ReventlessGwt.domainEvent,
+      onLog: FormatterVsCode$ReventlessGwt.platformLog,
+      onStop: FormatterVsCode$ReventlessGwt.platformStop
+    }) : ({
+      onStart: ($$package, param, domainPort, param$1) => {
+        console.log(`▶ platform ` + $$package + ` starting (domain http://localhost:` + domainPort.toString() + `)`);
+      },
+      onReady: domainEndpoint => {
+        console.log(`✓ platform ready — ` + domainEndpoint);
+      },
+      onDomainEvent: json => {
+        console.log("· event " + JSON.stringify(json));
+      },
+      onLog: line => {
+        console.log(line);
+      },
+      onStop: code => {
+        console.log(`■ platform stopped (code ` + Stdlib_Option.mapOr(code, "?", c => c.toString()) + `)`);
+      }
+    });
+  return await PlatformRunner$ReventlessGwt.run(opts.roots, opts.backend, opts.uiPorts, callbacks);
+}
+
+async function listPlatforms(opts) {
+  let pkgs = await PlatformScan$ReventlessGwt.scan(opts.roots);
+  pkgs.forEach(pkg => {
+    let obj = Object.fromEntries([
+      [
+        "name",
+        pkg.name
+      ],
+      [
+        "dir",
+        pkg.dir
+      ]
+    ]);
+    console.log(JSON.stringify(obj));
+  });
+  return 0;
+}
+
+async function main() {
+  Cancellation$ReventlessGwt.install();
+  let args = process.argv;
+  let msg = parseArgv(args);
+  if (msg.TAG === "Ok") {
+    let opts = msg._0;
+    if (opts.format === "VsCode") {
+      FormatterVsCode$ReventlessGwt.hello();
+    }
+    let match = opts.subcommand;
+    switch (match) {
+      case "Run" :
+        return await runOnce(opts);
+      case "Discover" :
+        return await runDiscover(opts);
+      case "Watch" :
+        return await runWatch(opts);
+      case "Platform" :
+        if (opts.listPlatforms) {
+          return await listPlatforms(opts);
+        } else {
+          return await runPlatform(opts);
+        }
+    }
+  } else {
+    console.error(msg._0);
+    if (args.some(a => a === "--help" ? true : a === "-h")) {
+      return 0;
+    } else {
+      return 2;
+    }
+  }
+}
+
+let defaultTimeoutMs = 5000;
+
+export {
+  toolVersion,
+  sha256,
+  lastDomainHash,
+  dateNowIso,
+  parseFormat,
+  defaultRoots,
+  help,
+  parseArgv,
+  passesFilter,
+  exnMessage,
+  defaultTimeoutMs,
+  raceWithTimeout,
+  runEntry,
+  loadAndCollect,
+  runFiles,
+  emitResult,
+  mergeScope,
+  pathUnderDir,
+  scopeSubset,
+  runOnce,
+  emitDomainAnalysis,
+  emitDiscovery,
+  runDiscover,
+  startBuildWatchers,
+  runWatch,
+  runPlatform,
+  listPlatforms,
+  main,
+}
+/* node:path Not a pure module */