@gjsify/cli 0.40.0 → 0.42.0

package/lib/commands/prune.js

@@ -0,0 +1,84 @@
+// `gjsify prune` — remove installed packages this target cannot use.
+//
+// The repair half of ADR 0025. `install`/`self-update` prune what they would not
+// have placed, but only going forward: a prefix that accreted foreign-platform
+// packages under an older CLI is only reachable by asking. That is this command,
+// and it is why it exists at all rather than the automatic pass alone.
+//
+// `--os/--cpu/--libc` are accepted here and deliberately NOT honoured by the
+// automatic pass: typed on `prune` they are a request ("show me what a darwin-arm64
+// host could not use"), while inherited by an install they would delete the host's
+// own packages. See `automaticPruneRefusal`.
+import { existsSync } from 'node:fs';
+import { acquireInstallLock } from '../utils/install-lock.js';
+import { defaultGlobalLayout } from '../utils/install-global.js';
+import { resolveHostPlatform } from '../utils/platform-check.js';
+import { executePrune, formatPruneReport, planPrune } from '../utils/prune-prefix.js';
+export const pruneCommand = {
+    command: 'prune',
+    description: 'Remove installed packages this host cannot use (foreign os/cpu/libc). ' +
+        'Reads each package manifest — a package that declares no platform is never touched.',
+    builder: (yargs) => yargs
+        .option('global', {
+        description: 'Prune the user-global XDG prefix (the `install -g` target) instead of the project.',
+        type: 'boolean',
+        alias: 'g',
+        default: false,
+    })
+        .option('dry-run', {
+        description: 'Report what would be removed without touching the filesystem.',
+        type: 'boolean',
+        default: false,
+    })
+        .option('verbose', {
+        description: 'List every package rather than the first few.',
+        type: 'boolean',
+        default: false,
+    })
+        .option('os', {
+        description: 'Prune AS IF the host were this OS (linux, darwin, win32). Defaults to this host.',
+        type: 'string',
+    })
+        .option('cpu', {
+        description: 'Prune AS IF the host were this architecture (x64, arm64, …). Defaults to this host.',
+        type: 'string',
+    })
+        .option('libc', {
+        description: 'Prune AS IF the host used this libc (glibc, musl). Defaults to this host.',
+        type: 'string',
+    }),
+    handler: async (args) => {
+        const layout = args.global ? defaultGlobalLayout() : null;
+        const prefix = layout ? layout.prefix : process.cwd();
+        if (!existsSync(`${prefix}/node_modules`)) {
+            console.log(`gjsify prune: nothing installed at ${prefix}`);
+            return;
+        }
+        // The flags are read HERE rather than through the npm config keys, so the
+        // automatic pass — which refuses to act on an overridden target — cannot be
+        // reached by way of this command's own options.
+        const target = resolveHostPlatform({
+            env: {
+                ...(args.os ? { npm_config_os: args.os } : {}),
+                ...(args.cpu ? { npm_config_cpu: args.cpu } : {}),
+                ...(args.libc ? { npm_config_libc: args.libc } : {}),
+            },
+        });
+        // A prune racing an install's extract would delete a half-written tree. The
+        // lock is the same one every writer of this prefix takes (ADR 0001).
+        const lock = await acquireInstallLock(prefix, {});
+        let result;
+        try {
+            result = executePrune(planPrune({ prefix, target }), { dryRun: args.dryRun });
+        }
+        finally {
+            lock.release();
+        }
+        console.log(formatPruneReport(result, { dryRun: args.dryRun, verbose: args.verbose }));
+        // Removing nothing is a SUCCESS — idempotent housekeeping, unlike `uninstall`
+        // where naming a package that is not there is a mistake worth reporting. Only
+        // a removal the user asked for and did not get is a failure.
+        if (result.failed.length > 0)
+            return process.exit(1);
+    },
+};

package/lib/commands/run.js

@@ -15,13 +15,15 @@
 // to disambiguate can pass `./<file>` explicitly.
 import { readFileSync, statSync } from 'node:fs';
 import { basename, delimiter, join, resolve } from 'node:path';
-import { spawn } from 'node:child_process';
+import { describeExit, spawnToCompletion } from '../utils/spawn.js';
 import { runGjsBundle } from '../utils/run-gjs.js';
 import { runRuntimeBundle } from '../utils/run-node.js';
 import { readPackageJson } from '../utils/pkg-json-edit.js';
 import { runNodeScript } from '../utils/node-script.js';
 import { nodeShimDir } from '../utils/gjsify-shim.js';
 import { findWorkspaceRoot } from '../utils/workspace-root.js';
+import { gjsifyCommandArgv } from '../utils/simple-command.js';
+import { isDaemonCommand } from '../utils/daemon-command.js';
 import { discoverWorkspaces } from '@gjsify/workspace';
 import { isGjs, hostRuntime } from '@gjsify/rolldown-plugin-gjsify/runtime';
 import { EXAMPLE_RUNTIMES, isExampleRuntime, readDeclaredRuntimes, checkRuntimeSupported, } from '../utils/runtimes.js';
@@ -124,7 +126,7 @@ export const runCommand = {
                 console.error(`gjsify run: --node-script cannot be combined with ${clash}.`);
                 return process.exit(1);
             }
-            await runNodeScript(target, extraArgs, { exitOnSuccess: true });
+            await runNodeScript(target, extraArgs, { completion: 'exit', exitOnSuccess: true });
             return;
         }
         // `--runtime <gjs|node|bun|deno>` (explicit) → run a BUNDLE FILE on the
@@ -174,10 +176,10 @@ export const runCommand = {
             // Terminal calls — exit on success, or the GJS main loop parks
             // this process forever (see RunGjsBundleOptions.exitOnSuccess).
             if (runtime === 'gjs') {
-                await runGjsBundle(file, extraArgs, { exitOnSuccess: true });
+                await runGjsBundle(file, extraArgs, { completion: 'exit', exitOnSuccess: true });
             }
             else {
-                await runRuntimeBundle(runtime, file, extraArgs, { exitOnSuccess: true });
+                await runRuntimeBundle(runtime, file, extraArgs, { completion: 'exit', exitOnSuccess: true });
             }
             return;
         }
@@ -209,10 +211,10 @@ async function runTargetOnRuntime(runtime, target, extraArgs) {
     const file = resolve(target);
     // Terminal call — exit on success (the GJS/GLib loop would otherwise park).
     if (runtime === 'gjs') {
-        await runGjsBundle(file, extraArgs, { exitOnSuccess: true });
+        await runGjsBundle(file, extraArgs, { completion: 'exit', exitOnSuccess: true });
     }
     else {
-        await runRuntimeBundle(runtime, file, extraArgs, { exitOnSuccess: true });
+        await runRuntimeBundle(runtime, file, extraArgs, { completion: 'exit', exitOnSuccess: true });
     }
 }
 /**
@@ -420,6 +422,16 @@ async function runScript(script, extraArgs, cwd = process.cwd()) {
             console.error(err.message);
             dispatchFailed = true;
         }
+        // A watch loop RESOLVES as soon as it is armed and then keeps running,
+        // so its resolution is not an ending to exit on: `gjsify run dev` used
+        // to take down the loop it had just started, the instant the first
+        // build+launch finished. Node never saw it — there the same script takes
+        // the shell-spawn path below — and it is the DOCUMENTED entry point:
+        // `gjsify create` prints `gjsify run dev`, and every template's `dev`
+        // script is a bare `gjsify dev`. Returning leaves the process on the
+        // main loop `runWatchLoop` holds, where Ctrl+C ends it.
+        if (!dispatchFailed && isDaemonCommand())
+            return;
         // A thrown command wins over `process.exitCode`; otherwise honour a
         // non-zero code the handler set instead of throwing (e.g. a failing
         // check) — a bare exit(0) here masked those as success too.
@@ -436,23 +448,23 @@ async function runScript(script, extraArgs, cwd = process.cwd()) {
         return process.exit(dispatchCode);
     }
     const fullCmd = extraArgs.length > 0 ? `${literal} ${extraArgs.map(shellEscape).join(' ')}` : literal;
-    // ensureMainLoop() (called inside spawn) keeps GJS alive after the
-    // child exits — without an explicit process.exit() the success path
-    // would park the loop forever. The error path already exits.
-    await new Promise((resolveOk, reject) => {
-        const child = spawn(fullCmd, [], { cwd, env, stdio: 'inherit', shell: true });
-        child.on('close', (code) => {
-            if (code === 0)
-                resolveOk();
-            else
-                reject(new Error(`script "${script}" exited with code ${code}`));
-        });
-        child.on('error', reject);
-    }).catch((err) => {
+    // `completion: 'exit'` — ensureMainLoop() (called inside the async spawn) keeps
+    // GJS alive after the child exits, and both paths below end in `process.exit`,
+    // which is what tears it down. `shell: true` deliberately skips the win32
+    // rewrite: this is a command LINE, and Node routes it through %COMSPEC%.
+    let result;
+    try {
+        result = await spawnToCompletion(fullCmd, [], { completion: 'exit', cwd, env, shell: true });
+    }
+    catch (err) {
         console.error(err.message);
-        process.exit(1);
-    });
-    process.exit(0);
+        return process.exit(1);
+    }
+    if (result.code !== 0) {
+        console.error(`script "${script}" exited with ${describeExit(result)}`);
+        return process.exit(1);
+    }
+    return process.exit(0);
 }
 function shellEscape(arg) {
     if (/^[a-zA-Z0-9_\-./=:@,]+$/.test(arg))
@@ -463,70 +475,11 @@ function shellEscape(arg) {
  * If `literal` is a SINGLE `gjsify <subcommand> …` command with no shell
  * operators / substitutions / unquoted globs, return the argv to feed `runCli`
  * (the subcommand + its args, with `extraArgs` appended). Otherwise null — the
- * caller falls back to the shell spawn path. Quotes are honoured so a quoted
- * glob (`'src/**'`) survives as a single literal token, exactly as the shell
- * would hand it to `gjsify` (which does its own glob expansion).
+ * caller falls back to the shell spawn path.
  */
 function gjsifyInProcessArgv(literal, extraArgs) {
-    const tokens = tokenizeSimpleCommand(literal);
-    if (!tokens || tokens.length < 2 || tokens[0] !== 'gjsify')
+    const argv = gjsifyCommandArgv(literal);
+    if (!argv)
         return null;
-    return [...tokens.slice(1), ...extraArgs];
-}
-/**
- * Quote-aware tokenizer for a SIMPLE command line (no shell features beyond
- * single/double quoting). Returns the tokens, or null if the string contains
- * anything the shell would treat specially — operators (`&& | ; < > &`),
- * substitutions (`$(...)` / backticks / `$VAR`), unquoted globs/expansions
- * (`* ? { } [ ] ~`), comments (`#`), or an unterminated quote — in which case
- * the caller MUST use the real shell instead.
- */
-function tokenizeSimpleCommand(cmd) {
-    const tokens = [];
-    let cur = '';
-    let has = false;
-    let quote = null;
-    for (let i = 0; i < cmd.length; i++) {
-        const c = cmd[i];
-        if (quote === "'") {
-            if (c === "'")
-                quote = null;
-            else
-                cur += c;
-            continue;
-        }
-        if (quote === '"') {
-            if (c === '"')
-                quote = null;
-            else if (c === '\\' && (cmd[i + 1] === '"' || cmd[i + 1] === '\\'))
-                cur += cmd[++i];
-            else if (c === '$' || c === '`')
-                return null; // substitution inside "…"
-            else
-                cur += c;
-            continue;
-        }
-        if (c === "'" || c === '"') {
-            quote = c;
-            has = true;
-            continue;
-        }
-        if (c === ' ' || c === '\t') {
-            if (has) {
-                tokens.push(cur);
-                cur = '';
-                has = false;
-            }
-            continue;
-        }
-        if ('|&;<>`$()\\\n\r*?{}[]~#!'.includes(c))
-            return null;
-        cur += c;
-        has = true;
-    }
-    if (quote)
-        return null; // unterminated quote
-    if (has)
-        tokens.push(cur);
-    return tokens;
+    return [...argv, ...extraArgs];
 }

package/lib/commands/self-update.d.ts

@@ -4,6 +4,7 @@ interface SelfUpdateOptions {
     force?: boolean;
     tag: string;
     skipDeps?: boolean;
+    prune?: boolean;
 }
 export declare const selfUpdateCommand: Command<unknown, SelfUpdateOptions>;
 /** Verdict of the post-install "did this change what runs?" check. */

package/lib/commands/self-update.js

@@ -25,7 +25,10 @@ import { dirname, join, posix, resolve, win32 } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { fetchPackument } from '@gjsify/npm-registry';
 import { installPackages, makeProgressReporter } from '../utils/install-backend.js';
+import { classifyInstall } from '../utils/install-provenance.js';
 import { defaultGlobalLayout, globalLayoutIsDefault, hasBundlerEngineInstalled, installGjsEnginePackages, linkGlobalBins, resolveBinOnPath, } from '../utils/install-global.js';
+import { resolveHostPlatform } from '../utils/platform-check.js';
+import { pruneAfterInstall } from '../utils/prune-prefix.js';
 const PACKAGE_NAME = '@gjsify/cli';
 export const selfUpdateCommand = {
     command: 'self-update',
@@ -45,6 +48,11 @@ export const selfUpdateCommand = {
         description: 'npm dist-tag or pinned version to install (e.g. `latest`, `next`, `0.5.0`).',
         type: 'string',
         default: 'latest',
+    })
+        .option('prune', {
+        description: 'After updating, remove packages an earlier install left behind that this host cannot use (foreign os/cpu/libc). Use --no-prune to disable.',
+        type: 'boolean',
+        default: true,
     })
         .option('skip-deps', {
         description: 'Update only the @gjsify/cli bundle itself; do not pull its runtime dependencies ' +
@@ -60,6 +68,24 @@ export const selfUpdateCommand = {
         const currentVersion = readCurrentVersion();
         const installedAtPrefix = existsSync(installedPkgJson);
         console.log(`Current ${PACKAGE_NAME}: v${currentVersion ?? '(unknown)'}`);
+        // REFUSE, do not warn-and-continue, when something else owns this install.
+        //
+        // Everything below writes the user-global XDG prefix. Under a `.deb`,
+        // `.rpm` or Flatpak that produces a SECOND copy which shadows the one the
+        // package manager tracks — so the next `apt upgrade` reverts it, or the two
+        // diverge, and the user's report is "I updated and nothing changed". A
+        // clean refusal naming the right command is strictly more useful than a
+        // successful write to the wrong place; #1064 is the same lesson one layer
+        // down, where the write succeeded and PATH still resolved the old binary.
+        const provenance = classifyInstall({ selfDir: readSelfDir(), xdgPrefix: layout.prefix });
+        if (provenance.managedElsewhere) {
+            console.error(`\ngjsify self-update: this gjsify is managed by something else — ${provenance.evidence}.\n` +
+                `Updating it from here would write ${layout.prefix} and leave you running two installs.\n\n` +
+                `Update with: ${provenance.updateWith}\n`);
+            // `return process.exit()` — a bare `process.exit()` is DEFERRED under
+            // GJS and the handler would run on into the install it just refused.
+            return process.exit(1);
+        }
         if (!installedAtPrefix) {
             console.warn(`\nWarning: no @gjsify/cli install found under ${layout.prefix}.\n` +
                 `self-update only manages installs created by install.mjs or \`gjsify install -g\`.\n` +
@@ -157,6 +183,13 @@ export const selfUpdateCommand = {
         if (pullDeps) {
             await installGjsEnginePackages(layout.prefix, target, { verbose: false });
         }
+        // Same ordering reason as `install -g`: before the LINK, whose launchers bake
+        // the resolved prebuild directories into their env.
+        if (args.prune !== false) {
+            pruneAfterInstall(layout.prefix, resolveHostPlatform({ env: {} }), {
+                hint: 'gjsify prune -g --dry-run',
+            });
+        }
         const linked = linkGlobalBins([PACKAGE_NAME], layout);
         if (linked.length === 0) {
             console.warn('self-update: install completed but no bins were linked — package.json may be missing a `bin` field.');
@@ -246,6 +279,28 @@ export function verifyPathResolution(opts) {
  * `import.meta.url` (the bundle file under GJS, or `lib/index.js` under
  * Node) until it finds a package.json with `name === '@gjsify/cli'`.
  */
+/**
+ * The directory of the running CLI's own package — the input the provenance
+ * question is actually about.
+ *
+ * The same upward walk `readCurrentVersion()` does, and for the same reason: it
+ * works from `lib/index.js` under Node and from the published `dist/cli.gjs.mjs`
+ * bundle under GJS. Honours the same `GJSIFY_CLI_PACKAGE_JSON` escape hatch, so a
+ * test can place a synthetic install anywhere without a real one.
+ */
+function readSelfDir() {
+    const override = process.env.GJSIFY_CLI_PACKAGE_JSON;
+    if (override)
+        return dirname(resolve(override));
+    const here = fileURLToPath(import.meta.url);
+    let dir = dirname(resolve(here));
+    for (let i = 0; i < 8 && dir !== dirname(dir); i++) {
+        if (existsSync(join(dir, 'package.json')))
+            return dir;
+        dir = dirname(dir);
+    }
+    return dirname(resolve(here));
+}
 function readCurrentVersion() {
     try {
         // Escape hatch for tests: point GJSIFY_CLI_PACKAGE_JSON at a synthetic

package/lib/commands/ship.js

@@ -20,7 +20,7 @@ import { deriveDepends, warnAboutGjsFloor } from '../utils/ship/depends.js';
 import { discoverPayload } from '../utils/ship/discover.js';
 import { resolveFormats, FORMAT_IDS } from '../utils/ship/formats.js';
 import { scanGiNamespaces } from '../utils/ship/gi-namespaces.js';
-import { buildTimestamp, isArchIndependent } from '../utils/ship/payload.js';
+import { assertPayloadMatchesArch, buildTimestamp, isArchIndependent } from '../utils/ship/payload.js';
 import { planOverlay, planStage } from '../utils/ship/plan.js';
 import { renderLauncher } from '../utils/ship/launcher.js';
 import { buildRpm } from '../utils/ship/rpm.js';
@@ -151,10 +151,15 @@ async function packOne(input) {
         hasSchemas: settings.schemaFiles.length > 0,
         extra: settings.extraDepends[format.id],
         typelibPackages: settings.typelibPackages,
+        bundledTypelibs: settings.typelibFiles,
         minGjsVersion: settings.minGjsVersion,
     });
     for (const warning of warnAboutGjsFloor(format.id, settings.minGjsVersion))
         console.warn(`${LOG} ${warning}`);
+    // Before the label is chosen, not after: `archName` collapses an
+    // arch-independent payload to `all`/`noarch`, and a mismatch only matters
+    // for a payload that IS architecture-specific.
+    assertPayloadMatchesArch(payload, settings.arch);
     const archLabel = format.archName(settings.arch, isArchIndependent(payload));
     const common = { settings, payload, prefix: format.prefix, depends, archLabel, mtime };
     const bytes = format.id === 'deb' ? await buildDeb(common) : await buildRpm(common);

package/lib/commands/showcase.js

@@ -411,7 +411,7 @@ async function runShowcaseOnRuntime(showcase, runtime, cliVersion) {
     // thrown: an exception escaping the handler makes yargs dump the command's
     // full `--help` above the message, which buries it.
     try {
-        await runRuntimeBundle(runtime, entry, [], { exitOnSuccess: true });
+        await runRuntimeBundle(runtime, entry, [], { completion: 'exit', exitOnSuccess: true });
     }
     catch (err) {
         console.error(`${err.message}\n\n` +

package/lib/commands/storybook.js

@@ -16,7 +16,6 @@
 // identically under Node and GJS. @gjsify/storybook is resolved from the
 // CONSUMER's node_modules by the generated entry, so it stays out of the CLI's
 // own dependencies.
-import { spawn } from 'node:child_process';
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join, relative, resolve } from 'node:path';
 import { hostRuntime } from '@gjsify/rolldown-plugin-gjsify/runtime';
@@ -165,18 +164,18 @@ export const storybookCommand = {
         const launch = async () => {
             if (runtime === 'gjs') {
                 const { runGjsBundle } = await import('../utils/run-gjs.js');
-                await runGjsBundle(outPath, [], { exitOnSuccess: true });
+                await runGjsBundle(outPath, [], { completion: 'exit', exitOnSuccess: true });
             }
             else if (runtime === 'node') {
                 const { runNodeBundle } = await import('../utils/run-node.js');
-                await runNodeBundle(outPath, [], { exitOnSuccess: true });
+                await runNodeBundle(outPath, [], { completion: 'exit', exitOnSuccess: true });
             }
             else {
                 // bun / deno — run the SAME `--app node` bundle via the shared
                 // runner (Node-API is their common ABI). node-gi is required
                 // because the storybook uses gi:// (checked in runRuntimeBundle).
                 const { runRuntimeBundle } = await import('../utils/run-node.js');
-                await runRuntimeBundle(runtime, outPath, [], { exitOnSuccess: true });
+                await runRuntimeBundle(runtime, outPath, [], { completion: 'exit', exitOnSuccess: true });
             }
         };
         if (!args.watch) {
@@ -186,77 +185,21 @@ export const storybookCommand = {
             await launch();
             return;
         }
-        // Watch mode: rebuild + relaunch on any change under the stories dir.
-        // The storybook bundle only needs system Gtk/Adw typelibs at runtime
-        // (no @gjsify native bridges), so a plain `gjs -m` / `node` child is
-        // enough and stays killable for relaunch.
-        const { watch } = await import('node:fs');
-        const spawnChild = async () => {
-            if (runtime === 'gjs') {
-                return spawn('gjs', ['-m', outPath], { stdio: 'inherit' });
-            }
-            // node / bun / deno — run the `--app node` bundle with the native
-            // typelib env wired like `gjsify run`. All three need @gjsify/node-gi
-            // (the storybook uses gi://), kept external by the bundler.
-            const { computeNativeEnvForBundle } = await import('../utils/run-gjs.js');
-            const { resolveNodeGiForBundle, nodeBinary } = await import('../utils/run-node.js');
-            const { RUNTIMES } = await import('../utils/runtimes.js');
-            // Same resolution base as `runRuntimeBundle`: the bundle's own dir
-            // first (that is where the runtime resolves the external specifier
-            // from), cwd as the fallback.
-            if (!resolveNodeGiForBundle(outPath, cwd)) {
-                throw new Error(`Cannot run the storybook on ${runtime}: \`@gjsify/node-gi\` is not installed. ` +
-                    `Add @gjsify/node-gi as a dependency to run the storybook on ${runtime}.`);
-            }
-            const { env: nativeEnv } = computeNativeEnvForBundle(outPath, cwd);
-            const env = { ...process.env, ...nativeEnv };
-            // `node` uses the resolved node binary (under a GJS-hosted CLI
-            // `process.execPath` is gjs); bun/deno launch via the shared spec
-            // (deno's `--node-modules-dir=manual`, etc.).
-            if (runtime === 'node') {
-                return spawn(nodeBinary(), [outPath], { stdio: 'inherit', env });
-            }
-            const [cmd, launchArgs] = RUNTIMES[runtime].launch(outPath);
-            return spawn(cmd, launchArgs, { stdio: 'inherit', env });
-        };
-        let child = null;
-        let rebuilding = false;
-        let pending = false;
-        const rebuild = async () => {
-            if (rebuilding) {
-                pending = true;
-                return;
-            }
-            rebuilding = true;
-            try {
+        // Watch mode: rebuild + relaunch on any change under the stories dir,
+        // through the loop shared with `gjsify dev` (`utils/watch-loop.ts`).
+        const { runWatchLoop, spawnBundleSupervised } = await import('../utils/watch-loop.js');
+        await runWatchLoop({
+            dir: storiesDir,
+            dirLabel: relative(cwd, storiesDir) || '.',
+            label: 'storybook',
+            // Stories are DISCOVERED, so the generated entry is re-derived on
+            // every pass — a new `*.story.ts` must show up without a restart.
+            prepare: () => {
                 writeEntry();
-                if (child) {
-                    child.kill();
-                    child = null;
-                }
-                await buildBundle();
-                if (!args.buildOnly) {
-                    child = await spawnChild();
-                }
-            }
-            catch (err) {
-                console.error(`[storybook] rebuild failed: ${err.message}`);
-            }
-            finally {
-                rebuilding = false;
-                if (pending) {
-                    pending = false;
-                    void rebuild();
-                }
-            }
-        };
-        await rebuild();
-        let debounce = null;
-        watch(storiesDir, { recursive: true }, () => {
-            if (debounce)
-                clearTimeout(debounce);
-            debounce = setTimeout(() => void rebuild(), 200);
+            },
+            build: buildBundle,
+            spawnChild: args.buildOnly ? null : () => spawnBundleSupervised(runtime, outPath, cwd, 'the storybook'),
+            output: outPath,
         });
-        console.log(`[storybook] watching ${relative(cwd, storiesDir) || '.'} — press Ctrl+C to stop`);
     },
 };

package/lib/commands/test.js

@@ -7,9 +7,9 @@
 // exit codes.
 import { existsSync, statSync, readdirSync } from 'node:fs';
 import { join, dirname, resolve, relative } from 'node:path';
-import { spawn } from 'node:child_process';
 import { isRuntimeAvailable, RUNTIMES } from '../utils/runtimes.js';
 import { nodeBinary } from '../utils/run-node.js';
+import { describeExit, spawnToCompletion } from '../utils/spawn.js';
 import { Config } from '../config.js';
 import { BuildAction } from '../actions/build.js';
 import { runGjsBundle } from '../utils/run-gjs.js';
@@ -190,23 +190,19 @@ async function buildTestBundle(entry, outfile, runtime, verbose) {
 /** Run a single test bundle and reject on non-zero exit. */
 async function runTestBundle(outfile, runtime) {
     if (runtime === 'gjs') {
-        await runGjsBundle(outfile);
+        // `completion: 'exit'` (this handler ends in `process.exit`) WITHOUT
+        // `exitOnSuccess`: the two answer different questions, and exiting here
+        // would truncate the multi-runtime loop after the first bundle.
+        await runGjsBundle(outfile, [], { completion: 'exit' });
         return;
     }
-    await new Promise((resolvePromise, reject) => {
-        // `nodeBinary()`, never a bare `'node'`: under GJS `process.execPath` is
-        // the `gjs` interpreter, which cannot run a `--app node` bundle, and on a
-        // host without Node a bare literal dies `spawn node ENOENT` — which is
-        // how a fully passing GJS suite was reported as a failed run.
-        const child = spawn(nodeBinary(), [outfile], { stdio: 'inherit' });
-        child.on('error', reject);
-        child.on('exit', (code) => {
-            if (code === 0)
-                resolvePromise();
-            else
-                reject(new Error(`node exited with code ${code}`));
-        });
-    });
+    // `nodeBinary()`, never a bare `'node'`: under GJS `process.execPath` is
+    // the `gjs` interpreter, which cannot run a `--app node` bundle, and on a
+    // host without Node a bare literal dies `spawn node ENOENT` — which is
+    // how a fully passing GJS suite was reported as a failed run.
+    const result = await spawnToCompletion(nodeBinary(), [outfile], { completion: 'exit' });
+    if (result.code !== 0)
+        throw new Error(`node exited with ${describeExit(result)}`);
 }
 /** True when `outfile` exists and is newer than every `.ts`/`.mts` file under the entry's directory tree. */
 function isFresh(outfile, entry) {