@gjsify/cli 0.41.0 → 0.42.0

package/lib/actions/build.d.ts

@@ -166,11 +166,25 @@ export declare class BuildAction {
          */
         globals?: string;
         excludeGlobals?: string[];
+        /**
+         * Allow a `@gjsify/*` this project cannot resolve to come from the copy
+         * installed beside the RUNNING CLI.
+         *
+         * OPT-IN PER CALLER, never inferred here, because this helper does NOT
+         * only bundle toolchain — the `node` shim `gjsify run` puts on the PATH
+         * routes any project's `node <file>` through `utils/node-script.ts` and
+         * into this same function, a consumer's `"start": "node ./src/main.mjs"`
+         * included. Each caller states what it is bundling and why that earns the
+         * fallback; `gjsify build` sets nothing, so a user's missing dependency
+         * stays fatal there.
+         */
+        resolveFromToolchain?: boolean;
     }): Promise<string>;
     /** Application mode */
     buildApp(app?: App, opts?: {
         watch?: boolean;
         preserveDefaultExport?: boolean;
+        toolchainAnchor?: string;
     }): Promise<RolldownOutput[]>;
     /**
      * Drive `rolldown.watch(...)`: rebuild on source change, apply the

package/lib/actions/build.js

@@ -5,12 +5,13 @@ import { resolveUserPlugins } from '../utils/resolve-plugin-by-name.js';
 import { resolveGlobalsList, writeRegisterInjectFile, detectAutoGlobals, detectNodeGiGlobals, } from '@gjsify/rolldown-plugin-gjsify/globals';
 import { pnpPlugin } from '@gjsify/rolldown-plugin-pnp';
 import { basename, dirname, extname, join, resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { chmod, mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';
 import { normalizeBundlerOptions, mergeBundlerOptions } from '../utils/normalize-bundler-options.js';
 import { inputSourceDirs, isOutdirInsideSource, libraryOutputLeakError } from '../utils/library-output.js';
 import { detectHtmlEntry, parseHtmlEntry, emitBrowserHtml, htmlOutPathFor } from '../utils/html-entry.js';
 import { assertGjsBundleLoadable } from '../utils/gjs-bundle-guard.js';
+import { giSystemProbes } from '../utils/gi-runtime-paths.js';
 import { escapeRawNulForGjs } from '../utils/gjs-source-escape.js';
 import { assertNodeBundleGlobalsShimmed } from '../utils/node-bundle-guard.js';
 const DEFAULT_GJS_SHEBANG = '#!/usr/bin/env -S gjs -m';
@@ -78,17 +79,41 @@ async function newestLockfileMtime(cwd) {
     }
     return newest;
 }
+/**
+ * Absolute path of the CLI module that is running, or `null` when it did not come
+ * from a `file:` URL.
+ *
+ * The conversion happens ONCE, here, inside a catch. A CLI loaded from a non-`file:`
+ * origin — the bundled/Flatpak shape `commands/tsc.ts` names as the reason its second
+ * anchor exists — would otherwise make `fileURLToPath` throw on the path that loads
+ * every config file and every plugin, not merely lose the fallback.
+ */
+function runningCliFile() {
+    try {
+        return fileURLToPath(import.meta.url);
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Fresh when the cached GJS bundle is newer than BOTH the source file AND the
  * project's lockfile (the dep-change signal). Missing bundle/source → not fresh
  * (rebuild). Shared by the plugin + config GJS-bundle caches.
+ *
+ * `anchorFile` is the running CLI, and only set when this bundle was allowed the
+ * toolchain fallback. Such a bundle can carry code from the CLI's OWN install,
+ * which neither the entry mtime nor the project lockfile tracks — so after a
+ * `gjsify self-update` a cached config/plugin bundle holding the previous CLI's
+ * `@gjsify/*` would otherwise stay "fresh" forever.
  */
-async function isBundleFresh(outfile, sourcePath, cwd) {
+async function isBundleFresh(outfile, sourcePath, cwd, anchorFile) {
     try {
         const outStat = await stat(outfile);
         const srcStat = await stat(sourcePath);
         const depMtime = await newestLockfileMtime(cwd);
-        return outStat.mtimeMs >= Math.max(srcStat.mtimeMs, depMtime);
+        const anchorMtime = anchorFile === undefined ? 0 : (await stat(anchorFile)).mtimeMs;
+        return outStat.mtimeMs >= Math.max(srcStat.mtimeMs, depMtime, anchorMtime);
     }
     catch {
         return false;
@@ -433,6 +458,9 @@ export class BuildAction {
                 label: pluginName,
                 verbose,
                 noCacheEnv: 'GJSIFY_NO_PLUGIN_CACHE',
+                // A bundler plugin runs inside the CLI process — toolchain by
+                // construction, not by where its file happens to sit.
+                resolveFromToolchain: true,
             });
         }
         catch (err) {
@@ -471,9 +499,13 @@ export class BuildAction {
         // policies is two artifacts, and the freshness check below (entry mtime + lockfile)
         // cannot see the `package.json` edit that changed one. Callers without a policy keep
         // their existing cache filenames.
-        const cacheKey = opts.globals === undefined && opts.excludeGlobals === undefined
+        // The anchor belongs in the key for the same reason: with it the artifact may
+        // contain code from a DIFFERENT install than without it, and two CLIs on one
+        // machine resolve to two different paths.
+        const anchorFile = opts.resolveFromToolchain === true ? runningCliFile() : null;
+        const cacheKey = opts.globals === undefined && opts.excludeGlobals === undefined && anchorFile === null
             ? inputPath
-            : `${inputPath} ${JSON.stringify([opts.globals ?? null, opts.excludeGlobals ?? null])}`;
+            : `${inputPath} ${JSON.stringify([opts.globals ?? null, opts.excludeGlobals ?? null, anchorFile])}`;
         // THE HASH GOES IN THE DIRECTORY, THE FILE KEEPS THE SOURCE'S NAME. As
         // `<name>-<hash>.mjs` it broke every script guarding its body with the standard
         // is-entry test: `audit-runtimes.mjs` asks whether `process.argv[1]` ENDS WITH its
@@ -482,7 +514,7 @@ export class BuildAction {
         // does — and a name is cheaper to keep right than an argv to rewrite.
         const outfile = join(cacheDir, `${safeName}-${shortHash(cacheKey)}`, `${basename(inputPath).replace(/\.[cm]?[jt]sx?$/i, '')}.mjs`);
         const cacheDisabled = opts.cache === false || (opts.noCacheEnv ? isTruthyEnv(process.env[opts.noCacheEnv]) : false);
-        if (!cacheDisabled && (await isBundleFresh(outfile, inputPath, cwd))) {
+        if (!cacheDisabled && (await isBundleFresh(outfile, inputPath, cwd, anchorFile ?? undefined))) {
             if (opts.verbose)
                 console.debug(`[gjsify] reusing cached GJS bundle ${outfile}`);
             return outfile;
@@ -499,7 +531,13 @@ export class BuildAction {
                 output: { file: outfile },
                 ...(opts.define ? { transform: { define: opts.define } } : {}),
             },
-        }).buildApp('gjs', { preserveDefaultExport: opts.preserveDefaultExport ?? true });
+        }).buildApp('gjs', {
+            preserveDefaultExport: opts.preserveDefaultExport ?? true,
+            // See `opts.resolveFromToolchain`: the CALLER decides whether this input is
+            // toolchain, because this helper alone cannot tell a config file from a
+            // consumer's `node ./src/main.mjs`.
+            ...(anchorFile === null ? {} : { toolchainAnchor: anchorFile }),
+        });
         return outfile;
     }
     /** Application mode */
@@ -558,6 +596,7 @@ export class BuildAction {
             consoleShim,
             ...(aliases ? { aliases } : {}),
             ...(opts.preserveDefaultExport ? { preserveDefaultExport: true } : {}),
+            ...(opts.toolchainAnchor !== undefined ? { toolchainAnchor: opts.toolchainAnchor } : {}),
         };
         const { autoMode, extras } = this.parseGlobalsValue(globals);
         const pnp = await buildPnpPlugin();
@@ -682,6 +721,13 @@ export class BuildAction {
         else if (extras) {
             pluginOpts.autoGlobalsInject = await this.resolveGlobalsInject(app, extras, verbose);
         }
+        // Fills the byte-1 GI prologue — built across #1152/#1160/#1026 and called by
+        // nothing, so every `--app gjs` bundle ever built shipped the empty string
+        // `giRuntimePathsStub` returns for an empty input. Only the FINAL build: the
+        // two analysis passes above bundle in memory to be PARSED for free globals,
+        // never written and never run, so a prologue there is work whose result is
+        // discarded.
+        const giProbes = app === 'gjs' ? giSystemProbes() : undefined;
         // Final build: orchestrator → rolldown → write
         const cfg = await gjsifyPlugin({
             input: userBundler.input,
@@ -690,6 +736,7 @@ export class BuildAction {
             userBanner,
             userAliases: aliases,
             shebang: this.configData.shebang,
+            giSystemProbes: giProbes,
         }, pluginOpts);
         const merged = mergeBundlerOptions(cfg.options, userBundler);
         const finalOpts = {

package/lib/bundler-pick.js

@@ -2,8 +2,16 @@
 // npm `rolldown(opts).write(opts.output)`; GJS gets `@gjsify/rolldown-native` (the
 // Vala/Rust prebuild) via `bundleWithPlugins()`, with `runNativeBundle` replicating
 // npm rolldown's `.write()` including nested chunk/asset subdirectories. The native
-// engine is the GJS DEFAULT with no env var, because npm `rolldown` is a Rust N-API
-// addon that cannot load under GJS at all.
+// engine is the GJS DEFAULT with no env var, because npm `rolldown` does not run
+// under GJS. Where it fails matters: NOT in the N-API addon, but in the JS entry
+// above it. `rolldown/dist/shared/binding-*.mjs` evaluates
+// `createRequire(import.meta.url)` at module scope and its platform detection then
+// calls `__require('node:fs')` / `__require('node:child_process')`; GJS refuses a
+// synchronous require of a builtin, so the load dies before any `.node` is opened.
+// The distinction is not pedantry — it says an N-API host alone would not be
+// enough; the wrapper has to be bypassed too, which is exactly what
+// `napiNodeAddonPlugin` does for napi-rs packages. See `status/open-todos.md`
+// § "Can `@gjsify/napi` retire the hand-written `-native` bridges?".
 //
 // `GJSIFY_BUNDLER=native|npm` overrides that: `native` throws when the prebuild is
 // not loadable for the running architecture instead of silently switching engines;

package/lib/cli-app.js

@@ -18,7 +18,7 @@
 import yargs from 'yargs';
 import { classifyCliFailure } from './cli-fail.js';
 import { cliVersion } from './utils/publish-headers.js';
-import { buildCommand as build, clearCommand as clear, copyCommand as copy, testCommand as test, runCommand as run, infoCommand as info, systemCheckCommand as systemCheck, checkCommand as check, showcaseCommand as showcase, createCommand as create, gresourceCommand as gresource, gettextCommand as gettext, gsettingsCommand as gsettings, flatpakCommand as flatpak, shipCommand as ship, dlxCommand as dlx, installCommand as install, foreachCommand as foreach, workspaceCommand as workspace, packCommand as pack, publishCommand as publish, whoamiCommand as whoami, loginCommand as login, logoutCommand as logout, trustCommand as trust, onboardCommand as onboard, selfUpdateCommand as selfUpdate, generateInstallerCommand as generateInstaller, pruneCommand as prune, uninstallCommand as uninstall, formatCommand as format, lintCommand as lint, fixCommand as fix, upgradeCommand as upgrade, barrelsCommand as barrels, tscCommand as tsc, affectedCommand as affected, storybookCommand as storybook, debugCommand as debug, browseCommand as browse, } from './commands/index.js';
+import { buildCommand as build, clearCommand as clear, copyCommand as copy, testCommand as test, runCommand as run, infoCommand as info, systemCheckCommand as systemCheck, checkCommand as check, showcaseCommand as showcase, createCommand as create, gresourceCommand as gresource, gettextCommand as gettext, gsettingsCommand as gsettings, flatpakCommand as flatpak, shipCommand as ship, dlxCommand as dlx, installCommand as install, foreachCommand as foreach, workspaceCommand as workspace, packCommand as pack, publishCommand as publish, whoamiCommand as whoami, loginCommand as login, logoutCommand as logout, trustCommand as trust, onboardCommand as onboard, selfUpdateCommand as selfUpdate, generateInstallerCommand as generateInstaller, pruneCommand as prune, uninstallCommand as uninstall, formatCommand as format, lintCommand as lint, fixCommand as fix, upgradeCommand as upgrade, barrelsCommand as barrels, tscCommand as tsc, affectedCommand as affected, storybookCommand as storybook, devCommand as dev, debugCommand as debug, browseCommand as browse, } from './commands/index.js';
 import { APP_NAME } from './constants.js';
 import { isBun, isDeno, isNode, gjsSystemVersion } from '@gjsify/rolldown-plugin-gjsify/runtime';
 import { ensureGjsifyShimOnPath } from './utils/gjsify-shim.js';
@@ -129,6 +129,7 @@ export async function runCli(argv) {
         .command(tsc.command, tsc.description, tsc.builder, tsc.handler)
         .command(affected.command, affected.description, affected.builder, affected.handler)
         .command(storybook.command, storybook.description, storybook.builder, storybook.handler)
+        .command(dev.command, dev.description, dev.builder, dev.handler)
         .command(debug.command, debug.description, debug.builder, debug.handler)
         .command(browse.command, browse.description, browse.builder, browse.handler)
         .demandCommand(1)

package/lib/commands/browse.js

@@ -112,6 +112,6 @@ export const browseCommand = {
             process.env.WEBKIT_INSPECTOR_HTTP_SERVER = `127.0.0.1:${inspectorPort}`;
         }
         const { runGjsBundle } = await import('../utils/run-gjs.js');
-        await runGjsBundle(outPath, [], { exitOnSuccess: true });
+        await runGjsBundle(outPath, [], { completion: 'exit', exitOnSuccess: true });
     },
 };

package/lib/commands/debug.js

@@ -158,6 +158,6 @@ export const debugCommand = {
             return;
         }
         const { runGjsBundle } = await import('../utils/run-gjs.js');
-        await runGjsBundle(outPath, [], { exitOnSuccess: true });
+        await runGjsBundle(outPath, [], { completion: 'exit', exitOnSuccess: true });
     },
 };

package/lib/commands/dev.d.ts

@@ -0,0 +1,13 @@
+import type { Command } from '../types/index.js';
+interface DevCliOptions {
+    entry?: string;
+    runtime?: string;
+    script?: string;
+    globals?: string;
+    outfile?: string;
+    watchDir?: string;
+    debounce: number;
+    buildOnly: boolean;
+}
+export declare const devCommand: Command<unknown, DevCliOptions>;
+export {};

package/lib/commands/dev.js

@@ -0,0 +1,132 @@
+// `gjsify dev` — the inner development loop: watch, rebuild, relaunch.
+//
+// It exists because `gjsify build --watch` cannot serve it on the host that
+// needs it most. That flag drives rolldown's watcher API, which only the npm
+// engine exposes (`bundler-pick.ts` refuses under `@gjsify/rolldown-native`), so
+// on a Node-free GJS host the loop was manual: edit, Ctrl-C, rebuild, relaunch.
+// `gjsify storybook --watch` had already shown the way around it — watch with
+// `fs.watch` and rebuild by re-entering the ordinary build command, which needs
+// no watcher API and is runtime-agnostic. That loop is now shared
+// (`utils/watch-loop.ts`) and this command is its second caller.
+//
+// WHAT to build is not re-declared here: it is read out of the project's own
+// `build:gjs` / `build:node` script (`utils/dev-plan.ts`), so the dev loop and
+// `gjsify run build` cannot drift into building different bundles.
+import { existsSync, readFileSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+import { noBundleError, planDev } from '../utils/dev-plan.js';
+import { buildAppForRuntime, EXAMPLE_RUNTIMES } from '../utils/runtimes.js';
+import { hostRuntime } from '@gjsify/rolldown-plugin-gjsify/runtime';
+function readPackage(cwd) {
+    try {
+        return JSON.parse(readFileSync(join(cwd, 'package.json'), 'utf8'));
+    }
+    catch {
+        // A missing or malformed package.json is not this command's error to
+        // report: `planDev` refuses right after, naming the flags that make
+        // `gjsify dev` work in a directory with no manifest at all.
+        return {};
+    }
+}
+export const devCommand = {
+    command: 'dev [entry]',
+    description: 'Watch this project, rebuild on change and relaunch the app.',
+    builder: (yargs) => yargs
+        .positional('entry', {
+        description: 'Entry point to build (default: the one the build script names, e.g. src/index.ts from `build:gjs`).',
+        type: 'string',
+    })
+        .option('runtime', {
+        description: 'Runtime to build for and launch on: gjs | node | bun | deno (default: the host runtime). ' +
+            'node/bun/deno build the same `--app node` bundle.',
+        type: 'string',
+        choices: EXAMPLE_RUNTIMES,
+        // No yargs `default` — the host default is applied in the
+        // handler, so `hostRuntime()` is evaluated where it can be seen.
+        defaultDescription: 'host runtime (gjs on gjs, else node/bun/deno)',
+    })
+        .option('script', {
+        description: 'package.json script the build flags are read from (default: build:gjs, or build:node for node/bun/deno).',
+        type: 'string',
+    })
+        .option('globals', { description: 'Override the build script `--globals` value.', type: 'string' })
+        .option('outfile', { description: 'Override the build script `--outfile` path.', type: 'string' })
+        .option('watch-dir', {
+        description: 'Directory watched recursively (default: the directory of the entry point).',
+        type: 'string',
+    })
+        .option('debounce', {
+        description: 'Quiet window in ms after a change before rebuilding.',
+        type: 'number',
+        default: 200,
+    })
+        .option('build-only', {
+        description: 'Rebuild on every change but never launch the app.',
+        type: 'boolean',
+        default: false,
+    }),
+    handler: async (args) => {
+        const cwd = process.cwd();
+        const pkg = readPackage(cwd);
+        // The cast, not a guard: yargs' `choices` above already rejects anything
+        // outside the four, and `hostRuntime()` returns exactly that union — a
+        // second check here would be validating our own vocabulary.
+        const runtime = (args.runtime ?? hostRuntime());
+        const app = buildAppForRuntime(runtime);
+        const scriptName = args.script ?? (app === 'gjs' ? 'build:gjs' : 'build:node');
+        let plan;
+        try {
+            plan = planDev({
+                scripts: pkg.scripts ?? {},
+                scriptName,
+                app,
+                declaredBundle: app === 'gjs' ? pkg.gjsify?.main : pkg.gjsify?.example?.node,
+                entry: args.entry,
+                globals: args.globals,
+                outfile: args.outfile,
+                watchDir: args.watchDir,
+            });
+        }
+        catch (err) {
+            console.error(err.message);
+            // `return process.exit()`: under GJS a bare `process.exit()` only
+            // SCHEDULES the exit and returns, so execution would fall through
+            // into the watch loop and the deferred exit would never carry its
+            // code. Same trap as `showcase.ts` / `storybook.ts`.
+            return process.exit(1);
+        }
+        const bundlePath = plan.bundle === undefined ? undefined : resolve(cwd, plan.bundle);
+        if (bundlePath === undefined && !args.buildOnly) {
+            console.error(noBundleError(scriptName, app).message);
+            return process.exit(1);
+        }
+        const watchDir = resolve(cwd, plan.watchDir);
+        if (!existsSync(watchDir)) {
+            // `fs.watch` on a missing directory throws a bare ENOENT with the
+            // path buried in a stack — say which directory was DERIVED and how
+            // to override it instead.
+            console.error(`gjsify dev: nothing to watch — ${relative(cwd, watchDir) || watchDir} does not exist.\n` +
+                `  Point the loop at your sources:   gjsify dev --watch-dir <dir>`);
+            return process.exit(1);
+        }
+        const target = bundlePath === undefined ? `\`${scriptName}\` output` : relative(cwd, bundlePath);
+        console.log(`Watching ${relative(cwd, watchDir) || '.'} → ${target} (runtime: ${runtime})`);
+        // In-process build — runtime-agnostic (Node uses npm rolldown, GJS the
+        // @gjsify/rolldown-native facade), no re-spawn of the CLI binary.
+        const { runCli } = await import('../cli-app.js');
+        const { runWatchLoop, spawnBundleSupervised } = await import('../utils/watch-loop.js');
+        await runWatchLoop({
+            dir: watchDir,
+            dirLabel: relative(cwd, watchDir) || '.',
+            label: 'dev',
+            build: () => runCli(plan.buildArgv),
+            spawnChild: args.buildOnly || bundlePath === undefined
+                ? null
+                : () => spawnBundleSupervised(runtime, bundlePath, cwd, 'this project'),
+            // Passed even under `--build-only`: what makes the loop feed itself
+            // is the WRITE, not the launch.
+            output: bundlePath,
+            debounceMs: args.debounce,
+        });
+    },
+};

package/lib/commands/dlx.js

@@ -100,7 +100,7 @@ export const dlxCommand = {
         }
         // Terminal call — exit on success, or the GJS main loop parks this
         // process forever (see RunGjsBundleOptions.exitOnSuccess).
-        await runGjsBundle(entry.bundlePath, extraArgs, { exitOnSuccess: true });
+        await runGjsBundle(entry.bundlePath, extraArgs, { completion: 'exit', exitOnSuccess: true });
     },
 };
 /**

package/lib/commands/index.d.ts

@@ -36,5 +36,6 @@ export * from './barrels.js';
 export * from './tsc.js';
 export * from './affected.js';
 export * from './storybook.js';
+export * from './dev.js';
 export * from './debug.js';
 export * from './browse.js';

package/lib/commands/index.js

@@ -36,5 +36,6 @@ export * from './barrels.js';
 export * from './tsc.js';
 export * from './affected.js';
 export * from './storybook.js';
+export * from './dev.js';
 export * from './debug.js';
 export * from './browse.js';

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/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` +