@gjsify/rolldown-plugin-gjsify 0.3.14

package/lib/plugin.d.ts

@@ -0,0 +1,25 @@
+import type { RolldownOptions, RolldownPluginOption } from 'rolldown';
+import type { PluginOptions } from './types/plugin-options.js';
+export interface GjsifyConfig {
+    options: RolldownOptions;
+    plugins: RolldownPluginOption[];
+}
+export interface GjsifyPluginInput {
+    input?: RolldownOptions['input'];
+    output: {
+        file?: string;
+        dir?: string;
+    };
+    userExternal?: string[];
+    userBanner?: string;
+    userAliases?: Record<string, string>;
+    /** Whether to prepend `#!/usr/bin/env -S gjs -m` to the GJS bundle. */
+    shebang?: boolean;
+}
+/**
+ * Build the Rolldown configuration template + plugin array for the given
+ * pluginOptions. The caller composes the returned `options.plugins` with
+ * its own user plugins and passes the merged options to `rolldown(...)`.
+ */
+export declare const gjsifyPlugin: (input: GjsifyPluginInput, pluginOptions?: PluginOptions) => Promise<GjsifyConfig>;
+export default gjsifyPlugin;

package/lib/plugin.js

@@ -0,0 +1,67 @@
+// `gjsifyPlugin` — orchestrator entry point.
+//
+// Picks the platform-specific factory based on `pluginOptions.app`
+// (or `library` for library mode) and returns the resolved Rolldown
+// configuration. Unlike the esbuild predecessor, this is NOT a single
+// `Plugin` object — it returns a *config bundle* the caller composes into
+// `rolldown(opts)`, because Rolldown does not have esbuild's `setup(build)`
+// hook through which a single plugin can mutate `build.initialOptions`.
+//
+// The CLI consumer (`@gjsify/cli`) calls `gjsifyPlugin(...)` to get back
+// `{ options, plugins }`, then calls `rolldown({ ...options, plugins:
+// [...userPlugins, ...plugins] })`.
+import { setupForGjs, setupForNode, setupForBrowser } from './app/index.js';
+import { setupLib } from './library/index.js';
+/**
+ * Build the Rolldown configuration template + plugin array for the given
+ * pluginOptions. The caller composes the returned `options.plugins` with
+ * its own user plugins and passes the merged options to `rolldown(...)`.
+ */
+export const gjsifyPlugin = async (input, pluginOptions = {}) => {
+    if (pluginOptions.library) {
+        switch (pluginOptions.library) {
+            case 'esm':
+            case 'cjs':
+                return await setupLib({
+                    input: input.input,
+                    output: input.output,
+                    userAliases: input.userAliases,
+                    pluginOptions,
+                });
+            default:
+                throw new TypeError('Unknown library type: ' + pluginOptions.library);
+        }
+    }
+    const app = pluginOptions.app ?? 'gjs';
+    switch (app) {
+        case 'gjs':
+            return await setupForGjs({
+                input: input.input,
+                output: input.output,
+                userExternal: input.userExternal,
+                userBanner: input.userBanner,
+                userAliases: input.userAliases,
+                shebang: input.shebang,
+                pluginOptions,
+            });
+        case 'node':
+            return await setupForNode({
+                input: input.input,
+                output: input.output,
+                userExternal: input.userExternal,
+                userAliases: input.userAliases,
+                pluginOptions,
+            });
+        case 'browser':
+            return await setupForBrowser({
+                input: input.input,
+                output: input.output,
+                userExternal: input.userExternal,
+                userAliases: input.userAliases,
+                pluginOptions,
+            });
+        default:
+            throw new TypeError('Unknown app platform: ' + app);
+    }
+};
+export default gjsifyPlugin;

package/lib/plugins/alias.d.ts

@@ -0,0 +1,5 @@
+import type { Plugin } from 'rolldown';
+export interface AliasPluginOptions {
+    entries: Record<string, string>;
+}
+export declare function aliasPlugin(options: AliasPluginOptions): Plugin;

package/lib/plugins/alias.js

@@ -0,0 +1,45 @@
+// Custom alias plugin — `@rollup/plugin-alias` returns the rewritten
+// specifier as the resolved id, then leaves Rolldown's default resolver to
+// load it. That fails for workspace package targets (`@gjsify/crypto` etc.)
+// when the importer's package.json doesn't list them as direct deps —
+// Rolldown rejects packages that aren't declared in the importer's manifest
+// even when they exist in a hoisted workspace `node_modules`.
+//
+// This plugin instead calls `this.resolve(target, importer, { skipSelf: true })`
+// which goes through the full plugin chain (including any subsequent resolvers)
+// and resolves to a real file path the default loader can read.
+//
+// Behaviour preserved from the esbuild predecessor's `aliasPlugin`:
+//   - exact string match (no prefix-aware semantics needed at this layer)
+//   - `node:<name>` specifiers map to the same target as `<name>`
+//     (handled in the alias-builder helpers, not here).
+export function aliasPlugin(options) {
+    const entries = options.entries;
+    const keys = Object.keys(entries);
+    return {
+        name: 'gjsify-alias',
+        resolveId: {
+            order: 'pre',
+            async handler(source, importer) {
+                if (!Object.prototype.hasOwnProperty.call(entries, source)) {
+                    return null;
+                }
+                const target = entries[source];
+                // Self-reference guard: if a user maps a specifier to itself
+                // (rare but legal), skip to avoid infinite loops.
+                if (target === source)
+                    return null;
+                const resolved = await this.resolve(target, importer, {
+                    skipSelf: true,
+                });
+                if (resolved !== null) {
+                    return resolved;
+                }
+                // Fall through to other resolvers if we couldn't load it
+                // ourselves. `null` from a `pre`-order resolveId lets the
+                // default chain continue.
+                return null;
+            },
+        },
+    };
+}

package/lib/plugins/css-as-string.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from 'rolldown';
+export declare function cssAsStringPlugin(): Plugin;

package/lib/plugins/css-as-string.js

@@ -0,0 +1,34 @@
+// Wrap `.css` imports as JS string default exports.
+//
+// Rolldown's experimental CSS bundling was removed (see
+// https://github.com/rolldown/rolldown/issues/4271) — when the bundler
+// sees a `.css` extension it errors out unless something else loads the
+// file first. We hook into `load` (with a path filter) BEFORE Rolldown's
+// CSS classification fires and emit a JS module whose default export is
+// the CSS source as a string. Consumers can then do:
+//
+//   import css from './app.css';
+//   provider.load_from_string(css);
+//
+// — the canonical pattern for `Gtk.CssProvider` under GJS.
+//
+// `@import` resolution is left to the user / CSS preprocessor. For simple
+// app CSS this is fine; for @import-heavy CSS, run a preprocessor (e.g.
+// sass / postcss) ahead of `gjsify build` so the input file is already
+// flat.
+import { readFile } from 'node:fs/promises';
+export function cssAsStringPlugin() {
+    return {
+        name: 'gjsify-css-as-string',
+        load: {
+            filter: { id: /\.css$/ },
+            async handler(id) {
+                const code = await readFile(id, 'utf8');
+                return {
+                    code: `export default ${JSON.stringify(code)};`,
+                    moduleType: 'js',
+                };
+            },
+        },
+    };
+}

package/lib/plugins/gjs-imports-empty.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from 'rolldown';
+export declare function gjsImportsEmptyPlugin(): Plugin;

package/lib/plugins/gjs-imports-empty.js

@@ -0,0 +1,26 @@
+// For `--app browser`: redirect `@girs/*` and `gi://*` imports to an empty
+// module. These are GJS-specific (GObject introspection bindings / GI
+// protocol) with no browser equivalent. They appear transitively via
+// `@gjsify/unit` and similar packages that have GJS-specific code paths.
+//
+// Marking them external would leave bare specifiers in the bundle that the
+// browser cannot resolve at runtime; instead we resolve them to a virtual
+// empty ESM module so the bundle is self-contained.
+const GJSIMPORTS_VIRTUAL_ID = '\0gjsify-empty-gjs-import';
+export function gjsImportsEmptyPlugin() {
+    return {
+        name: 'gjsify-gjs-imports-empty',
+        resolveId: {
+            order: 'pre',
+            filter: { id: /^(@girs\/|gi:\/\/)/ },
+            handler(_source) {
+                return { id: GJSIMPORTS_VIRTUAL_ID };
+            },
+        },
+        load(id) {
+            if (id !== GJSIMPORTS_VIRTUAL_ID)
+                return null;
+            return { code: 'export {}; export default {};', moduleSideEffects: false };
+        },
+    };
+}

package/lib/plugins/process-stub.d.ts

@@ -0,0 +1,28 @@
+import type { Plugin } from 'rolldown';
+export declare const GJS_PROCESS_STUB: string;
+/**
+ * Compose the GJS process stub with the user-supplied banner so the result
+ * is valid syntax for `gjs -m`. A leading `#!shebang` line in the user
+ * banner is hoisted to byte 0 of the output. Any `#` character that appears
+ * anywhere except byte 0 is a fatal SyntaxError under SpiderMonkey 128+ —
+ * putting our process stub before the user's shebang would break the bundle.
+ *
+ * Output shape:
+ *   [#!shebang\n][<process-stub>\n<rest-of-user-banner>]
+ *
+ * Either side of the bracket may be empty; the result is always concatenated
+ * without leading whitespace.
+ */
+export declare function composeBanner(stub: string, userBanner: string): string;
+/**
+ * Build a Rolldown plugin that injects the GJS process stub as a chunk
+ * banner. Runs with `enforce: 'post'`-equivalent ordering so the stub
+ * lands *after* any user `output.banner` value, except when the user
+ * banner starts with a `#!shebang` line — which is hoisted to byte 0
+ * by `composeBanner`.
+ */
+export interface ProcessStubPluginOptions {
+    /** User-supplied banner string. May contain a leading `#!shebang`. */
+    userBanner?: string;
+}
+export declare function processStubPlugin(options?: ProcessStubPluginOptions): Plugin;

package/lib/plugins/process-stub.js

@@ -0,0 +1,60 @@
+export const GJS_PROCESS_STUB = 'if(typeof globalThis.process==="undefined"){' +
+    'const _s=imports.system,_G=imports.gi.GLib;' +
+    'globalThis.process={' +
+    'platform:"linux",arch:"x64",version:"v20.0.0",' +
+    'env:new Proxy({},{' +
+    'get(_,p){return typeof p==="string"?(_G.getenv(p)??undefined):undefined},' +
+    'set(_,p,v){if(typeof p==="string")_G.setenv(p,String(v),true);return true},' +
+    'has(_,p){return typeof p==="string"&&_G.getenv(p)!==null},' +
+    'deleteProperty(_,p){if(typeof p==="string")_G.unsetenv(p);return true},' +
+    'ownKeys(){return _G.listenv()??[]},' +
+    'getOwnPropertyDescriptor(_,p){const v=_G.getenv(p);return v!==null?{value:v,writable:true,enumerable:true,configurable:true}:undefined}' +
+    '}),' +
+    'argv:_s?.programArgs?["gjs",_s.programInvocationName||"",..._s.programArgs]:["gjs"],' +
+    'versions:{},config:{},' +
+    'cwd(){return _G.get_current_dir()||"/"},' +
+    'exit(c){_s.exit(c??0)},' +
+    'stderr:{write(s){printerr(s)}},stdout:{write(s){print(s)}},stdin:null,' +
+    'exitCode:undefined,' +
+    'nextTick(fn,...a){Promise.resolve().then(()=>fn(...a))},' +
+    'hrtime(t){return t?[0,0]:[0,0]},' +
+    '};' +
+    '}';
+/**
+ * Compose the GJS process stub with the user-supplied banner so the result
+ * is valid syntax for `gjs -m`. A leading `#!shebang` line in the user
+ * banner is hoisted to byte 0 of the output. Any `#` character that appears
+ * anywhere except byte 0 is a fatal SyntaxError under SpiderMonkey 128+ —
+ * putting our process stub before the user's shebang would break the bundle.
+ *
+ * Output shape:
+ *   [#!shebang\n][<process-stub>\n<rest-of-user-banner>]
+ *
+ * Either side of the bracket may be empty; the result is always concatenated
+ * without leading whitespace.
+ */
+export function composeBanner(stub, userBanner) {
+    if (!userBanner)
+        return stub;
+    const shebangMatch = userBanner.match(/^#![^\n]*\n/);
+    if (!shebangMatch) {
+        return stub + '\n' + userBanner;
+    }
+    const shebang = shebangMatch[0];
+    const rest = userBanner.slice(shebang.length);
+    return shebang + stub + (rest ? '\n' + rest : '');
+}
+export function processStubPlugin(options = {}) {
+    const banner = composeBanner(GJS_PROCESS_STUB, options.userBanner ?? '');
+    return {
+        name: 'gjsify-process-stub',
+        renderChunk: {
+            order: 'post',
+            handler(code, chunk) {
+                if (!chunk.isEntry)
+                    return null;
+                return { code: banner + '\n' + code, map: null };
+            },
+        },
+    };
+}

package/lib/plugins/rewrite-node-modules-paths.d.ts

@@ -0,0 +1,38 @@
+import type { Plugin } from 'rolldown';
+export declare const REWRITE_FILTER: RegExp;
+/** True when the rewriter wants to look at this path — node_modules + supported ext. */
+export declare function shouldRewrite(path: string): boolean;
+/**
+ * Compute the directory the bundle's outfile lives in.
+ *
+ * For `import.meta.url` rewriting we emit a relative URL whose base is the
+ * bundle's `import.meta.url` — so we need to know where the bundle will be
+ * written. Both `output.file` and `output.dir` are accepted.
+ */
+export declare function getBundleDirFromOutput(opts: {
+    file?: string;
+    dir?: string;
+}): string;
+export interface RewriteResult {
+    code: string;
+    moduleType?: 'ts' | 'js';
+    map?: null;
+}
+/**
+ * Pure rewriter — same body as the esbuild predecessor. Returns the rewritten
+ * code (and module type for re-parsing) or `null` if the file doesn't reference
+ * any of the patterns we care about.
+ */
+export declare function rewriteContents(args: {
+    path: string;
+}, srcInput: string, bundleDir: string): RewriteResult | null;
+export interface NodeModulesPathRewriteOptions {
+    /** Bundle output directory, derived from `output.file` / `output.dir`. */
+    bundleDir: string;
+}
+/**
+ * Build a Rolldown plugin that runs the path rewriter as a `transform(code, id)`
+ * hook with `order: 'post'` — runs after the deepkit/blueprint/css pre-transforms
+ * but still during module loading, before chunking.
+ */
+export declare function nodeModulesPathRewritePlugin(options: NodeModulesPathRewriteOptions): Plugin;

package/lib/plugins/rewrite-node-modules-paths.js

@@ -0,0 +1,132 @@
+// Per-source rewriter for node_modules files that reference
+// `import.meta.url`, `__dirname`, or `__filename`. Mirrors the esbuild
+// predecessor's logic — body is identical because the rewrite is purely
+// a string transform on already-loaded source. The only delta is the
+// host: a Rolldown `transform(code, id)` plugin instead of an esbuild
+// `onLoad` registered inside the PnP plugin.
+//
+// Why a separate plugin and not nested in the PnP loader, like esbuild?
+// Rolldown / Rollup's `transform` hooks all run in sequence on every
+// loaded module — there is no first-onLoad-wins race. So the PnP loader
+// (`@gjsify/rolldown-plugin-pnp`) is solely responsible for reading
+// zip-resident bytes; this plugin runs as a separate `transform` step
+// after the bytes have been loaded, regardless of which loader produced
+// them. No more F5-bug folklore.
+import { dirname, join, relative, resolve } from 'node:path';
+import { inlineStaticReads } from '../utils/inline-static-reads.js';
+export const REWRITE_FILTER = /\.(m?js|cjs|[cm]?tsx?)$/;
+const DIRNAME_DECL_RE = /(?:var|let|const)\s+__dirname\b|export\s+(?:var|let|const)\s+__dirname\b/;
+const FILENAME_DECL_RE = /(?:var|let|const)\s+__filename\b|export\s+(?:var|let|const)\s+__filename\b/;
+/** True when the rewriter wants to look at this path — node_modules + supported ext. */
+export function shouldRewrite(path) {
+    return path.includes('node_modules') && REWRITE_FILTER.test(path);
+}
+/**
+ * Compute the directory the bundle's outfile lives in.
+ *
+ * For `import.meta.url` rewriting we emit a relative URL whose base is the
+ * bundle's `import.meta.url` — so we need to know where the bundle will be
+ * written. Both `output.file` and `output.dir` are accepted.
+ */
+export function getBundleDirFromOutput(opts) {
+    const outFile = opts.file ?? join(opts.dir ?? '.', 'bundle.mjs');
+    return dirname(resolve(outFile));
+}
+/** Pick the per-file loader Rolldown should re-parse with. */
+function moduleTypeForPath(path) {
+    const ext = path.split('.').pop() ?? 'js';
+    return ['ts', 'mts', 'cts', 'tsx'].includes(ext) ? 'ts' : 'js';
+}
+function buildDirFilenamePreamble(args) {
+    const lines = [];
+    if (args.needDirname && !args.dirnameDeclared) {
+        if (args.kind === 'esm-zip') {
+            lines.push(`var __dirname = new URL(".", import.meta.url).pathname.replace(/\\/$/, "");`);
+        }
+        else if (args.kind === 'esm-relative') {
+            lines.push(`var __dirname = new URL(${JSON.stringify(args.relDirWithSlash)}, import.meta.url).pathname.replace(/\\/$/, "");`);
+        }
+        else {
+            lines.push(`var __dirname = ${JSON.stringify(args.sourceDir)};`);
+        }
+    }
+    if (args.needFilename && !args.filenameDeclared) {
+        if (args.kind === 'esm-zip') {
+            lines.push(`var __filename = new URL(import.meta.url).pathname;`);
+        }
+        else if (args.kind === 'esm-relative') {
+            lines.push(`var __filename = new URL(${JSON.stringify(args.relPath)}, import.meta.url).pathname;`);
+        }
+        else {
+            lines.push(`var __filename = ${JSON.stringify(args.sourcePath)};`);
+        }
+    }
+    return lines;
+}
+/**
+ * Pure rewriter — same body as the esbuild predecessor. Returns the rewritten
+ * code (and module type for re-parsing) or `null` if the file doesn't reference
+ * any of the patterns we care about.
+ */
+export function rewriteContents(args, srcInput, bundleDir) {
+    if (!shouldRewrite(args.path))
+        return null;
+    // Step 1: inline statically-resolvable filesystem reads.
+    const inlined = inlineStaticReads(srcInput, args.path);
+    const src = inlined.contents;
+    const hasMetaUrl = src.includes('import.meta.url');
+    const hasDirname = src.includes('__dirname');
+    const hasFilename = src.includes('__filename');
+    if (!hasMetaUrl && !hasDirname && !hasFilename) {
+        if (inlined.inlined === 0)
+            return null;
+        return { code: src, moduleType: moduleTypeForPath(args.path) };
+    }
+    // Step 2: classify rewrite kind.
+    const dir = dirname(args.path);
+    const relPath = hasMetaUrl ? relative(bundleDir, args.path) : '';
+    const isZipResident = hasMetaUrl && relPath.includes('.zip/');
+    const kind = !hasMetaUrl ? 'cjs-absolute' : isZipResident ? 'esm-zip' : 'esm-relative';
+    const preamble = buildDirFilenamePreamble({
+        needDirname: hasDirname,
+        needFilename: hasFilename,
+        dirnameDeclared: DIRNAME_DECL_RE.test(src),
+        filenameDeclared: FILENAME_DECL_RE.test(src),
+        kind,
+        sourcePath: args.path,
+        sourceDir: dir,
+        relPath,
+        relDirWithSlash: (relative(bundleDir, dir) || '.') + '/',
+    });
+    // Step 3: rewrite import.meta.url for the regular esm-relative case.
+    let code = src;
+    if (kind === 'esm-relative') {
+        const runtimeFileUrl = `new URL(${JSON.stringify(relPath)}, import.meta.url)`;
+        code = code.replace(/\bimport\.meta\.url\b/g, `${runtimeFileUrl}.href`);
+    }
+    if (preamble.length > 0)
+        code = preamble.join('\n') + '\n' + code;
+    return { code, moduleType: moduleTypeForPath(args.path) };
+}
+/**
+ * Build a Rolldown plugin that runs the path rewriter as a `transform(code, id)`
+ * hook with `order: 'post'` — runs after the deepkit/blueprint/css pre-transforms
+ * but still during module loading, before chunking.
+ */
+export function nodeModulesPathRewritePlugin(options) {
+    return {
+        name: 'gjsify-node-modules-path-rewrite',
+        transform: {
+            order: 'post',
+            filter: { id: REWRITE_FILTER },
+            handler(code, id) {
+                if (!id.includes('node_modules'))
+                    return null;
+                const result = rewriteContents({ path: id }, code, options.bundleDir);
+                if (!result)
+                    return null;
+                return { code: result.code, map: null };
+            },
+        },
+    };
+}

package/lib/plugins/shebang.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from 'rolldown';
+export declare const GJS_SHEBANG = "#!/usr/bin/env -S gjs -m";
+export interface ShebangPluginOptions {
+    enabled?: boolean;
+    /** Override the shebang line. Defaults to `GJS_SHEBANG`. */
+    line?: string;
+}
+export declare function shebangPlugin(options?: ShebangPluginOptions): Plugin | null;

package/lib/plugins/shebang.js

@@ -0,0 +1,26 @@
+// Inject a `#!/usr/bin/env -S gjs -m` shebang at byte 0 of entry chunks.
+//
+// Rolldown's `output.banner` would also work, but a renderChunk hook with
+// `order: 'post'` makes ordering declarative — the shebang lands AFTER all
+// other banner / process-stub plugins have run, which is required because
+// the `#` character is only valid as the very first byte of the file under
+// SpiderMonkey 128+.
+export const GJS_SHEBANG = '#!/usr/bin/env -S gjs -m';
+export function shebangPlugin(options = {}) {
+    if (!options.enabled)
+        return null;
+    const line = options.line ?? GJS_SHEBANG;
+    return {
+        name: 'gjsify-shebang',
+        renderChunk: {
+            order: 'post',
+            handler(code, chunk) {
+                if (!chunk.isEntry)
+                    return null;
+                if (code.startsWith('#!'))
+                    return null;
+                return { code: line + '\n' + code, map: null };
+            },
+        },
+    };
+}

package/lib/shims/console-gjs.d.ts

@@ -0,0 +1,24 @@
+export declare const console: {
+    log: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    dir: (obj: unknown, options?: object) => void;
+    dirxml: (...args: unknown[]) => void;
+    table: (data: unknown, properties?: string[]) => void;
+    time: (label?: string) => void;
+    timeEnd: (label?: string) => void;
+    timeLog: (label?: string, ...args: unknown[]) => void;
+    trace: (...args: unknown[]) => void;
+    assert: (value: unknown, ...args: unknown[]) => void;
+    clear: () => void;
+    count: (label?: string) => void;
+    countReset: (label?: string) => void;
+    group: (...args: unknown[]) => void;
+    groupCollapsed: (...args: unknown[]) => void;
+    groupEnd: () => void;
+    profile: (_label?: string) => void;
+    profileEnd: (_label?: string) => void;
+    timeStamp: (_label?: string) => void;
+};

package/lib/shims/console-gjs.js

@@ -0,0 +1,24 @@
+// GJS console shim — bundled into GJS user builds via Rolldown's `inject`.
+// Uses print()/printerr() on GJS, bypassing GLib.log_structured() — no
+// `Gjs-Console-Message:` prefix, ANSI escapes work, output goes to
+// stdout/stderr instead of GLib's logging stream.
+//
+// `@gjsify/console` is resolved by the user's `gjsify build` Rolldown
+// run, NOT by tsc here. The bare specifier survives compilation and only
+// gets followed at user-build time, where the CLI's `@gjsify/node-polyfills`
+// dep tree has the package. tsc on this package would otherwise need the
+// `@gjsify/console` lib to be pre-built (build-order coupling).
+//
+// We can't reassign `globalThis.console` on SpiderMonkey 128 — the
+// property is non-configurable. Rolldown's `inject` option rewrites bare
+// `console` references to a named import from this shim instead, leaving
+// `globalThis.console` untouched and routing user `console.log(…)` calls
+// through our object.
+// @ts-ignore — resolved by Rolldown at user-build time, not by tsc here.
+import { log, info, debug, warn, error, dir, dirxml, table, time, timeEnd, timeLog, trace, assert, clear, count, countReset, group, groupCollapsed, groupEnd, profile, profileEnd, timeStamp } from '@gjsify/console';
+export const console = {
+    log, info, debug, warn, error, dir, dirxml, table,
+    time, timeEnd, timeLog, trace, assert, clear,
+    count, countReset, group, groupCollapsed, groupEnd,
+    profile, profileEnd, timeStamp,
+};

package/lib/types/app.d.ts

@@ -0,0 +1 @@
+export type App = 'gjs' | 'node' | 'browser';

package/lib/types/app.js

@@ -0,0 +1 @@
+export {};

package/lib/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './app.js';
+export * from './resolve-alias-options.js';
+export * from './plugin-options.js';

package/lib/types/index.js

@@ -0,0 +1,3 @@
+export * from './app.js';
+export * from './resolve-alias-options.js';
+export * from './plugin-options.js';

package/lib/types/plugin-options.d.ts

@@ -0,0 +1,46 @@
+import type { App } from './app.js';
+/** CSS handling forwarded to Rolldown / Lightning CSS. */
+export interface GjsifyCssOptions {
+    /** Browserslist-compatible target list. Defaults to `['firefox60']` for `--app gjs`. */
+    target?: string[];
+    /** Whether to minify the emitted CSS. Defaults to bundle-level `minify`. */
+    minify?: boolean;
+}
+export interface PluginOptions {
+    debug?: boolean;
+    app?: App;
+    aliases?: Record<string, string>;
+    /** Glob patterns to exclude when expanding entry points. */
+    exclude?: string[];
+    jsExtension?: string;
+    /** Override the bundle output format. */
+    format?: 'esm' | 'cjs';
+    /**
+     * Library mode — `'esm' | 'cjs'`. When set, the plugin emits an
+     * unbundled multi-entry library suitable for republication on npm
+     * rather than a single application bundle.
+     */
+    library?: 'esm' | 'cjs';
+    /**
+     * Inject a console shim into GJS builds that uses print()/printerr() instead
+     * of `GLib.log_structured()`. Removes the "Gjs-Console-Message:" prefix and
+     * lets the terminal interpret ANSI escape codes correctly. Only applies to
+     * `--app gjs`. Defaults to `true`.
+     */
+    consoleShim?: boolean;
+    /** Enable Deepkit TypeScript reflection. Defaults to `false`. */
+    reflection?: boolean;
+    /** CSS pipeline options forwarded to the Rolldown / Lightning CSS layer. */
+    css?: GjsifyCssOptions;
+    /**
+     * Path to a pre-computed globals stub file. The stub is an ESM file
+     * containing one `import '<pkg>/register';` per entry from the user's
+     * `--globals` CLI flag. When set, the plugin appends the stub path to
+     * Rolldown's inject list alongside the console shim.
+     *
+     * The plugin does no scanning or inference at this layer — the CLI is the
+     * sole source of truth for which `/register` modules get included. Only
+     * applies to `--app gjs`.
+     */
+    autoGlobalsInject?: string;
+}

package/lib/types/plugin-options.js

@@ -0,0 +1 @@
+export {};

package/lib/types/resolve-alias-options.d.ts

@@ -0,0 +1,2 @@
+export interface ResolveAliasOptions {
+}

package/lib/types/resolve-alias-options.js

@@ -0,0 +1 @@
+export {};

package/lib/utils/alias.d.ts

@@ -0,0 +1,12 @@
+import type { ResolveAliasOptions } from '../types/index.js';
+export declare const setNodeAliasPrefix: (ALIASES: Record<string, string>) => Record<string, string>;
+export declare const getAliasesForGjs: (options: ResolveAliasOptions) => {
+    [x: string]: string;
+};
+export declare const getAliasesForNode: (options: ResolveAliasOptions) => {
+    [x: string]: string;
+};
+/** Array of Node.js build in module names (also with node: prefix) */
+export declare const externalNode: string[];
+/** Array of NPM module names for which we have our own implementation */
+export declare const externalNPM: string[];