@gjsify/rolldown-plugin-gjsify 0.4.0 → 0.4.3

package/src/utils/auto-globals.ts

@@ -1,321 +0,0 @@
-// Iterative multi-pass build orchestrator for `--globals auto`.
-//
-// Architecturally identical to the esbuild predecessor — only the inner
-// build call swaps `esbuild.build()` for `rolldown()`. The "after
-// tree-shaking" analysis property is bundler-agnostic and load-bearing
-// per AGENTS.md "Tree-shakeability invariants — permanent". See the
-// rationale block at the top of `detect-free-globals.ts`.
-//
-// Pass 1: rolldown() with no globals injection
-//         → in-memory bundle parsed by acorn for free globals
-// Pass 2: rolldown() with detected globals injected
-//         → some injected register modules pull in MORE code that
-//           references additional globals (tree-shaking dependency cycle)
-// Pass N: repeat until the detected set converges (typically 2–3 iterations,
-//         capped at MAX_ITERATIONS=5)
-//
-// We deliberately do NOT minify the analysis builds: minification can
-// alias `globalThis` to a short variable and defeat MemberExpression
-// detection in detect-free-globals.ts.
-
-import type { InputOptions, RolldownPluginOption, TransformOptions } from 'rolldown';
-
-/**
- * In-memory bundle function — returns the per-entry chunk code strings.
- * Implementations: npm rolldown (Node default), `@gjsify/rolldown-native`
- * (GJS). Pulled out so auto-globals can run under either engine without
- * hardcoding npm rolldown (which can't load under GJS — the Rust prebuild's
- * init code uses `require('node:fs')` synchronously).
- *
- * The default impl below dynamically imports npm rolldown; the CLI
- * overrides this from `actions/build.ts` to route via the same engine the
- * final build uses.
- */
-export type AnalysisBundler = (input: {
-    rolldownInput: InputOptions;
-    format: 'esm' | 'cjs' | 'iife';
-}) => Promise<string[]>;
-
-const defaultBundler: AnalysisBundler = async ({ rolldownInput, format }) => {
-    // Indirect specifier so the GJS bundle doesn't pull npm rolldown in
-    // statically. Only reached when the caller doesn't override (Node).
-    const specifier = 'rolldown';
-    const mod = (await import(/* @vite-ignore */ specifier)) as typeof import('rolldown');
-    const build = await mod.rolldown(rolldownInput);
-    try {
-        const result = await build.generate({ format, minify: false, sourcemap: false });
-        const codes: string[] = [];
-        for (const entry of result.output) {
-            if (entry.type === 'chunk') codes.push(entry.code);
-        }
-        return codes;
-    } finally {
-        await build.close();
-    }
-};
-import { detectFreeGlobals } from './detect-free-globals.js';
-import { resolveGlobalsList, writeRegisterInjectFile } from './scan-globals.js';
-import { GJS_GLOBALS_MAP } from '@gjsify/resolve-npm/globals-map';
-import type { PluginOptions } from '../types/plugin-options.js';
-
-const GLOBALS_MAP: Record<string, string> = GJS_GLOBALS_MAP;
-
-/** Maximum iterations to prevent runaway loops on pathological inputs. */
-const MAX_ITERATIONS = 5;
-
-export interface AutoGlobalsResult {
-    /** Global identifiers detected in the bundle */
-    detected: Set<string>;
-    /** Path to the generated inject stub, or undefined if no globals needed */
-    injectPath: string | undefined;
-}
-
-function setsEqual(a: Set<string>, b: Set<string>): boolean {
-    if (a.size !== b.size) return false;
-    for (const x of a) if (!b.has(x)) return false;
-    return true;
-}
-
-async function applyExcludeGlobals(
-    detected: Set<string>,
-    currentInject: string | undefined,
-    extraRegisterPaths: Set<string>,
-    excludeGlobals: string[] | undefined,
-): Promise<AutoGlobalsResult> {
-    if (!excludeGlobals?.length) return { detected, injectPath: currentInject };
-
-    for (const id of excludeGlobals) detected.delete(id);
-    const filtered = detectedToRegisterPaths(detected);
-    for (const p of extraRegisterPaths) filtered.add(p);
-    const injectPath = filtered.size > 0 ? (await writeRegisterInjectFile(filtered)) ?? undefined : undefined;
-    return { detected, injectPath };
-}
-
-function detectedToRegisterPaths(detected: Set<string>): Set<string> {
-    const paths = new Set<string>();
-    for (const name of detected) {
-        const path = GLOBALS_MAP[name];
-        if (path) paths.add(path);
-    }
-    return paths;
-}
-
-export interface DetectAutoGlobalsOptions {
-    /**
-     * Extra explicit identifiers (or group aliases like `dom`/`web`/`node`)
-     * that should always be injected, in addition to whatever the iterative
-     * detection finds. Used by `--globals auto,<extras>` for cases where
-     * the detector cannot statically see a global because it's accessed via
-     * indirection (e.g. Excalibur's `BrowserComponent.nativeComponent.matchMedia`).
-     */
-    extraGlobalsList?: string;
-    /**
-     * Identifiers to remove from the auto-detected set before writing the
-     * inject stub. Useful for globals that appear as false positives from
-     * dead browser-compat code in npm dependencies whose polyfills require
-     * unavailable native libraries.
-     */
-    excludeGlobals?: string[];
-}
-
-/**
- * Build options accepted by the analyser. A subset of Rolldown's
- * `InputOptions` plus the `output` shape used by `RolldownBuild.generate`.
- *
- * The caller passes the same input + output options it would use for the
- * final build (input, plugins, external, define, …). We strip output-side
- * fields that would force a write-to-disk and replace them with in-memory
- * settings.
- */
-export interface AnalysisOptions {
-    input: InputOptions['input'];
-    plugins?: RolldownPluginOption[];
-    external?: InputOptions['external'];
-    resolve?: InputOptions['resolve'];
-    /**
-     * Pass-through to Rolldown's `transform` (Oxc-driven) — `define`,
-     * `dropLabels`, `treeShake`, etc. live here in Rolldown's shape.
-     */
-    transform?: TransformOptions;
-    /** Format for the analysis bundle output. Use 'esm' to match the final build. */
-    format?: 'esm' | 'cjs' | 'iife';
-}
-
-/**
- * Build a `gjsifyPlugin` for the analyser to insert into the plugin array.
- * Late-imported via dynamic `await import()` to break the cyclic dep
- * between this file and `../plugin.ts`.
- */
-type GjsifyPluginFactory = (
-    options: PluginOptions,
-) => RolldownPluginOption | Promise<RolldownPluginOption>;
-
-/**
- * Run an iterative Rolldown build (in-memory) with acorn-based global
- * detection. Each pass uses the globals discovered by the previous pass,
- * stopping once the detected set is stable (fixpoint reached).
- *
- * Returns the inject stub path that the caller should pass to the
- * final (real) build via `pluginOptions.autoGlobalsInject`.
- *
- * @param analysisOptions Rolldown input options for the in-memory build.
- * @param pluginOptions Gjsify plugin options (without `autoGlobalsInject`,
- *   which this function computes).
- * @param gjsifyPluginFactory Factory returning the gjsify plugin instance
- *   for a given set of plugin options. Provided by the caller to avoid a
- *   cyclic import between this module and `../plugin.ts`.
- * @param verbose Emit per-iteration debug output to console.
- * @param options Optional `extraGlobalsList` / `excludeGlobals`.
- */
-export async function detectAutoGlobals(
-    analysisOptions: AnalysisOptions,
-    pluginOptions: Omit<PluginOptions, 'autoGlobalsInject'>,
-    gjsifyPluginFactory: GjsifyPluginFactory,
-    verbose?: boolean,
-    options: DetectAutoGlobalsOptions = {},
-    bundler: AnalysisBundler = defaultBundler,
-): Promise<AutoGlobalsResult> {
-    const extraRegisterPaths = options.extraGlobalsList
-        ? resolveGlobalsList(options.extraGlobalsList)
-        : new Set<string>();
-
-    const excludeSet = new Set(options.excludeGlobals ?? []);
-
-    let detected = new Set<string>();
-    let currentInject: string | undefined = undefined;
-
-    if (extraRegisterPaths.size > 0) {
-        currentInject = (await writeRegisterInjectFile(extraRegisterPaths)) ?? undefined;
-    }
-
-    // Caller-provided plugins (e.g. PnP relay) survive every pass; the
-    // gjsify plugin appended last so its hooks run after any custom
-    // resolvers / loaders.
-    const callerPlugins = (analysisOptions.plugins ?? []).filter((p) => {
-        const name = p && typeof p === 'object' && 'name' in p ? p.name : undefined;
-        return name !== 'gjsify' && name !== 'gjsify-orchestrator';
-    });
-
-    for (let iteration = 1; iteration <= MAX_ITERATIONS; iteration++) {
-        const gjsifyInstance = await gjsifyPluginFactory({
-            ...pluginOptions,
-            autoGlobalsInject: currentInject,
-        } as PluginOptions);
-
-        // The auto-globals inject stub is a side-effect-only ESM file that
-        // imports `<pkg>/register/<feature>` paths. Rolldown's `transform.inject`
-        // is the source-AST per-identifier rewrite we MUST NOT use (see
-        // AGENTS.md "Tree-shakeability invariants"). Instead, when the
-        // analyser has produced an inject path, append it as an additional
-        // entry — Rolldown bundles its side effects into the output and the
-        // detector sees the resulting identifier references.
-        const inputWithInject = currentInject
-            ? appendInjectAsEntry(analysisOptions.input, currentInject)
-            : analysisOptions.input;
-
-        const chunkCodes = await bundler({
-            rolldownInput: {
-                input: inputWithInject,
-                external: analysisOptions.external,
-                resolve: analysisOptions.resolve,
-                transform: analysisOptions.transform,
-                plugins: [...callerPlugins, gjsifyInstance],
-                logLevel: 'silent',
-            },
-            format: analysisOptions.format ?? 'esm',
-        });
-
-        if (chunkCodes.length === 0) {
-            return { detected: new Set(), injectPath: currentInject };
-        }
-
-        // Parse each chunk independently and union the detected sets.
-        // Rolldown emits one chunk per entry — concatenating them would
-        // produce a syntactically invalid combined program (duplicate
-        // top-level declarations: `File`, `Buffer`, …) that acorn can't
-        // parse. Per-chunk parsing keeps each chunk's lexical scope intact.
-        const newDetected = new Set<string>();
-        for (let i = 0; i < chunkCodes.length; i++) {
-            const code = chunkCodes[i] ?? '';
-            try {
-                for (const id of detectFreeGlobals(code)) newDetected.add(id);
-            } catch (e) {
-                if ((globalThis as { process?: { env?: Record<string, string | undefined> } }).process?.env?.GJSIFY_DEBUG_AUTO_GLOBALS) {
-                    const path = `/tmp/gjsify-auto-globals-failed-chunk-${i}.mjs`;
-                    try {
-                        // eslint-disable-next-line @typescript-eslint/no-require-imports
-                        const fs = await import('node:fs');
-                        fs.writeFileSync(path, code);
-                        console.error(`[gjsify-auto-globals] parse failed on chunk #${i} — wrote ${path} for inspection`);
-                    } catch { /* ignore */ }
-                }
-                throw e;
-            }
-        }
-
-        // Apply excludeGlobals BEFORE writing the next iteration's inject file.
-        // Otherwise an excluded identifier would still appear in the inject
-        // import list and the analysis build itself would fail when the
-        // corresponding `@gjsify/<pkg>/register/<feature>` is not in the
-        // project's resolvable dep tree.
-        if (excludeSet.size > 0) {
-            for (const id of excludeSet) newDetected.delete(id);
-        }
-
-        // Fixpoint check: detection is monotonic — once a global is needed,
-        // more code gets pulled in by the next pass, which can only ADD
-        // requirements. So a set that didn't grow is a converged set.
-        if (setsEqual(detected, newDetected)) {
-            if (verbose) {
-                const sorted = [...detected].sort();
-                const extras = extraRegisterPaths.size > 0 ? ` (+ ${extraRegisterPaths.size} extra register module(s))` : '';
-                console.debug(
-                    `[gjsify] --globals auto: converged after ${iteration - 1} iteration(s), ${detected.size} global(s)${sorted.length ? ': ' + sorted.join(', ') : ''}${extras}`,
-                );
-            }
-            return applyExcludeGlobals(detected, currentInject, extraRegisterPaths, options.excludeGlobals);
-        }
-
-        detected = newDetected;
-        const registerPaths = detectedToRegisterPaths(detected);
-        for (const p of extraRegisterPaths) registerPaths.add(p);
-
-        if (registerPaths.size === 0) {
-            return { detected, injectPath: undefined };
-        }
-
-        currentInject = (await writeRegisterInjectFile(registerPaths)) ?? undefined;
-
-        if (verbose) {
-            const sorted = [...detected].sort();
-            console.debug(
-                `[gjsify] --globals auto: iteration ${iteration}, ${detected.size} global(s)${sorted.length ? ': ' + sorted.join(', ') : ''}`,
-            );
-        }
-    }
-
-    if (verbose) {
-        console.debug(
-            `[gjsify] --globals auto: hit max iterations (${MAX_ITERATIONS}), using last detected set`,
-        );
-    }
-    return applyExcludeGlobals(detected, currentInject, extraRegisterPaths, options.excludeGlobals);
-}
-
-/**
- * Append an additional entry path to a Rolldown `input` value while
- * preserving its shape (string → array, array → array, record → record).
- * The new entry is given the synthetic name `__gjsify_inject` when the
- * record form is used so it doesn't collide with user-named outputs.
- */
-function appendInjectAsEntry(
-    input: InputOptions['input'],
-    injectPath: string,
-): InputOptions['input'] {
-    if (input === undefined) return [injectPath];
-    if (typeof input === 'string') return [input, injectPath];
-    if (Array.isArray(input)) {
-        return [...input, injectPath];
-    }
-    return { ...input, __gjsify_inject: injectPath };
-}

package/src/utils/detect-free-globals.ts

@@ -1,284 +0,0 @@
-// Detect free (unbound) global identifiers in bundled JS output.
-//
-// Used by the `--globals auto` two-pass build: the first esbuild pass
-// produces a minified bundle without globals injection, this module
-// parses it with acorn and finds references to known GJS globals that
-// are not locally declared. The result feeds the second pass's inject
-// stub so only actually-needed globals are registered.
-
-import * as acorn from 'acorn';
-import * as walk from 'acorn-walk';
-import { GJS_GLOBALS_MAP } from '@gjsify/resolve-npm/globals-map';
-
-const KNOWN_GLOBALS = new Set(Object.keys(GJS_GLOBALS_MAP as Record<string, string>));
-
-/**
- * Method markers — `<host>.<method>(…)` patterns that imply a global
- * identifier should be injected even though the identifier itself never
- * appears in the bundle.
- *
- * Example: a project that calls `navigator.getGamepads()` doesn't reference
- * any of the gamepad-related identifiers in the globals map, but it still
- * needs `@gjsify/gamepad/register` to patch `navigator` with the method.
- * This marker maps `navigator.getGamepads` → inject the `GamepadEvent`
- * register path (which is the gamepad package's register entry).
- *
- * Keyed by `host.method` (lowercase host, exact method name). Values are
- * KNOWN_GLOBALS identifiers — the detector adds them as free globals if
- * the corresponding member expression is found in the bundle.
- */
-const METHOD_MARKERS: Record<string, string> = {
-    // Gamepad API — navigator.getGamepads is patched on by @gjsify/gamepad/register
-    'navigator.getGamepads': 'GamepadEvent',
-    // WebRTC — navigator.mediaDevices is patched on by @gjsify/webrtc/register/media-devices
-    'navigator.mediaDevices': 'MediaDevices',
-    // WebAssembly Promise APIs — the runtime stubs throw at first call, so
-    // any reference to these methods needs the `@gjsify/webassembly` polyfill.
-    // The register entry replaces the stubs with wrappers around the working
-    // synchronous `new WebAssembly.{Module,Instance}` constructors.
-    'WebAssembly.compile':              'WebAssembly',
-    'WebAssembly.compileStreaming':     'WebAssembly',
-    'WebAssembly.instantiate':          'WebAssembly',
-    'WebAssembly.instantiateStreaming': 'WebAssembly',
-    'WebAssembly.validate':             'WebAssembly',
-    // Note: URL.createObjectURL / URL.revokeObjectURL don't need markers —
-    // they are first-class static methods on @gjsify/url's URL class, so the
-    // free `URL` identifier (detected directly, maps to
-    // @gjsify/node-globals/register/url in GJS_GLOBALS_MAP) already pulls in
-    // the correct register module.
-};
-
-/**
- * Extract all bound names from a binding pattern
- * (Identifier, ObjectPattern, ArrayPattern, AssignmentPattern, RestElement).
- */
-function extractBindingNames(node: acorn.AnyNode): string[] {
-    if (!node) return [];
-    switch (node.type) {
-        case 'Identifier':
-            return [(node as acorn.Identifier).name];
-        case 'ObjectPattern':
-            return (node as acorn.ObjectPattern).properties.flatMap((p) =>
-                p.type === 'RestElement'
-                    ? extractBindingNames(p.argument)
-                    : extractBindingNames((p as acorn.Property).value),
-            );
-        case 'ArrayPattern':
-            return (node as acorn.ArrayPattern).elements.flatMap((e) =>
-                e
-                    ? e.type === 'RestElement'
-                        ? extractBindingNames(e.argument)
-                        : extractBindingNames(e)
-                    : [],
-            );
-        case 'AssignmentPattern':
-            return extractBindingNames((node as acorn.AssignmentPattern).left);
-        case 'RestElement':
-            return extractBindingNames((node as acorn.RestElement).argument);
-        default:
-            return [];
-    }
-}
-
-/**
- * Parse bundled JS code and return the set of free (unbound) identifiers
- * that match known GJS globals from `GJS_GLOBALS_MAP`.
- *
- * "Free" means the identifier is referenced but never declared in the
- * module (var/let/const/function/class/import/param/catch).
- *
- * After esbuild bundling + minification, local variables that shadow
- * globals are renamed to short names, so any surviving known-global name
- * in the output is almost certainly a true global reference. The
- * declared-names check is a safety net for edge cases where esbuild
- * keeps the original name.
- *
- * `typeof X` references ARE included — if code guards with
- * `typeof fetch !== 'undefined'`, it intends to use fetch when available
- * and we can provide it.
- */
-export function detectFreeGlobals(code: string): Set<string> {
-    const ast = acorn.parse(code, {
-        ecmaVersion: 'latest',
-        sourceType: 'module',
-        // Some bundled chunks carry an embedded `#!shebang` line —
-        // notably any project bundling its own CLI gets the
-        // `#!/usr/bin/env -S gjs -m` shebang hoisted to byte 0.
-        // Acorn rejects shebangs by default; allow them so the
-        // free-globals analyzer doesn't choke on its own input.
-        allowHashBang: true,
-    });
-
-    // --- Pass 1: collect all declared names across the entire module ---
-    const declaredNames = new Set<string>();
-
-    walk.simple(ast, {
-        VariableDeclarator(node: acorn.VariableDeclarator) {
-            for (const name of extractBindingNames(node.id)) {
-                declaredNames.add(name);
-            }
-        },
-        FunctionDeclaration(node: acorn.FunctionDeclaration) {
-            if (node.id) declaredNames.add(node.id.name);
-            for (const param of node.params) {
-                for (const name of extractBindingNames(param)) {
-                    declaredNames.add(name);
-                }
-            }
-        },
-        FunctionExpression(node: acorn.FunctionExpression) {
-            if (node.id) declaredNames.add(node.id.name);
-            for (const param of node.params) {
-                for (const name of extractBindingNames(param)) {
-                    declaredNames.add(name);
-                }
-            }
-        },
-        ArrowFunctionExpression(node: acorn.ArrowFunctionExpression) {
-            for (const param of node.params) {
-                for (const name of extractBindingNames(param)) {
-                    declaredNames.add(name);
-                }
-            }
-        },
-        ClassDeclaration(node: acorn.ClassDeclaration) {
-            if (node.id) declaredNames.add(node.id.name);
-        },
-        ImportSpecifier(node: acorn.ImportSpecifier) {
-            declaredNames.add(node.local.name);
-        },
-        ImportDefaultSpecifier(node: acorn.ImportDefaultSpecifier) {
-            declaredNames.add(node.local.name);
-        },
-        ImportNamespaceSpecifier(node: acorn.ImportNamespaceSpecifier) {
-            declaredNames.add(node.local.name);
-        },
-        CatchClause(node: acorn.CatchClause) {
-            if (node.param) {
-                for (const name of extractBindingNames(node.param)) {
-                    declaredNames.add(name);
-                }
-            }
-        },
-    });
-
-    // --- Pass 2: find Identifier nodes in reference position ---
-    // Also detects MemberExpressions like `globalThis.X` / `global.X` /
-    // `window.X` / `self.X` where X is a known global. esbuild's `define`
-    // config replaces `global`/`window` with `globalThis`, but we accept
-    // all four host-object names for safety (esbuild also never renames
-    // these because they are language keywords / pre-defined globals).
-    const freeGlobals = new Set<string>();
-    const HOST_OBJECTS = new Set(['globalThis', 'global', 'window', 'self', 'globalObject']);
-
-    walk.ancestor(ast, {
-        MemberExpression(node: acorn.MemberExpression) {
-            // Only dot-access — skip computed (bracket) access since the
-            // property is then a dynamic Expression, not a known name.
-            if (node.computed) return;
-            if (node.object.type !== 'Identifier') return;
-            if (node.property.type !== 'Identifier') return;
-
-            const objName = (node.object as acorn.Identifier).name;
-            const propName = (node.property as acorn.Identifier).name;
-
-            // Pattern A: globalThis.X / global.X / window.X / self.X
-            // The property is a known global identifier itself.
-            if (HOST_OBJECTS.has(objName)) {
-                if (KNOWN_GLOBALS.has(propName)) {
-                    freeGlobals.add(propName);
-                }
-                return;
-            }
-
-            // Pattern B: known-instance method markers like
-            // `navigator.getGamepads` → marker map forwards to a global
-            // identifier that triggers the right register path even though
-            // the identifier itself never appears in the bundle.
-            const markerKey = `${objName}.${propName}`;
-            const markerTarget = METHOD_MARKERS[markerKey];
-            if (markerTarget && KNOWN_GLOBALS.has(markerTarget)) {
-                freeGlobals.add(markerTarget);
-            }
-        },
-        Identifier(node: acorn.Identifier, ancestors: acorn.AnyNode[]) {
-            const name = node.name;
-
-            // Quick filter: only check known globals
-            if (!KNOWN_GLOBALS.has(name)) return;
-
-            // Skip if locally declared
-            if (declaredNames.has(name)) return;
-
-            // Determine if this Identifier is in a reference position
-            // by checking the parent node.
-            const parent = ancestors[ancestors.length - 2];
-            if (!parent) {
-                freeGlobals.add(name);
-                return;
-            }
-
-            switch (parent.type) {
-                // obj.prop — skip if this is the non-computed property
-                case 'MemberExpression': {
-                    const mem = parent as acorn.MemberExpression;
-                    if (mem.property === (node as acorn.AnyNode) && !mem.computed) return;
-                    break;
-                }
-                // { key: value } — skip if this is the non-computed key
-                case 'Property': {
-                    const prop = parent as acorn.Property;
-                    if (prop.key === (node as acorn.AnyNode) && !prop.computed) return;
-                    break;
-                }
-                // Method/property definitions in classes
-                case 'MethodDefinition':
-                case 'PropertyDefinition': {
-                    const def = parent as acorn.MethodDefinition | acorn.PropertyDefinition;
-                    if (def.key === (node as acorn.AnyNode) && !def.computed) return;
-                    break;
-                }
-                // label: — skip
-                case 'LabeledStatement': {
-                    const labeled = parent as acorn.LabeledStatement;
-                    if (labeled.label === (node as acorn.AnyNode)) return;
-                    break;
-                }
-                // export { X as Y } — skip the exported name
-                case 'ExportSpecifier': {
-                    const spec = parent as acorn.ExportSpecifier;
-                    if (spec.exported === (node as acorn.AnyNode)) return;
-                    break;
-                }
-                // Declaration ids (function name, class name, variable id)
-                // are already in declaredNames, but guard anyway
-                case 'FunctionDeclaration':
-                case 'FunctionExpression':
-                case 'ClassDeclaration':
-                case 'ClassExpression': {
-                    const decl = parent as
-                        | acorn.FunctionDeclaration
-                        | acorn.FunctionExpression
-                        | acorn.ClassDeclaration
-                        | acorn.ClassExpression;
-                    if (decl.id === (node as acorn.AnyNode)) return;
-                    break;
-                }
-                case 'VariableDeclarator': {
-                    const vd = parent as acorn.VariableDeclarator;
-                    if (vd.id === (node as acorn.AnyNode)) return;
-                    break;
-                }
-                // import { X } / import X — already in declaredNames
-                case 'ImportSpecifier':
-                case 'ImportDefaultSpecifier':
-                case 'ImportNamespaceSpecifier':
-                    return;
-            }
-
-            freeGlobals.add(name);
-        },
-    });
-
-    return freeGlobals;
-}

package/src/utils/entry-points.ts

@@ -1,48 +0,0 @@
-// Glob expansion for Rolldown entry-point input.
-//
-// Rolldown's `input` accepts:
-//   - a single path string
-//   - an array of strings
-//   - a record mapping output names to input paths
-//
-// `globToEntryPoints` accepts the same shapes and expands any glob patterns
-// against the filesystem via `fast-glob`. Pure-string entries return as-is
-// when they don't contain wildcards (fast-glob handles that gracefully).
-//
-// `.d.ts` files are always excluded — they are type-only declarations,
-// not parseable as runtime modules. esbuild handled this implicitly via
-// its loader table; Rolldown's Oxc parser errors on declaration-only
-// shapes (`get foo(): T;`).
-
-import fastGlob from 'fast-glob';
-
-export type EntryPoints = string | string[] | Record<string, string>;
-
-const DEFAULT_IGNORE = ['**/*.d.ts'];
-
-export const globToEntryPoints = async (
-    _entryPoints: EntryPoints | undefined,
-    ignore: string[] = [],
-): Promise<EntryPoints | undefined> => {
-    if (_entryPoints === undefined) return undefined;
-    const fullIgnore = [...DEFAULT_IGNORE, ...ignore];
-
-    if (typeof _entryPoints === 'string') {
-        const expanded = await fastGlob([_entryPoints], { ignore: fullIgnore });
-        return expanded;
-    }
-
-    if (Array.isArray(_entryPoints)) {
-        return await fastGlob(_entryPoints, { ignore: fullIgnore });
-    }
-
-    const entryPoints: Record<string, string> = {};
-    for (const input in _entryPoints) {
-        const output = _entryPoints[input];
-        const inputs = await fastGlob(input, { ignore: fullIgnore });
-        for (const matched of inputs) {
-            entryPoints[matched] = output;
-        }
-    }
-    return entryPoints;
-};

package/src/utils/extension.ts

@@ -1,7 +0,0 @@
-export const getJsExtensions = (allowExt?: string) => {
-    const extensions: Record<string, string> = {'.js': '.js', '.ts': '.js', '.mts': '.js', '.cts': '.js', '.cjs': '.js', '.mjs': '.js'};
-    if(allowExt && extensions[allowExt]) {
-        delete extensions[allowExt]
-    }
-    return extensions;
-}

package/src/utils/index.ts

@@ -1,7 +0,0 @@
-export * from './alias.js';
-export * from './entry-points.js';
-export * from './extension.js';
-export * from './merge.js';
-export { detectFreeGlobals } from './detect-free-globals.js';
-export { resolveGlobalsList, writeRegisterInjectFile } from './scan-globals.js';
-export { inlineStaticReads } from './inline-static-reads.js';