@gjsify/cli 0.38.1 → 0.40.0

package/lib/utils/ship/settings.js

@@ -0,0 +1,184 @@
+// Turning a project into a fully-defaulted {@link ShipSettings}.
+//
+// Kept free of the filesystem: the caller discovers the payload (bundle files,
+// icons, schemas, licence) and hands the paths in, so every defaulting and
+// every refusal is unit-testable without building an app first. The precedent
+// is `utils/copy-targets.ts`, and the reason is the same — the cases worth
+// testing are the ones that must FAIL.
+//
+// Precedence is uniform: CLI flag > `gjsify.ship` > `gjsify.flatpak` (metadata
+// only) > derived from package.json. Never a yargs `default:`, which is
+// indistinguishable from a value the user typed and would clobber the config.
+import { basename } from 'node:path';
+import { DEFAULT_GJS_FLOOR } from './depends.js';
+import { assertRelease, normaliseVersion } from './version.js';
+/** Freedesktop main category → deb `Section:` / rpm `Group:`. First match wins. */
+const CATEGORY_SECTIONS = [
+    ['Development', { section: 'devel', group: 'Development/Tools' }],
+    ['Education', { section: 'education', group: 'Applications/Education' }],
+    ['Game', { section: 'games', group: 'Amusements/Games' }],
+    ['Graphics', { section: 'graphics', group: 'Applications/Multimedia' }],
+    ['AudioVideo', { section: 'sound', group: 'Applications/Multimedia' }],
+    ['Network', { section: 'net', group: 'Applications/Internet' }],
+    ['Office', { section: 'text', group: 'Applications/Productivity' }],
+    ['Science', { section: 'science', group: 'Applications/Engineering' }],
+    ['System', { section: 'admin', group: 'Applications/System' }],
+    ['Utility', { section: 'utils', group: 'Applications/System' }],
+];
+export function resolveShipSettings(input) {
+    const warnings = [];
+    const { pkg, ship, flatpak, discovered } = input;
+    // Both blocks extend AppMetadata, so `gjsify.ship` overriding
+    // `gjsify.flatpak` key-by-key is exactly the fallback ADR 0024 § 8 asks
+    // for. The non-metadata keys each block carries ride along unread.
+    const metadata = { ...flatpak, ...definedOnly(ship) };
+    const binaryName = ship.binaryName ?? deriveBinaryName(pkg.name);
+    const appId = ship.appId ?? flatpak.appId ?? reverseDnsOrThrow(pkg.name, binaryName);
+    const name = metadata.name ?? titleCase(binaryName);
+    const kind = metadata.kind ?? 'app';
+    const rawVersion = ship.version ?? pkg.version;
+    if (!rawVersion) {
+        throw new Error('gjsify ship: no version — set `version` in package.json or `gjsify.ship.version`.');
+    }
+    const normalised = normaliseVersion(rawVersion);
+    warnings.push(...normalised.warnings);
+    const license = metadata.license?.project ?? pkg.license;
+    if (!license) {
+        throw new Error('gjsify ship: no licence — set `license` in package.json (an SPDX id, e.g. "MIT") ' +
+            'or `gjsify.ship.license.project`. Both deb and rpm carry it as a required field.');
+    }
+    const maintainer = ship.maintainer ?? formatAuthor(pkg.author) ?? formatDeveloper(metadata);
+    if (!maintainer) {
+        throw new Error('gjsify ship: no maintainer — set `author` in package.json ("Name <you@example.com>"), ' +
+            '`gjsify.ship.maintainer`, or `gjsify.ship.developer`. dpkg refuses a package without one.');
+    }
+    const summary = metadata.summary ?? pkg.description ?? name;
+    const description = descriptionParagraphs(metadata.description) ?? [summary];
+    const sections = sectionsFor(metadata.categories);
+    if (kind === 'app' && discovered.iconFiles.length === 0) {
+        warnings.push(`gjsify ship: no icon found — the installed app will show a placeholder in menus and app stores. ` +
+            'Point `gjsify.ship.icon` at an SVG (or a directory of sized PNGs).');
+    }
+    const settings = {
+        projectDir: input.projectDir,
+        appId,
+        name,
+        binaryName,
+        version: normalised.version,
+        release: assertRelease(ship.release ?? '1'),
+        maintainer,
+        summary,
+        description,
+        license,
+        licenseFile: discovered.licenseFile,
+        homepage: metadata.homepageUrl ?? pkg.homepage,
+        section: ship.section ?? sections.section,
+        group: ship.group ?? sections.group,
+        kind,
+        extraDepends: { deb: ship.depends?.deb ?? [], rpm: ship.depends?.rpm ?? [] },
+        typelibPackages: ship.typelibPackages ?? {},
+        bundlePath: discovered.bundlePath,
+        bundleDir: discovered.bundleDir,
+        iconFiles: discovered.iconFiles,
+        schemaFiles: discovered.schemaFiles,
+        extraFiles: ship.extraFiles ?? {},
+        execArgs: ship.execArgs ?? [],
+        outDir: input.cli.outDir ?? ship.outDir ?? 'ship',
+        arch: input.cli.arch ?? process.arch,
+        minGjsVersion: ship.minGjsVersion ?? DEFAULT_GJS_FLOOR,
+    };
+    return { settings, metadata, warnings };
+}
+/** The bundle path a project declares, in the order the rest of the CLI reads them. */
+export function declaredBundlePath(pkg, ship) {
+    return ship.bundle ?? pkg.gjsify?.main ?? pkg.main;
+}
+/** npm package name → a package/binary name both dpkg and rpm accept. */
+export function deriveBinaryName(pkgName) {
+    if (!pkgName) {
+        throw new Error('gjsify ship: no package name — set `name` in package.json or `gjsify.ship.binaryName`.');
+    }
+    const unscoped = pkgName.includes('/') ? pkgName.split('/').pop() : pkgName;
+    const candidate = unscoped
+        .toLowerCase()
+        .replace(/[^a-z\d+.-]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    // dpkg: at least two characters, starts alphanumeric, then [a-z0-9+.-].
+    // rpm is looser, so satisfying dpkg satisfies both.
+    if (!/^[a-z\d][a-z\d+.-]+$/.test(candidate)) {
+        throw new Error(`gjsify ship: cannot derive a package name from "${pkgName}" (got "${candidate}"). ` +
+            'Set `gjsify.ship.binaryName` to something matching `[a-z0-9][a-z0-9+.-]+`.');
+    }
+    return candidate;
+}
+function reverseDnsOrThrow(pkgName, binaryName) {
+    if (pkgName && /^[A-Za-z][\w-]*(\.[A-Za-z][\w-]*){2,}$/.test(pkgName))
+        return pkgName;
+    throw new Error(`gjsify ship: no application id. Set \`gjsify.ship.appId\` (or \`gjsify.flatpak.appId\`) to a ` +
+        `reverse-DNS id such as "io.github.you.${titleCase(binaryName).replace(/\s+/g, '')}". ` +
+        'It names the desktop entry, the AppStream component and the installed icon, so it cannot be guessed.');
+}
+function definedOnly(value) {
+    return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== undefined));
+}
+function titleCase(value) {
+    return value
+        .split(/[-_.]+/)
+        .filter((part) => part.length > 0)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(' ');
+}
+function sectionsFor(categories) {
+    for (const [category, mapped] of CATEGORY_SECTIONS) {
+        if (categories?.includes(category))
+            return mapped;
+    }
+    return { section: 'misc', group: 'Applications/System' };
+}
+function formatAuthor(author) {
+    if (typeof author === 'string') {
+        // npm's shorthand is `Name <email> (url)`; the url has no place in
+        // either package format's maintainer field.
+        return author.replace(/\s*\([^)]*\)\s*$/, '').trim() || undefined;
+    }
+    if (author?.name)
+        return author.email ? `${author.name} <${author.email}>` : author.name;
+    return undefined;
+}
+function formatDeveloper(metadata) {
+    const developer = metadata.developer;
+    if (!developer?.name)
+        return undefined;
+    return developer.email ? `${developer.name} <${developer.email}>` : developer.name;
+}
+/** AppStream description (string or blocks) → plain paragraphs for deb/rpm. */
+export function descriptionParagraphs(description) {
+    if (description === undefined)
+        return undefined;
+    if (typeof description === 'string') {
+        const paragraphs = description
+            .trim()
+            .split(/\n\n+/)
+            .map((p) => p.trim().replace(/\s+/g, ' '))
+            .filter((p) => p.length > 0);
+        return paragraphs.length > 0 ? paragraphs : undefined;
+    }
+    const out = [];
+    for (const block of description) {
+        if ('p' in block) {
+            out.push(block.p.trim().replace(/\s+/g, ' '));
+        }
+        else {
+            for (const item of block.ul) {
+                out.push(`* ${(typeof item === 'string' ? item : item.item).trim().replace(/\s+/g, ' ')}`);
+            }
+        }
+    }
+    return out.length > 0 ? out : undefined;
+}
+/** `LICENSE`, `LICENSE.md`, … — the names a licence file actually has. */
+export const LICENSE_FILE_NAMES = ['LICENSE', 'LICENSE.md', 'LICENSE.txt', 'COPYING', 'COPYING.md'];
+/** The bundle's own basename, used as the launcher's exec target. */
+export function bundleEntryName(bundlePath) {
+    return basename(bundlePath);
+}

package/lib/utils/ship/stage-writer.d.ts

@@ -0,0 +1,17 @@
+import type { PayloadEntry } from './payload.js';
+import type { StagedFile } from './types.js';
+/**
+ * Materialise a planned tree under `root`, replacing whatever was there.
+ *
+ * The directory is wiped first: a stale file from a previous run is otherwise
+ * indistinguishable from a staged one, and would be packed.
+ */
+export declare function writeStage(root: string, files: readonly StagedFile[]): void;
+/**
+ * Read a staged tree back as a payload.
+ *
+ * Modes come from the PLAN, not from `stat()`: a checked-out tree can carry
+ * whatever umask the build host had, and an executable bit that survives on
+ * one machine and not another is exactly the kind of difference that ships.
+ */
+export declare function readStage(roots: readonly string[], files: readonly StagedFile[]): PayloadEntry[];

package/lib/utils/ship/stage-writer.js

@@ -0,0 +1,49 @@
+// Writing the planned payload to disk, and reading it back for the packers.
+//
+// The round trip is the point. `gjsify ship --stage` writes `stage/`; a packer
+// then reads `stage/` (plus the format's `overlay/`) rather than the planner's
+// in-memory list, so "what the user inspected" and "what got packed" cannot
+// diverge. It also makes the staged tree a legitimate deliverable on its own —
+// which is what a Flatpak module's `cp -a stage/.` will consume once Flatpak
+// moves under `ship` (ADR 0024 § 8).
+import { chmodSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join, sep } from 'node:path';
+import { listFilesRecursive } from './discover.js';
+/**
+ * Materialise a planned tree under `root`, replacing whatever was there.
+ *
+ * The directory is wiped first: a stale file from a previous run is otherwise
+ * indistinguishable from a staged one, and would be packed.
+ */
+export function writeStage(root, files) {
+    rmSync(root, { recursive: true, force: true, maxRetries: 5 });
+    mkdirSync(root, { recursive: true });
+    for (const file of files) {
+        const target = join(root, file.path.split('/').join(sep));
+        mkdirSync(dirname(target), { recursive: true });
+        const data = file.source.kind === 'text' ? new TextEncoder().encode(file.source.text) : readFileSync(file.source.path);
+        writeFileSync(target, data);
+        chmodSync(target, file.mode);
+    }
+}
+/**
+ * Read a staged tree back as a payload.
+ *
+ * Modes come from the PLAN, not from `stat()`: a checked-out tree can carry
+ * whatever umask the build host had, and an executable bit that survives on
+ * one machine and not another is exactly the kind of difference that ships.
+ */
+export function readStage(roots, files) {
+    const modes = new Map(files.map((file) => [file.path, file.mode]));
+    const byPath = new Map();
+    for (const root of roots) {
+        for (const rel of listFilesRecursive(root)) {
+            byPath.set(rel, {
+                path: rel,
+                mode: modes.get(rel) ?? 0o644,
+                data: new Uint8Array(readFileSync(join(root, rel.split('/').join(sep)))),
+            });
+        }
+    }
+    return [...byPath.values()].sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+}

package/lib/utils/ship/types.d.ts

@@ -0,0 +1,114 @@
+/** One file in the payload, addressed relative to the install prefix. */
+export interface StagedFile {
+    /** Prefix-relative path, e.g. `bin/learn6502`, `share/applications/x.desktop`. */
+    path: string;
+    /** POSIX mode bits. */
+    mode: number;
+    /** Where the bytes come from. */
+    source: {
+        kind: 'text';
+        text: string;
+    } | {
+        kind: 'file';
+        path: string;
+    };
+}
+/** A packed artifact on disk. */
+export interface ShipArtifact {
+    format: FormatId;
+    /** Absolute path to the written file. */
+    path: string;
+    /** Size in bytes. */
+    size: number;
+}
+export type FormatId = 'deb' | 'rpm';
+/**
+ * Everything that is per-FORMAT, as data.
+ *
+ * `prefix` is the one value the payload itself cannot be blind to — a launcher
+ * derives it at runtime (ADR 0024 § 3), but a D-Bus service file and an RPM's
+ * directory ownership need it spelled out.
+ */
+export interface FormatDescriptor {
+    id: FormatId;
+    /** Install prefix the format's contents hang under. */
+    prefix: string;
+    /** Where the project's licence text goes in this format's overlay. */
+    licenseDest: (binaryName: string) => string;
+    /**
+     * `debian-copyright` renders the machine-readable copyright 1.0 format
+     * Debian policy asks for; `plain` copies the licence file verbatim.
+     */
+    licenseKind: 'debian-copyright' | 'plain';
+    /**
+     * This format's spelling of the architecture.
+     *
+     * `archIndependent` is DERIVED from the payload, not configured: a
+     * `--app gjs` bundle is JavaScript and a shell launcher, so it really does
+     * install everywhere, and saying `amd64` would make apt refuse it on an
+     * arm64 machine it runs on perfectly. One `.so` in the payload flips it.
+     */
+    archName: (arch: string, archIndependent: boolean) => string;
+    /** Artifact filename, given the resolved settings and the resolved arch label. */
+    fileName: (settings: ShipSettings, archLabel: string) => string;
+}
+/** The resolved, fully defaulted configuration for one `gjsify ship` run. */
+export interface ShipSettings {
+    /** Absolute path to the project being shipped. */
+    projectDir: string;
+    /** Reverse-DNS application id — desktop entry, metainfo and icon basename. */
+    appId: string;
+    /** Human-readable display name. */
+    name: string;
+    /** Package name: the `bin/` entry, the deb `Package:`, the rpm `Name:`. */
+    binaryName: string;
+    /** Upstream version, normalised for package managers. */
+    version: string;
+    /** Package revision within one upstream version (deb revision / rpm release). */
+    release: string;
+    /** `Maintainer:` / `Packager:`, `Name <email>`. */
+    maintainer: string;
+    /** One-line summary. */
+    summary: string;
+    /** Multi-paragraph description, already split. */
+    description: string[];
+    /** SPDX identifier of the project licence. */
+    license: string;
+    /** Absolute path to the licence file, when one was found. */
+    licenseFile?: string;
+    homepage?: string;
+    /** deb `Section:`. */
+    section: string;
+    /** rpm `Group:`. */
+    group: string;
+    /** `'app'` stages a desktop entry and an icon; `'cli'` stages neither. */
+    kind: 'app' | 'cli';
+    /** Extra runtime dependencies per format, appended to the derived set. */
+    extraDepends: {
+        deb: string[];
+        rpm: string[];
+    };
+    /** Project-supplied GI-namespace → package rows, filling gaps in the built-in table. */
+    typelibPackages: Record<string, {
+        deb: string;
+        rpm: string;
+    }>;
+    /** Absolute path to the built bundle that `bin/<binaryName>` executes. */
+    bundlePath: string;
+    /** Absolute path of the directory staged wholesale into `lib/<binaryName>/`. */
+    bundleDir: string;
+    /** Absolute paths of the icon files to install, largest-first is not required. */
+    iconFiles: string[];
+    /** Absolute paths of `*.gschema.xml` files to install. */
+    schemaFiles: string[];
+    /** `<dest relative to prefix>` → absolute source path. */
+    extraFiles: Record<string, string>;
+    /** Arguments appended to the launcher's `exec` line. */
+    execArgs: string[];
+    /** Output root; `stage/`, `overlay/` and `out/` hang under it. */
+    outDir: string;
+    /** Target architecture in `process.arch` spelling. */
+    arch: string;
+    /** Minimum GJS the emitted dependency asks for. */
+    minGjsVersion: string;
+}

package/lib/utils/ship/types.js

@@ -0,0 +1,10 @@
+// The vocabulary `gjsify ship` is written in (ADR 0024).
+//
+// ONE payload, one layout per OS, one packer per format. Everything that
+// differs between a `.deb` and an `.rpm` is a {@link FormatDescriptor} field or
+// a {@link StagedFile} in that format's overlay — never a branch in the
+// staging code. The reference implementation this design is taken from
+// (`refs/gtkx`, MPL-2.0, reimplemented not copied) expresses the same
+// distinction as `if (target === 'deb')` inside its stager, and pays for it:
+// adding a fifth target there means editing six files.
+export {};

package/lib/utils/ship/version.d.ts

@@ -0,0 +1,17 @@
+export interface NormalisedVersion {
+    /** The version string to write into `Version:`. */
+    version: string;
+    /** Non-fatal transformations worth telling the user about. */
+    warnings: string[];
+}
+/**
+ * Convert an npm/semver version into one both dpkg and rpm order correctly.
+ *
+ * - a leading `v` is dropped (`v1.2.3` is a tag, not a version)
+ * - `+buildmetadata` is dropped — neither format has a place for it, and both
+ *   would sort it as part of the version
+ * - `-prerelease` becomes `~prerelease`, with inner `-` flattened to `.`
+ */
+export declare function normaliseVersion(raw: string): NormalisedVersion;
+/** Validate a Debian revision / RPM release. */
+export declare function assertRelease(release: string): string;

package/lib/utils/ship/version.js

@@ -0,0 +1,55 @@
+// npm version → package-manager version.
+//
+// The three vocabularies disagree in ways that are silent rather than loud:
+// npm's `1.2.0-rc.1` sorts BEFORE `1.2.0`, and so does Debian's and RPM's
+// `1.2.0~rc.1` — but `1.2.0-rc.1` fed to dpkg is read as upstream `1.2.0` with
+// revision `rc.1`, which sorts AFTER `1.2.0`. A prerelease that upgrades to
+// nothing is the kind of defect that only shows up once a release is out, so
+// the conversion happens here and is asserted rather than hoped for.
+// Spelled out rather than `\w`, which admits `_` — a character deb-version(7)
+// does not allow. `1.0.0_beta` would pass here and dpkg would refuse the
+// finished package at install time, one step too late to be useful.
+/** `dpkg` upstream-version grammar, minus the `-` that separates the revision. */
+const PACKAGE_VERSION = /^\d[A-Za-z0-9.+~]*$/;
+/** Debian revision / RPM release. */
+const RELEASE = /^[A-Za-z0-9][A-Za-z0-9.+~]*$/;
+/**
+ * Convert an npm/semver version into one both dpkg and rpm order correctly.
+ *
+ * - a leading `v` is dropped (`v1.2.3` is a tag, not a version)
+ * - `+buildmetadata` is dropped — neither format has a place for it, and both
+ *   would sort it as part of the version
+ * - `-prerelease` becomes `~prerelease`, with inner `-` flattened to `.`
+ */
+export function normaliseVersion(raw) {
+    const warnings = [];
+    let value = raw.trim();
+    if (value.startsWith('v'))
+        value = value.slice(1);
+    const plus = value.indexOf('+');
+    if (plus !== -1) {
+        warnings.push(`gjsify ship: dropped the build metadata "${value.slice(plus)}" from version ${raw} — ` +
+            'neither dpkg nor rpm has a field for it. Set `gjsify.ship.version` to pin an exact package version.');
+        value = value.slice(0, plus);
+    }
+    const dash = value.indexOf('-');
+    if (dash !== -1) {
+        const prerelease = value.slice(dash + 1).replace(/-/g, '.');
+        value = `${value.slice(0, dash)}~${prerelease}`;
+    }
+    if (!PACKAGE_VERSION.test(value)) {
+        throw new Error(`gjsify ship: "${raw}" is not a usable package version (normalised to "${value}"). ` +
+            'It must start with a digit and contain only letters, digits, `.`, `+` and `~`. ' +
+            'Set `gjsify.ship.version` in package.json to override it.');
+    }
+    return { version: value, warnings };
+}
+/** Validate a Debian revision / RPM release. */
+export function assertRelease(release) {
+    if (!RELEASE.test(release)) {
+        throw new Error(`gjsify ship: "${release}" is not a usable package release. ` +
+            'It must start with a letter or digit and contain only letters, digits, `.`, `+` and `~`. ' +
+            'Set `gjsify.ship.release` in package.json.');
+    }
+    return release;
+}

package/lib/utils/spawn.d.ts

@@ -32,8 +32,14 @@ export interface SpawnToCompletionOptions {
      * stderr**, for a parent whose own stdout is machine-readable: `gjsify pack
      * --json` emits JSON there, and interleaved lifecycle-script log lines make it
      * unparseable for anything piping into `JSON.parse`.
+     *
+     * `'capture'` collects both streams into {@link SpawnCompletion} and emits
+     * NEITHER, for a caller that reports the child's output only on failure. Unlike
+     * `'pipe'` it works on both paths, so it composes with `completion: 'return'` —
+     * `'pipe'` hands back a live `ChildProcess` the blocking path cannot produce,
+     * which is why that one is `'exit'`-only.
      */
-    stdio?: 'inherit' | 'pipe' | 'inherit-stderr';
+    stdio?: 'inherit' | 'pipe' | 'inherit-stderr' | 'capture';
     /**
      * Run `cmd` through the platform shell so `&&`, `|` and env-var references work.
      * `cmd` is then a whole command LINE and `args` must be empty — npm/yarn script
@@ -65,6 +71,10 @@ export interface SpawnCompletion {
     code: number | null;
     /** The terminating signal, or `null` on a normal exit. */
     signal: NodeJS.Signals | null;
+    /** The child's stdout — only under `stdio: 'capture'`, `''` when it wrote none. */
+    stdout?: string;
+    /** The child's stderr — only under `stdio: 'capture'`, `''` when it wrote none. */
+    stderr?: string;
 }
 /**
  * Run `cmd args…` to completion and resolve with its exit code and signal.

package/lib/utils/spawn.js

@@ -122,6 +122,16 @@ export function spawnToCompletion(cmd, args, opts) {
         });
         if (r.error)
             return Promise.reject(mapSpawnError(r.error, opts));
+        // `'capture'` hands both streams back instead of emitting them — this path
+        // already pipes, so it is the same read, routed to the caller.
+        if (opts.stdio === 'capture') {
+            return Promise.resolve({
+                code: r.status,
+                signal: r.signal ?? null,
+                stdout: String(r.stdout ?? ''),
+                stderr: String(r.stderr ?? ''),
+            });
+        }
         // Captured stdout goes to the parent's STDERR under `'inherit-stderr'`, the
         // destination the streaming path routes it to, so the two agree on where a
         // lifecycle script's chatter lands.
@@ -140,9 +150,11 @@ export function spawnToCompletion(cmd, args, opts) {
             // `['inherit', 2, 2]` is stdin inherited, stdout AND stderr → fd 2.
             stdio: opts.stdio === 'pipe'
                 ? ['ignore', 'pipe', 'pipe']
-                : opts.stdio === 'inherit-stderr'
-                    ? ['inherit', 2, 2]
-                    : 'inherit',
+                : opts.stdio === 'capture'
+                    ? ['inherit', 'pipe', 'pipe']
+                    : opts.stdio === 'inherit-stderr'
+                        ? ['inherit', 2, 2]
+                        : 'inherit',
         };
         if (opts.shell)
             spawnOpts.shell = true;
@@ -152,10 +164,22 @@ export function spawnToCompletion(cmd, args, opts) {
             spawnOpts.windowsVerbatimArguments = true;
         const child = spawn(win.cmd, win.args, spawnOpts);
         opts.onSpawn?.(child);
+        // Collected only under `'capture'`; the other modes never attach a reader,
+        // so an inherited stream is untouched.
+        let captured;
+        if (opts.stdio === 'capture') {
+            // Bound to a const the listeners close over: narrowing `captured` does
+            // not survive into a callback, and `captured!` would be a lie the day
+            // someone reorders these lines.
+            const buf = { stdout: '', stderr: '' };
+            captured = buf;
+            child.stdout?.on('data', (d) => (buf.stdout += String(d)));
+            child.stderr?.on('data', (d) => (buf.stderr += String(d)));
+        }
         // `close` (not `exit`) so piped stdio is fully drained before the caller's
         // flushers run; with `stdio: 'inherit'` the two are emitted back to back.
         child.on('close', (code, signal) => {
-            resolvePromise({ code, signal });
+            resolvePromise(captured ? { code, signal, ...captured } : { code, signal });
         });
         child.on('error', (err) => {
             reject(mapSpawnError(err, opts));

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gjsify/cli",
-    "version": "0.38.1",
+    "version": "0.40.0",
     "description": "CLI for Gjsify",
     "type": "module",
     "main": "lib/index.js",
@@ -134,20 +134,21 @@
         "cli"
     ],
     "dependencies": {
-        "@gjsify/buffer": "^0.38.1",
-        "@gjsify/create-app": "^0.38.1",
-        "@gjsify/node-globals": "^0.38.1",
-        "@gjsify/node-polyfills": "^0.38.1",
-        "@gjsify/npm-registry": "^0.38.1",
-        "@gjsify/resolve-npm": "^0.38.1",
-        "@gjsify/rolldown-plugin-gjsify": "^0.38.1",
-        "@gjsify/vite-plugin-blueprint": "^0.38.1",
-        "@gjsify/rolldown-plugin-pnp": "^0.38.1",
-        "@gjsify/semver": "^0.38.1",
-        "@gjsify/tar": "^0.38.1",
-        "@gjsify/tsc": "^0.38.1",
-        "@gjsify/web-polyfills": "^0.38.1",
-        "@gjsify/workspace": "^0.38.1",
+        "@gjsify/buffer": "^0.40.0",
+        "@gjsify/create-app": "^0.40.0",
+        "@gjsify/node-globals": "^0.40.0",
+        "@gjsify/node-polyfills": "^0.40.0",
+        "@gjsify/npm-registry": "^0.40.0",
+        "@gjsify/resolve-npm": "^0.40.0",
+        "@gjsify/rolldown-plugin-gjsify": "^0.40.0",
+        "@gjsify/vite-plugin-blueprint": "^0.40.0",
+        "@gjsify/rolldown-plugin-pnp": "^0.40.0",
+        "@gjsify/semver": "^0.40.0",
+        "@gjsify/tar": "^0.40.0",
+        "@gjsify/tsc": "^0.40.0",
+        "@gjsify/web-polyfills": "^0.40.0",
+        "@gjsify/workspace": "^0.40.0",
+        "acorn": "^8.17.0",
         "cosmiconfig": "^9.0.2",
         "get-tsconfig": "^4.14.0",
         "pkg-types": "^2.3.1",
@@ -155,13 +156,13 @@
         "yargs": "^18.0.0"
     },
     "devDependencies": {
-        "@gjsify/unit": "^0.38.1",
+        "@gjsify/unit": "^0.40.0",
         "@types/yargs": "^17.0.35",
         "typescript": "^6.0.3"
     },
     "peerDependencies": {
-        "@gjsify/oxfmt-native": "^0.38.1",
-        "@gjsify/rolldown-native": "^0.38.1"
+        "@gjsify/oxfmt-native": "^0.40.0",
+        "@gjsify/rolldown-native": "^0.40.0"
     },
     "peerDependenciesMeta": {
         "@gjsify/oxfmt-native": {