@gjsify/cli 0.41.0 → 0.43.0

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.d.ts

@@ -3,6 +3,8 @@ interface ShipOptions {
     target?: string[];
     out?: string;
     stage: boolean;
+    'from-stage'?: string;
+    'expect-target'?: string;
     'skip-build': boolean;
     arch?: string;
     verbose: boolean;

package/lib/commands/ship.js

@@ -5,12 +5,23 @@
 // thin on purpose: every decision worth testing lives in `utils/ship/*` as a
 // pure function, and what is left here is filesystem work and printing.
 //
+// TWO PHASES, one verb each (ADR 0024 § A2). Phase one ASSEMBLES: it resolves
+// the settings, plans the payload, writes `stage/`, and writes the closure that
+// makes that tree packable somewhere else (`.gjsify-ship-stage.json`, see
+// `utils/ship/stage-manifest.ts`). Phase two FINISHES: `--from-stage <dir>`
+// packs a stage that arrived from another host, with no project, no config and
+// no built bundle in reach. With neither flag both phases run in one process,
+// which is what a developer on one machine wants and what the e2e suite
+// compares the split against byte for byte.
+//
 // Scope today is Linux and `--app gjs`: no runtime is bundled, because GJS and
 // GTK come from the distribution and shipping ~100 MiB of them would be cargo
 // cult (ADR 0024 § 4). macOS and Windows layouts, and Flatpak as a target under
-// this command, are the later stages of the same ADR.
+// this command, are the later stages of the same ADR — and they are the reason
+// the split exists at all: a `.dmg` is a UDIF image over a real HFS+/APFS
+// volume and no Linux host in this tree can write one (§ A1).
 import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { basename, join, relative, resolve } from 'node:path';
+import { basename, dirname, join, relative, resolve } from 'node:path';
 import { Config } from '../config.js';
 import { renderDesktopEntry, renderMetainfoApp, renderMetainfoCli, validateAppMetadata, } from '../utils/app-metadata.js';
 import { readPackageJson } from '../utils/pkg-json.js';
@@ -20,11 +31,12 @@ 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 { planOverlay, planStage } from '../utils/ship/plan.js';
+import { assertPayloadMatchesArch, buildTimestamp, isArchIndependent, readPayloadFacts, } from '../utils/ship/payload.js';
+import { assertOverlayIsLicensed, planOverlay, planStage } from '../utils/ship/plan.js';
 import { renderLauncher } from '../utils/ship/launcher.js';
 import { buildRpm } from '../utils/ship/rpm.js';
 import { declaredBundlePath, resolveShipSettings } from '../utils/ship/settings.js';
+import { assertExpectedTarget, assertFormatsStaged, formatTarget, overlayFiles, readStageManifest, resolveStageMtime, warnOnToolSkew, writeStageManifest, } from '../utils/ship/stage-manifest.js';
 import { readStage, writeStage } from '../utils/ship/stage-writer.js';
 const LOG = '[gjsify ship]';
 export const shipCommand = {
@@ -45,6 +57,17 @@ export const shipCommand = {
         type: 'boolean',
         default: false,
         description: 'Produce the staged payload and stop, without packing anything.',
+    })
+        .option('from-stage', {
+        type: 'string',
+        normalize: true,
+        description: 'Pack a staged payload written by an earlier `--stage` run. Needs no project: the stage ' +
+            'carries its own closure.',
+    })
+        .option('expect-target', {
+        type: 'string',
+        description: 'With --from-stage: refuse unless the stage was assembled for this `<os>-<arch>`, e.g. ' +
+            '`linux-arm64`.',
     })
         .option('skip-build', {
         type: 'boolean',
@@ -61,109 +84,279 @@ export const shipCommand = {
         description: 'Print each staged file and the GI namespaces the bundle imports.',
     }),
     handler: async (args) => {
-        const projectDir = process.cwd();
-        const config = new Config();
-        // No `.catch(() => ({}))` here, unlike the flatpak commands: a config
-        // file that fails to load would silently become "no config", and the
-        // result is a shipped artifact carrying default metadata the author
-        // never chose. An unreadable config is an error worth printing.
-        const configData = await config.forCommand(projectDir);
-        const ship = configData.ship ?? {};
-        const flatpak = configData.flatpak ?? {};
-        assertShippableTarget(configData.app);
-        const pkg = (readPackageJson(join(projectDir, 'package.json')) ?? {});
-        // Resolved before anything is built or written: a typo'd `--target`
-        // should not cost a build and leave a half-written `ship/stage/`.
-        const formats = resolveFormats(args.target ?? ship.targets ?? FORMAT_IDS);
-        if (!args['skip-build'])
-            await runProjectBuild(projectDir);
-        const discovered = discoverPayload({
-            projectDir,
-            pkg,
-            ship,
-            flatpakIcon: flatpak.icon,
-            declaredBundle: declaredBundlePath(pkg, ship),
-        });
-        const { settings, metadata, warnings } = resolveShipSettings({
-            projectDir,
-            pkg,
-            ship,
-            flatpak,
-            cli: { outDir: args.out, arch: args.arch },
-            discovered,
+        // The two phases share nothing but `packOne`, and the branch is first
+        // so that `--from-stage` never touches the cwd: a finishing host has no
+        // project there, and reading one would make the artifact depend on
+        // whatever directory the job happened to start in.
+        if (args['from-stage'] !== undefined)
+            return await finishFromStage(args, args['from-stage']);
+        await assemble(args);
+    },
+};
+/**
+ * Phase one: resolve, plan, stage, and write the closure — then, unless
+ * `--stage` was passed, pack right here.
+ */
+async function assemble(args) {
+    const projectDir = process.cwd();
+    const config = new Config();
+    // No `.catch(() => ({}))` here, unlike the flatpak commands: a config
+    // file that fails to load would silently become "no config", and the
+    // result is a shipped artifact carrying default metadata the author
+    // never chose. An unreadable config is an error worth printing.
+    const configData = await config.forCommand(projectDir);
+    const ship = configData.ship ?? {};
+    const flatpak = configData.flatpak ?? {};
+    assertShippableTarget(configData.app);
+    const pkg = (readPackageJson(join(projectDir, 'package.json')) ?? {});
+    // Resolved before anything is built or written: a typo'd `--target`
+    // should not cost a build and leave a half-written `ship/stage/`.
+    const formats = resolveFormats(args.target ?? ship.targets ?? FORMAT_IDS);
+    if (!args['skip-build'])
+        await runProjectBuild(projectDir);
+    const discovered = discoverPayload({
+        projectDir,
+        pkg,
+        ship,
+        flatpakIcon: flatpak.icon,
+        declaredBundle: declaredBundlePath(pkg, ship),
+    });
+    const { settings, metadata, warnings } = resolveShipSettings({
+        projectDir,
+        pkg,
+        ship,
+        flatpak,
+        cli: { outDir: args.out, arch: args.arch },
+        discovered,
+    });
+    for (const warning of warnings)
+        console.warn(`${LOG} ${warning}`);
+    const mtime = buildTimestamp(settings.bundlePath);
+    const metadataInputs = {
+        appId: settings.appId,
+        name: settings.name,
+        command: settings.binaryName,
+        kind: settings.kind,
+        metadata,
+        configKey: 'gjsify.ship',
+        copyrightYear: new Date(mtime * 1000).getUTCFullYear(),
+    };
+    // Warn rather than fail: an incomplete AppStream component still
+    // installs and still runs. It is app STORES that will reject it, and
+    // that is a different day's problem than getting the package built.
+    for (const missing of validateAppMetadata(metadataInputs)) {
+        console.warn(`${LOG} ${missing.field} is not set — ${missing.hint}`);
+    }
+    // Printed, not assumed. The text may come from an ancestor — one `LICENSE`
+    // at a monorepo root covers every package under it (see `discoverLicense`)
+    // — and which file was baked into the copyright is not recoverable from the
+    // artifact afterwards without unpacking it.
+    if (settings.licenseFile !== undefined && dirname(settings.licenseFile) !== projectDir) {
+        console.log(`${LOG} licence text from ${relative(projectDir, settings.licenseFile)} ` +
+            '(this package carries none of its own)');
+    }
+    const stageInputs = {
+        bundleFiles: discovered.bundleFiles,
+        launcher: renderLauncher(settings, basename(settings.bundlePath)),
+        metainfo: settings.kind === 'app' ? renderMetainfoApp(metadataInputs) : renderMetainfoCli(metadataInputs),
+        desktopEntry: settings.kind === 'app' ? renderDesktopEntry(metadataInputs) : undefined,
+        licenseText: settings.licenseFile === undefined ? undefined : readFileSync(settings.licenseFile, 'utf-8'),
+    };
+    const outRoot = resolve(projectDir, settings.outDir);
+    const stageDir = join(outRoot, 'stage');
+    const staged = planStage(settings, stageInputs);
+    writeStage(stageDir, staged);
+    console.log(`${LOG} staged ${staged.length} file(s) in ${relative(projectDir, stageDir)}/`);
+    if (args.verbose)
+        for (const file of staged)
+            console.log(`${LOG}   ${file.path}`);
+    // Scanned from the BUILD TREE's bundle, which is why it has to be recorded:
+    // `gi://` specifiers are what the emitted `Depends:` is derived from
+    // (ADR 0024 § 6), and the packing host has the staged copy but no way to
+    // tell which staged file is the entry.
+    const namespaces = scanGiNamespaces(readFileSync(settings.bundlePath, 'utf-8'));
+    if (args.verbose)
+        console.log(`${LOG} gi namespaces: ${namespaces.join(', ') || '(none)'}`);
+    const overlay = new Map();
+    for (const format of formats)
+        overlay.set(format.id, planOverlay(settings, format, stageInputs));
+    // The dependency derivation runs HERE as well, and its result is thrown
+    // away. It is the only check in the pipeline that can refuse a project
+    // (`gi://Nautilus` with no known package, ADR 0024 § 6), and this is the
+    // host that has the `package.json` the refusal tells you to edit — letting
+    // it fire two jobs later, on a machine with no project, would name a fix
+    // nobody there can apply. Facts come from the PLAN, which has the same
+    // paths the payload will have.
+    const facts = readPayloadFacts(staged);
+    for (const format of formats) {
+        deriveDepends(format.id, {
+            namespaces,
+            hasIcons: facts.hasIcons,
+            hasSchemas: facts.hasSchemas,
+            extra: settings.extraDepends[format.id],
+            typelibPackages: settings.typelibPackages,
+            bundledTypelibs: facts.bundledTypelibs,
+            minGjsVersion: settings.minGjsVersion,
         });
-        for (const warning of warnings)
+        for (const warning of warnAboutGjsFloor(format.id, settings.minGjsVersion))
+            console.warn(`${LOG} ${warning}`);
+    }
+    // Written unconditionally, not only under `--stage`: a `ship/stage/` that
+    // is sometimes packable elsewhere and sometimes not is a worse contract
+    // than one that always is, and it is what lets the e2e suite compare the
+    // one-process artifact with the two-phase one.
+    const manifest = writeStageManifest({ stageDir, settings, formats, mtime, namespaces, staged, overlay });
+    if (args.stage) {
+        console.log(`${LOG} stage manifest: ${formatTarget(manifest.target)}, formats ${manifest.formats.join(', ')}`);
+        return;
+    }
+    const artifacts = [];
+    for (const format of formats) {
+        artifacts.push(await packOne({
+            format,
+            settings,
+            arch: settings.arch,
+            staged,
+            overlay: overlay.get(format.id) ?? [],
+            stageDir,
+            outRoot,
+            namespaces,
+            mtime,
+        }));
+    }
+    printArtifacts(projectDir, artifacts);
+}
+/**
+ * Phase two: pack a stage that was assembled somewhere else.
+ *
+ * Everything this needs is in the stage. Nothing under the cwd is read, and
+ * that is the property under test — `tests/e2e/ship-from-stage` deletes the
+ * project tree between the two phases, because without the deletion every
+ * accidental reach-back succeeds and the suite proves nothing.
+ */
+async function finishFromStage(args, fromStage) {
+    if (args.stage) {
+        throw new Error('gjsify ship: --stage and --from-stage are the two halves of one split and cannot run together. ' +
+            '`--stage` assembles a payload and stops; `--from-stage <dir>` packs one that is already ' +
+            'assembled. Run them as two commands, on the host each belongs on (ADR 0024 § A2).');
+    }
+    if (args['skip-build']) {
+        throw new Error('gjsify ship: --from-stage never runs a build — the payload it packs was built and staged by an ' +
+            'earlier run — so --skip-build has nothing to skip. Drop it.');
+    }
+    if (args.arch !== undefined) {
+        throw new Error('gjsify ship: --arch is decided when the stage is assembled, not when it is packed: the launcher, ' +
+            'the payload and the recorded target were all fixed then. Pass --arch to ' +
+            '`gjsify ship --stage`, and use `--expect-target <os>-<arch>` here to assert which leg you are ' +
+            'packing.');
+    }
+    const cwd = process.cwd();
+    const stageDir = resolve(cwd, fromStage);
+    const manifest = readStageManifest(stageDir);
+    assertExpectedTarget(manifest, args['expect-target']);
+    const formats = resolveFormats(args.target ?? manifest.formats);
+    assertFormatsStaged(manifest, formats);
+    for (const warning of warnOnToolSkew(manifest))
+        console.warn(`${LOG} ${warning}`);
+    const { mtime, warnings } = resolveStageMtime(manifest);
+    for (const warning of warnings)
+        console.warn(`${LOG} ${warning}`);
+    console.log(`${LOG} packing ${manifest.settings.binaryName} ${manifest.settings.version}-${manifest.settings.release} ` +
+        `for ${formatTarget(manifest.target)} from ${relative(cwd, stageDir) || '.'}/`);
+    if (args.verbose) {
+        for (const file of manifest.staged)
+            console.log(`${LOG}   ${file.path}`);
+        console.log(`${LOG} gi namespaces: ${manifest.namespaces.join(', ') || '(none)'}`);
+    }
+    // The stage's own directory is not written to — `writeStage` wipes what it
+    // is pointed at, and pointing it at an arriving stage would delete the
+    // payload. The overlay is the only thing this phase materialises, and it
+    // goes beside the artifacts.
+    const outRoot = args.out === undefined ? dirname(stageDir) : resolve(cwd, args.out);
+    const artifacts = [];
+    for (const format of formats) {
+        for (const warning of warnAboutGjsFloor(format.id, manifest.settings.minGjsVersion)) {
             console.warn(`${LOG} ${warning}`);
-        const mtime = buildTimestamp(settings.bundlePath);
-        const metadataInputs = {
-            appId: settings.appId,
-            name: settings.name,
-            command: settings.binaryName,
-            kind: settings.kind,
-            metadata,
-            configKey: 'gjsify.ship',
-            copyrightYear: new Date(mtime * 1000).getUTCFullYear(),
-        };
-        // Warn rather than fail: an incomplete AppStream component still
-        // installs and still runs. It is app STORES that will reject it, and
-        // that is a different day's problem than getting the package built.
-        for (const missing of validateAppMetadata(metadataInputs)) {
-            console.warn(`${LOG} ${missing.field} is not set — ${missing.hint}`);
-        }
-        const stageInputs = {
-            bundleFiles: discovered.bundleFiles,
-            launcher: renderLauncher(settings, basename(settings.bundlePath)),
-            metainfo: settings.kind === 'app' ? renderMetainfoApp(metadataInputs) : renderMetainfoCli(metadataInputs),
-            desktopEntry: settings.kind === 'app' ? renderDesktopEntry(metadataInputs) : undefined,
-            licenseText: settings.licenseFile === undefined ? undefined : readFileSync(settings.licenseFile, 'utf-8'),
-        };
-        const outRoot = resolve(projectDir, settings.outDir);
-        const stageDir = join(outRoot, 'stage');
-        const staged = planStage(settings, stageInputs);
-        writeStage(stageDir, staged);
-        console.log(`${LOG} staged ${staged.length} file(s) in ${relative(projectDir, stageDir)}/`);
-        if (args.verbose)
-            for (const file of staged)
-                console.log(`${LOG}   ${file.path}`);
-        if (args.stage)
-            return;
-        const namespaces = scanGiNamespaces(readFileSync(settings.bundlePath, 'utf-8'));
-        if (args.verbose)
-            console.log(`${LOG} gi namespaces: ${namespaces.join(', ') || '(none)'}`);
-        const artifacts = [];
-        for (const format of formats) {
-            artifacts.push(await packOne({ format, settings, stageInputs, staged, stageDir, outRoot, namespaces, mtime }));
-        }
-        for (const artifact of artifacts) {
-            console.log(`${LOG} ${artifact.format}: ${relative(projectDir, artifact.path)} (${artifact.size} bytes)`);
         }
-    },
-};
+        artifacts.push(await packOne({
+            format,
+            settings: manifest.settings,
+            arch: manifest.target.arch,
+            staged: manifest.staged,
+            overlay: overlayFiles(manifest, format.id),
+            stageDir,
+            outRoot,
+            namespaces: manifest.namespaces,
+            mtime,
+        }));
+    }
+    printArtifacts(cwd, artifacts);
+}
 async function packOne(input) {
     const { format, settings, stageDir, outRoot, mtime } = input;
-    const overlay = planOverlay(settings, format, input.stageInputs);
+    assertOverlayIsLicensed(format.id, settings.binaryName, input.overlay);
     const overlayDir = join(outRoot, 'overlay', format.id);
-    writeStage(overlayDir, overlay);
-    const payload = readStage([stageDir, overlayDir], [...input.staged, ...overlay]);
+    writeStage(overlayDir, input.overlay);
+    const payload = readStage([stageDir, overlayDir], [...input.staged, ...input.overlay]);
+    // What the package installs, read off what it installs. The three questions
+    // this answers used to be answered from the project's file lists, which are
+    // absolute paths on the build host and therefore unavailable here.
+    const facts = readPayloadFacts(payload);
     const depends = deriveDepends(format.id, {
         namespaces: input.namespaces,
-        kind: settings.kind,
-        hasSchemas: settings.schemaFiles.length > 0,
+        hasIcons: facts.hasIcons,
+        hasSchemas: facts.hasSchemas,
         extra: settings.extraDepends[format.id],
         typelibPackages: settings.typelibPackages,
+        bundledTypelibs: facts.bundledTypelibs,
         minGjsVersion: settings.minGjsVersion,
     });
-    for (const warning of warnAboutGjsFloor(format.id, settings.minGjsVersion))
-        console.warn(`${LOG} ${warning}`);
-    const archLabel = format.archName(settings.arch, isArchIndependent(payload));
+    // `--arch` is a CLAIM about the payload and nothing else compared it to one:
+    // an x86-64 `.so` staged with `--arch arm64` packed at exit 0 and `rpm -qp
+    // --qf %{ARCH}` confirmed `aarch64`, because rpm reads the header and the
+    // header was written from the claim. Read the two bytes further that settle
+    // it before the label reaches a header. Payload-versus-LABEL, never
+    // payload-versus-HOST — a host check would refuse the cross-host pack this
+    // whole split exists for.
+    //
+    // And BEFORE the label is chosen, not after — this ordering is load-bearing:
+    // `archName` collapses an arch-independent payload to `all`/`noarch`, so
+    // asserting afterwards would compare against a label that no longer names an
+    // architecture, and the mismatch that matters is exactly the one on a payload
+    // that IS architecture-specific.
+    assertPayloadMatchesArch(payload, input.arch);
+    const archLabel = format.archName(input.arch, isArchIndependent(payload));
     const common = { settings, payload, prefix: format.prefix, depends, archLabel, mtime };
-    const bytes = format.id === 'deb' ? await buildDeb(common) : await buildRpm(common);
+    // A SWITCH with a `never` guard, not a ternary. `format.id === 'deb' ? deb : rpm`
+    // read as a dispatch and behaved as one only while there were exactly two
+    // formats: a third would have taken the else-branch and written an RPM under a
+    // `.dmg` name, at exit 0. This is the same closed-vocabulary hazard the format
+    // list has, one level worse — a wrong ARTIFACT rather than a rejected
+    // declaration — so the compiler owns it now.
+    let bytes;
+    switch (format.id) {
+        case 'deb':
+            bytes = await buildDeb(common);
+            break;
+        case 'rpm':
+            bytes = await buildRpm(common);
+            break;
+        default: {
+            const unhandled = format.id;
+            throw new Error(`gjsify ship: no packer is wired for format "${String(unhandled)}".`);
+        }
+    }
     const outDir = join(outRoot, 'out');
     mkdirSync(outDir, { recursive: true });
     const target = join(outDir, format.fileName(settings, archLabel));
     writeFileSync(target, bytes);
     return { format: format.id, path: target, size: bytes.byteLength };
 }
+function printArtifacts(base, artifacts) {
+    for (const artifact of artifacts) {
+        console.log(`${LOG} ${artifact.format}: ${relative(base, artifact.path)} (${artifact.size} bytes)`);
+    }
+}
 /**
  * Refuse a build target this command cannot package correctly.
  *
@@ -176,6 +369,10 @@ async function packOne(input) {
  * An undeclared target is the common case for a GJS app and is allowed: `app`
  * otherwise defaults to the HOST runtime, which would refuse a perfectly good
  * GJS project merely for running this command under Node.
+ *
+ * Phase one only, and nothing checks it again in phase two: a stage can only
+ * exist because this passed, and the staged `bin/<name>` carries the
+ * `exec gjs -m` line that proves it.
  */
 function assertShippableTarget(app) {
     if (app === undefined || app === 'gjs')

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