@gjsify/cli 0.3.20 → 0.4.0

package/src/utils/install-global.ts

@@ -1,182 +0,0 @@
-// Global-install helpers for `gjsify install -g <pkg>`.
-//
-// Layout (XDG-compliant, ~ = $HOME):
-//
-//   ~/.local/share/gjsify/global/
-//     node_modules/<pkg>/                  ← extracted package contents
-//       package.json
-//       bin/<pkg>                          ← original npm bin
-//       bin/<pkg>-gjs                      ← GJS bundle (declared via `gjsify.bin`)
-//       <pkg-data-files>                   ← e.g. `dist-templates/` for ts-for-gir
-//   ~/.local/bin/<bin-name>                ← symlink to the matching bin under node_modules
-//
-// Unlike the project install path (`gjsify install <pkg>` without -g), this
-// mode installs the requested top-level packages plus their runtime deps into
-// a user-owned XDG location, never mutates a project package.json, and links
-// bins into the user's PATH so the package is invocable as `<bin-name>` from
-// anywhere — the closest GJS equivalent of `npm i -g`.
-//
-// `gjsify.bin` (when declared) wins over the standard npm `bin` field on this
-// path because the user explicitly asked for the GJS-runnable artifact: e.g.
-// `ts-for-gir` (npm bin = bin/ts-for-gir Node script) becomes a symlink to
-// `bin/ts-for-gir-gjs` (the self-contained GJS bundle) instead.
-
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-
-export interface GlobalLayout {
-    /** Where extracted package trees live: `<prefix>/node_modules/<pkg>/`. */
-    prefix: string;
-    /** Where bin-name symlinks land. Typically `~/.local/bin`. */
-    binDir: string;
-}
-
-/**
- * Compute the canonical global install layout for the current user. Honours
- * `XDG_DATA_HOME` (per the XDG Base Directory Spec) plus
- * `GJSIFY_GLOBAL_PREFIX` and `GJSIFY_GLOBAL_BIN_DIR` escape hatches for tests.
- */
-export function defaultGlobalLayout(): GlobalLayout {
-    const prefixOverride = process.env.GJSIFY_GLOBAL_PREFIX;
-    const binOverride = process.env.GJSIFY_GLOBAL_BIN_DIR;
-    const home = os.homedir();
-    const xdgData = process.env.XDG_DATA_HOME ?? path.join(home, '.local', 'share');
-    return {
-        prefix: prefixOverride ?? path.join(xdgData, 'gjsify', 'global'),
-        binDir: binOverride ?? path.join(home, '.local', 'bin'),
-    };
-}
-
-export interface LinkedBin {
-    /** The bin-name (key from `bin` / `gjsify.bin`). */
-    name: string;
-    /** Absolute path to the file the symlink points at. */
-    target: string;
-    /** Absolute path to the symlink (under `binDir`). */
-    link: string;
-}
-
-/**
- * Install each top-level package's bin entries into `binDir` as small POSIX
- * `sh` launchers that exec the real bin. Reads each package's installed
- * `package.json` to discover bins; prefers `gjsify.bin` (GJS-bundled bins)
- * over the npm `bin` field, falling back to npm `bin` when no GJS map is
- * declared. Stale launchers are replaced (latest install wins).
- *
- * Why launchers instead of symlinks:
- *
- *   When a GJS bundle is invoked via a symlink in $PATH, the kernel follows
- *   the symlink to find the executable but passes the original (symlink)
- *   path to it. The bundle's shebang then runs as `gjs -m <symlink-path>`,
- *   which makes `import.meta.url` resolve to the symlink directory — so any
- *   path computation relative to `import.meta.url` (e.g. ts-for-gir's
- *   `findTemplatesRoot()`, version-discovery `readFileSync`s, gjsify's own
- *   `import.meta.url` rewrites) looks for assets in the wrong place.
- *
- *   A `sh` launcher invokes the real path explicitly, so the bundle sees its
- *   real install location in `import.meta.url` and every relative read works.
- *   This costs ~50 bytes per bin and one extra `exec` per launch — both
- *   negligible compared to `gjs -m` cold-start time.
- *
- *   Plain Node bins are unaffected by either approach (Node defaults to
- *   resolving symlinks in ESM module URLs); launchers are uniform for
- *   simplicity and so we don't need to discriminate by runtime here.
- */
-export function linkGlobalBins(packageNames: string[], layout: GlobalLayout): LinkedBin[] {
-    fs.mkdirSync(layout.binDir, { recursive: true });
-    const created: LinkedBin[] = [];
-
-    for (const pkgName of packageNames) {
-        const pkgDir = path.join(layout.prefix, 'node_modules', pkgName);
-        const pkgJsonPath = path.join(pkgDir, 'package.json');
-        if (!fs.existsSync(pkgJsonPath)) continue;
-
-        const pkgJson = readJson(pkgJsonPath);
-        const binMap = pickBinMap(pkgName, pkgJson);
-        if (!binMap || binMap.size === 0) continue;
-
-        for (const [binName, binTarget] of binMap) {
-            const targetAbs = path.join(pkgDir, binTarget);
-            if (!fs.existsSync(targetAbs)) continue;
-            try {
-                fs.chmodSync(targetAbs, 0o755);
-            } catch {
-                /* best effort */
-            }
-            const linkPath = path.join(layout.binDir, binName);
-            fs.rmSync(linkPath, { force: true });
-            // Inline `${target}` directly — this file is rewritten on every
-            // install, paths are user-owned, and POSIX `sh` quoting via
-            // single-quotes plus `'\''` for embedded quotes is well-defined.
-            const launcher = `#!/bin/sh\nexec ${shQuote(targetAbs)} "$@"\n`;
-            fs.writeFileSync(linkPath, launcher);
-            fs.chmodSync(linkPath, 0o755);
-            created.push({ name: binName, target: targetAbs, link: linkPath });
-        }
-    }
-
-    return created;
-}
-
-function shQuote(s: string): string {
-    return `'${s.replace(/'/g, `'\\''`)}'`;
-}
-
-function pickBinMap(
-    pkgName: string,
-    pkgJson: Record<string, unknown>,
-): Map<string, string> | null {
-    const gjsifyEntry = pkgJson.gjsify as { bin?: string | Record<string, string> } | undefined;
-    if (gjsifyEntry?.bin !== undefined) {
-        return normalizeBin(pkgName, gjsifyEntry.bin);
-    }
-    const npmBin = pkgJson.bin as string | Record<string, string> | undefined;
-    if (npmBin !== undefined) {
-        return normalizeBin(pkgName, npmBin);
-    }
-    return null;
-}
-
-function normalizeBin(
-    pkgName: string,
-    bin: string | Record<string, string>,
-): Map<string, string> {
-    const out = new Map<string, string>();
-    if (typeof bin === 'string') {
-        const baseName = pkgName.startsWith('@')
-            ? pkgName.slice(pkgName.indexOf('/') + 1)
-            : pkgName;
-        out.set(baseName, bin);
-        return out;
-    }
-    for (const [k, v] of Object.entries(bin)) out.set(k, v);
-    return out;
-}
-
-function readJson(file: string): Record<string, unknown> {
-    return JSON.parse(fs.readFileSync(file, 'utf-8')) as Record<string, unknown>;
-}
-
-/** Returns `true` if `binDir` is on the user's PATH. */
-export function binDirOnPath(binDir: string): boolean {
-    const PATH = process.env.PATH ?? '';
-    const sep = process.platform === 'win32' ? ';' : ':';
-    const want = path.resolve(binDir);
-    return PATH.split(sep).some((entry) => entry && path.resolve(entry) === want);
-}
-
-/**
- * Extracts the package name from a spec like `name@1.2`, `@scope/name`,
- * or `@scope/name@latest`. Returns the unchanged string for plain names.
- */
-export function specToPackageName(spec: string): string {
-    if (spec.startsWith('@')) {
-        const slash = spec.indexOf('/');
-        if (slash < 0) return spec;
-        const at = spec.indexOf('@', slash);
-        return at < 0 ? spec : spec.slice(0, at);
-    }
-    const at = spec.indexOf('@');
-    return at < 0 ? spec : spec.slice(0, at);
-}

package/src/utils/normalize-bundler-options.ts

@@ -1,129 +0,0 @@
-// One-release deprecation shim: maps the legacy `esbuild?: BuildOptions`
-// field on `.gjsifyrc.js` / `package.json#gjsify` into the equivalent
-// `bundler?: RolldownOptions` shape. Logs a single warning per build.
-//
-// Drop in 0.5.0.
-
-import type { OutputOptions } from 'rolldown';
-import type { ConfigData, BundlerOptions, LegacyEsbuildOptions } from '../types/config-data.js';
-
-let warnedOnce = false;
-
-export function normalizeBundlerOptions(configData: ConfigData): BundlerOptions {
-    const fromBundler: BundlerOptions = (configData.bundler ?? {}) as BundlerOptions;
-    if (!configData.esbuild) return fromBundler;
-
-    if (!warnedOnce) {
-        warnedOnce = true;
-        // eslint-disable-next-line no-console
-        console.warn(
-            "[gjsify] DEPRECATION: the 'esbuild' config key is deprecated and will be removed in 0.5.0. " +
-                "Rename it to 'bundler' (typed as RolldownOptions). See the migration notes in the gjsify CHANGELOG.",
-        );
-    }
-
-    const fromEsbuild = legacyEsbuildToRolldown(configData.esbuild);
-    // Plain user-config merge — we deliberately do NOT call
-    // `mergeBundlerOptions` here, because that function strips `input` and
-    // `external` from its overrides arg (it assumes the *orchestrator* is
-    // the override source and the user the base). Here both inputs are
-    // user-provided config and `input` must survive the merge.
-    const out: BundlerOptions = { ...fromEsbuild, ...fromBundler };
-    if (fromEsbuild.output || fromBundler.output) {
-        out.output = { ...(fromEsbuild.output ?? {}), ...(fromBundler.output ?? {}) };
-    }
-    if (fromEsbuild.transform || fromBundler.transform) {
-        out.transform = { ...(fromEsbuild.transform ?? {}), ...(fromBundler.transform ?? {}) };
-        if (fromEsbuild.transform?.define || fromBundler.transform?.define) {
-            out.transform.define = {
-                ...(fromEsbuild.transform?.define ?? {}),
-                ...(fromBundler.transform?.define ?? {}),
-            };
-        }
-    }
-    if (fromEsbuild.resolve || fromBundler.resolve) {
-        out.resolve = { ...(fromEsbuild.resolve ?? {}), ...(fromBundler.resolve ?? {}) };
-    }
-    return out;
-}
-
-/** Map the supported subset of esbuild BuildOptions into RolldownOptions. */
-function legacyEsbuildToRolldown(esb: LegacyEsbuildOptions): BundlerOptions {
-    const out: BundlerOptions = {};
-    const output: OutputOptions = {};
-    const transform: NonNullable<BundlerOptions['transform']> = {};
-    const resolve: NonNullable<BundlerOptions['resolve']> = {};
-
-    if (esb.outfile !== undefined) output.file = esb.outfile;
-    if (esb.outdir !== undefined) output.dir = esb.outdir;
-    if (esb.format !== undefined) output.format = esb.format;
-    if (esb.minify !== undefined) output.minify = esb.minify;
-    if (esb.sourcemap !== undefined) {
-        // esbuild has 'external' / 'both' which Rolldown doesn't — coerce to boolean.
-        output.sourcemap =
-            esb.sourcemap === 'inline'
-                ? 'inline'
-                : Boolean(esb.sourcemap);
-    }
-    if (esb.banner?.js !== undefined) output.banner = esb.banner.js;
-
-    if (esb.target !== undefined) {
-        transform.target = Array.isArray(esb.target) ? esb.target.join(',') : esb.target;
-    }
-    if (esb.define !== undefined) transform.define = esb.define;
-
-    if (esb.mainFields !== undefined) resolve.mainFields = esb.mainFields;
-    if (esb.conditions !== undefined) resolve.conditionNames = esb.conditions;
-
-    if (esb.external !== undefined) out.external = esb.external;
-    if (esb.platform !== undefined) out.platform = esb.platform;
-
-    if (Object.keys(output).length > 0) out.output = output;
-    if (Object.keys(transform).length > 0) out.transform = transform;
-    if (Object.keys(resolve).length > 0) out.resolve = resolve;
-
-    // Discarded silently:
-    //   esb.inject  — esbuild's array-of-side-effect-files; surfaced at the
-    //                 CLI layer instead, via input expansion.
-    //   esb.loader  — Rolldown infers module types from extensions natively.
-    return out;
-}
-
-/**
- * Shallow merge with deep-merge of `output`, `transform`, and `resolve`. The
- * second argument wins on conflicts, matching `merge(target, ...sources)`
- * semantics from `@gjsify/rolldown-plugin-gjsify/utils/merge`.
- *
- * `base` is typically the Rolldown-generic shape returned by the orchestrator;
- * `overrides` is the user's `BundlerOptions` from `.gjsifyrc.js` plus CLI
- * flag merges. Single-output assumption matches `BundlerOptions['output']`.
- *
- * The orchestrator-side `input` is authoritative — it's the post-glob-expansion
- * value. Overriding it with the user's raw glob string would re-introduce
- * unresolved glob patterns into the final Rolldown call. Same for `external`,
- * which the orchestrator concatenates with platform defaults already.
- */
-export function mergeBundlerOptions(
-    base: BundlerOptions,
-    overrides: BundlerOptions,
-): BundlerOptions {
-    // Strip fields the orchestrator owns authoritatively — the user has
-    // already had their say via the orchestrator's `userExternal` / input
-    // expansion; merging the raw values back on top would clobber the
-    // post-processing.
-    const { input: _ignoredInput, external: _ignoredExternal, ...overridesRest } = overrides;
-    const out: BundlerOptions = { ...base, ...overridesRest };
-    if (base.output || overrides.output) {
-        out.output = { ...(base.output ?? {}), ...(overrides.output ?? {}) };
-    }
-    if (base.transform || overrides.transform) {
-        out.transform = { ...(base.transform ?? {}), ...(overrides.transform ?? {}) };
-        if (base.transform?.define || overrides.transform?.define) {
-            out.transform.define = { ...(base.transform?.define ?? {}), ...(overrides.transform?.define ?? {}) };
-        }
-    }
-    if (base.resolve || overrides.resolve) {
-        out.resolve = { ...(base.resolve ?? {}), ...(overrides.resolve ?? {}) };
-    }
-    return out;
-}

package/src/utils/parse-spec.ts

@@ -1,48 +0,0 @@
-// Parse a `gjsify dlx` package spec — distinguishes local paths from npm specs.
-
-import { existsSync } from 'node:fs';
-import { isAbsolute, resolve } from 'node:path';
-
-export type ParsedSpec =
-    | { kind: 'local'; path: string }
-    | { kind: 'registry'; name: string; version?: string; spec: string };
-
-const NPM_NAME_RE = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/;
-
-/**
- * Parse a CLI input into either a local-path or an npm-registry spec.
- *
- * Local: starts with `./`, `../`, `/`, or is an existing directory path.
- * Registry: `<name>` | `<name>@<version>` | `@scope/<name>` | `@scope/<name>@<version>`
- *
- * The full spec string is preserved on the registry case so it can be passed
- * verbatim to `npm install` (which already understands dist-tags, ranges,
- * git URIs, tarball URLs, etc. — we don't re-parse those).
- */
-export function parseSpec(input: string): ParsedSpec {
-    if (!input) throw new Error('dlx: empty package spec');
-
-    if (input.startsWith('./') || input.startsWith('../') || isAbsolute(input)) {
-        return { kind: 'local', path: resolve(input) };
-    }
-
-    if (existsSync(input)) {
-        return { kind: 'local', path: resolve(input) };
-    }
-
-    // Registry spec: split off the version after the LAST `@` that isn't the
-    // leading scope separator.
-    let name = input;
-    let version: string | undefined;
-    const lastAt = input.lastIndexOf('@');
-    if (lastAt > 0) {
-        name = input.slice(0, lastAt);
-        version = input.slice(lastAt + 1);
-    }
-
-    if (!NPM_NAME_RE.test(name)) {
-        throw new Error(`dlx: invalid package name "${name}"`);
-    }
-
-    return { kind: 'registry', name, version, spec: input };
-}

package/src/utils/resolve-gjs-entry.ts

@@ -1,96 +0,0 @@
-// Resolve the GJS entry point of an installed package.
-//
-// Per the `gjsify` field convention (see CLI reference):
-//
-//   {
-//     "gjsify": {
-//       "main": "dist/gjs.js",
-//       "bin":  { "name-a": "dist/a.js", "name-b": "dist/b.js" }
-//     }
-//   }
-//
-// Resolution order:
-//   1. user-supplied bin name + `gjsify.bin[name]`     → that path
-//   2. single-entry `gjsify.bin`                       → the only path
-//   3. `gjsify.main`                                   → that path
-//   4. fallback: `package.json#main`                   → that path (advisory warning)
-//   5. otherwise: hard-fail with a fix hint
-
-import { readFileSync } from 'node:fs';
-import { existsSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-
-interface ResolvedEntry {
-    bundlePath: string;
-    binName: string | null;
-    fromFallback: boolean;
-}
-
-interface PackageJson {
-    name?: string;
-    main?: string;
-    gjsify?: {
-        main?: string;
-        bin?: Record<string, string>;
-        prebuilds?: string;
-    };
-}
-
-export function resolveGjsEntry(
-    pkgDir: string,
-    binName: string | null,
-): ResolvedEntry {
-    const pkgJsonPath = join(pkgDir, 'package.json');
-    if (!existsSync(pkgJsonPath)) {
-        throw new Error(`dlx: no package.json found at ${pkgDir}`);
-    }
-    const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8')) as PackageJson;
-
-    const gjsifyBin = pkg.gjsify?.bin;
-    const gjsifyMain = pkg.gjsify?.main;
-    const fallbackMain = pkg.main;
-
-    let entry: string | undefined;
-    let resolvedBin: string | null = null;
-    let fromFallback = false;
-
-    if (binName !== null) {
-        if (!gjsifyBin || !gjsifyBin[binName]) {
-            const known = gjsifyBin ? Object.keys(gjsifyBin).join(', ') : '(none)';
-            throw new Error(
-                `dlx: package "${pkg.name ?? pkgDir}" has no GJS bin named "${binName}" — known: ${known}`,
-            );
-        }
-        entry = gjsifyBin[binName];
-        resolvedBin = binName;
-    } else if (gjsifyBin && Object.keys(gjsifyBin).length === 1) {
-        const onlyBin = Object.keys(gjsifyBin)[0];
-        entry = gjsifyBin[onlyBin];
-        resolvedBin = onlyBin;
-    } else if (gjsifyMain) {
-        entry = gjsifyMain;
-    } else if (fallbackMain) {
-        entry = fallbackMain;
-        fromFallback = true;
-    }
-
-    if (gjsifyBin && Object.keys(gjsifyBin).length > 1 && binName === null) {
-        const names = Object.keys(gjsifyBin).join(', ');
-        throw new Error(
-            `dlx: package "${pkg.name ?? pkgDir}" defines multiple GJS bins — pass one of: ${names}`,
-        );
-    }
-
-    if (!entry) {
-        throw new Error(
-            `dlx: package "${pkg.name ?? pkgDir}" has no GJS entry — set \`gjsify.main\` (or \`gjsify.bin\`) in its package.json`,
-        );
-    }
-
-    const bundlePath = resolve(pkgDir, entry);
-    if (!existsSync(bundlePath)) {
-        throw new Error(`dlx: GJS entry not found: ${bundlePath}`);
-    }
-
-    return { bundlePath, binName: resolvedBin, fromFallback };
-}

package/src/utils/resolve-plugin-by-name.ts

@@ -1,106 +0,0 @@
-// Resolve `bundler.plugins` entries that are specified by package name in
-// the user's gjsify config, e.g.:
-//
-//   "bundler": {
-//     "plugins": [
-//       { "name": "@gjsify/vite-plugin-blueprint", "options": { "minify": true } },
-//       { "name": "@gjsify/vite-plugin-gettext", "export": "msgfmtPlugin", "options": { ... } }
-//     ]
-//   }
-//
-// Lets `package.json#gjsify` describe the full plugin chain without dropping
-// to a JS-form config file (`gjsify.config.mjs`). Resolution is anchored at
-// the project root (where the config lives) so the project's own
-// `node_modules` wins over the CLI's own dependencies.
-
-import { createRequire } from 'node:module';
-import { join } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import type { RolldownPluginOption } from 'rolldown';
-
-/** User-supplied entry: a package name + optional named export and options. */
-export interface PluginByName {
-    name: string;
-    /** Named export to invoke. Defaults to the module's default export. */
-    export?: string;
-    /** Options forwarded to the plugin factory. */
-    options?: unknown;
-}
-
-/** Type-guard: a `PluginByName` shape rather than a Rolldown plugin object. */
-export function isPluginByName(value: unknown): value is PluginByName {
-    return (
-        typeof value === 'object' &&
-        value !== null &&
-        typeof (value as { name?: unknown }).name === 'string' &&
-        // RolldownPluginOption can be `false | null | undefined | Plugin | Promise<Plugin>`.
-        // A real plugin always has a function-shape behavior; `name` alone is shared
-        // with our shape, so we additionally require absence of plugin-shape fields.
-        !('apply' in value) &&
-        !('resolveId' in value) &&
-        !('load' in value) &&
-        !('transform' in value) &&
-        !('renderChunk' in value) &&
-        !('generateBundle' in value)
-    );
-}
-
-/**
- * Resolve a list of mixed user plugins. Entries that are already plugin
- * objects pass through unchanged; entries shaped like `PluginByName` get
- * dynamically imported, instantiated with their `options`, and returned in
- * the same position. Resolution is anchored at `projectDir`.
- *
- * Throws when a name fails to resolve, when the chosen export is not a
- * function, or when the factory returns nothing.
- */
-export async function resolveUserPlugins(
-    plugins: ReadonlyArray<RolldownPluginOption | PluginByName>,
-    projectDir: string,
-): Promise<RolldownPluginOption[]> {
-    const requireFromProject = createRequire(join(projectDir, 'package.json'));
-    const out: RolldownPluginOption[] = [];
-
-    for (const entry of plugins) {
-        if (!isPluginByName(entry)) {
-            out.push(entry as RolldownPluginOption);
-            continue;
-        }
-
-        let resolvedPath: string;
-        try {
-            resolvedPath = requireFromProject.resolve(entry.name);
-        } catch (err) {
-            throw new Error(
-                `gjsify config: failed to resolve plugin "${entry.name}" from ${projectDir}. ` +
-                    `Add it to your project's dependencies, or pass a Plugin object directly. ` +
-                    `(${(err as Error).message})`,
-            );
-        }
-
-        const mod = await import(pathToFileURL(resolvedPath).href);
-        const exportName = entry.export ?? 'default';
-        const factory = (mod as Record<string, unknown>)[exportName];
-
-        if (typeof factory !== 'function') {
-            const available = Object.keys(mod).filter(
-                (k) => typeof (mod as Record<string, unknown>)[k] === 'function',
-            );
-            throw new Error(
-                `gjsify config: plugin "${entry.name}" has no function export "${exportName}". ` +
-                    `Available function exports: ${available.length ? available.join(', ') : '(none)'}.`,
-            );
-        }
-
-        const plugin = await (factory as (opts?: unknown) => unknown)(entry.options);
-        if (plugin === undefined || plugin === null) {
-            throw new Error(
-                `gjsify config: plugin "${entry.name}" factory returned ${plugin}. ` +
-                    `Check the plugin's signature — it should return a Rolldown/Vite plugin object.`,
-            );
-        }
-        out.push(plugin as RolldownPluginOption);
-    }
-
-    return out;
-}

package/src/utils/run-gjs.ts

@@ -1,90 +0,0 @@
-// Shared utility for running a GJS bundle with native package env vars.
-// Used by `gjsify run`, `gjsify dlx`, and the showcase command (via dlx).
-//
-// Detection runs the same exhaustive node_modules walker (`detectNativePackages`)
-// from two starting points and merges by package name (CWD shadows bundle):
-//
-//   1. process.cwd()          — picks up native deps in the user's project
-//                               (yarn / pnpm / npm node_modules walking up).
-//   2. dirname(bundlePath)    — picks up native deps in whatever node_modules
-//                               the bundle lives in. Critical for `gjsify dlx`
-//                               where the bundle resides in
-//                               `~/.cache/gjsify/dlx/<sha>/.../node_modules/<pkg>/dist/`
-//                               and the user's CWD is unrelated. The bundle-side
-//                               walk also catches transitive deps' typelibs.
-//
-// Env composition is split out as `computeNativeEnvForBundle()` — a pure
-// function that takes a bundle path + cwd and returns the env it would inject.
-// This lets the e2e tests assert the env without spawning gjs.
-
-import { spawn } from 'node:child_process';
-import { dirname, resolve } from 'node:path';
-import { detectNativePackages, buildNativeEnv } from './detect-native-packages.js';
-
-/**
- * Pure env computation for a given bundle. Returns the LD_LIBRARY_PATH /
- * GI_TYPELIB_PATH values that {@link runGjsBundle} would inject into the
- * spawned `gjs` process, plus the formatted env-prefix string used for the
- * `$ …` echo.
- */
-export function computeNativeEnvForBundle(
-    bundlePath: string,
-    cwd: string = process.cwd(),
-): { env: { LD_LIBRARY_PATH: string; GI_TYPELIB_PATH: string }; envPrefix: string } {
-    const resolvedBundle = resolve(bundlePath);
-
-    const cwdPackages = detectNativePackages(cwd);
-    const bundlePackages = detectNativePackages(dirname(resolvedBundle));
-
-    const seen = new Set(cwdPackages.map((p) => p.name));
-    const nativePackages = [
-        ...cwdPackages,
-        ...bundlePackages.filter((p) => !seen.has(p.name)),
-    ];
-
-    const env = buildNativeEnv(nativePackages);
-    const envPrefix = Object.entries(env)
-        .filter(([, value]) => value !== undefined && value !== '')
-        .map(([key, value]) => `${key}=${value}`)
-        .join(' ');
-
-    return { env, envPrefix };
-}
-
-/**
- * Run a GJS bundle, automatically setting LD_LIBRARY_PATH and GI_TYPELIB_PATH
- * for any installed native gjsify packages discoverable from either the CWD
- * or the bundle's own node_modules tree.
- */
-export async function runGjsBundle(bundlePath: string, extraArgs: string[] = []): Promise<void> {
-    const { env: nativeEnv, envPrefix } = computeNativeEnvForBundle(bundlePath);
-
-    const env = {
-        ...process.env,
-        ...nativeEnv,
-    };
-
-    const gjsArgs = ['-m', bundlePath, ...extraArgs];
-
-    // Print the exact command being executed so users can copy-paste it to
-    // run gjs directly without the wrapper. Env vars are only shown if we
-    // actually set any (i.e. native gjsify packages were detected).
-    const gjsCommand = ['gjs', ...gjsArgs.map((a) => (a.includes(' ') ? `"${a}"` : a))].join(' ');
-    console.log(`$ ${envPrefix ? `${envPrefix} ` : ''}${gjsCommand}`);
-
-    const child = spawn('gjs', gjsArgs, { env, stdio: 'inherit' });
-
-    await new Promise<void>((resolvePromise, reject) => {
-        child.on('close', (code) => {
-            if (code !== 0) {
-                reject(new Error(`gjs exited with code ${code}`));
-            } else {
-                resolvePromise();
-            }
-        });
-        child.on('error', reject);
-    }).catch((err) => {
-        console.error(err.message);
-        process.exit(1);
-    });
-}

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-    "compilerOptions": {
-      "rootDir": "src",
-      "outDir": "lib",
-      "declarationDir": "lib",
-      "declaration": true,
-      "target": "ESNext",
-      "module": "NodeNext",
-      "moduleResolution": "NodeNext",
-      "types": ["node"],
-      "esModuleInterop": true,
-      "strict": true,
-      "skipLibCheck": true
-    },
-    "files": ["src/index.ts"]
-}