@gjsify/rolldown-plugin-gjsify 0.3.14

package/lib/utils/scan-globals.js

@@ -0,0 +1,85 @@
+// Explicit `--globals` CLI flag support.
+//
+// This module resolves a user-provided comma-separated list of global
+// identifiers (e.g. `fetch,Buffer,process,URL,crypto`) into the
+// corresponding set of `@gjsify/<pkg>/register` subpaths and writes an
+// ESM stub file that the esbuild plugin injects via its
+// `autoGlobalsInject` option.
+//
+// gjsify does NOT scan user code to guess which globals are needed —
+// the user declares them explicitly via `gjsify build --globals <list>`
+// (or via the default script scaffolded by `@gjsify/create-app`). See
+// the "Tree-shakeable Globals" section in AGENTS.md for the rationale.
+import { writeFile, mkdir } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+import { join } from 'node:path';
+import { GJS_GLOBALS_MAP, GJS_GLOBALS_GROUPS } from '@gjsify/resolve-npm/globals-map';
+const GLOBALS_MAP = GJS_GLOBALS_MAP;
+const GLOBALS_GROUPS = GJS_GLOBALS_GROUPS;
+/**
+ * Resolve a `--globals` CLI argument into the set of `/register` subpaths
+ * that must be injected into the build.
+ *
+ * The argument is a comma-separated list of identifiers or group names.
+ * Group names (`node`, `web`, `dom`) expand to all identifiers in that group.
+ * Unknown tokens are silently ignored. Empty or whitespace-only input returns
+ * an empty set.
+ *
+ * Examples:
+ *   resolveGlobalsList('fetch,Buffer,process')
+ *     → Set { 'fetch/register', '@gjsify/buffer/register', '@gjsify/node-globals/register' }
+ *
+ *   resolveGlobalsList('node,web')
+ *     → Set { '@gjsify/buffer/register', '@gjsify/node-globals/register', 'fetch/register', … }
+ *
+ *   resolveGlobalsList('')
+ *     → Set { }
+ */
+export function resolveGlobalsList(globalsArg) {
+    const result = new Set();
+    const trimmed = globalsArg.trim();
+    if (!trimmed)
+        return result;
+    for (const rawToken of trimmed.split(',')) {
+        const token = rawToken.trim();
+        if (!token)
+            continue;
+        const group = GLOBALS_GROUPS[token];
+        if (group) {
+            for (const id of group) {
+                const path = GLOBALS_MAP[id];
+                if (path)
+                    result.add(path);
+            }
+        }
+        else {
+            const path = GLOBALS_MAP[token];
+            if (path)
+                result.add(path);
+        }
+    }
+    return result;
+}
+/**
+ * Write a stub ESM file with `import` statements for the given register
+ * paths and return its absolute path, suitable for passing to esbuild's
+ * `inject` option via the plugin's `autoGlobalsInject` field.
+ *
+ * The file lives inside `<cwd>/node_modules/.cache/gjsify/` so esbuild's
+ * module resolver can follow the bare specifiers in the generated imports.
+ *
+ * The file name is hashed by content so repeated builds with the same
+ * set reuse the same file (no churn, idempotent on disk).
+ */
+export async function writeRegisterInjectFile(registerPaths, cwd = process.cwd()) {
+    if (registerPaths.size === 0)
+        return null;
+    const sorted = [...registerPaths].sort();
+    const content = sorted.map((p) => `import '${p}';`).join('\n') + '\n';
+    const hash = createHash('sha1').update(content).digest('hex').slice(0, 10);
+    const cacheDir = join(cwd, 'node_modules', '.cache', 'gjsify');
+    await mkdir(cacheDir, { recursive: true });
+    const path = join(cacheDir, `auto-globals-${hash}.mjs`);
+    await writeFile(path, content, 'utf-8');
+    return path;
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@gjsify/rolldown-plugin-gjsify",
+  "version": "0.3.14",
+  "description": "Rolldown / Rollup / Vite plugin orchestrator for GJS, Node, and Browser targets",
+  "type": "module",
+  "main": "lib/index.js",
+  "module": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./globals": {
+      "types": "./lib/globals.d.ts",
+      "default": "./lib/globals.js"
+    },
+    "./shims/console-gjs": {
+      "default": "./lib/shims/console-gjs.js"
+    }
+  },
+  "scripts": {
+    "clear": "rm -rf lib tsconfig.tsbuildinfo || exit 0",
+    "check": "tsc --noEmit",
+    "build": "tsc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gjsify/gjsify.git"
+  },
+  "bugs": {
+    "url": "https://github.com/gjsify/gjsify/issues"
+  },
+  "homepage": "https://github.com/gjsify/gjsify/tree/main/packages/infra/rolldown-plugin-gjsify#readme",
+  "keywords": [
+    "gjs",
+    "rolldown",
+    "rollup",
+    "vite",
+    "plugin",
+    "gjsify"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@gjsify/resolve-npm": "^0.3.14",
+    "@gjsify/rolldown-plugin-deepkit": "^0.3.14",
+    "@gjsify/rolldown-plugin-pnp": "^0.3.14",
+    "@gjsify/vite-plugin-blueprint": "^0.3.14",
+    "@rollup/pluginutils": "^5.1.4",
+    "acorn": "^8.14.0",
+    "acorn-walk": "^8.3.4",
+    "fast-glob": "^3.3.3",
+    "lightningcss": "^1.32.0"
+  },
+  "peerDependencies": {
+    "rolldown": "^1.0.0-rc.18"
+  },
+  "peerDependenciesMeta": {
+    "rolldown": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.0",
+    "rolldown": "^1.0.0-rc.18",
+    "typescript": "^6.0.3"
+  }
+}

package/src/app/browser.ts

@@ -0,0 +1,102 @@
+// `--app browser` Rolldown configuration factory.
+//
+// Browser builds redirect `@girs/*` and `gi://*` to an empty virtual module
+// (they appear transitively via `@gjsify/unit` and similar packages with
+// GJS-specific code paths). Standard Node.js → browser polyfill aliases
+// for `process` and `assert` keep `@gjsify/unit`'s top-level imports
+// resolvable in a browser bundle.
+
+import { aliasPlugin } from '../plugins/alias.js';
+import type { RolldownOptions, RolldownPluginOption } from 'rolldown';
+
+import { deepkitPlugin } from '@gjsify/rolldown-plugin-deepkit';
+import blueprintPlugin from '@gjsify/vite-plugin-blueprint';
+
+import type { PluginOptions } from '../types/plugin-options.js';
+import { globToEntryPoints } from '../utils/entry-points.js';
+import { gjsImportsEmptyPlugin } from '../plugins/gjs-imports-empty.js';
+import { cssAsStringPlugin } from '../plugins/css-as-string.js';
+
+export interface BrowserBuildConfig {
+    options: RolldownOptions;
+    plugins: RolldownPluginOption[];
+}
+
+export interface BrowserFactoryInput {
+    input?: RolldownOptions['input'];
+    output: { file?: string; dir?: string };
+    userExternal?: string[];
+    userAliases?: Record<string, string>;
+    pluginOptions: PluginOptions;
+}
+
+export const setupForBrowser = async (input: BrowserFactoryInput): Promise<BrowserBuildConfig> => {
+    const userExternal = input.userExternal ?? [];
+    const external = [...userExternal];
+
+    const exclude = input.pluginOptions.exclude ?? [];
+    const entryPoints = await globToEntryPoints(input.input, exclude);
+
+    // `@gjsify/unit` has `await import('process')` inside a try-catch that
+    // is unreachable in browser (typeof document check comes first), but
+    // Rolldown still resolves it statically. Map to `@gjsify/empty` so the
+    // build succeeds. `assert` → `@gjsify/assert` because `@gjsify/unit`
+    // imports `node:assert` at the top level.
+    const browserPolyfillAliases: Record<string, string> = {
+        process: '@gjsify/empty',
+        'node:process': '@gjsify/empty',
+        assert: '@gjsify/assert',
+        'node:assert': '@gjsify/assert',
+    };
+
+    const aliasMap: Record<string, string> = {
+        ...browserPolyfillAliases,
+        ...(input.pluginOptions.aliases ?? {}),
+        ...(input.userAliases ?? {}),
+    };
+
+    const options: RolldownOptions = {
+        input: entryPoints,
+        platform: 'browser',
+        external,
+        resolve: {
+            mainFields: ['browser', 'module', 'main'],
+            conditionNames: ['import', 'browser'],
+        },
+        transform: {
+            target: 'esnext',
+            define: {
+                global: 'globalThis',
+                window: 'globalThis',
+            },
+        },
+        output: {
+            ...input.output,
+            format: 'esm',
+            minify: false,
+            sourcemap: false,
+            // Single-bundle output. `codeSplitting: false` replaces the
+            // deprecated `inlineDynamicImports: true`.
+            codeSplitting: false,
+        },
+        treeshake: true,
+    };
+
+    const plugins: RolldownPluginOption[] = [
+        gjsImportsEmptyPlugin(),
+        aliasPlugin({ entries: flattenAliases(aliasMap) }),
+        blueprintPlugin() as RolldownPluginOption,
+        deepkitPlugin({ reflection: input.pluginOptions.reflection }),
+        cssAsStringPlugin(),
+    ];
+
+    return { options, plugins };
+};
+
+function flattenAliases(map: Record<string, string>): Record<string, string> {
+    const out: Record<string, string> = {};
+    for (const [from, to] of Object.entries(map)) {
+        if (to) out[from] = to;
+    }
+    return out;
+}

package/src/app/gjs.ts

@@ -0,0 +1,260 @@
+// `--app gjs` Rolldown configuration factory.
+//
+// Mirrors the esbuild predecessor's `setupForGjs` exactly in terms of the
+// effective build behaviour: same externals, same alias map, same target
+// (firefox128 for JS, firefox60 for CSS), same console-shim injection,
+// same process-stub banner, same `random-access-file` fs-backed-fallback.
+//
+// Returns a partial `RolldownOptions` template plus the plugin array the
+// caller should compose with their user-supplied options. Library mode is
+// handled separately by `setupLib`.
+
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+import type { RolldownOptions, RolldownPluginOption } from 'rolldown';
+import { aliasPlugin } from '../plugins/alias.js';
+
+import { deepkitPlugin } from '@gjsify/rolldown-plugin-deepkit';
+import blueprintPlugin from '@gjsify/vite-plugin-blueprint';
+
+import type { PluginOptions } from '../types/plugin-options.js';
+import { getAliasesForGjs } from '../utils/alias.js';
+import { globToEntryPoints } from '../utils/entry-points.js';
+import {
+    nodeModulesPathRewritePlugin,
+    getBundleDirFromOutput,
+} from '../plugins/rewrite-node-modules-paths.js';
+import { processStubPlugin } from '../plugins/process-stub.js';
+import { cssAsStringPlugin } from '../plugins/css-as-string.js';
+import { shebangPlugin, GJS_SHEBANG } from '../plugins/shebang.js';
+
+const _shimDir = dirname(fileURLToPath(import.meta.url));
+
+/** Resolved Rolldown configuration template + plugins for `--app gjs`. */
+export interface GjsBuildConfig {
+    options: RolldownOptions;
+    plugins: RolldownPluginOption[];
+}
+
+export interface GjsFactoryInput {
+    /** User entry points after CLI / config merging. */
+    input?: RolldownOptions['input'];
+    /** Output `file` or `dir` so `import.meta.url` rewriter knows the bundle path. */
+    output: { file?: string; dir?: string };
+    /** Caller-supplied externals (`gjsify build --external`). */
+    userExternal?: string[];
+    /** User-supplied banner string (may contain a leading `#!shebang`). */
+    userBanner?: string;
+    /** User-supplied resolve.alias overrides. */
+    userAliases?: Record<string, string>;
+    /** Whether to prepend the `#!/usr/bin/env -S gjs -m` shebang. */
+    shebang?: boolean;
+    /** Plugin options forwarded to sub-plugins (deepkit, css, …). */
+    pluginOptions: PluginOptions;
+}
+
+export const setupForGjs = async (input: GjsFactoryInput): Promise<GjsBuildConfig> => {
+    const userExternal = input.userExternal ?? [];
+    // Rolldown's `external` array does not support glob patterns the way
+    // esbuild's did (`gi://*`). We use a function predicate so any
+    // `gi://Foo?version=…` URI matches by prefix and the GJS-built-in
+    // string specifiers stay externalised by name.
+    const exactExternal = ['cairo', 'gettext', 'system', ...userExternal];
+    const external = (id: string): boolean => {
+        if (id.startsWith('gi://')) return true;
+        if (exactExternal.includes(id)) return true;
+        return false;
+    };
+    const format = input.pluginOptions.format ?? 'esm';
+
+    const exclude = input.pluginOptions.exclude ?? [];
+    const entryPoints = await globToEntryPoints(input.input, exclude);
+
+    const aliasMap = {
+        ...getAliasesForGjs({ external }),
+        ...(input.pluginOptions.aliases ?? {}),
+        ...(input.userAliases ?? {}),
+    };
+
+    // The console shim replaces all `console` references with print()/printerr()-
+    // based implementations that bypass GLib.log_structured() — no prefix,
+    // ANSI codes work. Disabled via `pluginOptions.consoleShim === false`.
+    const consoleShimEnabled = input.pluginOptions.consoleShim !== false;
+    const consoleShimPath = consoleShimEnabled
+        ? resolve(_shimDir, '../shims/console-gjs.js')
+        : null;
+
+    // The auto-globals inject stub (when present) is side-effect-imported
+    // via a virtual entry — its register modules write to globalThis, so
+    // the import chain matters but no name binding does. We can't use
+    // Rolldown's `inject` for this because the auto-globals invariant
+    // forbids source-AST rewrites for global identifiers (false positives
+    // from isomorphic guards / bracket access — see AGENTS.md).
+    const sideEffectImports: string[] = [];
+    if (input.pluginOptions.autoGlobalsInject) sideEffectImports.push(input.pluginOptions.autoGlobalsInject);
+
+    const virtualEntries = wrapInputWithSideEffects(entryPoints, sideEffectImports);
+    const finalInput = virtualEntries.input;
+
+    const options: RolldownOptions = {
+        input: finalInput,
+        platform: 'neutral',
+        external,
+        // 'browser' field is needed so packages like create-hash, create-hmac,
+        // randombytes use their pure-JS browser entry instead of index.js
+        // (which does require('crypto') and causes circular dependencies via
+        // the crypto → @gjsify/crypto alias).
+        resolve: {
+            mainFields: format === 'esm' ? ['browser', 'module', 'main'] : ['browser', 'main', 'module'],
+            // ESM: omit 'require' — packages listing 'require' before 'import'
+            // would silently route through their CJS entry.
+            conditionNames: format === 'esm' ? ['browser', 'import'] : ['browser', 'require', 'import'],
+        },
+        transform: {
+            // Compile target: GJS 1.86 / SpiderMonkey 128 ≈ firefox128.
+            target: 'firefox128',
+            define: {
+                global: 'globalThis',
+                window: 'globalThis',
+                'process.env.READABLE_STREAM': '"disable"',
+            },
+            // Console shim: rewrite bare `console` references to a named
+            // import from our shim module. We use Rolldown's `inject`
+            // (Oxc-driven, lives under `transform`) because:
+            //   1. `globalThis.console` is non-configurable on SpiderMonkey
+            //      128 so a register-style global write throws.
+            //   2. We're replacing console unconditionally — there's no
+            //      tree-shake-aware detection concern that motivated the
+            //      auto-globals invariant.
+            ...(consoleShimPath ? { inject: { console: [consoleShimPath, 'console'] } } : {}),
+        },
+        output: {
+            ...input.output,
+            format,
+            minify: false,
+            sourcemap: false,
+            // App builds emit a single bundle file. Disable code-splitting
+            // so dynamic imports get inlined and the entire program lands
+            // in one chunk that matches `gjsify build --outfile foo.js`.
+            // (`codeSplitting: false` replaces the deprecated
+            // `inlineDynamicImports: true` in Rolldown ≥ 1.0-rc.18.)
+            codeSplitting: false,
+        },
+        treeshake: true,
+    };
+
+    const bundleDir = getBundleDirFromOutput(input.output);
+
+    const plugins: RolldownPluginOption[] = [
+        // Virtual-entry plugin runs FIRST so its resolveId/load match the
+        // synthetic input ids that `wrapInputWithSideEffects` produces.
+        ...(virtualEntries.plugin ? [virtualEntries.plugin] : []),
+        // random-access-file's 'browser' field maps to a throwing stub; force
+        // the fs-backed Node entry. Implemented via the gjsify alias plugin
+        // as a direct entry-table override.
+        aliasPlugin({
+            entries: {
+                'random-access-file': 'random-access-file/index.js',
+                ...flattenAliases(aliasMap),
+            },
+        }),
+        blueprintPlugin() as RolldownPluginOption,
+        deepkitPlugin({ reflection: input.pluginOptions.reflection }),
+        cssAsStringPlugin(),
+        nodeModulesPathRewritePlugin({ bundleDir }),
+        processStubPlugin({ userBanner: input.userBanner }),
+        shebangPlugin({ enabled: input.shebang === true, line: GJS_SHEBANG }),
+    ];
+
+    return { options, plugins };
+};
+
+interface VirtualEntriesResult {
+    input: RolldownOptions['input'];
+    plugin: RolldownPluginOption | null;
+}
+
+/**
+ * If there are side-effect imports to land alongside the user's entry,
+ * wrap each entry in a virtual module that imports them first then
+ * re-exports the entry. Returns the rewritten `input` plus the resolveId/load
+ * plugin that resolves the virtual ids.
+ *
+ * Single-input case: `'src/index.ts'` → `'\0gjsify-entry:src/index.ts'`.
+ * Array-input case: each element gets the same wrapper id.
+ * Record-input case: values get wrapped, keys preserved.
+ *
+ * `\0`-prefixed ids are Rollup's convention for synthetic modules — Rolldown
+ * recognises and treats them as not-from-disk, skipping the default loader.
+ */
+function wrapInputWithSideEffects(
+    input: RolldownOptions['input'],
+    sideEffects: string[],
+): VirtualEntriesResult {
+    if (sideEffects.length === 0 || input === undefined) {
+        return { input, plugin: null };
+    }
+
+    const userEntries = new Map<string, string>(); // virtualId → realPath
+    const PREFIX = '\0gjsify-entry:';
+
+    function wrap(realPath: string): string {
+        const id = PREFIX + realPath;
+        userEntries.set(id, realPath);
+        return id;
+    }
+
+    let wrappedInput: RolldownOptions['input'];
+    if (typeof input === 'string') {
+        wrappedInput = wrap(input);
+    } else if (Array.isArray(input)) {
+        wrappedInput = input.map(wrap);
+    } else {
+        const out: Record<string, string> = {};
+        for (const [name, path] of Object.entries(input)) {
+            out[name] = wrap(path);
+        }
+        wrappedInput = out;
+    }
+
+    const sideEffectImports = sideEffects
+        .map((p) => `import ${JSON.stringify(p)};`)
+        .join('\n');
+
+    const plugin: RolldownPluginOption = {
+        name: 'gjsify-virtual-entry',
+        async resolveId(source, importer) {
+            if (source.startsWith(PREFIX)) return source;
+            return null;
+        },
+        async load(id) {
+            if (!id.startsWith(PREFIX)) return null;
+            const realPath = userEntries.get(id);
+            if (!realPath) return null;
+            // Resolve the user-provided entry path through the full
+            // resolver chain so the re-export targets a real on-disk
+            // module — otherwise Rolldown treats `src/foo.ts` as a bare
+            // specifier and emits it as an external import.
+            const resolved = await this.resolve(realPath, undefined, { skipSelf: true });
+            const target = resolved?.id ?? realPath;
+            return {
+                code: `${sideEffectImports}\nexport * from ${JSON.stringify(target)};\n`,
+                moduleSideEffects: true,
+            };
+        },
+    };
+
+    return { input: wrappedInput, plugin };
+}
+
+/**
+ * Flatten the legacy `Record<string, string>` alias map into the
+ * `@rollup/plugin-alias` `entries` array shape, dropping empty values.
+ */
+function flattenAliases(map: Record<string, string>): Record<string, string> {
+    const out: Record<string, string> = {};
+    for (const [from, to] of Object.entries(map)) {
+        if (to) out[from] = to;
+    }
+    return out;
+}

package/src/app/index.ts

@@ -0,0 +1,6 @@
+export { setupForGjs } from './gjs.js';
+export type { GjsBuildConfig, GjsFactoryInput } from './gjs.js';
+export { setupForNode } from './node.js';
+export type { NodeBuildConfig, NodeFactoryInput } from './node.js';
+export { setupForBrowser } from './browser.js';
+export type { BrowserBuildConfig, BrowserFactoryInput } from './browser.js';

package/src/app/node.ts

@@ -0,0 +1,128 @@
+// `--app node` Rolldown configuration factory.
+//
+// Same external set + alias map as the esbuild predecessor. The
+// `createRequire` banner that esbuild needed for ESM-output CJS interop
+// translates to Rolldown's `output.banner` directly — Rolldown itself does
+// not synthesise a `require()` shim for ESM consumers of bundled CJS code.
+
+import { aliasPlugin } from '../plugins/alias.js';
+import type { RolldownOptions, RolldownPluginOption } from 'rolldown';
+
+import { deepkitPlugin } from '@gjsify/rolldown-plugin-deepkit';
+import { EXTERNALS_NODE } from '@gjsify/resolve-npm';
+
+import type { PluginOptions } from '../types/plugin-options.js';
+import { getAliasesForNode } from '../utils/alias.js';
+import { globToEntryPoints } from '../utils/entry-points.js';
+import {
+    nodeModulesPathRewritePlugin,
+    getBundleDirFromOutput,
+} from '../plugins/rewrite-node-modules-paths.js';
+import { cssAsStringPlugin } from '../plugins/css-as-string.js';
+
+export interface NodeBuildConfig {
+    options: RolldownOptions;
+    plugins: RolldownPluginOption[];
+}
+
+export interface NodeFactoryInput {
+    input?: RolldownOptions['input'];
+    output: { file?: string; dir?: string };
+    userExternal?: string[];
+    userAliases?: Record<string, string>;
+    pluginOptions: PluginOptions;
+}
+
+export const setupForNode = async (input: NodeFactoryInput): Promise<NodeBuildConfig> => {
+    const userExternal = input.userExternal ?? [];
+    // node-datachannel is a native C++ addon that cannot be bundled — its
+    // `require('../build/Release/node_datachannel.node')` must resolve at
+    // runtime against the real node_modules tree.
+    //
+    // Note: Rolldown's `external` array does NOT support glob patterns the
+    // way esbuild's did (`gi://*`, `@girs/*`). We use a function predicate
+    // instead so the gi:// URI scheme and the @girs/ namespace are matched
+    // by prefix.
+    const exactExternal = [
+        ...EXTERNALS_NODE as string[],
+        'node-datachannel',
+        ...userExternal,
+    ];
+    const external = (id: string): boolean => {
+        if (id.startsWith('gi://')) return true;
+        if (id.startsWith('@girs/')) return true;
+        if (exactExternal.includes(id)) return true;
+        return false;
+    };
+    const format = input.pluginOptions.format ?? 'esm';
+
+    const exclude = input.pluginOptions.exclude ?? [];
+    const entryPoints = await globToEntryPoints(input.input, exclude);
+
+    const aliasMap = {
+        ...getAliasesForNode({ external }),
+        ...(input.pluginOptions.aliases ?? {}),
+        ...(input.userAliases ?? {}),
+    };
+
+    const bundleDir = getBundleDirFromOutput(input.output);
+
+    // Rolldown's CJS interop wraps bundled CJS via `__commonJSMin` and
+    // routes external Node-builtin `require()` through `__require` —
+    // both injected internally. Unlike esbuild we therefore don't need a
+    // top-of-bundle `const require = createRequire(...)` shim. Keeping
+    // one collides with bundled CJS sources that declare their own
+    // `const require = createRequire(...)` (e.g. yargs's ESM platform
+    // shim) — `SyntaxError: Identifier 'require' has already been
+    // declared`.
+    const banner: string | undefined = undefined;
+
+    const options: RolldownOptions = {
+        input: entryPoints,
+        platform: 'node',
+        external,
+        resolve: {
+            mainFields: format === 'esm' ? ['module', 'main', 'browser'] : ['main', 'module', 'browser'],
+            // CJS-priority conditions for Node bundles. Rolldown uses the first
+            // matching key, so including 'import' would route packages like ws
+            // v8 (whose exports map lists 'import' before 'require') through
+            // their incomplete ESM wrapper.
+            conditionNames: format === 'esm' ? ['require', 'node', 'module'] : ['require'],
+        },
+        transform: {
+            target: 'node24',
+            define: {
+                global: 'globalThis',
+                window: 'globalThis',
+            },
+        },
+        output: {
+            ...input.output,
+            format,
+            minify: false,
+            sourcemap: false,
+            banner,
+            // Single-bundle output. `codeSplitting: false` replaces the
+            // deprecated `inlineDynamicImports: true`.
+            codeSplitting: false,
+        },
+        treeshake: true,
+    };
+
+    const plugins: RolldownPluginOption[] = [
+        aliasPlugin({ entries: flattenAliases(aliasMap) }),
+        deepkitPlugin({ reflection: input.pluginOptions.reflection }),
+        cssAsStringPlugin(),
+        nodeModulesPathRewritePlugin({ bundleDir }),
+    ];
+
+    return { options, plugins };
+};
+
+function flattenAliases(map: Record<string, string>): Record<string, string> {
+    const out: Record<string, string> = {};
+    for (const [from, to] of Object.entries(map)) {
+        if (to) out[from] = to;
+    }
+    return out;
+}

package/src/globals.ts

@@ -0,0 +1,11 @@
+// Public subpath export for the `--globals` CLI support.
+//
+// Consumed by `@gjsify/cli` to resolve the user's explicit `--globals` list
+// (or auto-detect via the iterative multi-pass build) and write the inject
+// stub that the plugin picks up via its `autoGlobalsInject` option. See the
+// "Tree-shakeable Globals" section in AGENTS.md for the architecture.
+
+export { resolveGlobalsList, writeRegisterInjectFile } from './utils/scan-globals.js';
+export { detectFreeGlobals } from './utils/detect-free-globals.js';
+export { detectAutoGlobals } from './utils/auto-globals.js';
+export type { AutoGlobalsResult, DetectAutoGlobalsOptions, AnalysisOptions } from './utils/auto-globals.js';