@reventlessdev/reventless-gwt 1.0.0-alpha.100

package/src/BuildClassifier.res

@@ -0,0 +1,147 @@
+// Turns a ReScript v12 `rescript build -w` stdout line-stream into build status
+// callbacks. One classifier per managed package.
+//
+// The watch output cycle is:
+//   Parsed N source files          ← a compile pass begins
+//   Compiled N modules
+//   Finished incremental compilation   ← success terminator
+// On a type/syntax error there is NO terminator — rescript prints a
+// "We've found a bug for you!" block and waits. So success is detected on the
+// "Finished … compilation" line; failure is detected by an error marker and
+// flushed after the output settles (debounced), since there is no end line.
+//
+// Backstop: a build that prints "Parsed …" but then emits neither a terminator
+// nor a recognised error marker — a crashed/hung watcher, or an error in a form
+// the markers miss — would otherwise pin the consumer (the VS Code status bar)
+// at "building" forever. A generous wall-clock watchdog fails such a build so
+// the UI recovers.
+
+@val external now: unit => float = "performance.now"
+@val external setTimeout: (unit => unit, int) => float = "setTimeout"
+@val external clearTimeout: float => unit = "clearTimeout"
+
+let stripAnsi: string => string = %raw(`s => s.replace(/\x1b\[[0-9;]*m/g, "")`)
+
+type callbacks = {
+  onStart: unit => unit,
+  onOk: float => unit,
+  onFail: string => unit,
+}
+
+let isStartLine = (l: string) =>
+  String.startsWith(l, "Parsed ") && String.endsWith(l, "source files")
+
+let isFinishLine = (l: string) =>
+  String.includes(l, "Finished") && String.includes(l, "compilation")
+
+let isErrorMarker = (l: string) =>
+  String.includes(l, "We've found a bug for you!") ||
+  String.includes(l, "Syntax error") ||
+  (String.startsWith(l, "Found ") && String.includes(l, "error"))
+
+// Returns a `feed` function: hand it each raw stdout line. `watchdogMs` bounds
+// how long a started-but-unterminated compile may stay "building" before it is
+// reported failed (see the backstop note above).
+let make = (~watchdogMs: int=120_000, cb: callbacks): (string => unit) => {
+  let compiling = ref(false)
+  let hasError = ref(false)
+  let startTime = ref(0.0)
+  let buffer = ref([])
+  let timer: ref<option<float>> = ref(None)
+  let watchdog: ref<option<float>> = ref(None)
+
+  let clearTimer = () =>
+    switch timer.contents {
+    | Some(t) => {
+        clearTimeout(t)
+        timer := None
+      }
+    | None => ()
+    }
+
+  let clearWatchdog = () =>
+    switch watchdog.contents {
+    | Some(t) => {
+        clearTimeout(t)
+        watchdog := None
+      }
+    | None => ()
+    }
+
+  let reset = () => {
+    compiling := false
+    hasError := false
+    buffer := []
+  }
+
+  // Cap the failure message so a pathological build can't emit an unbounded
+  // line. 20 was too tight — a multi-error build has several "We've found a bug"
+  // blocks and the tail (later errors) was silently dropped; keep enough to
+  // carry a handful of blocks.
+  let maxMessageLines = 200
+
+  // After output settles, a build that saw an error (and thus no "Finished"
+  // terminator) is reported failed, capturing a concise message. The condition
+  // is `hasError` alone — not `compiling && hasError` — so an error emitted
+  // *before* the first "Parsed …" line (a crashed toolchain, a pnpm/resolution
+  // failure) still settles into an `onFail` instead of leaving the consumer
+  // pinned at its previous state forever.
+  let settle = () =>
+    if hasError.contents {
+      let msg = buffer.contents->Array.slice(~start=0, ~end=maxMessageLines)->Array.join("\n")
+      clearWatchdog()
+      cb.onFail(msg)
+      reset()
+    }
+
+  let arm = () => {
+    clearTimer()
+    timer := Some(setTimeout(settle, 400))
+  }
+
+  // Last-resort timer: fail a build still compiling after `watchdogMs` with no
+  // terminator and no recognised error, so the consumer never spins forever.
+  let armWatchdog = () => {
+    clearWatchdog()
+    watchdog :=
+      Some(
+        setTimeout(() =>
+          if compiling.contents {
+            clearTimer()
+            cb.onFail("build watchdog: no completion within " ++ Int.toString(watchdogMs / 1000) ++ "s")
+            reset()
+          }
+        , watchdogMs),
+      )
+  }
+
+  line => {
+    let l = stripAnsi(line)->String.trim
+    if isStartLine(l) {
+      if !compiling.contents {
+        cb.onStart()
+      }
+      compiling := true
+      hasError := false
+      buffer := []
+      startTime := now()
+      arm()
+      armWatchdog()
+    } else if isFinishLine(l) {
+      clearTimer()
+      clearWatchdog()
+      if compiling.contents {
+        cb.onOk(now() -. startTime.contents)
+        reset()
+      }
+    } else {
+      if String.length(l) > 0 {
+        buffer.contents->Array.push(l)
+      }
+      if isErrorMarker(l) {
+        hasError := true
+      }
+      arm()
+    }
+  }
+}

package/src/BuildClassifier.res.mjs

@@ -0,0 +1,136 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let stripAnsi = (s => s.replace(/\x1b\[[0-9;]*m/g, ""));
+
+function isStartLine(l) {
+  if (l.startsWith("Parsed ")) {
+    return l.endsWith("source files");
+  } else {
+    return false;
+  }
+}
+
+function isFinishLine(l) {
+  if (l.includes("Finished")) {
+    return l.includes("compilation");
+  } else {
+    return false;
+  }
+}
+
+function isErrorMarker(l) {
+  if (l.includes("We've found a bug for you!") || l.includes("Syntax error")) {
+    return true;
+  } else if (l.startsWith("Found ")) {
+    return l.includes("error");
+  } else {
+    return false;
+  }
+}
+
+function make(watchdogMsOpt, cb) {
+  let watchdogMs = watchdogMsOpt !== undefined ? watchdogMsOpt : 120000;
+  let compiling = {
+    contents: false
+  };
+  let hasError = {
+    contents: false
+  };
+  let startTime = {
+    contents: 0.0
+  };
+  let buffer = {
+    contents: []
+  };
+  let timer = {
+    contents: undefined
+  };
+  let watchdog = {
+    contents: undefined
+  };
+  let clearTimer = () => {
+    let t = timer.contents;
+    if (t !== undefined) {
+      clearTimeout(t);
+      timer.contents = undefined;
+      return;
+    }
+  };
+  let clearWatchdog = () => {
+    let t = watchdog.contents;
+    if (t !== undefined) {
+      clearTimeout(t);
+      watchdog.contents = undefined;
+      return;
+    }
+  };
+  let reset = () => {
+    compiling.contents = false;
+    hasError.contents = false;
+    buffer.contents = [];
+  };
+  let settle = () => {
+    if (!hasError.contents) {
+      return;
+    }
+    let msg = buffer.contents.slice(0, 200).join("\n");
+    clearWatchdog();
+    cb.onFail(msg);
+    reset();
+  };
+  let arm = () => {
+    clearTimer();
+    timer.contents = setTimeout(settle, 400);
+  };
+  let armWatchdog = () => {
+    clearWatchdog();
+    watchdog.contents = setTimeout(() => {
+      if (compiling.contents) {
+        clearTimer();
+        cb.onFail("build watchdog: no completion within " + (watchdogMs / 1000 | 0).toString() + "s");
+        return reset();
+      }
+    }, watchdogMs);
+  };
+  return line => {
+    let l = stripAnsi(line).trim();
+    if (isStartLine(l)) {
+      if (!compiling.contents) {
+        cb.onStart();
+      }
+      compiling.contents = true;
+      hasError.contents = false;
+      buffer.contents = [];
+      startTime.contents = performance.now();
+      arm();
+      return armWatchdog();
+    } else if (isFinishLine(l)) {
+      clearTimer();
+      clearWatchdog();
+      if (compiling.contents) {
+        cb.onOk(performance.now() - startTime.contents);
+        return reset();
+      } else {
+        return;
+      }
+    } else {
+      if (l.length > 0) {
+        buffer.contents.push(l);
+      }
+      if (isErrorMarker(l)) {
+        hasError.contents = true;
+      }
+      return arm();
+    }
+  };
+}
+
+export {
+  stripAnsi,
+  isStartLine,
+  isFinishLine,
+  isErrorMarker,
+  make,
+}
+/* No side effect */

package/src/Cancellation.res

@@ -0,0 +1,37 @@
+// SIGINT / SIGTERM trap. Sets a module-level flag that the main loop
+// polls between tests. The VS Code and JSON streaming formatters flush a
+// `runEnd` event with the skipped remainder before the process exits.
+
+type process
+@val external process: process = "process"
+@send external onSignal: (process, string, unit => unit) => unit = "on"
+@send external exit: (process, int) => unit = "exit"
+
+let cancelled = ref(false)
+let handlers: ref<array<unit => unit>> = ref([])
+
+let isCancelled = () => cancelled.contents
+
+let onCancel = (handler: unit => unit) =>
+  handlers := Array.concat(handlers.contents, [handler])
+
+let install = () => {
+  let handler = () => {
+    if !cancelled.contents {
+      cancelled := true
+      handlers.contents->Array.forEach(h =>
+        try h() catch {
+        | _ => ()
+        }
+      )
+    } else {
+      // Second signal: the first requested a graceful drain, but a hung await
+      // can keep the process alive indefinitely. Honour the operator's repeat
+      // SIGINT/SIGTERM as a hard exit (130 = terminated by SIGINT) so only the
+      // one signal — not SIGKILL — is needed to break out.
+      process->exit(130)
+    }
+  }
+  process->onSignal("SIGINT", handler)
+  process->onSignal("SIGTERM", handler)
+}

package/src/Cancellation.res.mjs

@@ -0,0 +1,46 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let cancelled = {
+  contents: false
+};
+
+let handlers = {
+  contents: []
+};
+
+function isCancelled() {
+  return cancelled.contents;
+}
+
+function onCancel(handler) {
+  handlers.contents = handlers.contents.concat([handler]);
+}
+
+function install() {
+  let handler = () => {
+    if (cancelled.contents) {
+      process.exit(130);
+    } else {
+      cancelled.contents = true;
+      handlers.contents.forEach(h => {
+        try {
+          return h();
+        } catch (exn) {
+          return;
+        }
+      });
+    }
+  };
+  process.on("SIGINT", handler);
+  process.on("SIGTERM", handler);
+}
+
+export {
+  cancelled,
+  handlers,
+  isCancelled,
+  onCancel,
+  install,
+}
+/* No side effect */

package/src/ChildProcess.res

@@ -0,0 +1,102 @@
+// Minimal `node:child_process` binding for the watch-mode build manager. The
+// only consumer is ProcessManager, which spawns one `pnpm run start`
+// (`rescript build -w`) per package. Children are spawned **detached** so each
+// gets its own process group; killing the negative pid then tears down the whole
+// tree (pnpm + the rescript watcher it spawns) — no orphaned compilers.
+
+type t
+type stream
+
+type spawnOptions = {
+  cwd: string,
+  detached: bool,
+  env: Dict.t<string>,
+}
+
+@module("node:child_process")
+external _spawn: (string, array<string>, spawnOptions) => t = "spawn"
+
+@val external _processEnv: Dict.t<string> = "process.env"
+
+// Merge the current process env with optional overrides into a fresh dict — node's
+// `spawn` replaces the whole env, so callers that pass `~env` still inherit PATH etc.
+let mergeEnv = (overrides: option<Dict.t<string>>): Dict.t<string> => {
+  let m = Dict.make()
+  _processEnv->Dict.toArray->Array.forEach(((k, v)) => m->Dict.set(k, v))
+  switch overrides {
+  | Some(o) => o->Dict.toArray->Array.forEach(((k, v)) => m->Dict.set(k, v))
+  | None => ()
+  }
+  m
+}
+
+@get external _pid: t => Nullable.t<int> = "pid"
+@get external _stdout: t => stream = "stdout"
+@get external _stderr: t => stream = "stderr"
+@send external _streamSetEncoding: (stream, string) => unit = "setEncoding"
+@send external _streamOn: (stream, string, string => unit) => unit = "on"
+@send external _streamOnEnd: (stream, string, unit => unit) => unit = "on"
+@send external _procOnClose: (t, string, Nullable.t<int> => unit) => unit = "on"
+@send external _procOnError: (t, string, JsExn.t => unit) => unit = "on"
+@send external _kill: (t, string) => bool = "kill"
+@val external _processKill: (int, string) => unit = "process.kill"
+
+let spawn = (cmd: string, args: array<string>, ~cwd: string, ~env: option<Dict.t<string>>=?): t =>
+  _spawn(cmd, args, {cwd, detached: true, env: mergeEnv(env)})
+
+let pid = (proc: t): option<int> => proc->_pid->Nullable.toOption
+
+// Subscribe to a stream line-by-line (stdout or stderr), buffering partial
+// chunks. Used to classify ReScript compiler markers in Phase 5. On stream
+// `end` the final unterminated line is flushed — crash/panic messages
+// typically lack a trailing newline, so without this the last (often most
+// diagnostic) line was silently dropped.
+let onLines = (s: stream, cb: string => unit): unit => {
+  _streamSetEncoding(s, "utf8")
+  let buf = ref("")
+  _streamOn(s, "data", chunk => {
+    buf := buf.contents ++ chunk
+    let rec drain = () =>
+      switch String.indexOf(buf.contents, "\n") {
+      | -1 => ()
+      | idx => {
+          let line = String.slice(buf.contents, ~start=0, ~end=idx)
+          buf := String.slice(buf.contents, ~start=idx + 1, ~end=String.length(buf.contents))
+          cb(line)
+          drain()
+        }
+      }
+    drain()
+  })
+  _streamOnEnd(s, "end", () =>
+    if buf.contents != "" {
+      let last = buf.contents
+      buf := ""
+      cb(last)
+    }
+  )
+}
+
+let onStdoutLine = (proc: t, cb: string => unit): unit => onLines(proc->_stdout, cb)
+let onStderrLine = (proc: t, cb: string => unit): unit => onLines(proc->_stderr, cb)
+let onClose = (proc: t, cb: option<int> => unit): unit =>
+  _procOnClose(proc, "close", code => cb(code->Nullable.toOption))
+
+// A spawn failure (ENOENT for a missing binary, EACCES, …) emits `"error"` on
+// the child, not `"close"`. Without a listener Node re-throws it as an uncaught
+// exception and crashes the whole CLI. Route the message to the caller instead.
+let onError = (proc: t, cb: string => unit): unit =>
+  _procOnError(proc, "error", e => cb(e->JsExn.message->Option.getOr("spawn failed")))
+
+// Kill the child's whole process group (negative pid) so the rescript watcher
+// pnpm spawned dies too. Falls back to a direct kill if the pid is gone.
+let killTree = (proc: t, signal: string): unit =>
+  switch proc->pid {
+  | Some(p) =>
+    try {
+      _processKill(-p, signal)
+    } catch {
+    | _ => ignore(proc->_kill(signal))
+    }
+  | None => ignore(proc->_kill(signal))
+  }

package/src/ChildProcess.res.mjs

@@ -0,0 +1,107 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+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_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Nodechild_process from "node:child_process";
+
+function mergeEnv(overrides) {
+  let m = {};
+  Object.entries(process.env).forEach(param => {
+    m[param[0]] = param[1];
+  });
+  if (overrides !== undefined) {
+    Object.entries(overrides).forEach(param => {
+      m[param[0]] = param[1];
+    });
+  }
+  return m;
+}
+
+function spawn(cmd, args, cwd, env) {
+  return Nodechild_process.spawn(cmd, args, {
+    cwd: cwd,
+    detached: true,
+    env: mergeEnv(env)
+  });
+}
+
+function pid(proc) {
+  return Primitive_option.fromNullable(proc.pid);
+}
+
+function onLines(s, cb) {
+  s.setEncoding("utf8");
+  let buf = {
+    contents: ""
+  };
+  s.on("data", chunk => {
+    buf.contents = buf.contents + chunk;
+    let drain = () => {
+      while (true) {
+        let idx = buf.contents.indexOf("\n");
+        if (idx === -1) {
+          return;
+        }
+        let line = buf.contents.slice(0, idx);
+        buf.contents = buf.contents.slice(idx + 1 | 0, buf.contents.length);
+        cb(line);
+        continue;
+      };
+    };
+    drain();
+  });
+  s.on("end", () => {
+    if (buf.contents === "") {
+      return;
+    }
+    let last = buf.contents;
+    buf.contents = "";
+    cb(last);
+  });
+}
+
+function onStdoutLine(proc, cb) {
+  onLines(proc.stdout, cb);
+}
+
+function onStderrLine(proc, cb) {
+  onLines(proc.stderr, cb);
+}
+
+function onClose(proc, cb) {
+  proc.on("close", code => cb((code == null) ? undefined : Primitive_option.some(code)));
+}
+
+function onError(proc, cb) {
+  proc.on("error", e => cb(Stdlib_Option.getOr(Stdlib_JsExn.message(e), "spawn failed")));
+}
+
+function killTree(proc, signal) {
+  let p = Primitive_option.fromNullable(proc.pid);
+  if (p !== undefined) {
+    try {
+      process.kill(-p | 0, signal);
+      return;
+    } catch (exn) {
+      proc.kill(signal);
+      return;
+    }
+  } else {
+    proc.kill(signal);
+    return;
+  }
+}
+
+export {
+  mergeEnv,
+  spawn,
+  pid,
+  onLines,
+  onStdoutLine,
+  onStderrLine,
+  onClose,
+  onError,
+  killTree,
+}
+/* Stdlib_JsExn Not a pure module */