@gjsify/rolldown-plugin-gjsify 0.3.14

package/lib/app/browser.d.ts

@@ -0,0 +1,17 @@
+import type { RolldownOptions, RolldownPluginOption } from 'rolldown';
+import type { PluginOptions } from '../types/plugin-options.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 declare const setupForBrowser: (input: BrowserFactoryInput) => Promise<BrowserBuildConfig>;

package/lib/app/browser.js

@@ -0,0 +1,77 @@
+// `--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 { deepkitPlugin } from '@gjsify/rolldown-plugin-deepkit';
+import blueprintPlugin from '@gjsify/vite-plugin-blueprint';
+import { globToEntryPoints } from '../utils/entry-points.js';
+import { gjsImportsEmptyPlugin } from '../plugins/gjs-imports-empty.js';
+import { cssAsStringPlugin } from '../plugins/css-as-string.js';
+export const setupForBrowser = async (input) => {
+    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 = {
+        process: '@gjsify/empty',
+        'node:process': '@gjsify/empty',
+        assert: '@gjsify/assert',
+        'node:assert': '@gjsify/assert',
+    };
+    const aliasMap = {
+        ...browserPolyfillAliases,
+        ...(input.pluginOptions.aliases ?? {}),
+        ...(input.userAliases ?? {}),
+    };
+    const options = {
+        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 = [
+        gjsImportsEmptyPlugin(),
+        aliasPlugin({ entries: flattenAliases(aliasMap) }),
+        blueprintPlugin(),
+        deepkitPlugin({ reflection: input.pluginOptions.reflection }),
+        cssAsStringPlugin(),
+    ];
+    return { options, plugins };
+};
+function flattenAliases(map) {
+    const out = {};
+    for (const [from, to] of Object.entries(map)) {
+        if (to)
+            out[from] = to;
+    }
+    return out;
+}

package/lib/app/gjs.d.ts

@@ -0,0 +1,27 @@
+import type { RolldownOptions, RolldownPluginOption } from 'rolldown';
+import type { PluginOptions } from '../types/plugin-options.js';
+/** 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 declare const setupForGjs: (input: GjsFactoryInput) => Promise<GjsBuildConfig>;

package/lib/app/gjs.js

@@ -0,0 +1,211 @@
+// `--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 { aliasPlugin } from '../plugins/alias.js';
+import { deepkitPlugin } from '@gjsify/rolldown-plugin-deepkit';
+import blueprintPlugin from '@gjsify/vite-plugin-blueprint';
+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));
+export const setupForGjs = async (input) => {
+    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) => {
+        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 = [];
+    if (input.pluginOptions.autoGlobalsInject)
+        sideEffectImports.push(input.pluginOptions.autoGlobalsInject);
+    const virtualEntries = wrapInputWithSideEffects(entryPoints, sideEffectImports);
+    const finalInput = virtualEntries.input;
+    const options = {
+        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 = [
+        // 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(),
+        deepkitPlugin({ reflection: input.pluginOptions.reflection }),
+        cssAsStringPlugin(),
+        nodeModulesPathRewritePlugin({ bundleDir }),
+        processStubPlugin({ userBanner: input.userBanner }),
+        shebangPlugin({ enabled: input.shebang === true, line: GJS_SHEBANG }),
+    ];
+    return { options, plugins };
+};
+/**
+ * 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, sideEffects) {
+    if (sideEffects.length === 0 || input === undefined) {
+        return { input, plugin: null };
+    }
+    const userEntries = new Map(); // virtualId → realPath
+    const PREFIX = '\0gjsify-entry:';
+    function wrap(realPath) {
+        const id = PREFIX + realPath;
+        userEntries.set(id, realPath);
+        return id;
+    }
+    let wrappedInput;
+    if (typeof input === 'string') {
+        wrappedInput = wrap(input);
+    }
+    else if (Array.isArray(input)) {
+        wrappedInput = input.map(wrap);
+    }
+    else {
+        const out = {};
+        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 = {
+        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) {
+    const out = {};
+    for (const [from, to] of Object.entries(map)) {
+        if (to)
+            out[from] = to;
+    }
+    return out;
+}

package/lib/app/index.d.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/lib/app/index.js

@@ -0,0 +1,3 @@
+export { setupForGjs } from './gjs.js';
+export { setupForNode } from './node.js';
+export { setupForBrowser } from './browser.js';

package/lib/app/node.d.ts

@@ -0,0 +1,17 @@
+import type { RolldownOptions, RolldownPluginOption } from 'rolldown';
+import type { PluginOptions } from '../types/plugin-options.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 declare const setupForNode: (input: NodeFactoryInput) => Promise<NodeBuildConfig>;

package/lib/app/node.js

@@ -0,0 +1,102 @@
+// `--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 { deepkitPlugin } from '@gjsify/rolldown-plugin-deepkit';
+import { EXTERNALS_NODE } from '@gjsify/resolve-npm';
+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 const setupForNode = async (input) => {
+    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,
+        'node-datachannel',
+        ...userExternal,
+    ];
+    const external = (id) => {
+        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 = undefined;
+    const options = {
+        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 = [
+        aliasPlugin({ entries: flattenAliases(aliasMap) }),
+        deepkitPlugin({ reflection: input.pluginOptions.reflection }),
+        cssAsStringPlugin(),
+        nodeModulesPathRewritePlugin({ bundleDir }),
+    ];
+    return { options, plugins };
+};
+function flattenAliases(map) {
+    const out = {};
+    for (const [from, to] of Object.entries(map)) {
+        if (to)
+            out[from] = to;
+    }
+    return out;
+}

package/lib/globals.d.ts

@@ -0,0 +1,4 @@
+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';

package/lib/globals.js

@@ -0,0 +1,9 @@
+// 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';

package/lib/index.d.ts

@@ -0,0 +1,17 @@
+export * from './types/index.js';
+export * from './utils/index.js';
+export * from './app/index.js';
+export * from './library/index.js';
+export { REWRITE_FILTER, getBundleDirFromOutput, rewriteContents, shouldRewrite, nodeModulesPathRewritePlugin, } from './plugins/rewrite-node-modules-paths.js';
+export type { NodeModulesPathRewriteOptions, RewriteResult, } from './plugins/rewrite-node-modules-paths.js';
+export { processStubPlugin, GJS_PROCESS_STUB, composeBanner } from './plugins/process-stub.js';
+export type { ProcessStubPluginOptions } from './plugins/process-stub.js';
+export { cssAsStringPlugin } from './plugins/css-as-string.js';
+export { shebangPlugin, GJS_SHEBANG } from './plugins/shebang.js';
+export type { ShebangPluginOptions } from './plugins/shebang.js';
+export { gjsImportsEmptyPlugin } from './plugins/gjs-imports-empty.js';
+export * from './plugin.js';
+import { gjsifyPlugin } from './plugin.js';
+export { gjsifyPlugin };
+export default gjsifyPlugin;
+export * from '@gjsify/resolve-npm';

package/lib/index.js

@@ -0,0 +1,15 @@
+// Public re-exports for `@gjsify/rolldown-plugin-gjsify`.
+export * from './types/index.js';
+export * from './utils/index.js';
+export * from './app/index.js';
+export * from './library/index.js';
+export { REWRITE_FILTER, getBundleDirFromOutput, rewriteContents, shouldRewrite, nodeModulesPathRewritePlugin, } from './plugins/rewrite-node-modules-paths.js';
+export { processStubPlugin, GJS_PROCESS_STUB, composeBanner } from './plugins/process-stub.js';
+export { cssAsStringPlugin } from './plugins/css-as-string.js';
+export { shebangPlugin, GJS_SHEBANG } from './plugins/shebang.js';
+export { gjsImportsEmptyPlugin } from './plugins/gjs-imports-empty.js';
+export * from './plugin.js';
+import { gjsifyPlugin } from './plugin.js';
+export { gjsifyPlugin };
+export default gjsifyPlugin;
+export * from '@gjsify/resolve-npm';

package/lib/library/index.d.ts

@@ -0,0 +1,2 @@
+export { setupLib } from './lib.js';
+export type { LibBuildConfig, LibFactoryInput } from './lib.js';

package/lib/library/index.js

@@ -0,0 +1 @@
+export { setupLib } from './lib.js';

package/lib/library/lib.d.ts

@@ -0,0 +1,16 @@
+import type { RolldownOptions, RolldownPluginOption } from 'rolldown';
+import type { PluginOptions } from '../types/plugin-options.js';
+export interface LibBuildConfig {
+    options: RolldownOptions;
+    plugins: RolldownPluginOption[];
+}
+export interface LibFactoryInput {
+    input?: RolldownOptions['input'];
+    output: {
+        file?: string;
+        dir?: string;
+    };
+    userAliases?: Record<string, string>;
+    pluginOptions: PluginOptions;
+}
+export declare const setupLib: (input: LibFactoryInput) => Promise<LibBuildConfig>;

package/lib/library/lib.js

@@ -0,0 +1,118 @@
+// Library mode — multi-entry, unbundled output for republication on npm.
+//
+// Equivalent to esbuild's `bundle: false`: every input file is emitted
+// 1:1 with its imports preserved as-is (resolved by Rolldown). The user
+// alias map is applied so `node:fs` → `fs/promises` style remappings still
+// work, and the JS extension table mirrors the esbuild predecessor.
+//
+// Targeting `esnext` and `platform: 'neutral'` matches the original
+// library config: consumers downstream (downstream apps using `gjsify
+// build --app gjs|node|browser`) re-bundle and apply their own target
+// lowering. Library output stays maximally portable.
+import { aliasPlugin } from '../plugins/alias.js';
+import { cssAsStringPlugin } from '../plugins/css-as-string.js';
+import { globToEntryPoints } from '../utils/entry-points.js';
+export const setupLib = async (input) => {
+    // Derive output format from `library: 'esm' | 'cjs'` when the caller
+    // didn't pass `format` explicitly. The library type and the emitted
+    // module format are inseparable: a CJS-library build that emits ESM
+    // (or vice versa) is broken by definition.
+    const format = input.pluginOptions.format ?? input.pluginOptions.library ?? 'esm';
+    const exclude = input.pluginOptions.exclude ?? [];
+    const entryPoints = await globToEntryPoints(input.input, exclude);
+    // Derive `preserveModulesRoot` from the common ancestor of every
+    // resolved entry. Workspaces use various roots (`src/`, `src/ts/`,
+    // `lib/`); without stripping the right one, Rolldown emits paths
+    // like `lib/esm/<root>/<file>.js` instead of `lib/esm/<file>.js`,
+    // which doesn't match the package.json `exports` map.
+    const preserveModulesRoot = computeCommonRoot(entryPoints);
+    const aliasMap = {
+        ...(input.pluginOptions.aliases ?? {}),
+        ...(input.userAliases ?? {}),
+    };
+    // Library mode keeps all third-party / workspace imports as-is so the
+    // emitted package re-exports its dep tree by reference. Rolldown's
+    // default behaviour would inline workspace packages into the output
+    // directory; we mark anything not starting with `./` or `/` as external.
+    const external = (id) => {
+        if (id.startsWith('./') || id.startsWith('../') || id.startsWith('/'))
+            return false;
+        return true;
+    };
+    const options = {
+        input: entryPoints,
+        platform: 'neutral',
+        external,
+        resolve: {
+            mainFields: format === 'esm' ? ['module', 'main'] : ['main'],
+            conditionNames: format === 'esm' ? ['module', 'import'] : ['require'],
+        },
+        transform: { target: 'esnext' },
+        output: {
+            ...input.output,
+            format,
+            // Library mode = preserve module structure (multi-file output,
+            // imports resolved but not bundled).
+            preserveModules: true,
+            // Strip the source root from the emitted paths. Without this,
+            // Rolldown keeps the full project-relative path. The root is
+            // computed from the common ancestor of resolved entries.
+            preserveModulesRoot,
+            minify: false,
+            sourcemap: false,
+        },
+        treeshake: false,
+    };
+    const plugins = [
+        aliasPlugin({ entries: flattenAliases(aliasMap) }),
+        // Rolldown removed experimental CSS bundling — `.css` files would
+        // error at the bundler level. Library-mode packages that bundle
+        // CSS as a string (e.g. `@gjsify/adwaita-fonts/index.css`) need
+        // the same `load` hook the app factories install. The result is a
+        // tiny JS module re-exporting the CSS source, which preserveModules
+        // emits 1:1.
+        cssAsStringPlugin(),
+    ];
+    return { options, plugins };
+};
+/**
+ * Compute the common-ancestor directory of a set of entry paths so
+ * Rolldown's `preserveModulesRoot` strips the right prefix from emitted
+ * file paths. Falls back to `'src'` when there are no entries or the
+ * entries don't share a meaningful prefix.
+ */
+function computeCommonRoot(entries) {
+    const paths = entries === undefined
+        ? []
+        : typeof entries === 'string'
+            ? [entries]
+            : Array.isArray(entries)
+                ? entries
+                : Object.values(entries);
+    if (paths.length === 0)
+        return 'src';
+    const split = paths.map((p) => p.split('/').filter(Boolean));
+    const head = split[0];
+    let i = 0;
+    for (; i < head.length; i++) {
+        const seg = head[i];
+        if (!split.every((parts) => parts[i] === seg))
+            break;
+    }
+    if (i === 0)
+        return 'src';
+    // Drop the basename if the common prefix points at a single file.
+    const commonParts = head.slice(0, i);
+    // Heuristic: treat the prefix as a directory when at least one path
+    // has more segments after it.
+    const hasMoreAfter = split.some((parts) => parts.length > i);
+    return hasMoreAfter ? commonParts.join('/') : commonParts.slice(0, -1).join('/') || 'src';
+}
+function flattenAliases(map) {
+    const out = {};
+    for (const [from, to] of Object.entries(map)) {
+        if (to)
+            out[from] = to;
+    }
+    return out;
+}