@gjsify/cli 0.3.16 → 0.3.18

package/lib/commands/build.js

@@ -6,11 +6,20 @@ export const buildCommand = {
     builder: (yargs) => {
         return yargs
             .option('entry-points', {
-            description: "The entry points you want to bundle",
+            description: "The entry points you want to bundle. Defaults to bundler.input from package.json#gjsify or .gjsifyrc.js, falling back to src/index.ts when neither is set.",
             array: true,
             type: 'string',
             normalize: true,
-            default: ['src/index.ts'],
+            // No yargs `default` here on purpose. A yargs default value
+            // is indistinguishable from "user passed the flag" in the
+            // parsed args (cliArgs.entryPoints?.length is truthy either
+            // way), so the merge step in config.ts would unconditionally
+            // overwrite `bundler.input` declared in package.json#gjsify —
+            // silently ignoring `gjsify.bundler.input: "src/start.ts"`
+            // and producing a bundle from the wrong entry point. The
+            // fallback to src/index.ts is applied in config.ts AFTER
+            // merging with the cosmiconfig data.
+            defaultDescription: "src/index.ts (fallback)",
             coerce: (arg) => {
                 // Removes duplicates
                 return [...new Set(arg)];
@@ -43,10 +52,10 @@ export const buildCommand = {
             normalize: true,
         })
             .option('minify', {
-            description: "When enabled, the generated code will be minified instead of pretty-printed",
+            description: "Minify the bundled output. Defaults to true; use --no-minify to emit pretty-printed code (e.g. for debugging or readable bundle review).",
             type: 'boolean',
             normalize: true,
-            default: false
+            defaultDescription: 'true',
         })
             .option('library', {
             description: "Use this if you want to build a library for Gjsify",

package/lib/commands/showcase.js

@@ -1,5 +1,5 @@
 import { discoverShowcases, findShowcase } from '../utils/discover-showcases.js';
-import { runMinimalChecks, checkGwebgl, detectPackageManager, buildInstallCommand, } from '../utils/check-system-deps.js';
+import { runMinimalChecks, detectPackageManager, buildInstallCommand, } from '../utils/check-system-deps.js';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 export const showcaseCommand = {
@@ -58,12 +58,15 @@ export const showcaseCommand = {
             console.error('Run "gjsify showcase" to list available showcases.');
             process.exit(1);
         }
-        // System dependency check before delegating — only what this showcase needs.
+        // System dependency check before delegating — only system libs (gjs,
+        // gtk4, …). The showcase's npm deps (incl. `@gjsify/webgl` with the
+        // gwebgl Vala prebuild) are fetched by `gjsify dlx` into the npm
+        // cache, and `runGjsBundle()` picks the prebuild up from the bundle
+        // dir via `detectNativePackages()`. Pre-flight-checking npm deps
+        // here would fail for `npx @gjsify/cli showcase` (no project
+        // node_modules, CLI doesn't dep on the showcase libs).
         const results = runMinimalChecks();
-        if (showcase.needsWebgl) {
-            results.push(checkGwebgl(process.cwd()));
-        }
-        const missingHard = results.filter((r) => !r.found && (r.severity === 'required' || r.id === 'gwebgl'));
+        const missingHard = results.filter((r) => !r.found && r.severity === 'required');
         if (missingHard.length > 0) {
             console.error('Missing system dependencies:\n');
             for (const dep of missingHard) {

package/lib/config.js

@@ -214,14 +214,26 @@ export class Config {
         const transform = (bundler.transform ??= {});
         if (cliArgs.entryPoints?.length)
             bundler.input = cliArgs.entryPoints;
+        // Fallback when neither the CLI flag nor the cosmiconfig data set an
+        // entry point. Applied here (post-merge) rather than as a yargs
+        // `default:` because yargs defaults are indistinguishable from
+        // user-set values, and would silently overwrite `bundler.input`
+        // declared in package.json#gjsify.
+        if (!bundler.input)
+            bundler.input = ['src/index.ts'];
         if (cliArgs.outfile !== undefined)
             output.file = cliArgs.outfile;
         if (cliArgs.outdir !== undefined)
             output.dir = cliArgs.outdir;
         if (cliArgs.format !== undefined)
             output.format = cliArgs.format;
+        // CLI flag wins over config; if neither is set, minify by default.
+        // Pretty-printed output is opt-in via `--no-minify` or
+        // `bundler.output.minify: false` in the config.
         if (cliArgs.minify !== undefined)
             output.minify = cliArgs.minify;
+        if (output.minify === undefined)
+            output.minify = true;
         if (cliArgs.logLevel) {
             // Map esbuild log levels to Rolldown's narrower set:
             //   esbuild   → rolldown

package/lib/utils/detect-native-packages.d.ts

@@ -18,19 +18,6 @@ export interface NativePackage {
  * node_modules shadows outer ones), matching Node.js resolution semantics.
  */
 export declare function detectNativePackages(startDir: string): NativePackage[];
-/**
- * Resolve native packages using Node.js module resolution from a given file path.
- * Reads the nearest package.json to discover dependencies, then checks each
- * for gjsify native prebuilds metadata.
- *
- * Also checks the **nearest package.json itself** — a workspace package may
- * have its own prebuilds (e.g. `@gjsify/webgl` running its own test) and
- * never list itself in dependencies.
- *
- * This complements detectNativePackages() (filesystem walk from CWD) by using
- * require.resolve() — which handles hoisting, workspaces, and nested node_modules.
- */
-export declare function resolveNativePackages(fromFilePath: string): NativePackage[];
 /**
  * Build the LD_LIBRARY_PATH and GI_TYPELIB_PATH env var values for the detected native packages.
  * Prepends the new paths to any existing values from the environment.

package/lib/utils/detect-native-packages.js

@@ -1,10 +1,17 @@
 // Utility to find npm packages with gjsify native prebuilds.
 // Packages declare: "gjsify": { "prebuilds": "<dir>" } in their package.json.
 // The CLI uses this to auto-set LD_LIBRARY_PATH / GI_TYPELIB_PATH before running gjs.
+//
+// One algorithm — `detectNativePackages(startDir)` — walks up from `startDir`
+// and exhaustively scans every `node_modules` it finds. Used by:
+//   * `gjsify run`, `gjsify info`, `gjsify install` — startDir = process.cwd()
+//   * `runGjsBundle()` — startDir = dirname(bundlePath), so DLX-cache layouts
+//     (`~/.cache/gjsify/dlx/<sha>/.../node_modules/<pkg>/dist/bundle.js`) get
+//     their full transitive prebuild set picked up automatically. The
+//     transitive walk is what makes `gjsify showcase` / `gjsify dlx` work
+//     for packages whose Vala typelibs live in *indirect* deps.
 import { readdirSync, existsSync, readFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { dirname, join, resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
+import { join, resolve } from 'node:path';
 /** Map Node.js process.arch values to the convention used in prebuilds/ directories. */
 function nodeArchToLinuxArch(arch) {
     const map = {
@@ -119,77 +126,6 @@ export function detectNativePackages(startDir) {
     }
     return merged;
 }
-/** Walk up from dir to find the nearest package.json. */
-function findNearestPackageJson(startDir) {
-    let dir = resolve(startDir);
-    while (true) {
-        const candidate = join(dir, 'package.json');
-        if (existsSync(candidate))
-            return candidate;
-        const parent = resolve(dir, '..');
-        if (parent === dir)
-            return null;
-        dir = parent;
-    }
-}
-/**
- * Resolve native packages using Node.js module resolution from a given file path.
- * Reads the nearest package.json to discover dependencies, then checks each
- * for gjsify native prebuilds metadata.
- *
- * Also checks the **nearest package.json itself** — a workspace package may
- * have its own prebuilds (e.g. `@gjsify/webgl` running its own test) and
- * never list itself in dependencies.
- *
- * This complements detectNativePackages() (filesystem walk from CWD) by using
- * require.resolve() — which handles hoisting, workspaces, and nested node_modules.
- */
-export function resolveNativePackages(fromFilePath) {
-    const arch = nodeArchToLinuxArch(process.arch);
-    const results = [];
-    try {
-        const req = createRequire(pathToFileURL(fromFilePath).href);
-        // Find the nearest package.json to get the dependency list
-        const nearestPkgJson = findNearestPackageJson(dirname(resolve(fromFilePath)));
-        if (!nearestPkgJson)
-            return results;
-        const pkg = readPackageJson(nearestPkgJson);
-        if (!pkg)
-            return results;
-        // Check the nearest package itself (e.g. @gjsify/webgl running its own
-        // test bundle — webgl never lists itself in dependencies)
-        const ownName = typeof pkg['name'] === 'string' ? pkg['name'] : '';
-        if (ownName) {
-            const ownNative = checkPackage(dirname(nearestPkgJson), ownName, arch);
-            if (ownNative)
-                results.push(ownNative);
-        }
-        const deps = pkg['dependencies'];
-        if (!deps)
-            return results;
-        for (const depName of Object.keys(deps)) {
-            try {
-                // Resolve the package's main entry, then walk up to find its package.json.
-                // We cannot use require.resolve(name + '/package.json') because packages
-                // with an "exports" field may not expose ./package.json as a subpath.
-                const entryPath = req.resolve(depName);
-                const depPkgJson = findNearestPackageJson(dirname(entryPath));
-                if (!depPkgJson)
-                    continue;
-                const native = checkPackage(dirname(depPkgJson), depName, arch);
-                if (native)
-                    results.push(native);
-            }
-            catch {
-                // Dependency not resolvable — skip
-            }
-        }
-    }
-    catch {
-        // Resolution failed — return empty
-    }
-    return results;
-}
 /**
  * Build the LD_LIBRARY_PATH and GI_TYPELIB_PATH env var values for the detected native packages.
  * Prepends the new paths to any existing values from the environment.

package/lib/utils/run-gjs.d.ts

@@ -1,9 +1,19 @@
+/**
+ * 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 declare function computeNativeEnvForBundle(bundlePath: string, cwd?: string): {
+    env: {
+        LD_LIBRARY_PATH: string;
+        GI_TYPELIB_PATH: string;
+    };
+    envPrefix: string;
+};
 /**
  * Run a GJS bundle, automatically setting LD_LIBRARY_PATH and GI_TYPELIB_PATH
- * for any installed native gjsify packages.
- *
- * Detection uses two strategies:
- * 1. Filesystem walk from CWD (finds packages in the user's project)
- * 2. require.resolve from the bundle's location (finds packages in the CLI's dependency tree)
+ * for any installed native gjsify packages discoverable from either the CWD
+ * or the bundle's own node_modules tree.
  */
 export declare function runGjsBundle(bundlePath: string, extraArgs?: string[]): Promise<void>;

package/lib/utils/run-gjs.js

@@ -1,29 +1,53 @@
 // Shared utility for running a GJS bundle with native package env vars.
-// Used by both the `run` and `showcase` commands.
+// 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 { resolve } from 'node:path';
-import { detectNativePackages, resolveNativePackages, buildNativeEnv } from './detect-native-packages.js';
+import { dirname, resolve } from 'node:path';
+import { detectNativePackages, buildNativeEnv } from './detect-native-packages.js';
 /**
- * Run a GJS bundle, automatically setting LD_LIBRARY_PATH and GI_TYPELIB_PATH
- * for any installed native gjsify packages.
- *
- * Detection uses two strategies:
- * 1. Filesystem walk from CWD (finds packages in the user's project)
- * 2. require.resolve from the bundle's location (finds packages in the CLI's dependency tree)
+ * 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 async function runGjsBundle(bundlePath, extraArgs = []) {
-    const cwd = process.cwd();
+export function computeNativeEnvForBundle(bundlePath, cwd = process.cwd()) {
     const resolvedBundle = resolve(bundlePath);
-    // Detect from CWD (filesystem walk) + bundle location (require.resolve)
     const cwdPackages = detectNativePackages(cwd);
-    const bundlePackages = resolveNativePackages(resolvedBundle);
-    // Merge, deduplicating by name (CWD takes precedence)
-    const seen = new Set(cwdPackages.map(p => p.name));
+    const bundlePackages = detectNativePackages(dirname(resolvedBundle));
+    const seen = new Set(cwdPackages.map((p) => p.name));
     const nativePackages = [
         ...cwdPackages,
-        ...bundlePackages.filter(p => !seen.has(p.name)),
+        ...bundlePackages.filter((p) => !seen.has(p.name)),
     ];
-    const nativeEnv = buildNativeEnv(nativePackages);
+    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, extraArgs = []) {
+    const { env: nativeEnv, envPrefix } = computeNativeEnvForBundle(bundlePath);
     const env = {
         ...process.env,
         ...nativeEnv,
@@ -32,11 +56,7 @@ export async function runGjsBundle(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 envPrefix = Object.entries(nativeEnv)
-        .filter(([, value]) => value !== undefined && value !== '')
-        .map(([key, value]) => `${key}=${value}`)
-        .join(' ');
-    const gjsCommand = ['gjs', ...gjsArgs.map(a => a.includes(' ') ? `"${a}"` : a)].join(' ');
+    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((resolvePromise, reject) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gjsify/cli",
-  "version": "0.3.16",
+  "version": "0.3.18",
   "description": "CLI for Gjsify",
   "type": "module",
   "main": "lib/index.js",
@@ -23,19 +23,19 @@
     "cli"
   ],
   "dependencies": {
-    "@gjsify/create-app": "^0.3.16",
-    "@gjsify/node-polyfills": "^0.3.16",
-    "@gjsify/npm-registry": "^0.3.16",
-    "@gjsify/resolve-npm": "^0.3.16",
-    "@gjsify/rolldown-plugin-gjsify": "^0.3.16",
-    "@gjsify/rolldown-plugin-pnp": "^0.3.16",
-    "@gjsify/semver": "^0.3.16",
-    "@gjsify/tar": "^0.3.16",
-    "@gjsify/web-polyfills": "^0.3.16",
+    "@gjsify/create-app": "^0.3.18",
+    "@gjsify/node-polyfills": "^0.3.18",
+    "@gjsify/npm-registry": "^0.3.18",
+    "@gjsify/resolve-npm": "^0.3.18",
+    "@gjsify/rolldown-plugin-gjsify": "^0.3.18",
+    "@gjsify/rolldown-plugin-pnp": "^0.3.18",
+    "@gjsify/semver": "^0.3.18",
+    "@gjsify/tar": "^0.3.18",
+    "@gjsify/web-polyfills": "^0.3.18",
     "cosmiconfig": "^9.0.1",
     "get-tsconfig": "^4.14.0",
     "pkg-types": "^2.3.1",
-    "rolldown": "^1.0.0-rc.18",
+    "rolldown": "^1.0.0",
     "yargs": "^18.0.0"
   },
   "devDependencies": {

package/src/commands/build.ts

@@ -8,11 +8,20 @@ export const buildCommand: Command<any, CliBuildOptions> = {
     builder: (yargs) => {
         return yargs
             .option('entry-points', {
-                description: "The entry points you want to bundle",
+                description: "The entry points you want to bundle. Defaults to bundler.input from package.json#gjsify or .gjsifyrc.js, falling back to src/index.ts when neither is set.",
                 array: true,
                 type: 'string',
                 normalize: true,
-                default: ['src/index.ts'],
+                // No yargs `default` here on purpose. A yargs default value
+                // is indistinguishable from "user passed the flag" in the
+                // parsed args (cliArgs.entryPoints?.length is truthy either
+                // way), so the merge step in config.ts would unconditionally
+                // overwrite `bundler.input` declared in package.json#gjsify —
+                // silently ignoring `gjsify.bundler.input: "src/start.ts"`
+                // and producing a bundle from the wrong entry point. The
+                // fallback to src/index.ts is applied in config.ts AFTER
+                // merging with the cosmiconfig data.
+                defaultDescription: "src/index.ts (fallback)",
                 coerce: (arg: string[]) => {
                     // Removes duplicates
                     return [...new Set(arg)];
@@ -45,10 +54,10 @@ export const buildCommand: Command<any, CliBuildOptions> = {
                 normalize: true,
             })
             .option('minify', {
-                description: "When enabled, the generated code will be minified instead of pretty-printed",
+                description: "Minify the bundled output. Defaults to true; use --no-minify to emit pretty-printed code (e.g. for debugging or readable bundle review).",
                 type: 'boolean',
                 normalize: true,
-                default: false
+                defaultDescription: 'true',
             })
             .option('library', {
                 description: "Use this if you want to build a library for Gjsify",

package/src/commands/showcase.ts

@@ -2,7 +2,6 @@ import type { Command } from '../types/index.js';
 import { discoverShowcases, findShowcase } from '../utils/discover-showcases.js';
 import {
     runMinimalChecks,
-    checkGwebgl,
     detectPackageManager,
     buildInstallCommand,
 } from '../utils/check-system-deps.js';
@@ -79,13 +78,16 @@ export const showcaseCommand: Command<any, ShowcaseOptions> = {
             process.exit(1);
         }
 
-        // System dependency check before delegating — only what this showcase needs.
+        // System dependency check before delegating — only system libs (gjs,
+        // gtk4, …). The showcase's npm deps (incl. `@gjsify/webgl` with the
+        // gwebgl Vala prebuild) are fetched by `gjsify dlx` into the npm
+        // cache, and `runGjsBundle()` picks the prebuild up from the bundle
+        // dir via `detectNativePackages()`. Pre-flight-checking npm deps
+        // here would fail for `npx @gjsify/cli showcase` (no project
+        // node_modules, CLI doesn't dep on the showcase libs).
         const results = runMinimalChecks();
-        if (showcase.needsWebgl) {
-            results.push(checkGwebgl(process.cwd()));
-        }
         const missingHard = results.filter(
-            (r) => !r.found && (r.severity === 'required' || r.id === 'gwebgl'),
+            (r) => !r.found && r.severity === 'required',
         );
         if (missingHard.length > 0) {
             console.error('Missing system dependencies:\n');

package/src/config.ts

@@ -231,10 +231,20 @@ export class Config {
         const transform = (bundler.transform ??= {});
 
         if (cliArgs.entryPoints?.length) bundler.input = cliArgs.entryPoints;
+        // Fallback when neither the CLI flag nor the cosmiconfig data set an
+        // entry point. Applied here (post-merge) rather than as a yargs
+        // `default:` because yargs defaults are indistinguishable from
+        // user-set values, and would silently overwrite `bundler.input`
+        // declared in package.json#gjsify.
+        if (!bundler.input) bundler.input = ['src/index.ts'];
         if (cliArgs.outfile !== undefined) output.file = cliArgs.outfile;
         if (cliArgs.outdir !== undefined) output.dir = cliArgs.outdir;
         if (cliArgs.format !== undefined) output.format = cliArgs.format as 'esm' | 'cjs' | 'iife';
+        // CLI flag wins over config; if neither is set, minify by default.
+        // Pretty-printed output is opt-in via `--no-minify` or
+        // `bundler.output.minify: false` in the config.
         if (cliArgs.minify !== undefined) output.minify = cliArgs.minify;
+        if (output.minify === undefined) output.minify = true;
         if (cliArgs.logLevel) {
             // Map esbuild log levels to Rolldown's narrower set:
             //   esbuild   → rolldown

package/src/utils/detect-native-packages.ts

@@ -1,11 +1,18 @@
 // Utility to find npm packages with gjsify native prebuilds.
 // Packages declare: "gjsify": { "prebuilds": "<dir>" } in their package.json.
 // The CLI uses this to auto-set LD_LIBRARY_PATH / GI_TYPELIB_PATH before running gjs.
+//
+// One algorithm — `detectNativePackages(startDir)` — walks up from `startDir`
+// and exhaustively scans every `node_modules` it finds. Used by:
+//   * `gjsify run`, `gjsify info`, `gjsify install` — startDir = process.cwd()
+//   * `runGjsBundle()` — startDir = dirname(bundlePath), so DLX-cache layouts
+//     (`~/.cache/gjsify/dlx/<sha>/.../node_modules/<pkg>/dist/bundle.js`) get
+//     their full transitive prebuild set picked up automatically. The
+//     transitive walk is what makes `gjsify showcase` / `gjsify dlx` work
+//     for packages whose Vala typelibs live in *indirect* deps.
 
 import { readdirSync, existsSync, readFileSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import { dirname, join, resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
+import { join, resolve } from 'node:path';
 
 export interface NativePackage {
     /** npm package name, e.g. "@gjsify/webgl" */
@@ -129,76 +136,6 @@ export function detectNativePackages(startDir: string): NativePackage[] {
     return merged;
 }
 
-/** Walk up from dir to find the nearest package.json. */
-function findNearestPackageJson(startDir: string): string | null {
-    let dir = resolve(startDir);
-    while (true) {
-        const candidate = join(dir, 'package.json');
-        if (existsSync(candidate)) return candidate;
-        const parent = resolve(dir, '..');
-        if (parent === dir) return null;
-        dir = parent;
-    }
-}
-
-/**
- * Resolve native packages using Node.js module resolution from a given file path.
- * Reads the nearest package.json to discover dependencies, then checks each
- * for gjsify native prebuilds metadata.
- *
- * Also checks the **nearest package.json itself** — a workspace package may
- * have its own prebuilds (e.g. `@gjsify/webgl` running its own test) and
- * never list itself in dependencies.
- *
- * This complements detectNativePackages() (filesystem walk from CWD) by using
- * require.resolve() — which handles hoisting, workspaces, and nested node_modules.
- */
-export function resolveNativePackages(fromFilePath: string): NativePackage[] {
-    const arch = nodeArchToLinuxArch(process.arch);
-    const results: NativePackage[] = [];
-
-    try {
-        const req = createRequire(pathToFileURL(fromFilePath).href);
-
-        // Find the nearest package.json to get the dependency list
-        const nearestPkgJson = findNearestPackageJson(dirname(resolve(fromFilePath)));
-        if (!nearestPkgJson) return results;
-
-        const pkg = readPackageJson(nearestPkgJson);
-        if (!pkg) return results;
-
-        // Check the nearest package itself (e.g. @gjsify/webgl running its own
-        // test bundle — webgl never lists itself in dependencies)
-        const ownName = typeof pkg['name'] === 'string' ? pkg['name'] as string : '';
-        if (ownName) {
-            const ownNative = checkPackage(dirname(nearestPkgJson), ownName, arch);
-            if (ownNative) results.push(ownNative);
-        }
-
-        const deps = pkg['dependencies'] as Record<string, string> | undefined;
-        if (!deps) return results;
-
-        for (const depName of Object.keys(deps)) {
-            try {
-                // Resolve the package's main entry, then walk up to find its package.json.
-                // We cannot use require.resolve(name + '/package.json') because packages
-                // with an "exports" field may not expose ./package.json as a subpath.
-                const entryPath = req.resolve(depName);
-                const depPkgJson = findNearestPackageJson(dirname(entryPath));
-                if (!depPkgJson) continue;
-                const native = checkPackage(dirname(depPkgJson), depName, arch);
-                if (native) results.push(native);
-            } catch {
-                // Dependency not resolvable — skip
-            }
-        }
-    } catch {
-        // Resolution failed — return empty
-    }
-
-    return results;
-}
-
 /**
  * Build the LD_LIBRARY_PATH and GI_TYPELIB_PATH env var values for the detected native packages.
  * Prepends the new paths to any existing values from the environment.

package/src/utils/run-gjs.ts

@@ -1,34 +1,63 @@
 // Shared utility for running a GJS bundle with native package env vars.
-// Used by both the `run` and `showcase` commands.
+// 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 { resolve } from 'node:path';
-import { detectNativePackages, resolveNativePackages, buildNativeEnv } from './detect-native-packages.js';
+import { dirname, resolve } from 'node:path';
+import { detectNativePackages, buildNativeEnv } from './detect-native-packages.js';
 
 /**
- * Run a GJS bundle, automatically setting LD_LIBRARY_PATH and GI_TYPELIB_PATH
- * for any installed native gjsify packages.
- *
- * Detection uses two strategies:
- * 1. Filesystem walk from CWD (finds packages in the user's project)
- * 2. require.resolve from the bundle's location (finds packages in the CLI's dependency tree)
+ * 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 async function runGjsBundle(bundlePath: string, extraArgs: string[] = []): Promise<void> {
-    const cwd = process.cwd();
+export function computeNativeEnvForBundle(
+    bundlePath: string,
+    cwd: string = process.cwd(),
+): { env: { LD_LIBRARY_PATH: string; GI_TYPELIB_PATH: string }; envPrefix: string } {
     const resolvedBundle = resolve(bundlePath);
 
-    // Detect from CWD (filesystem walk) + bundle location (require.resolve)
     const cwdPackages = detectNativePackages(cwd);
-    const bundlePackages = resolveNativePackages(resolvedBundle);
+    const bundlePackages = detectNativePackages(dirname(resolvedBundle));
 
-    // Merge, deduplicating by name (CWD takes precedence)
-    const seen = new Set(cwdPackages.map(p => p.name));
+    const seen = new Set(cwdPackages.map((p) => p.name));
     const nativePackages = [
         ...cwdPackages,
-        ...bundlePackages.filter(p => !seen.has(p.name)),
+        ...bundlePackages.filter((p) => !seen.has(p.name)),
     ];
 
-    const nativeEnv = buildNativeEnv(nativePackages);
+    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,
@@ -40,11 +69,7 @@ export async function runGjsBundle(bundlePath: string, extraArgs: string[] = [])
     // 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 envPrefix = Object.entries(nativeEnv)
-        .filter(([, value]) => value !== undefined && value !== '')
-        .map(([key, value]) => `${key}=${value}`)
-        .join(' ');
-    const gjsCommand = ['gjs', ...gjsArgs.map(a => a.includes(' ') ? `"${a}"` : a)].join(' ');
+    const gjsCommand = ['gjs', ...gjsArgs.map((a) => (a.includes(' ') ? `"${a}"` : a))].join(' ');
     console.log(`$ ${envPrefix ? `${envPrefix} ` : ''}${gjsCommand}`);
 
     const child = spawn('gjs', gjsArgs, { env, stdio: 'inherit' });