@gjsify/cli 0.3.13 → 0.3.15

package/lib/actions/build.d.ts

@@ -1,12 +1,11 @@
 import type { ConfigData } from "../types/index.js";
-import type { App } from "@gjsify/esbuild-plugin-gjsify";
-import { BuildOptions, BuildResult, Plugin } from "esbuild";
+import type { App } from "@gjsify/rolldown-plugin-gjsify";
+import type { RolldownOutput } from "rolldown";
 export declare class BuildAction {
     readonly configData: ConfigData;
     constructor(configData?: ConfigData);
-    getEsBuildDefaults(): BuildOptions;
     /** Library mode */
-    buildLibrary(): Promise<BuildResult<BuildOptions>[]>;
+    buildLibrary(): Promise<RolldownOutput[]>;
     /**
      * Parse the `--globals` value into { autoMode, extras }.
      * - `auto`             → { autoMode: true, extras: '' }
@@ -19,104 +18,26 @@ export declare class BuildAction {
     private parseGlobalsValue;
     /**
      * Resolve the `--globals` CLI list into a pre-computed inject stub path
-     * that the esbuild plugin will append to its `inject` list. Only runs
-     * for `--app gjs` — Node and browser builds rely on native globals.
+     * that the orchestrator appends to its input list. Only runs for
+     * `--app gjs` — Node and browser builds rely on native globals.
      *
      * Used only for the explicit-only path (no `auto` token in the value).
-     * The auto path is handled in `buildApp` via the two-pass build.
+     * The auto path is handled in `buildApp` via the iterative multi-pass build.
      */
     private resolveGlobalsInject;
     /**
-     * Post-processing: prepend GJS shebang and mark the output file executable.
-     * Only runs for GJS app builds with a resolvable single outfile.
+     * Post-processing: prepend the resolved shebang line and mark the
+     * output executable. Only runs for GJS app builds with a single outfile.
+     * The shebang plugin in `@gjsify/rolldown-plugin-gjsify` already injects
+     * during bundling — this hook is the safety net for anything that
+     * bypassed the plugin (e.g. user-supplied banners that out-ordered it),
+     * plus the chmod.
      */
     private applyShebang;
     /** Application mode */
-    buildApp(app?: App): Promise<BuildResult<{
-        format: "esm" | "cjs";
-        plugins: Plugin[];
-        bundle?: boolean;
-        splitting?: boolean;
-        preserveSymlinks?: boolean;
-        outfile?: string;
-        metafile?: boolean;
-        outdir?: string;
-        outbase?: string;
-        external?: string[];
-        packages?: "bundle" | "external";
-        alias?: Record<string, string>;
-        loader?: {
-            [ext: string]: import("esbuild").Loader;
-        };
-        resolveExtensions?: string[];
-        mainFields?: string[];
-        conditions?: string[];
-        write?: boolean;
-        allowOverwrite?: boolean;
-        tsconfig?: string;
-        outExtension?: {
-            [ext: string]: string;
-        };
-        publicPath?: string;
-        entryNames?: string;
-        chunkNames?: string;
-        assetNames?: string;
-        inject?: string[];
-        banner?: {
-            [type: string]: string;
-        };
-        footer?: {
-            [type: string]: string;
-        };
-        entryPoints?: (string | {
-            in: string;
-            out: string;
-        })[] | Record<string, string>;
-        stdin?: import("esbuild").StdinOptions;
-        absWorkingDir?: string;
-        nodePaths?: string[];
-        sourcemap?: boolean | "linked" | "inline" | "external" | "both";
-        legalComments?: "none" | "inline" | "eof" | "linked" | "external";
-        sourceRoot?: string;
-        sourcesContent?: boolean;
-        globalName?: string;
-        target?: string | string[];
-        supported?: Record<string, boolean>;
-        platform?: import("esbuild").Platform;
-        mangleProps?: RegExp;
-        reserveProps?: RegExp;
-        mangleQuoted?: boolean;
-        mangleCache?: Record<string, string | false>;
-        drop?: import("esbuild").Drop[];
-        dropLabels?: string[];
-        minify?: boolean;
-        minifyWhitespace?: boolean;
-        minifyIdentifiers?: boolean;
-        minifySyntax?: boolean;
-        lineLimit?: number;
-        charset?: import("esbuild").Charset;
-        treeShaking?: boolean;
-        ignoreAnnotations?: boolean;
-        jsx?: "transform" | "preserve" | "automatic";
-        jsxFactory?: string;
-        jsxFragment?: string;
-        jsxImportSource?: string;
-        jsxDev?: boolean;
-        jsxSideEffects?: boolean;
-        define?: {
-            [key: string]: string;
-        };
-        pure?: string[];
-        keepNames?: boolean;
-        absPaths?: import("esbuild").AbsPaths[];
-        color?: boolean;
-        logLevel?: import("esbuild").LogLevel;
-        logLimit?: number;
-        logOverride?: Record<string, import("esbuild").LogLevel>;
-        tsconfigRaw?: string | import("esbuild").TsconfigRaw;
-    }>[]>;
+    buildApp(app?: App): Promise<RolldownOutput[]>;
     start(buildType?: {
         library?: boolean;
         app?: App;
-    }): Promise<BuildResult<BuildOptions>[]>;
+    }): Promise<RolldownOutput[]>;
 }

package/lib/actions/build.js

@@ -1,11 +1,12 @@
-import { build } from "esbuild";
-import { gjsifyPlugin } from "@gjsify/esbuild-plugin-gjsify";
-import { resolveGlobalsList, writeRegisterInjectFile, detectAutoGlobals, } from "@gjsify/esbuild-plugin-gjsify/globals";
-import { getBundleDir, rewriteContents } from "@gjsify/esbuild-plugin-gjsify";
-import { getPnpPlugin } from "@gjsify/resolve-npm/pnp-relay";
+import { rolldown } from "rolldown";
+import { gjsifyPlugin, textLoaderPlugin, resolveShebangLine } from "@gjsify/rolldown-plugin-gjsify";
+import { resolveUserPlugins } from "../utils/resolve-plugin-by-name.js";
+import { resolveGlobalsList, writeRegisterInjectFile, detectAutoGlobals, } from "@gjsify/rolldown-plugin-gjsify/globals";
+import { pnpPlugin } from "@gjsify/rolldown-plugin-pnp";
 import { dirname, extname } from "node:path";
 import { chmod, readFile, writeFile } from "node:fs/promises";
-const GJS_SHEBANG = "#!/usr/bin/env -S gjs -m\n";
+import { normalizeBundlerOptions, mergeBundlerOptions } from "../utils/normalize-bundler-options.js";
+const DEFAULT_GJS_SHEBANG = "#!/usr/bin/env -S gjs -m";
 /**
  * `true` when `path` points at a location that's unsafe to use as a build
  * outfile (would overwrite source). Currently catches:
@@ -26,104 +27,81 @@ function isUnsafeDefaultOutput(path) {
  * @gjsify/{node,web}-polyfills) are resolvable for external consumers without
  * each one having to be a direct devDep.
  *
- * Wires the @gjsify/esbuild-plugin-gjsify rewriter (`__filename`/`__dirname`
- * injection for CJS code in node_modules) into the pnp plugin's onLoad —
- * esbuild stops at the first matching onLoad, so the rewriter MUST run from
- * inside the pnp plugin's onLoad rather than as a separate registration.
+ * The path rewriter (`__filename`/`__dirname` + `import.meta.url` injection
+ * for node_modules code) is registered separately by the orchestrator —
+ * Rolldown's transform hooks all run sequentially, no shared `onLoad` race.
  */
 async function buildPnpPlugin() {
-    return getPnpPlugin({
-        issuerUrl: import.meta.url,
-        transformContentsFactory: (build) => {
-            const bundleDir = getBundleDir(build);
-            return (args, contents) => rewriteContents(args, contents, bundleDir);
-        },
-    });
+    return pnpPlugin({ issuerUrl: import.meta.url });
 }
 export class BuildAction {
     configData;
     constructor(configData = {}) {
         this.configData = configData;
     }
-    getEsBuildDefaults() {
-        const defaults = {
-            allowOverwrite: true,
-        };
-        return defaults;
-    }
     /** Library mode */
     async buildLibrary() {
-        let { verbose, library, esbuild, typescript, exclude } = this.configData;
-        library ||= {};
-        esbuild ||= {};
-        typescript ||= {};
-        const moduleOutdir = library?.module ? dirname(library.module) : undefined;
-        const mainOutdir = library?.main ? dirname(library.main) : undefined;
-        const moduleOutExt = library.module ? extname(library.module) : ".js";
-        const mainOutExt = library.main ? extname(library.main) : ".js";
+        const { verbose, library, typescript, exclude, aliases } = this.configData;
+        const lib = library ?? {};
+        const userBundler = normalizeBundlerOptions(this.configData);
+        const moduleOutdir = lib.module ? dirname(lib.module) : undefined;
+        const mainOutdir = lib.main ? dirname(lib.main) : undefined;
+        const moduleOutExt = lib.module ? extname(lib.module) : ".js";
+        const mainOutExt = lib.main ? extname(lib.main) : ".js";
         const multipleBuilds = moduleOutdir && mainOutdir && moduleOutdir !== mainOutdir;
-        const pnpPlugin = await buildPnpPlugin();
-        const pnpPlugins = pnpPlugin ? [pnpPlugin] : [];
+        const pnp = await buildPnpPlugin();
+        const pnpPlugins = pnp ? [pnp] : [];
         const results = [];
         if (multipleBuilds) {
             const moduleFormat = moduleOutdir.includes("/cjs") || moduleOutExt === ".cjs"
                 ? "cjs"
                 : "esm";
-            results.push(await build({
-                ...this.getEsBuildDefaults(),
-                ...esbuild,
-                format: moduleFormat,
-                outdir: moduleOutdir,
-                plugins: [
-                    ...pnpPlugins,
-                    gjsifyPlugin({
-                        debug: verbose,
-                        library: moduleFormat,
-                        exclude,
-                        reflection: typescript?.reflection,
-                        jsExtension: moduleOutExt,
-                    }),
-                ],
+            results.push(await runOneLibraryBuild({
+                pluginOpts: {
+                    debug: verbose,
+                    library: moduleFormat,
+                    exclude,
+                    reflection: typescript?.reflection,
+                    jsExtension: moduleOutExt,
+                },
+                userBundler,
+                output: { dir: moduleOutdir },
+                userAliases: aliases,
+                pnpPlugins,
             }));
             const mainFormat = mainOutdir.includes("/cjs") || mainOutExt === ".cjs" ? "cjs" : "esm";
-            results.push(await build({
-                ...this.getEsBuildDefaults(),
-                ...esbuild,
-                format: mainFormat,
-                outdir: mainOutdir,
-                plugins: [
-                    ...pnpPlugins,
-                    gjsifyPlugin({
-                        debug: verbose,
-                        library: mainFormat,
-                        exclude,
-                        reflection: typescript?.reflection,
-                        jsExtension: mainOutExt,
-                    }),
-                ],
+            results.push(await runOneLibraryBuild({
+                pluginOpts: {
+                    debug: verbose,
+                    library: mainFormat,
+                    exclude,
+                    reflection: typescript?.reflection,
+                    jsExtension: mainOutExt,
+                },
+                userBundler,
+                output: { dir: mainOutdir },
+                userAliases: aliases,
+                pnpPlugins,
             }));
         }
         else {
-            const outfilePath = esbuild?.outfile || library?.module || library?.main;
+            const outfilePath = userBundler.output?.file ?? lib.module ?? lib.main;
             const outExt = outfilePath ? extname(outfilePath) : ".js";
-            const outdir = esbuild?.outdir || (outfilePath ? dirname(outfilePath) : undefined);
-            const format = esbuild?.format ??
+            const outdir = userBundler.output?.dir ?? (outfilePath ? dirname(outfilePath) : undefined);
+            const format = userBundler.output?.format ??
                 (outdir?.includes("/cjs") || outExt === ".cjs" ? "cjs" : "esm");
-            results.push(await build({
-                ...this.getEsBuildDefaults(),
-                ...esbuild,
-                format,
-                outdir,
-                plugins: [
-                    ...pnpPlugins,
-                    gjsifyPlugin({
-                        debug: verbose,
-                        library: format,
-                        exclude,
-                        reflection: typescript?.reflection,
-                        jsExtension: outExt,
-                    }),
-                ],
+            results.push(await runOneLibraryBuild({
+                pluginOpts: {
+                    debug: verbose,
+                    library: format,
+                    exclude,
+                    reflection: typescript?.reflection,
+                    jsExtension: outExt,
+                },
+                userBundler,
+                output: { dir: outdir },
+                userAliases: aliases,
+                pnpPlugins,
             }));
         }
         return results;
@@ -152,11 +130,11 @@ export class BuildAction {
     }
     /**
      * Resolve the `--globals` CLI list into a pre-computed inject stub path
-     * that the esbuild plugin will append to its `inject` list. Only runs
-     * for `--app gjs` — Node and browser builds rely on native globals.
+     * that the orchestrator appends to its input list. Only runs for
+     * `--app gjs` — Node and browser builds rely on native globals.
      *
      * Used only for the explicit-only path (no `auto` token in the value).
-     * The auto path is handled in `buildApp` via the two-pass build.
+     * The auto path is handled in `buildApp` via the iterative multi-pass build.
      */
     async resolveGlobalsInject(app, globals, verbose) {
         if (app !== "gjs")
@@ -173,8 +151,12 @@ export class BuildAction {
         return injectPath ?? undefined;
     }
     /**
-     * Post-processing: prepend GJS shebang and mark the output file executable.
-     * Only runs for GJS app builds with a resolvable single outfile.
+     * Post-processing: prepend the resolved shebang line and mark the
+     * output executable. Only runs for GJS app builds with a single outfile.
+     * The shebang plugin in `@gjsify/rolldown-plugin-gjsify` already injects
+     * during bundling — this hook is the safety net for anything that
+     * bypassed the plugin (e.g. user-supplied banners that out-ordered it),
+     * plus the chmod.
      */
     async applyShebang(outfile, verbose) {
         if (!outfile) {
@@ -182,44 +164,49 @@ export class BuildAction {
                 console.warn("[gjsify] --shebang skipped: no single outfile (use --outfile for GJS executables)");
             return;
         }
+        const line = resolveShebangLine(this.configData.shebang) ?? DEFAULT_GJS_SHEBANG;
         const content = await readFile(outfile, "utf-8");
         if (content.startsWith("#!")) {
             if (verbose)
                 console.debug(`[gjsify] --shebang skipped: ${outfile} already starts with a shebang`);
         }
         else {
-            await writeFile(outfile, GJS_SHEBANG + content);
+            await writeFile(outfile, line + "\n" + content);
         }
         await chmod(outfile, 0o755);
         if (verbose)
-            console.debug(`[gjsify] --shebang: wrote shebang + chmod 0o755 to ${outfile}`);
+            console.debug(`[gjsify] --shebang: wrote ${line} + chmod 0o755 to ${outfile}`);
     }
     /** Application mode */
     async buildApp(app = "gjs") {
-        const { verbose, esbuild, typescript, exclude, library: pgk, aliases, excludeGlobals, } = this.configData;
-        const format = esbuild?.format ??
-            (esbuild?.outfile?.endsWith(".cjs") ? "cjs" : "esm");
+        const { verbose, typescript, exclude, library: pkg, aliases, excludeGlobals, } = this.configData;
+        const userBundler = normalizeBundlerOptions(this.configData);
+        const formatRaw = userBundler.output?.format ??
+            (userBundler.output?.file?.endsWith(".cjs") ? "cjs" : "esm");
+        // The orchestrator only handles esm/cjs (iife is not a GJS / Node /
+        // browser-bundle target we support). Coerce.
+        const format = formatRaw === "iife" ? "esm" : formatRaw;
         // Set default outfile if no outdir is set
-        if (esbuild &&
-            !esbuild?.outfile &&
-            !esbuild?.outdir &&
-            (pgk?.main || pgk?.module)) {
-            const candidate = esbuild?.format === "cjs"
-                ? pgk.main || pgk.module
-                : pgk.module || pgk.main;
+        let outfile = userBundler.output?.file;
+        let outdir = userBundler.output?.dir;
+        if (!outfile && !outdir && (pkg?.main || pkg?.module)) {
+            const candidate = format === "cjs"
+                ? pkg.main ?? pkg.module
+                : pkg.module ?? pkg.main;
             if (candidate && isUnsafeDefaultOutput(candidate)) {
-                // `package.json#main`/`module` commonly points at a TypeScript
-                // source (e.g. `src/index.ts` for TS-direct workflows). Falling
-                // back to that value would have esbuild OVERWRITE the source.
-                // Surface a clear error and require an explicit outfile/outdir
-                // instead of silently destroying the user's code.
                 throw new Error(`gjsify build: refusing to default --outfile to ${candidate} ` +
                     `(would overwrite a TypeScript source file). Pass --outfile/--outdir ` +
-                    `explicitly, or set "gjsify.esbuild.outfile" in package.json.`);
+                    `explicitly, or set "gjsify.bundler.output.file" in package.json.`);
             }
-            esbuild.outfile = candidate;
+            outfile = candidate;
         }
         const { consoleShim, globals } = this.configData;
+        const userExternal = Array.isArray(userBundler.external)
+            ? userBundler.external
+            : undefined;
+        const userBanner = typeof userBundler.output?.banner === "string"
+            ? userBundler.output.banner
+            : undefined;
         const pluginOpts = {
             debug: verbose,
             app,
@@ -230,65 +217,106 @@ export class BuildAction {
             ...(aliases ? { aliases } : {}),
         };
         const { autoMode, extras } = this.parseGlobalsValue(globals);
-        const pnpPlugin = await buildPnpPlugin();
-        const pnpPlugins = pnpPlugin ? [pnpPlugin] : [];
+        const pnp = await buildPnpPlugin();
+        const pnpPlugins = pnp ? [pnp] : [];
+        // User-supplied text loaders need to be available during BOTH the
+        // auto-globals pre-build (`detectAutoGlobals`) and the final build —
+        // otherwise Rolldown's parser hits unknown extensions like `.ui` /
+        // `.asm` during the pre-build, fails to parse them as JS/JSX, and
+        // the auto-globals iteration aborts before the final plugin chain is
+        // ever assembled. Build the user-plugin chain once, up front, and
+        // pass it into both passes.
+        const userTextLoader = textLoaderPlugin({ loaders: this.configData.loaders });
+        const userPlugins = userTextLoader ? [userTextLoader] : [];
+        // User-supplied bundler.plugins (mix of plugin objects + by-name
+        // entries) — resolved from the project's node_modules. Same
+        // ordering rationale as the text loader: must be present during
+        // auto-globals pre-build to avoid claiming the same files via
+        // Rolldown's default classifier.
+        if (userBundler.plugins?.length) {
+            const resolved = await resolveUserPlugins(userBundler.plugins, process.cwd());
+            userPlugins.push(...resolved);
+        }
         // --- Auto mode (with optional extras): iterative multi-pass build ---
-        // The extras token is used for cases where the detector cannot
-        // statically see a global (e.g. Excalibur indirects globalThis via
-        // BrowserComponent.nativeComponent). Common pattern: --globals auto,dom
         if (app === "gjs" && autoMode) {
+            const gjsifyPluginFactory = async (opts) => {
+                const cfg = await gjsifyPlugin({
+                    input: userBundler.input,
+                    output: { file: outfile, dir: outdir },
+                    userExternal,
+                    userBanner,
+                    userAliases: aliases,
+                    shebang: this.configData.shebang,
+                }, opts);
+                return cfg.plugins;
+            };
             const { injectPath } = await detectAutoGlobals({
-                ...this.getEsBuildDefaults(),
-                ...esbuild,
+                input: userBundler.input,
+                plugins: [...pnpPlugins, ...userPlugins],
+                external: userBundler.external,
+                transform: userBundler.transform,
                 format,
-                plugins: pnpPlugins,
-            }, pluginOpts, verbose, { extraGlobalsList: extras, excludeGlobals });
-            const result = await build({
-                ...this.getEsBuildDefaults(),
-                ...esbuild,
-                format,
-                plugins: [
-                    ...pnpPlugins,
-                    gjsifyPlugin({
-                        ...pluginOpts,
-                        autoGlobalsInject: injectPath,
-                    }),
-                ],
-            });
-            if (app === "gjs" && this.configData.shebang) {
-                await this.applyShebang(esbuild?.outfile, verbose);
-            }
-            return [result];
+            }, pluginOpts, gjsifyPluginFactory, verbose, { extraGlobalsList: extras, excludeGlobals });
+            pluginOpts.autoGlobalsInject = injectPath;
+        }
+        else if (extras) {
+            pluginOpts.autoGlobalsInject = await this.resolveGlobalsInject(app, extras, verbose);
+        }
+        // Final build: orchestrator → rolldown → write
+        const cfg = await gjsifyPlugin({
+            input: userBundler.input,
+            output: { file: outfile, dir: outdir },
+            userExternal,
+            userBanner,
+            userAliases: aliases,
+            shebang: this.configData.shebang,
+        }, pluginOpts);
+        const merged = mergeBundlerOptions(cfg.options, userBundler);
+        const finalOpts = {
+            ...merged,
+            // Drop user-config plugins from `merged` — they survived
+            // mergeBundlerOptions via spread but have already been resolved
+            // and appended into `userPlugins` above. Re-emitting the raw
+            // entries (which may include `BundlerPluginByName` shapes
+            // Rolldown doesn't understand) would crash the build.
+            plugins: [...pnpPlugins, ...userPlugins, ...cfg.plugins],
+        };
+        const build = await rolldown(finalOpts);
+        let writeResult;
+        try {
+            writeResult = await build.write(finalOpts.output ?? {});
+        }
+        finally {
+            await build.close();
         }
-        // --- Explicit list (no `auto` token) or none mode ---
-        const autoGlobalsInject = extras
-            ? await this.resolveGlobalsInject(app, extras, verbose)
-            : undefined;
-        const result = await build({
-            ...this.getEsBuildDefaults(),
-            ...esbuild,
-            format,
-            plugins: [
-                ...pnpPlugins,
-                gjsifyPlugin({
-                    ...pluginOpts,
-                    autoGlobalsInject,
-                }),
-            ],
-        });
         if (app === "gjs" && this.configData.shebang) {
-            await this.applyShebang(esbuild?.outfile, verbose);
+            await this.applyShebang(outfile, verbose);
         }
-        return [result];
+        return [writeResult];
     }
     async start(buildType = { app: "gjs" }) {
-        const results = [];
         if (buildType.library) {
-            results.push(...(await this.buildLibrary()));
-        }
-        else {
-            results.push(...(await this.buildApp(buildType.app)));
+            return await this.buildLibrary();
         }
-        return results;
+        return await this.buildApp(buildType.app);
+    }
+}
+async function runOneLibraryBuild(args) {
+    const cfg = await gjsifyPlugin({
+        input: args.userBundler.input,
+        output: args.output,
+        userAliases: args.userAliases,
+    }, args.pluginOpts);
+    const merged = mergeBundlerOptions(cfg.options, args.userBundler);
+    const finalOpts = {
+        ...merged,
+        plugins: [...args.pnpPlugins, ...cfg.plugins],
+    };
+    const build = await rolldown(finalOpts);
+    try {
+        return await build.write(finalOpts.output ?? {});
+    }
+    finally {
+        await build.close();
     }
 }

package/lib/commands/flatpak/build.d.ts

@@ -0,0 +1,16 @@
+import type { Command } from '../../types/index.js';
+interface FlatpakBuildOptions {
+    manifest?: string;
+    buildDir?: string;
+    install?: boolean;
+    repo?: string;
+    bundle?: string;
+    tarball?: string;
+    forceClean?: boolean;
+    sandbox?: boolean;
+    deleteBuildDirs?: boolean;
+    installDepsFrom?: string;
+    verbose?: boolean;
+}
+export declare const flatpakBuildCommand: Command<unknown, FlatpakBuildOptions>;
+export {};