@dbx-tools/projen 0.6.142 → 0.6.144

package/src/uniffi.ts

@@ -0,0 +1,50 @@
+const defaultedParameters = (source: string): Map<string, Set<string>> => {
+  const methods = new Map<string, Set<string>>();
+  for (const match of source.matchAll(/^\s*(?:async\s+)?(\w+)\(([^)]*)\)/gm)) {
+    const parameters = match[2]
+      .split(",")
+      .map((parameter) => parameter.trim())
+      .filter((parameter) => parameter.includes("="))
+      .map((parameter) => parameter.match(/^(\w+)\s*:/)?.[1])
+      .filter((parameter): parameter is string => parameter !== undefined);
+    if (parameters.length > 0) methods.set(match[1], new Set(parameters));
+  }
+  return methods;
+};
+
+export const makeDefaultedInterfaceParametersOptional = (source: string): string => {
+  const defaults = defaultedParameters(source);
+  return source.replace(/export interface \w+Like \{[\s\S]*?^\}/gm, (block) =>
+    block.replace(/^(\s*)(\w+)\(([^)]*)\)/gm, (signature, indent, method, parameters) => {
+      const defaulted = defaults.get(method);
+      if (!defaulted) return signature;
+      const repaired = parameters
+        .split(",")
+        .map((parameter: string) => {
+          const match = parameter.match(/^(\s*)(\w+)(\s*:\s*.*)$/);
+          if (!match || !defaulted.has(match[2])) return parameter;
+          return `${match[1]}${match[2]}?${match[3]}`;
+        })
+        .join(",");
+      return `${indent}${method}(${repaired})`;
+    }),
+  );
+};
+
+export interface TypeScriptBindingModule {
+  readonly specifier: string;
+  readonly source: string;
+}
+
+/** Add explicit type exports for interfaces that TypeScript misses through UBRN's star exports. */
+export const addExplicitInterfaceReexports = (
+  facade: string,
+  modules: readonly TypeScriptBindingModule[],
+): string => {
+  const exports = modules.flatMap(({ specifier, source }) => {
+    const names = [...source.matchAll(/^export interface (\w+)/gm)].map((match) => match[1]!);
+    return names.length > 0 ? [`export type { ${names.join(", ")} } from '${specifier}';`] : [];
+  });
+  if (exports.length === 0) return facade;
+  return `${facade.trimEnd()}\n${exports.join("\n")}\n`;
+};

package/tasks/barrels.ts

@@ -1,18 +1,27 @@
 #!/usr/bin/env -S bun
 import { sep } from "node:path";
+import { parseArgs } from "node:util";
 import { log, string } from "@dbx-tools/shared-core";
 import { generateBarrels } from "../src/barrels.ts";
 import { recordedPackages } from "../src/packages.ts";
 import { watchLoop, watchRoots } from "../src/watch.ts";
 
 const logger = log.logger("projen:barrels");
+const { values } = parseArgs({
+  args: process.argv.slice(2),
+  options: {
+    watch: { type: "boolean" },
+    dir: { type: "string", multiple: true },
+  },
+  strict: false,
+});
 
 /** The recorded package dir that owns `abs`, if any (for a targeted barrel rebuild). */
 function ownerPackageDir(abs: string, pkgDirs: string[]): string | undefined {
   return pkgDirs.find((dir) => abs === dir || abs.startsWith(dir + sep));
 }
 
-if (process.argv.includes("--watch")) {
+if (values.watch) {
   // Watch the package roots; a source edit inside a package rebuilds just that
   // package's `index.ts` barrel (no re-synth - the projenrc watcher owns that).
   // watchLoop already drops generated paths, so a barrel write never re-triggers us.
@@ -44,7 +53,10 @@ if (process.argv.includes("--watch")) {
     if (n) logger.success(`rebuilt ${string.pluralize(n, "barrel")}`);
   });
 } else {
-  const n = generateBarrels();
+  const dirs = Array.isArray(values.dir)
+    ? values.dir.filter((value): value is string => typeof value === "string")
+    : [];
+  const n = generateBarrels(dirs.length ? { dirs } : undefined);
   logger.success(
     n === 0 ? "barrels already up to date" : `updated ${string.pluralize(n, "barrel")}`,
   );

package/tasks/bump.ts

@@ -48,12 +48,14 @@
  *   - a URL: always publish to that registry.
  */
 import { chmodSync, existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { exec, project } from "@dbx-tools/core";
 import { log, net } from "@dbx-tools/shared-core";
 import { Command, Option } from "commander";
 import { activePythonIndexes, resolveLocalPypi } from "./python-registry.ts";
+import { readDbxToolsConfig, repoRoot } from "../src/packages.ts";
 import {
   type Semver,
   compareSemver,
@@ -144,6 +146,21 @@ function resolveLocalRegistry(value: string): string | undefined {
   return trimmed;
 }
 
+function localCargoRegistry(): string | undefined {
+  if (process.env.LOCAL_CARGO_REGISTRY) return process.env.LOCAL_CARGO_REGISTRY;
+  const config = join(homedir(), ".cargo", "config.toml");
+  if (!existsSync(config)) return undefined;
+  const source = readFileSync(config, "utf8");
+  const sections = [
+    ...source.matchAll(/^\[registries\.([^\]]+)\]\s*\n([\s\S]*?)(?=^\[|(?![\s\S]))/gm),
+  ];
+  for (const section of sections) {
+    const index = section[2]?.match(/^\s*index\s*=\s*["']([^"']+)["']/m)?.[1];
+    if (index && net.isLoopbackHost(index.replace(/^sparse\+/, ""))) return section[1];
+  }
+  return undefined;
+}
+
 const program = new Command();
 program
   .description("Bump the release version, then commit, tag, and push it")
@@ -368,6 +385,57 @@ program
         );
       }
       await Promise.all(localPublishes);
+      if (opts.version && (publishToLocalRegistry || localPypi)) {
+        const publishUniFFIScript = fileURLToPath(
+          new URL("./publish-uniffi-local.ts", import.meta.url),
+        );
+        await exec.spawn(
+          "bun",
+          [
+            publishUniFFIScript,
+            "--version",
+            version,
+            ...(publishToLocalRegistry ? ["--registry", localRegistry] : []),
+            ...(localPypi ? ["--pypi-publish-url", localPypi.publishUrl] : []),
+          ],
+          {
+            cwd: process.cwd(),
+            stdout: "inherit",
+            stderr: "inherit",
+            stdin: "ignore",
+            check: true,
+          },
+        );
+        logger.success(`published host-native bindings for ${version}`);
+      }
+      const rust = readDbxToolsConfig(repoRoot)?.rust;
+      const hasRustCrates = Boolean(
+        rust &&
+        typeof rust === "object" &&
+        !Array.isArray(rust) &&
+        Array.isArray((rust as { crates?: unknown }).crates) &&
+        (rust as { crates: unknown[] }).crates.length,
+      );
+      if (opts.version && hasRustCrates) {
+        const cargoRegistry = localCargoRegistry();
+        if (cargoRegistry) {
+          const publishUniFFIScript = fileURLToPath(
+            new URL("./publish-uniffi-local.ts", import.meta.url),
+          );
+          await exec.spawn(
+            "bun",
+            [publishUniFFIScript, "--version", version, "--cargo-registry", cargoRegistry],
+            {
+              cwd: process.cwd(),
+              stdout: "inherit",
+              stderr: "inherit",
+              stdin: "ignore",
+              check: true,
+            },
+          );
+          logger.success(`published Rust ${version} to ${cargoRegistry}`);
+        }
+      }
     },
   );
 

package/tasks/publish-python.ts

@@ -22,6 +22,11 @@ interface PythonProjectFile {
   readonly source: string;
 }
 
+function isPrivatePythonProject(source: string): boolean {
+  const section = source.match(/^\[tool\.dbx-tools\]\s*\n([\s\S]*?)(?=^\[|(?![\s\S]))/m)?.[1] ?? "";
+  return /^\s*private\s*=\s*true\s*$/m.test(section);
+}
+
 export interface StampPythonProjectsOptions {
   readonly rewriteDependencies?: boolean;
 }
@@ -45,7 +50,7 @@ export function stampPythonProjects(
     .map((entry) => resolve(root, entry.name, "pyproject.toml"))
     .filter(existsSync)
     .sort();
-  const projects: PythonProjectFile[] = packageFiles.map((path) => {
+  const allProjects: PythonProjectFile[] = packageFiles.map((path) => {
     const source = readFileSync(path, "utf8");
     const name = /^name = "([^"]+)"$/m.exec(source)?.[1];
     if (!name) throw new Error(`Missing project name in ${path}`);
@@ -57,6 +62,7 @@ export function stampPythonProjects(
       source,
     };
   });
+  const projects = allProjects.filter((project) => !isPrivatePythonProject(project.source));
   if (projects.length === 0) throw new Error(`No Python packages found under ${root}`);
 
   try {
@@ -67,7 +73,7 @@ export function stampPythonProjects(
       }
       let stamped = project.source.replace(versionPattern, `version = "${version}"`);
       if (options.rewriteDependencies ?? true) {
-        for (const sibling of projects) {
+        for (const sibling of allProjects) {
           stamped = stamped.replace(
             new RegExp(
               `${escapeRegExp(sibling.name)} @ git\\+[^" ]+#subdirectory=[^" ]+/${escapeRegExp(sibling.directory)}`,

package/tasks/publish-uniffi-local.ts

@@ -0,0 +1,207 @@
+#!/usr/bin/env -S bun
+import { chmodSync, existsSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { arch, platform } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseArgs } from "node:util";
+import { spawnSync } from "node:child_process";
+import { readDbxToolsConfig, repoRoot } from "../src/packages.ts";
+import type { RustBindingMapping, RustWorkspaceMapping } from "../src/project-rs.ts";
+
+const parsed = parseArgs({
+  options: {
+    version: { type: "string" },
+    registry: { type: "string" },
+    "pypi-publish-url": { type: "string" },
+    "cargo-registry": { type: "string" },
+  },
+});
+
+function run(command: string, args: string[], capture = false): string {
+  const result = spawnSync(command, args, {
+    cwd: repoRoot,
+    encoding: capture ? "utf8" : undefined,
+    stdio: capture ? "pipe" : "inherit",
+  });
+  if (result.status !== 0) throw new Error(`${command} exited with ${result.status}`);
+  return capture ? String(result.stdout).trim() : "";
+}
+
+function commandAvailable(command: string): boolean {
+  return spawnSync(command, ["--version"], { stdio: "ignore" }).status === 0;
+}
+
+function rustHost(): string {
+  const host = run("rustc", ["-vV"], true).match(/^host:\s+(.+)$/m)?.[1];
+  if (!host) throw new Error("Unable to detect the local Rust target from rustc -vV");
+  return host;
+}
+
+function pythonTag(): string {
+  const value = run(
+    "uv",
+    [
+      "run",
+      "python",
+      "-c",
+      "import sysconfig; print(sysconfig.get_platform().replace('-', '_').replace('.', '_'))",
+    ],
+    true,
+  );
+  if (!value) throw new Error("Unable to detect the local Python wheel platform tag");
+  return value;
+}
+
+function nativeTarget(): {
+  cpu: "arm64" | "x64";
+  libc?: "glibc";
+  node: string;
+  os: "darwin" | "linux" | "win32";
+} {
+  const os = platform();
+  const machine = arch();
+  const cpu = machine === "arm64" ? "arm64" : machine === "x64" ? "x64" : undefined;
+  if (!cpu) throw new Error(`Unsupported local architecture: ${machine}`);
+  if (os === "darwin") return { os, cpu, node: `darwin-${cpu}` };
+  if (os === "win32") return { os, cpu, node: `win32-${cpu}-msvc` };
+  if (os === "linux") {
+    const libc = rustHost().includes("musl") ? undefined : "glibc";
+    return { os, cpu, node: `linux-${cpu}-${libc ? "gnu" : "musl"}`, ...(libc ? { libc } : {}) };
+  }
+  throw new Error(`Unsupported local platform: ${os}`);
+}
+
+function rustConfig(): RustWorkspaceMapping | undefined {
+  const value = readDbxToolsConfig(repoRoot)?.rust;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const config = value as Partial<RustWorkspaceMapping>;
+  return Array.isArray(config.bindings) ? (config as RustWorkspaceMapping) : undefined;
+}
+
+function artifacts(directory: string, suffix: string): string[] {
+  if (!existsSync(directory)) return [];
+  return readdirSync(directory)
+    .filter((name) => name.endsWith(suffix))
+    .map((name) => join(directory, name));
+}
+
+function publishCargo(config: RustWorkspaceMapping, registry: string): void {
+  const manifests = config.crates
+    .map((crate) => resolve(repoRoot, crate, "Cargo.toml"))
+    .filter((manifest) => !/^publish = false$/m.test(readFileSync(manifest, "utf8")));
+  const originals = new Map(
+    manifests.map((manifest) => [manifest, readFileSync(manifest, "utf8")]),
+  );
+  try {
+    const crateNames = manifests.map(
+      (manifest) => readFileSync(manifest, "utf8").match(/^name = "([^"]+)"$/m)?.[1],
+    );
+    for (const manifest of manifests) {
+      const mode = statSync(manifest).mode;
+      let source = readFileSync(manifest, "utf8");
+      for (const crateName of crateNames) {
+        if (!crateName) continue;
+        source = source.replace(
+          new RegExp(
+            `(${crateName.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&")} = \\{[^}]*)( \\})`,
+            "g",
+          ),
+          `$1, registry = "${registry}"$2`,
+        );
+      }
+      chmodSync(manifest, mode | 0o200);
+      writeFileSync(manifest, source);
+      chmodSync(manifest, mode);
+    }
+    for (const crateName of crateNames) {
+      if (!crateName) continue;
+      run("cargo", [
+        "publish",
+        "--package",
+        crateName,
+        "--registry",
+        registry,
+        "--allow-dirty",
+        "--no-verify",
+      ]);
+    }
+  } finally {
+    for (const [manifest, source] of originals) {
+      const mode = statSync(manifest).mode;
+      chmodSync(manifest, mode | 0o200);
+      writeFileSync(manifest, source);
+      chmodSync(manifest, mode);
+    }
+  }
+}
+
+function buildAndPublish(binding: RustBindingMapping, version: string): void {
+  const registry = parsed.values.registry;
+  const pypiPublishUrl = parsed.values["pypi-publish-url"];
+  const includeNode = Boolean(registry && binding.node && binding.nodePackage);
+  const includePython = Boolean(pypiPublishUrl && binding.python && binding.pythonPackage);
+  if (!includeNode && !includePython) return;
+
+  const target = nativeTarget();
+  const output = resolve(repoRoot, "dist/uniffi");
+  run("bun", [
+    resolve(dirname(fileURLToPath(import.meta.url)), "uniffi-release.ts"),
+    "build",
+    "--crate",
+    binding.crate,
+    "--rust",
+    binding.rust,
+    "--node",
+    includeNode ? binding.node! : "",
+    "--python",
+    includePython ? binding.python! : "",
+    "--node-package",
+    includeNode ? binding.nodePackage! : "",
+    "--python-package",
+    includePython ? binding.pythonPackage! : "",
+    "--cargo-target",
+    rustHost(),
+    "--node-triple",
+    target.node,
+    "--python-tag",
+    pythonTag(),
+    "--os",
+    target.os,
+    "--cpu",
+    target.cpu,
+    "--libc",
+    target.libc ?? "",
+    "--facade",
+    "true",
+    "--version",
+    version,
+  ]);
+
+  if (includeNode) {
+    const packages = [
+      ...artifacts(join(output, "npm"), ".tgz"),
+      ...artifacts(join(output, "npm-facade"), ".tgz"),
+    ];
+    for (const packageFile of packages)
+      run("npm", ["publish", packageFile, "--registry", registry!]);
+  }
+  if (includePython) {
+    const wheels = artifacts(join(output, "python"), ".whl");
+    if (wheels.length === 0) throw new Error(`No wheel produced for ${binding.crate}`);
+    for (const wheel of wheels) run("uv", ["publish", "--publish-url", pypiPublishUrl!, wheel]);
+  }
+}
+
+const version = parsed.values.version;
+if (!version) throw new Error("Missing --version");
+const config = rustConfig();
+if (config?.bindings.length) {
+  if (!commandAvailable("cargo") || !commandAvailable("rustc")) {
+    throw new Error("Cargo and rustc are required because UniFFI Rust projects were detected");
+  }
+  for (const binding of config.bindings) buildAndPublish(binding, version);
+}
+const cargoRegistry = parsed.values["cargo-registry"];
+if (cargoRegistry && config?.crates.length) {
+  publishCargo(config, cargoRegistry);
+}

package/tasks/rust.ts

@@ -0,0 +1,132 @@
+#!/usr/bin/env -S bun
+import { existsSync } from "node:fs";
+import { dirname, isAbsolute, resolve, sep } from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { log } from "@dbx-tools/shared-core";
+import { readDbxToolsConfig, repoRoot } from "../src/packages.ts";
+import {
+  discoverRustCrates,
+  hasUniFFIBindings,
+  type RustBindingMapping,
+  type RustWorkspaceMapping,
+} from "../src/project-rs.ts";
+import { runSynth } from "../src/scaffold.ts";
+import { watchLoop } from "../src/watch.ts";
+
+const logger = log.logger("projen:rust");
+
+function rustConfig(): RustWorkspaceMapping | undefined {
+  const value = readDbxToolsConfig(repoRoot)?.rust;
+  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+  const candidate = value as Partial<RustWorkspaceMapping>;
+  if (typeof candidate.root !== "string") return undefined;
+  if (!Array.isArray(candidate.crates) || !Array.isArray(candidate.bindings)) return undefined;
+  return candidate as RustWorkspaceMapping;
+}
+
+function cargoAvailable(): boolean {
+  return spawnSync("cargo", ["--version"], { stdio: "ignore" }).status === 0;
+}
+
+function currentStructure(config: RustWorkspaceMapping): RustWorkspaceMapping {
+  const root = resolve(repoRoot, config.root);
+  const directories = discoverRustCrates(root);
+  const crates = directories.map((directory) => `${config.root}/${directory}`);
+  const recorded = new Map(config.bindings.map((binding) => [binding.rust, binding]));
+  const bindings = crates.flatMap((rust) => {
+    if (!hasUniFFIBindings(resolve(repoRoot, rust))) return [];
+    const binding = recorded.get(rust);
+    return binding ? [binding] : [{ crate: "", rust }];
+  });
+  return { root: config.root, crates, bindings };
+}
+
+/** Whether discovered crate membership or UniFFI marker membership changed. */
+export function rustStructureChanged(config: RustWorkspaceMapping): boolean {
+  return !sameStructure(config, currentStructure(config));
+}
+
+function sameStructure(left: RustWorkspaceMapping, right: RustWorkspaceMapping): boolean {
+  return (
+    JSON.stringify(left.crates) === JSON.stringify(right.crates) &&
+    JSON.stringify(left.bindings.map((binding) => binding.rust)) ===
+      JSON.stringify(right.bindings.map((binding) => binding.rust))
+  );
+}
+
+function ownerBinding(
+  path: string,
+  bindings: readonly RustBindingMapping[],
+): RustBindingMapping | undefined {
+  const absolute = isAbsolute(path) ? path : resolve(repoRoot, path);
+  return bindings.find((binding) => {
+    const directory = resolve(repoRoot, binding.rust);
+    return absolute === directory || absolute.startsWith(directory + sep);
+  });
+}
+
+function generate(binding: RustBindingMapping): void {
+  const targets = [
+    ...(binding.node ? ["--node", binding.node] : []),
+    ...(binding.python ? ["--python", binding.python] : []),
+  ];
+  const result = spawnSync(
+    process.execPath,
+    [
+      resolve(dirname(fileURLToPath(import.meta.url)), "uniffi.ts"),
+      "--crate",
+      binding.crate,
+      ...targets,
+    ],
+    { cwd: repoRoot, stdio: "inherit" },
+  );
+  if (result.status !== 0) throw new Error(`binding generation exited with ${result.status}`);
+}
+
+const config = rustConfig();
+
+async function main(): Promise<void> {
+  if (!config || config.crates.length === 0 || !existsSync(resolve(repoRoot, config.root))) return;
+  if (!cargoAvailable()) {
+    throw new Error("Cargo is required because Rust projects were detected");
+  }
+  if (!process.argv.includes("--watch")) {
+    for (const binding of config.bindings) generate(binding);
+    return;
+  }
+
+  watchLoop("rust", [resolve(repoRoot, config.root)], (changed) => {
+    const latest = rustConfig() ?? config;
+    if (rustStructureChanged(latest)) {
+      logger.start("Rust project structure changed - re-synthesizing (+install)");
+      runSynth({ post: true });
+      logger.success("Rust project structure synchronized");
+      const refreshed = rustConfig();
+      if (!refreshed) return;
+      const targets = new Map<string, RustBindingMapping>();
+      for (const path of changed) {
+        const binding = ownerBinding(path, refreshed.bindings);
+        if (binding) targets.set(binding.crate, binding);
+      }
+      for (const binding of targets.values()) {
+        logger.start(`generating ${binding.crate} bindings`);
+        generate(binding);
+        logger.success(`generated ${binding.crate} bindings`);
+      }
+      return;
+    }
+    const targets = new Map<string, RustBindingMapping>();
+    for (const path of changed) {
+      const binding = ownerBinding(path, latest.bindings);
+      if (binding) targets.set(binding.crate, binding);
+    }
+    for (const binding of targets.values()) {
+      logger.start(`generating ${binding.crate} bindings`);
+      generate(binding);
+      logger.success(`generated ${binding.crate} bindings`);
+    }
+  });
+}
+
+if (import.meta.main) await main();

package/tasks/sync.ts

@@ -2,6 +2,7 @@
 import { fileURLToPath } from "node:url";
 import { log } from "@dbx-tools/shared-core";
 import concurrently from "concurrently";
+import { readDbxToolsConfig, repoRoot } from "../src/packages.ts";
 import { runSynth } from "../src/scaffold.ts";
 
 const logger = log.logger("projen:sync");
@@ -24,6 +25,16 @@ function taskPath(script: string): string {
   return fileURLToPath(new URL(`./${script}`, import.meta.url));
 }
 
+/** Whether synth recorded at least one Rust crate for the focused watcher. */
+function hasRustProjects(): boolean {
+  const rust = readDbxToolsConfig(repoRoot)?.rust;
+  if (!rust || typeof rust !== "object" || Array.isArray(rust)) return false;
+  return (
+    Array.isArray((rust as { crates?: unknown }).crates) &&
+    (rust as { crates: unknown[] }).crates.length > 0
+  );
+}
+
 if (!process.argv.includes("--watch")) {
   // One-shot: full synth (+install + barrels via the post-synth component). This is
   // the scriptable path, so a failed synth stays a failed exit code.
@@ -52,21 +63,26 @@ if (!process.argv.includes("--watch")) {
     );
   }
 
-  const { result } = concurrently(
-    [
-      { command: `bun "${taskPath("projenrc.ts")}"`, name: "projenrc", prefixColor: "magenta" },
-      { command: `bun "${taskPath("barrels.ts")}" --watch`, name: "barrels", prefixColor: "cyan" },
-      { command: `bun "${taskPath("openapi.ts")}" --watch`, name: "openapi", prefixColor: "green" },
-    ],
-    {
-      prefix: "name",
-      // No `killOthersOn`: one watcher falling over is no reason to tear the other two
-      // down. `-1` is concurrently's spelling for "restart forever", so a crashed
-      // watcher comes back instead of silently leaving its outputs stale.
-      restartTries: -1,
-      restartDelay: RESTART_DELAY_MS,
-    },
-  );
+  const watchers = [
+    { command: `bun "${taskPath("projenrc.ts")}"`, name: "projenrc", prefixColor: "magenta" },
+    { command: `bun "${taskPath("barrels.ts")}" --watch`, name: "barrels", prefixColor: "cyan" },
+    { command: `bun "${taskPath("openapi.ts")}" --watch`, name: "openapi", prefixColor: "green" },
+  ];
+  if (hasRustProjects()) {
+    watchers.push({
+      command: `bun "${taskPath("rust.ts")}" --watch`,
+      name: "rust",
+      prefixColor: "yellow",
+    });
+  }
+  const { result } = concurrently(watchers, {
+    prefix: "name",
+    // No `killOthersOn`: one watcher falling over is no reason to tear the other two
+    // down. `-1` is concurrently's spelling for "restart forever", so a crashed
+    // watcher comes back instead of silently leaving its outputs stale.
+    restartTries: -1,
+    restartDelay: RESTART_DELAY_MS,
+  });
 
   let stopping = false;