@gjsify/cli 0.3.21 → 0.4.0

package/src/commands/install.ts

@@ -1,195 +0,0 @@
-// `gjsify install [pkg...]` — install packages with gjsify-aware post-checks.
-//
-// Modes:
-//   gjsify install                    → project install (npm install)
-//   gjsify install <pkg> [<pkg>...]   → add package(s) to project (npm install <pkg>...)
-//   gjsify install -g <pkg> [...]     → user-global install (XDG, GJS-runnable bin)
-//
-// Project mode delegates to `npm install` in cwd and runs `runMinimalChecks()`
-// + `detectNativePackages()` to surface missing system deps and `@gjsify/*`
-// packages with native prebuilds.
-//
-// Global mode is the GJS equivalent of `npm i -g`: extracts the package tree
-// into `${XDG_DATA_HOME}/gjsify/global/node_modules/<pkg>/` via the native
-// install backend (no Node/npm required at runtime), then symlinks the bins
-// declared by `gjsify.bin` (preferred) or `bin` (fallback) into
-// `~/.local/bin/`. Subsequent commands invoked by name resolve to the
-// extracted package, so package-relative assets like `@ts-for-gir/cli`'s
-// `dist-templates/` are found by ordinary `__dirname/..` resolution — no
-// embedded asset stores, no separate release tarballs.
-
-import { spawn } from 'node:child_process';
-import { mkdirSync } from 'node:fs';
-import type { Command } from '../types/index.js';
-import {
-    buildInstallCommand,
-    detectPackageManager,
-    runMinimalChecks,
-} from '../utils/check-system-deps.js';
-import { detectNativePackages } from '../utils/detect-native-packages.js';
-import { installPackages } from '../utils/install-backend.js';
-import {
-    binDirOnPath,
-    defaultGlobalLayout,
-    linkGlobalBins,
-    specToPackageName,
-} from '../utils/install-global.js';
-
-interface InstallOptions {
-    packages?: string[];
-    global?: boolean;
-    'save-dev'?: boolean;
-    'save-peer'?: boolean;
-    'save-optional'?: boolean;
-    verbose: boolean;
-}
-
-export const installCommand: Command<any, InstallOptions> = {
-    command: 'install [packages..]',
-    description:
-        'Install npm dependencies in the current project (or globally with -g), then run gjsify-aware post-checks.',
-    builder: (yargs) =>
-        yargs
-            .positional('packages', {
-                description: 'Optional package specs. With none, runs a full project install.',
-                type: 'string',
-                array: true,
-            })
-            .option('global', {
-                description:
-                    'Install into the user-global XDG location and symlink bins into ~/.local/bin.',
-                type: 'boolean',
-                alias: 'g',
-                default: false,
-            })
-            .option('save-dev', { type: 'boolean', alias: 'D' })
-            .option('save-peer', { type: 'boolean' })
-            .option('save-optional', { type: 'boolean', alias: 'O' })
-            .option('verbose', {
-                description: 'Verbose install logging.',
-                type: 'boolean',
-                default: false,
-            }),
-    handler: async (args) => {
-        if (args.global) {
-            if (!args.packages || args.packages.length === 0) {
-                console.error(
-                    'gjsify install --global requires at least one <pkg> argument.',
-                );
-                process.exit(1);
-            }
-            for (const flag of ['save-dev', 'save-peer', 'save-optional'] as const) {
-                if (args[flag]) {
-                    console.warn(
-                        `gjsify install --global ignores --${flag}: global installs do not modify a project package.json.`,
-                    );
-                }
-            }
-            await installGlobalAndLink(args.packages, { verbose: args.verbose });
-            return;
-        }
-
-        const npmArgs = ['install'];
-        if (args['save-dev']) npmArgs.push('--save-dev');
-        if (args['save-peer']) npmArgs.push('--save-peer');
-        if (args['save-optional']) npmArgs.push('--save-optional');
-        if (args.verbose) npmArgs.push('--loglevel', 'verbose');
-        if (args.packages && args.packages.length > 0) {
-            npmArgs.push(...args.packages);
-        }
-
-        await spawnNpm(npmArgs);
-
-        await runPostInstallChecks();
-    },
-};
-
-async function spawnNpm(npmArgs: string[]): Promise<void> {
-    return new Promise<void>((resolve, reject) => {
-        const child = spawn('npm', npmArgs, { stdio: 'inherit' });
-        child.on('close', (code) => {
-            if (code === 0) resolve();
-            else reject(new Error(`npm install exited with code ${code}`));
-        });
-        child.on('error', (err) => {
-            const code = (err as NodeJS.ErrnoException).code;
-            const msg = code === 'ENOENT'
-                ? 'npm not found on PATH — install Node.js first.'
-                : `npm install failed: ${err.message}`;
-            reject(new Error(msg));
-        });
-    }).catch((err: Error) => {
-        console.error(err.message);
-        process.exit(1);
-    });
-}
-
-async function installGlobalAndLink(
-    specs: string[],
-    opts: { verbose: boolean },
-): Promise<void> {
-    const layout = defaultGlobalLayout();
-    mkdirSync(layout.prefix, { recursive: true });
-
-    console.log(`gjsify install --global  → ${layout.prefix}`);
-    console.log(`                  bins → ${layout.binDir}`);
-
-    await installPackages({
-        prefix: layout.prefix,
-        specs,
-        verbose: opts.verbose,
-    });
-
-    const packageNames = specs.map(specToPackageName);
-    const created = linkGlobalBins(packageNames, layout);
-
-    if (created.length === 0) {
-        console.warn(
-            '\nNo bins declared (neither `gjsify.bin` nor `bin` in package.json) — nothing was symlinked.',
-        );
-    } else {
-        console.log(`\nLinked ${created.length} bin(s):`);
-        for (const e of created) {
-            console.log(`  • ${e.link}  →  ${e.target}`);
-        }
-    }
-
-    if (created.length > 0 && !binDirOnPath(layout.binDir)) {
-        console.warn(
-            `\nNote: ${layout.binDir} is not on your PATH.\n` +
-                `Add it to your shell rc file:\n  export PATH="${layout.binDir}:$PATH"`,
-        );
-    }
-}
-
-async function runPostInstallChecks(): Promise<void> {
-    console.log('\n--- gjsify post-install checks ---');
-
-    // 1. System deps that GJS apps typically need.
-    const results = runMinimalChecks();
-    const missing = results.filter((r) => !r.found && r.severity === 'required');
-    if (missing.length > 0) {
-        console.warn('Missing required system dependencies:\n');
-        for (const dep of missing) {
-            console.warn(`  ✗  ${dep.name}`);
-        }
-        const pm = detectPackageManager();
-        const cmd = buildInstallCommand(pm, missing);
-        if (cmd) console.warn(`\nInstall with:\n  ${cmd}`);
-    } else {
-        console.log('System dependencies OK.');
-    }
-
-    // 2. Surface @gjsify/* packages with native prebuilds — `gjsify run`
-    //    will set LD_LIBRARY_PATH / GI_TYPELIB_PATH for these automatically.
-    const native = detectNativePackages(process.cwd());
-    if (native.length > 0) {
-        console.log(
-            `\nDetected ${native.length} @gjsify/* package(s) with native prebuilds:`,
-        );
-        for (const pkg of native) {
-            console.log(`  • ${pkg.name}`);
-        }
-        console.log('\nUse `gjsify run <bundle>` to launch with LD_LIBRARY_PATH/GI_TYPELIB_PATH set.');
-    }
-}

package/src/commands/run.ts

@@ -1,33 +0,0 @@
-import { resolve } from 'node:path';
-import type { Command } from '../types/index.js';
-import { runGjsBundle } from '../utils/run-gjs.js';
-
-interface RunOptions {
-    file: string;
-    args: string[];
-}
-
-export const runCommand: Command<any, RunOptions> = {
-    command: 'run <file> [args..]',
-    description: 'Run a GJS bundle, automatically setting LD_LIBRARY_PATH and GI_TYPELIB_PATH for any installed native gjsify packages (e.g. @gjsify/webgl).',
-    builder: (yargs) => {
-        return yargs
-            .positional('file', {
-                description: 'The GJS bundle to run (e.g. dist/gjs.js)',
-                type: 'string',
-                normalize: true,
-                demandOption: true,
-            })
-            .positional('args', {
-                description: 'Extra arguments passed through to gjs',
-                type: 'string',
-                array: true,
-                default: [],
-            });
-    },
-    handler: async (args) => {
-        const file = resolve(args.file as string);
-        const extraArgs = (args.args as string[]) ?? [];
-        await runGjsBundle(file, extraArgs);
-    },
-};

package/src/commands/showcase.ts

@@ -1,149 +0,0 @@
-import type { Command } from '../types/index.js';
-import { discoverShowcases, findShowcase } from '../utils/discover-showcases.js';
-import {
-    runMinimalChecks,
-    detectPackageManager,
-    buildInstallCommand,
-} from '../utils/check-system-deps.js';
-import { spawn } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-import { readFileSync } from 'node:fs';
-
-function readCliVersion(): string | undefined {
-    try {
-        const pkgUrl = new URL('../../package.json', import.meta.url);
-        const pkg = JSON.parse(readFileSync(pkgUrl, 'utf8')) as { version?: unknown };
-        return typeof pkg.version === 'string' ? pkg.version : undefined;
-    } catch {
-        return undefined;
-    }
-}
-
-interface ShowcaseOptions {
-    name?: string;
-    json: boolean;
-    list: boolean;
-}
-
-export const showcaseCommand: Command<any, ShowcaseOptions> = {
-    command: 'showcase [name]',
-    description: 'List or run curated gjsify showcase applications.',
-    builder: (yargs) =>
-        yargs
-            .positional('name', {
-                description: 'Showcase name to run (omit to list all)',
-                type: 'string',
-            })
-            .option('json', {
-                description: 'Output as JSON',
-                type: 'boolean',
-                default: false,
-            })
-            .option('list', {
-                description: 'List available showcases',
-                type: 'boolean',
-                default: false,
-            }),
-    handler: async (args) => {
-        // List mode: no name given, or --list flag
-        if (!args.name || args.list) {
-            const showcases = discoverShowcases();
-
-            if (args.json) {
-                console.log(JSON.stringify(showcases, null, 2));
-                return;
-            }
-
-            if (showcases.length === 0) {
-                console.log('No showcases found. The CLI ships a curated list in `showcases.json`; if it is missing the CLI install is incomplete.');
-                return;
-            }
-
-            const grouped = new Map<string, typeof showcases>();
-            for (const sc of showcases) {
-                const list = grouped.get(sc.category) ?? [];
-                list.push(sc);
-                grouped.set(sc.category, list);
-            }
-
-            console.log('Available gjsify showcases:\n');
-            for (const [category, list] of grouped) {
-                console.log(`  ${category.toUpperCase()}:`);
-                const maxNameLen = Math.max(...list.map((e) => e.name.length));
-                for (const sc of list) {
-                    const pad = ' '.repeat(maxNameLen - sc.name.length + 2);
-                    const desc = sc.description ? `${pad}${sc.description}` : '';
-                    console.log(`    ${sc.name}${desc}`);
-                }
-                console.log('');
-            }
-
-            console.log('Run a showcase:  gjsify showcase <name>');
-            return;
-        }
-
-        const showcase = findShowcase(args.name);
-        if (!showcase) {
-            console.error(`Unknown showcase: "${args.name}"`);
-            console.error('Run "gjsify showcase" to list available showcases.');
-            process.exit(1);
-        }
-
-        // System dependency check before delegating — only system libs (gjs,
-        // gtk4, …). The showcase's npm deps (incl. `@gjsify/webgl` with the
-        // gwebgl Vala prebuild) are fetched by `gjsify dlx` into the npm
-        // cache, and `runGjsBundle()` picks the prebuild up from the bundle
-        // dir via `detectNativePackages()`. Pre-flight-checking npm deps
-        // here would fail for `npx @gjsify/cli showcase` (no project
-        // node_modules, CLI doesn't dep on the showcase libs).
-        const results = runMinimalChecks();
-        const missingHard = results.filter(
-            (r) => !r.found && r.severity === 'required',
-        );
-        if (missingHard.length > 0) {
-            console.error('Missing system dependencies:\n');
-            for (const dep of missingHard) {
-                console.error(`  ✗  ${dep.name}`);
-            }
-            const pm = detectPackageManager();
-            const cmd = buildInstallCommand(pm, missingHard);
-            if (cmd) {
-                console.error(`\nInstall with:\n  ${cmd}`);
-            }
-            process.exit(1);
-        }
-
-        // Delegate to `gjsify dlx <package>@<cli-version>` — same npm-cache,
-        // same atomic symlink-swap, same `gjsify.main` resolution. Re-spawning
-        // the CLI keeps the dlx logic in one place.
-        //
-        // Pinning to the CLI's own version is load-bearing: showcases ship in
-        // lockstep with the CLI, so users running `npx @gjsify/cli@X showcase
-        // <name>` expect the matching `@gjsify/example-*@X`. Without the pin,
-        // dlx caches the first resolved-latest on disk; subsequent CLI
-        // releases leave that cache untouched until the 7-day TTL expires,
-        // and the user gets a stale showcase that may be missing deps the
-        // newer CLI assumes (the `@gjsify/http-soup-bridge` regression
-        // reported against `@gjsify/cli@0.3.17`).
-        const cliVersion = readCliVersion();
-        const dlxSpec = cliVersion ? `${showcase.packageName}@${cliVersion}` : showcase.packageName;
-        console.log(`Running showcase: ${showcase.name} (via gjsify dlx ${dlxSpec})\n`);
-        const cliBin = fileURLToPath(new URL('../index.js', import.meta.url));
-        const child = spawn(process.execPath, [cliBin, 'dlx', dlxSpec], {
-            stdio: 'inherit',
-        });
-        await new Promise<void>((resolvePromise, reject) => {
-            child.on('close', (code) => {
-                if (code !== 0) {
-                    reject(new Error(`gjsify dlx exited with code ${code}`));
-                } else {
-                    resolvePromise();
-                }
-            });
-            child.on('error', reject);
-        }).catch((err) => {
-            console.error(err.message);
-            process.exit(1);
-        });
-    },
-};

package/src/config.ts

@@ -1,304 +0,0 @@
-import { APP_NAME } from  './constants.js';
-import { cosmiconfig, type Options as LoadOptions } from 'cosmiconfig';
-
-/** Default cosmiconfig search places for a given module name (matches cosmiconfig defaults). */
-function defaultSearchPlaces(name: string): string[] {
-    return [
-        'package.json',
-        `.${name}rc`,
-        `.${name}rc.json`,
-        `.${name}rc.yaml`,
-        `.${name}rc.yml`,
-        `.${name}rc.js`,
-        `.${name}rc.ts`,
-        `.${name}rc.mjs`,
-        `.${name}rc.cjs`,
-        `${name}.config.js`,
-        `${name}.config.ts`,
-        `${name}.config.mjs`,
-        `${name}.config.cjs`,
-    ];
-}
-import { readPackageJSON, resolvePackageJSON } from 'pkg-types';
-import { getTsconfig } from 'get-tsconfig';
-
-/** Deep merge objects (replaces lodash.merge) */
-function merge<T extends Record<string, any>>(target: T, ...sources: Record<string, any>[]): T {
-    for (const source of sources) {
-        if (!source) continue;
-        for (const key of Object.keys(source)) {
-            const targetVal = (target as any)[key];
-            const sourceVal = source[key];
-            if (sourceVal !== undefined) {
-                if (isPlainObject(targetVal) && isPlainObject(sourceVal)) {
-                    merge(targetVal, sourceVal);
-                } else {
-                    (target as any)[key] = sourceVal;
-                }
-            }
-        }
-    }
-    return target;
-}
-
-function isPlainObject(val: unknown): val is Record<string, any> {
-    return typeof val === 'object' && val !== null && !Array.isArray(val) && Object.getPrototypeOf(val) === Object.prototype;
-}
-
-/**
- * Read a dotted path (`a.b.c`) from a plain object. Returns `undefined` for
- * any missing segment. Intentionally narrow — only used for surfacing
- * `package.json` fields into compile-time defines, not for arbitrary deep
- * traversal.
- */
-function readDottedPath(obj: Record<string, unknown>, path: string): unknown {
-    if (!path.includes('.')) return obj[path];
-    let cursor: unknown = obj;
-    for (const segment of path.split('.')) {
-        if (cursor === null || cursor === undefined || typeof cursor !== 'object') return undefined;
-        cursor = (cursor as Record<string, unknown>)[segment];
-    }
-    return cursor;
-}
-
-import type { CliBuildOptions, ConfigData, CosmiconfigResult, ConfigDataTypescript, ConfigDataLibrary} from './types/index.js';
-import type { ArgumentsCamelCase } from 'yargs';
-
-export class Config {
-
-    readonly loadOptions: Partial<LoadOptions> = {}
-
-    constructor(loadOptions: Partial<LoadOptions> = {}) {
-        if(Object.keys(loadOptions).length) {
-            this.loadOptions = loadOptions;
-        }
-    }
-
-    /** Loads gjsify config file, e.g `.gjsifyrc.js` */
-    private async load(searchFrom?: string) {
-        // cosmiconfig's default first-match-wins behaviour silently drops one
-        // source when both `package.json#gjsify` and an explicit config file
-        // (`.gjsifyrc.js`, `gjsify.config.mjs`, ...) are present. Project hits
-        // this footgun: adding `gjsify.bin` to package.json (so `gjsify dlx`
-        // resolves the GJS bundle) silently disables `.gjsifyrc.js`. We
-        // explicitly load both sources and merge — package.json is the lower
-        // layer, the explicit file wins on key collisions.
-        //
-        // Run two searches:
-        //   1. Default (includes package.json) — for projects that only use
-        //      package.json#gjsify and no separate file.
-        //   2. Explicit-file only (package.json excluded) — to find the
-        //      `.gjsifyrc.*` / `gjsify.config.*` regardless of whether
-        //      package.json#gjsify exists.
-        const fileExplorer = cosmiconfig(APP_NAME, {
-            ...this.loadOptions,
-            searchPlaces: (this.loadOptions.searchPlaces ?? defaultSearchPlaces(APP_NAME))
-                .filter((p) => p !== 'package.json'),
-        });
-        const fileResult = await fileExplorer.search(searchFrom) as CosmiconfigResult<ConfigData> | null;
-
-        const merged: ConfigData = {};
-        try {
-            const pkg = await this.readPackageJSON(searchFrom) as { gjsify?: ConfigData };
-            if (isPlainObject(pkg?.gjsify)) merge(merged, pkg.gjsify);
-        } catch {
-            // Missing or unreadable package.json — skip.
-        }
-        if (fileResult?.config && isPlainObject(fileResult.config)) {
-            merge(merged, fileResult.config);
-        }
-
-        merged.bundler ||= {};
-        merged.library ||= {};
-        merged.typescript ||= {};
-
-        return {
-            config: merged,
-            filepath: fileResult?.filepath ?? '',
-            isEmpty: !fileResult && Object.keys(merged).length === 3, // only the three default-empty objects
-        };
-    }
-
-    /** Loads package.json of the current project */
-    private async readPackageJSON(dirPath?: string) {   
-        dirPath = await resolvePackageJSON(dirPath)     
-        const pkg = await readPackageJSON(dirPath);
-        return pkg;
-    }
-
-    /** Loads tsconfig.json of the current project */
-    private async readTSConfig(dirPath?: string) {     
-        const tsconfig = getTsconfig(dirPath)?.config || {};
-        return tsconfig;
-    }
-
-    async forBuild(cliArgs: ArgumentsCamelCase<CliBuildOptions>) {
-        const configFile = await this.load(process.cwd());
-        const configData: ConfigData = {...configFile.config};
-        const configFilePath = configFile.filepath || process.cwd();
-        const pkg = await this.readPackageJSON(configFilePath) as ConfigDataLibrary;
-        const tsConfig = await this.readTSConfig(configFilePath) as ConfigDataTypescript;
-
-        tsConfig.reflection ||= cliArgs.reflection;
-
-        // TODO replace with `cliArgs.logLevel`
-        configData.verbose = cliArgs.verbose || false;
-        configData.exclude = cliArgs.exclude || [];
-        if (cliArgs.consoleShim !== undefined) configData.consoleShim = cliArgs.consoleShim;
-        if (cliArgs.globals !== undefined) configData.globals = cliArgs.globals;
-        if (cliArgs.shebang !== undefined) configData.shebang = cliArgs.shebang;
-        if (cliArgs.excludeGlobals) {
-            const raw = Array.isArray(cliArgs.excludeGlobals)
-                ? cliArgs.excludeGlobals.join(',')
-                : String(cliArgs.excludeGlobals);
-            const ids = raw.split(',').map((s: string) => s.trim()).filter(Boolean);
-            if (ids.length) configData.excludeGlobals = [...(configData.excludeGlobals ?? []), ...ids];
-        }
-
-        merge(configData.library ??= {}, pkg, configData.library);
-        merge(configData.typescript ??= {}, tsConfig, configData.typescript);
-
-        // Parse `KEY=VALUE` style flags into Record<string, string>.
-        // - `--define`: VALUE is a JS expression (string literals must be
-        //   pre-quoted by the caller, e.g. `'"1.2.3"'`).
-        // - `--alias`: VALUE is the substitute module specifier.
-        const parseKvPairs = (entries: readonly string[], flag: string): Record<string, string> => {
-            const out: Record<string, string> = {};
-            for (const entry of entries) {
-                const idx = entry.indexOf('=');
-                if (idx === -1) {
-                    throw new Error(`Invalid --${flag} value '${entry}'. Expected KEY=VALUE.`);
-                }
-                const key = entry.slice(0, idx).trim();
-                const value = entry.slice(idx + 1);
-                if (!key) {
-                    throw new Error(`Invalid --${flag} value '${entry}'. Empty key.`);
-                }
-                out[key] = value;
-            }
-            return out;
-        };
-        const defineMap = parseKvPairs(cliArgs.define ?? [], 'define');
-        const aliasMap = parseKvPairs(cliArgs.alias ?? [], 'alias');
-        if (Object.keys(aliasMap).length) {
-            configData.aliases = { ...(configData.aliases ?? {}), ...aliasMap };
-        }
-
-        // Resolve `defineFromPackageJson` / `defineFromEnv` into raw
-        // KEY=<JSON-stringified value> entries that get merged into the
-        // bundler's `transform.define` map below. Both produce JS expressions
-        // (the value side of a Rolldown define is substituted at the call
-        // site, not stringified again) — so a missing env variable resolves
-        // to the literal `undefined`, letting consumer code use
-        // `typeof X === 'undefined'` or `X ?? fallback` guards.
-        const fromPkgDefines: Record<string, string> = {};
-        if (configData.defineFromPackageJson) {
-            for (const [name, spec] of Object.entries(configData.defineFromPackageJson)) {
-                if (!spec || typeof spec.field !== 'string' || !spec.field) {
-                    throw new Error(
-                        `gjsify config: defineFromPackageJson["${name}"] is missing a "field" string`,
-                    );
-                }
-                const value = readDottedPath(pkg as Record<string, unknown>, spec.field);
-                fromPkgDefines[name] = value === undefined ? 'undefined' : JSON.stringify(value);
-            }
-        }
-        const fromEnvDefines: Record<string, string> = {};
-        if (configData.defineFromEnv) {
-            for (const [name, spec] of Object.entries(configData.defineFromEnv)) {
-                if (!spec || typeof spec.env !== 'string' || !spec.env) {
-                    throw new Error(
-                        `gjsify config: defineFromEnv["${name}"] is missing an "env" string`,
-                    );
-                }
-                const raw = process.env[spec.env];
-                const value = raw !== undefined ? raw : spec.default;
-                fromEnvDefines[name] = value === undefined ? 'undefined' : JSON.stringify(value);
-            }
-        }
-
-        // Merge CLI flags into the Rolldown-shape `bundler` field. Mappings:
-        //   --entry-points  → bundler.input
-        //   --outfile       → bundler.output.file
-        //   --outdir        → bundler.output.dir
-        //   --format        → bundler.output.format
-        //   --minify        → bundler.output.minify
-        //   --log-level     → bundler.logLevel
-        //   --external      → bundler.external
-        //   --define        → bundler.transform.define
-        const bundler = (configData.bundler ??= {});
-        const output = (bundler.output ??= {});
-        const transform = (bundler.transform ??= {});
-
-        if (cliArgs.entryPoints?.length) bundler.input = cliArgs.entryPoints;
-        // Fallback when neither the CLI flag nor the cosmiconfig data set an
-        // entry point. Applied here (post-merge) rather than as a yargs
-        // `default:` because yargs defaults are indistinguishable from
-        // user-set values, and would silently overwrite `bundler.input`
-        // declared in package.json#gjsify.
-        if (!bundler.input) bundler.input = ['src/index.ts'];
-        if (cliArgs.outfile !== undefined) output.file = cliArgs.outfile;
-        if (cliArgs.outdir !== undefined) output.dir = cliArgs.outdir;
-        if (cliArgs.format !== undefined) output.format = cliArgs.format as 'esm' | 'cjs' | 'iife';
-        // CLI flag wins over config; if neither is set, minify by default.
-        // Pretty-printed output is opt-in via `--no-minify` or
-        // `bundler.output.minify: false` in the config.
-        //
-        // When minify is enabled (boolean true) we expand it to a MinifyOptions
-        // object that PRESERVES function and class .name properties. Rolldown's
-        // default mangler renames every top-level class to short identifiers
-        // (`e`, `t`, ...), which collapses Function.name → 'e' for many
-        // distinct classes. Libraries like Excalibur key runtime data
-        // structures off `c.name` (e.g. `Query.createId` hashes
-        // `c_${component.name}` to dedupe ECS queries), so once class names
-        // collide every query with N components is treated as identical and
-        // the wrong filter wins. Keeping the .name property only costs a few
-        // bytes per class but keeps name-driven library code working
-        // (Excalibur ECS, deepkit reflection, error stacks, etc.).
-        if (cliArgs.minify !== undefined) output.minify = cliArgs.minify;
-        if (output.minify === undefined) output.minify = true;
-        if (output.minify === true) {
-            output.minify = { mangle: { keepNames: { function: true, class: true } } };
-        }
-        if (cliArgs.logLevel) {
-            // Map esbuild log levels to Rolldown's narrower set:
-            //   esbuild   → rolldown
-            //   silent    → silent
-            //   error     → warn   (rolldown has no error-only)
-            //   warning   → warn
-            //   info      → info
-            //   debug     → debug
-            //   verbose   → debug  (rolldown has no verbose)
-            const map: Record<string, 'silent' | 'warn' | 'info' | 'debug'> = {
-                silent: 'silent',
-                error: 'warn',
-                warning: 'warn',
-                warn: 'warn',
-                info: 'info',
-                debug: 'debug',
-                verbose: 'debug',
-            };
-            const level = map[cliArgs.logLevel] ?? 'warn';
-            bundler.logLevel = level;
-        }
-        if (cliArgs.external?.length) {
-            const userExternal = Array.isArray(bundler.external) ? bundler.external : [];
-            bundler.external = [...userExternal, ...cliArgs.external];
-        }
-        if (Object.keys(defineMap).length || Object.keys(fromPkgDefines).length || Object.keys(fromEnvDefines).length) {
-            // CLI --define wins over package.json/env (manual overrides during
-            // debugging beat declarative config).
-            transform.define = {
-                ...(transform.define ?? {}),
-                ...fromPkgDefines,
-                ...fromEnvDefines,
-                ...defineMap,
-            };
-        }
-
-        if(configData.verbose) console.debug("configData", configData);
-
-        return configData;
-
-    }
-}

package/src/constants.ts

@@ -1 +0,0 @@
-export const APP_NAME = 'gjsify'