@gjsify/cli 0.3.21 → 0.4.3

package/lib/actions/build.js

@@ -1,4 +1,4 @@
-import { rolldown } from "rolldown";
+import { runBundle, bundleToChunks } from "../bundler-pick.js";
 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";
@@ -256,7 +256,7 @@ export class BuildAction {
                 external: userBundler.external,
                 transform: userBundler.transform,
                 format,
-            }, pluginOpts, gjsifyPluginFactory, verbose, { extraGlobalsList: extras, excludeGlobals });
+            }, pluginOpts, gjsifyPluginFactory, verbose, { extraGlobalsList: extras, excludeGlobals }, bundleToChunks);
             pluginOpts.autoGlobalsInject = injectPath;
         }
         else if (extras) {
@@ -281,14 +281,7 @@ export class BuildAction {
             // 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();
-        }
+        const writeResult = await runBundle(finalOpts);
         if (app === "gjs" && this.configData.shebang) {
             await this.applyShebang(outfile, verbose);
         }
@@ -312,11 +305,5 @@ async function runOneLibraryBuild(args) {
         ...merged,
         plugins: [...args.pnpPlugins, ...cfg.plugins],
     };
-    const build = await rolldown(finalOpts);
-    try {
-        return await build.write(finalOpts.output ?? {});
-    }
-    finally {
-        await build.close();
-    }
+    return await runBundle(finalOpts);
 }

package/lib/bundler-pick.d.ts

@@ -0,0 +1,79 @@
+import type { RolldownOutput } from 'rolldown';
+import type { BundlerOptions } from './types/index.js';
+export interface NativePluginContext {
+    resolve(specifier: string, importer?: string, opts?: {
+        skipSelf?: boolean;
+        isEntry?: boolean;
+    }): Promise<{
+        id: string;
+        external: boolean;
+    } | null>;
+    warn(message: string): void;
+    error(message: string): never;
+}
+export interface NativePlugin {
+    name: string;
+    idFilter?: {
+        load?: string;
+        transform?: string;
+        resolveId?: string;
+    };
+    load?: (this: NativePluginContext, id: string) => unknown;
+    transform?: (this: NativePluginContext, code: string, id: string, moduleType: string) => unknown;
+    resolveId?: (this: NativePluginContext, specifier: string, importer: string | undefined, opts: {
+        isEntry: boolean;
+    }) => unknown;
+    renderChunk?: (this: NativePluginContext, code: string, chunk: {
+        fileName: string;
+        name: string;
+        isEntry: boolean;
+    }) => unknown;
+    banner?: (this: NativePluginContext, chunk: {
+        fileName: string;
+        name: string;
+        isEntry: boolean;
+    }) => unknown;
+    footer?: (this: NativePluginContext, chunk: {
+        fileName: string;
+        name: string;
+        isEntry: boolean;
+    }) => unknown;
+    intro?: (this: NativePluginContext, chunk: {
+        fileName: string;
+        name: string;
+        isEntry: boolean;
+    }) => unknown;
+    outro?: (this: NativePluginContext, chunk: {
+        fileName: string;
+        name: string;
+        isEntry: boolean;
+    }) => unknown;
+    buildStart?: (this: NativePluginContext) => unknown;
+    buildEnd?: (this: NativePluginContext) => unknown;
+    generateBundle?: (this: NativePluginContext) => unknown;
+    writeBundle?: (this: NativePluginContext) => unknown;
+    closeBundle?: (this: NativePluginContext) => unknown;
+}
+/**
+ * In-memory bundle used by `--globals auto` for AST-driven detection.
+ * Mirrors the shape of `AnalysisBundler` in
+ * `@gjsify/rolldown-plugin-gjsify/utils/auto-globals`. Routes through the
+ * same engine as the final build (npm rolldown on Node, native on GJS) so
+ * the GJS-bundled CLI doesn't try to load the unloadable npm crate.
+ */
+export declare function bundleToChunks(input: {
+    rolldownInput: import('rolldown').InputOptions;
+    format: 'esm' | 'cjs' | 'iife';
+}): Promise<string[]>;
+/**
+ * Run a bundle with the picked engine. Drop-in replacement for the
+ * `rolldown(opts).write(opts.output)` flow used directly in build.ts.
+ */
+export declare function runBundle(finalOpts: BundlerOptions): Promise<RolldownOutput>;
+export declare function shouldUseNative(): Promise<boolean>;
+export type PluginRecord = {
+    name?: string;
+    [k: string]: unknown;
+};
+export declare function isPluginObject(p: unknown): p is PluginRecord;
+export declare function toNativePlugin(p: PluginRecord): NativePlugin;

package/lib/bundler-pick.js

@@ -0,0 +1,436 @@
+// Phase D-2.B.5b — runtime bundler pick.
+//
+// Default behavior: call npm `rolldown(opts).write(opts.output)` exactly
+// as before. Setting `GJSIFY_BUNDLER=native` opts into the
+// `@gjsify/rolldown-native` Vala/Rust prebuild via `bundleWithPlugins()`.
+//
+// The native path is only attempted under GJS — under Node it falls
+// back to npm rolldown silently. Under GJS, if the prebuild isn't
+// loadable for the running architecture, we throw so the caller
+// notices the configuration mismatch instead of silently using a
+// different code path.
+//
+// Plugin shape conversion: rolldown plugins may declare hooks either
+// as bare functions (`load(id)`) or as `{filter, handler}` objects.
+// Both shapes are translated to `NativePlugin` form. `filter.id`
+// regex/string sources become `idFilter.<hook>` regex strings on the
+// Rust side. `this.resolve()` / `this.warn()` / `this.error()` calls
+// inside hook handlers route through the B.3 nested protocol.
+//
+// Plugins that depend on rolldown context methods we don't implement
+// (`this.parse`, `this.emitFile`, `this.getModuleInfo`, …) will fail
+// at hook-call time. The current gjsify plugin set doesn't use any
+// of those, so we don't gate on it; future incompatibilities surface
+// as build errors rather than silent wrong behavior.
+import { promises as fs } from 'node:fs';
+import * as path from 'node:path';
+import { createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+// npm `rolldown` is a Rust crate with platform-specific prebuilds; loading
+// it eagerly at module init pulls musl-detection code that does
+// `require('node:fs')` synchronously — fine on Node, but fatal under GJS
+// where the createRequire polyfill rejects synchronous builtin loads.
+// Dynamic import keeps it off the GJS code path entirely; the native
+// branch (`@gjsify/rolldown-native`) handles bundling there.
+async function loadNpmRolldown() {
+    // Indirect specifier so Rolldown's static-analysis doesn't try to
+    // bundle the npm crate into a GJS target build.
+    const specifier = 'rolldown';
+    const mod = (await import(/* @vite-ignore */ specifier));
+    return mod.rolldown;
+}
+/**
+ * In-memory bundle used by `--globals auto` for AST-driven detection.
+ * Mirrors the shape of `AnalysisBundler` in
+ * `@gjsify/rolldown-plugin-gjsify/utils/auto-globals`. Routes through the
+ * same engine as the final build (npm rolldown on Node, native on GJS) so
+ * the GJS-bundled CLI doesn't try to load the unloadable npm crate.
+ */
+export async function bundleToChunks(input) {
+    if (await shouldUseNative()) {
+        const native = await tryLoadNative();
+        if (!native)
+            throw new Error('@gjsify/rolldown-native not loadable');
+        const rawPlugins = (input.rolldownInput.plugins ?? []);
+        const nativePlugins = [];
+        for (const p of rawPlugins) {
+            if (isPluginObject(p))
+                nativePlugins.push(toNativePlugin(p));
+        }
+        const opts = liftTransformExtras(stripUnserializable({
+            ...input.rolldownInput,
+            input: normalizeInputForNative(input.rolldownInput.input),
+            format: input.format,
+        }));
+        delete opts.plugins;
+        const result = await native.bundleWithPlugins(opts, nativePlugins);
+        const codes = [];
+        for (const item of result.output) {
+            if (item.type === 'chunk')
+                codes.push(item.code);
+        }
+        return codes;
+    }
+    const rolldown = await loadNpmRolldown();
+    const build = await rolldown(input.rolldownInput);
+    try {
+        const result = await build.generate({ format: input.format, minify: false, sourcemap: false });
+        const codes = [];
+        for (const entry of result.output) {
+            if (entry.type === 'chunk')
+                codes.push(entry.code);
+        }
+        return codes;
+    }
+    finally {
+        await build.close();
+    }
+}
+/**
+ * Run a bundle with the picked engine. Drop-in replacement for the
+ * `rolldown(opts).write(opts.output)` flow used directly in build.ts.
+ */
+export async function runBundle(finalOpts) {
+    if (await shouldUseNative()) {
+        return await runNativeBundle(finalOpts);
+    }
+    const rolldown = await loadNpmRolldown();
+    const build = await rolldown(finalOpts);
+    try {
+        return await build.write(finalOpts.output ?? {});
+    }
+    finally {
+        await build.close();
+    }
+}
+let _nativeProbe = null;
+export async function shouldUseNative() {
+    const env = globalThis.process?.env ?? {};
+    const choice = env.GJSIFY_BUNDLER;
+    // Explicit env-var override always wins.
+    if (choice === 'npm')
+        return false;
+    if (choice === 'native') {
+        const native = await tryLoadNative();
+        if (!native) {
+            throw new Error('GJSIFY_BUNDLER=native but @gjsify/rolldown-native is not loadable (no prebuild for this architecture, or not running under GJS).');
+        }
+        return true;
+    }
+    // Phase D-3.1 — runtime-aware default.
+    //   Node:    use npm rolldown (no FFI loading cost at install time).
+    //   GJS:     try @gjsify/rolldown-native — it's the only engine
+    //            that can actually run here (npm rolldown is a Rust
+    //            crate). Fall back to npm only on Node.
+    const isGjs = typeof globalThis.imports?.gi !== 'undefined';
+    if (!isGjs)
+        return false;
+    const native = await tryLoadNative();
+    return native !== null;
+}
+async function tryLoadNative() {
+    if (_nativeProbe)
+        return _nativeProbe;
+    _nativeProbe = (async () => {
+        const isGjs = typeof globalThis.imports?.gi !== 'undefined';
+        if (!isGjs)
+            return null;
+        try {
+            // Under GJS the ESM loader has no node_modules resolver — a bare
+            // `import('@gjsify/rolldown-native')` would throw `Module not
+            // found`. Resolve via createRequire (PnP+node_modules-aware) to
+            // a real path, then dynamic-import the resulting file:// URL.
+            // Under Node a bare specifier import works directly, so we keep
+            // the simpler form there.
+            //
+            // `createRequire` + `pathToFileURL` are statically imported at
+            // the top of this file so the GJS bundle inlines them via
+            // `@gjsify/module` / `@gjsify/url`. A *dynamic* `import('node:…')`
+            // would instead hit the GJS native ESM loader which doesn't
+            // know the `node:` URI scheme and throws — silently swallowed
+            // by the surrounding catch, leaving the caller to fall back
+            // to npm rolldown (which then throws ImportError for `rolldown`).
+            const specifier = '@gjsify/rolldown-native';
+            let target = specifier;
+            if (isGjs) {
+                const require = createRequire(import.meta.url);
+                const resolved = require.resolve(specifier);
+                target = pathToFileURL(resolved).href;
+            }
+            const mod = (await import(/* @vite-ignore */ target));
+            if (!mod.hasNativeRolldown())
+                return null;
+            return mod;
+        }
+        catch {
+            return null;
+        }
+    })();
+    return _nativeProbe;
+}
+async function runNativeBundle(finalOpts) {
+    const native = await tryLoadNative();
+    if (!native) {
+        throw new Error('@gjsify/rolldown-native not loadable');
+    }
+    const rawPlugins = (finalOpts.plugins ?? []);
+    const nativePlugins = [];
+    for (const p of rawPlugins) {
+        if (isPluginObject(p))
+            nativePlugins.push(toNativePlugin(p));
+    }
+    // Strip plugins from opts — bundleWithPlugins gets them as a
+    // separate argument and the Rust side wires them into rolldown's
+    // own plugin chain. Normalize `input` to the Rust deserializer's
+    // expected `InputItem[]` shape, and flatten `output: { … }` (npm
+    // rolldown's JS-side shape) into the top-level keys the Rust
+    // BundlerOptions deserializer expects.
+    const { output: outputOpts, plugins: _droppedPlugins, ...rest } = finalOpts;
+    void _droppedPlugins;
+    const bundlerOpts = liftTransformExtras(stripUnserializable({
+        ...rest,
+        ...(outputOpts ?? {}),
+        input: normalizeInputForNative(finalOpts.input),
+    }));
+    if (globalThis.process?.env?.GJSIFY_DEBUG_NATIVE_OPTS) {
+        // Debug switch to inspect the shape we ship to the native facade —
+        // mismatches surface as Rust serde parse errors that point at column
+        // numbers in this JSON.
+        console.error('[gjsify-bundler-pick] native opts JSON:', JSON.stringify(bundlerOpts));
+    }
+    const result = await native.bundleWithPlugins(bundlerOpts, nativePlugins);
+    // The native facade returns the BundleOutput shape but doesn't
+    // write files — replicate `.write()` here so callers see the same
+    // on-disk layout whether they used npm rolldown or native.
+    const outputCfg = (finalOpts.output ?? {});
+    const outDir = outputCfg.dir ?? (outputCfg.file ? path.dirname(outputCfg.file) : process.cwd());
+    if (outDir)
+        await fs.mkdir(outDir, { recursive: true });
+    for (const item of result.output) {
+        if (item.type === 'chunk') {
+            const target = outputCfg.file && result.output.length === 1
+                ? outputCfg.file
+                : path.join(outDir, item.fileName);
+            await fs.writeFile(target, item.code, 'utf8');
+        }
+    }
+    // Synthesize the RolldownOutput shape downstream code touches.
+    return synthRolldownOutput(result);
+}
+/**
+ * Drop fields the JSON encoder can't ship to the Rust deserializer.
+ * `external` may be a function predicate (npm rolldown supports this);
+ * functions vanish under `JSON.stringify` and surface as parse errors on
+ * the Rust side. Strip top-level function values so the option object
+ * is JSON-clean. (The actual external behavior under native rolldown
+ * comes from arrays/regex strings, set elsewhere by the orchestrator.)
+ *
+ * Also drops `sourcemap: false` — the JS API accepts a boolean while
+ * the Rust deserializer expects an enum (`'File' | 'Inline' | 'Hidden'`).
+ * Omitting the field has the same effect as `false`.
+ */
+function stripUnserializable(opts) {
+    const out = {};
+    for (const [k, v] of Object.entries(opts)) {
+        if (typeof v === 'function')
+            continue;
+        if (k === 'sourcemap' && typeof v === 'boolean')
+            continue;
+        out[k] = v;
+    }
+    return out;
+}
+/**
+ * The Rust deserializer in the native facade treats `define` and `inject`
+ * as top-level fields on `BundlerOptions`, while npm rolldown's JS API
+ * groups them under `transform.{define,inject}`. Lift them out so the
+ * orchestrator's shape (built around the JS API) is accepted by the Rust
+ * side too. Other transform sub-options (`target`, `dropLabels`, …) stay
+ * where they are because they are real TransformOptions fields.
+ */
+function liftTransformExtras(opts) {
+    const transform = opts['transform'];
+    if (!transform)
+        return opts;
+    const lift = {};
+    const remaining = { ...transform };
+    for (const key of ['define', 'inject']) {
+        if (key in remaining) {
+            lift[key] = remaining[key];
+            delete remaining[key];
+        }
+    }
+    // `inject` shape diverges between engines: npm rolldown accepts a map
+    // `{ alias: 'module' | [module, named] }`; the native Rust deserializer
+    // expects an array of named-import descriptors. Convert if needed.
+    if (lift['inject'] !== undefined && !Array.isArray(lift['inject'])) {
+        lift['inject'] = mapToInjectArray(lift['inject']);
+    }
+    return {
+        ...opts,
+        transform: Object.keys(remaining).length === 0 ? undefined : remaining,
+        ...lift,
+    };
+}
+function mapToInjectArray(map) {
+    const out = [];
+    for (const [alias, value] of Object.entries(map)) {
+        if (typeof value === 'string') {
+            // Default-import binding: `import alias from 'module'`
+            out.push({ type: 'default', from: value, alias });
+        }
+        else {
+            // Named-import binding: `import { imported as alias } from 'from'`
+            const [from, imported] = value;
+            out.push({ type: 'named', from, imported, alias });
+        }
+    }
+    return out;
+}
+/**
+ * The native rolldown facade's Rust deserializer requires
+ * `input: BundleInputItem[]` (i.e. `[{ import, name? }]`). Normalize the
+ * other shapes npm rolldown accepts (string, string[], record) into that
+ * shape so callers can pass either engine the same options object.
+ */
+function normalizeInputForNative(input) {
+    if (input === undefined)
+        return [];
+    if (typeof input === 'string')
+        return [{ import: input }];
+    if (Array.isArray(input)) {
+        return input.map((v) => typeof v === 'string' ? { import: v } : v);
+    }
+    return Object.entries(input).map(([name, file]) => ({ name, import: file }));
+}
+export function isPluginObject(p) {
+    return p !== null && typeof p === 'object' && !Array.isArray(p);
+}
+function pickHook(raw) {
+    if (typeof raw === 'function')
+        return { fn: raw };
+    if (raw !== null && typeof raw === 'object' && 'handler' in raw) {
+        const obj = raw;
+        const idFilter = filterToRegexSource(obj.filter?.id);
+        const out = { fn: obj.handler };
+        if (idFilter !== undefined)
+            out.idFilter = idFilter;
+        return out;
+    }
+    return undefined;
+}
+function filterToRegexSource(f) {
+    if (f === undefined)
+        return undefined;
+    if (Array.isArray(f)) {
+        const sources = f.map(oneToSource).filter((x) => x !== undefined);
+        return sources.length === 0 ? undefined : sources.length === 1 ? sources[0] : `(?:${sources.join('|')})`;
+    }
+    return oneToSource(f);
+}
+function oneToSource(f) {
+    if (f instanceof RegExp)
+        return f.source;
+    if (typeof f === 'string') {
+        // Treat plain strings as substring match. Escape regex metas
+        // so glob-like inputs don't accidentally turn into wild
+        // regexes.
+        return f.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    return undefined;
+}
+export function toNativePlugin(p) {
+    const name = typeof p.name === 'string' ? p.name : 'unnamed-plugin';
+    const out = { name };
+    const idFilter = {};
+    const load = pickHook(p.load);
+    if (load) {
+        out.load = load.fn;
+        if (load.idFilter)
+            idFilter.load = load.idFilter;
+    }
+    const transform = pickHook(p.transform);
+    if (transform) {
+        out.transform = transform.fn;
+        if (transform.idFilter)
+            idFilter.transform = transform.idFilter;
+    }
+    const resolveId = pickHook(p.resolveId);
+    if (resolveId) {
+        out.resolveId = resolveId.fn;
+        if (resolveId.idFilter)
+            idFilter.resolveId = resolveId.idFilter;
+    }
+    const renderChunk = pickHook(p.renderChunk);
+    if (renderChunk)
+        out.renderChunk = renderChunk.fn;
+    const banner = pickHook(p.banner);
+    if (banner)
+        out.banner = banner.fn;
+    const footer = pickHook(p.footer);
+    if (footer)
+        out.footer = footer.fn;
+    const intro = pickHook(p.intro);
+    if (intro)
+        out.intro = intro.fn;
+    const outro = pickHook(p.outro);
+    if (outro)
+        out.outro = outro.fn;
+    const buildStart = pickHook(p.buildStart);
+    if (buildStart)
+        out.buildStart = buildStart.fn;
+    const buildEnd = pickHook(p.buildEnd);
+    if (buildEnd)
+        out.buildEnd = buildEnd.fn;
+    const generateBundle = pickHook(p.generateBundle);
+    if (generateBundle)
+        out.generateBundle = generateBundle.fn;
+    const writeBundle = pickHook(p.writeBundle);
+    if (writeBundle)
+        out.writeBundle = writeBundle.fn;
+    const closeBundle = pickHook(p.closeBundle);
+    if (closeBundle)
+        out.closeBundle = closeBundle.fn;
+    if (Object.keys(idFilter).length > 0)
+        out.idFilter = idFilter;
+    return out;
+}
+function synthRolldownOutput(result) {
+    // RolldownOutput's exact shape in the npm types is rich; we fill
+    // in what downstream code in `build.ts` actually touches (none of
+    // it inspects the output beyond logging the file count today).
+    // Cast through unknown to satisfy the structural type without
+    // pulling in every internal field.
+    return {
+        output: result.output.map((item) => {
+            if (item.type === 'chunk') {
+                return {
+                    type: 'chunk',
+                    fileName: item.fileName,
+                    code: item.code,
+                    name: item.name,
+                    isEntry: item.isEntry,
+                    isDynamicEntry: item.isDynamicEntry,
+                    map: item.map ?? null,
+                    sourcemapFileName: item.sourcemapFilename ?? null,
+                    imports: item.imports,
+                    dynamicImports: item.dynamicImports,
+                    facadeModuleId: null,
+                    moduleIds: [],
+                    modules: {},
+                    exports: [],
+                    referencedFiles: [],
+                    importedBindings: {},
+                };
+            }
+            return {
+                type: 'asset',
+                fileName: item.fileName,
+                names: item.names,
+                originalFileNames: item.originalFileNames,
+                source: item.sourceText ?? '',
+                needsCodeReference: false,
+            };
+        }),
+    };
+}

package/lib/commands/foreach.d.ts

@@ -0,0 +1,17 @@
+import type { Command } from '../types/index.js';
+interface ForeachOptions {
+    script?: string;
+    args?: string[];
+    all?: boolean;
+    parallel?: boolean;
+    topological?: boolean;
+    'topological-dev'?: boolean;
+    include?: string[];
+    exclude?: string[];
+    private?: boolean;
+    verbose?: boolean;
+    jobs?: number;
+    exec?: boolean;
+}
+export declare const foreachCommand: Command<any, ForeachOptions>;
+export {};