@gjsify/cli 0.3.20 → 0.4.0

package/src/utils/discover-showcases.ts

@@ -1,75 +0,0 @@
-// Static discovery of showcase packages from `showcases.json`.
-//
-// Earlier versions read showcases from the CLI's own `package.json#dependencies`
-// — every showcase had to be a direct CLI dependency. That made the CLI tarball
-// blow up with each new showcase and required a CLI rebuild to publish a new
-// one. Static manifest decouples both: the CLI reads the manifest at runtime,
-// `gjsify showcase <name>` delegates to `gjsify dlx <package>`.
-
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-export interface ShowcaseInfo {
-    /** Short name, e.g. "three-postprocessing-pixel" */
-    name: string;
-    /** Full npm package name, e.g. "@gjsify/example-dom-three-postprocessing-pixel" */
-    packageName: string;
-    /** Category: "dom" or "node" */
-    category: string;
-    /** Description for the list view */
-    description: string;
-    /** Whether the showcase needs the gwebgl native prebuild. */
-    needsWebgl: boolean;
-}
-
-interface ManifestEntry {
-    name: string;
-    package: string;
-    category: string;
-    description?: string;
-    needsWebgl?: boolean;
-}
-
-interface Manifest {
-    showcases: ManifestEntry[];
-}
-
-function manifestPath(): string {
-    // `showcases.json` lives at the package root: ../../showcases.json from lib/utils/.
-    return join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'showcases.json');
-}
-
-/**
- * Read the curated showcase list from `showcases.json`. Returns showcases
- * sorted by category then name. An empty list (or missing manifest) yields
- * an empty array — `gjsify showcase` then prints the empty-state message.
- */
-export function discoverShowcases(): ShowcaseInfo[] {
-    const path = manifestPath();
-    if (!existsSync(path)) return [];
-
-    let manifest: Manifest;
-    try {
-        manifest = JSON.parse(readFileSync(path, 'utf-8')) as Manifest;
-    } catch {
-        return [];
-    }
-    if (!Array.isArray(manifest.showcases)) return [];
-
-    const showcases: ShowcaseInfo[] = manifest.showcases.map((e) => ({
-        name: e.name,
-        packageName: e.package,
-        category: e.category,
-        description: e.description ?? '',
-        needsWebgl: Boolean(e.needsWebgl),
-    }));
-
-    showcases.sort((a, b) => a.category.localeCompare(b.category) || a.name.localeCompare(b.name));
-    return showcases;
-}
-
-/** Find a single showcase by short name. */
-export function findShowcase(name: string): ShowcaseInfo | undefined {
-    return discoverShowcases().find((e) => e.name === name);
-}

package/src/utils/dlx-cache.ts

@@ -1,135 +0,0 @@
-// Cache for `gjsify dlx` — content-addressable, atomic, parallel-safe.
-//
-// Pattern adapted from refs/pnpm/exec/commands/src/dlx.ts:
-//   - cache key = sha256 over sorted [packages, registries]
-//   - cache layout: <root>/<sha>/{pkg,timestamp-pid}/
-//   - prepare into a fresh temp dir, then atomically swap a `pkg` symlink
-//   - TTL via lstat mtime + maxAgeMinutes (default 7 days)
-
-import { createHash } from 'node:crypto';
-import { lstatSync, mkdirSync, realpathSync, renameSync, rmSync, symlinkSync, type Stats } from 'node:fs';
-import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
-
-const ONE_MINUTE_MS = 60_000;
-const DEFAULT_TTL_MIN = 60 * 24 * 7; // 7 days
-
-function lexCompare(a: string, b: string): number {
-    return a < b ? -1 : a > b ? 1 : 0;
-}
-
-interface CacheKeyOpts {
-    packages: string[];
-    registries?: Record<string, string>;
-}
-
-/** Stable, sorted JSON hash of inputs. */
-export function createCacheKey(opts: CacheKeyOpts): string {
-    const sortedPkgs = [...opts.packages].sort(lexCompare);
-    const sortedRegs = Object.entries(opts.registries ?? {}).sort(([a], [b]) => lexCompare(a, b));
-    const payload = JSON.stringify([sortedPkgs, sortedRegs]);
-    return createHash('sha256').update(payload).digest('hex');
-}
-
-/** $XDG_CACHE_HOME/gjsify/dlx — created if missing. */
-export function dlxCacheRoot(): string {
-    const xdg = process.env.XDG_CACHE_HOME;
-    const base = xdg && xdg.length > 0 ? xdg : join(homedir(), '.cache');
-    const root = join(base, 'gjsify', 'dlx');
-    mkdirSync(root, { recursive: true });
-    return root;
-}
-
-/** Per-key cache directory: <root>/<sha>. */
-export function cacheDirFor(cacheKey: string): string {
-    const dir = join(dlxCacheRoot(), cacheKey);
-    mkdirSync(dir, { recursive: true });
-    return dir;
-}
-
-/** A fresh prepare directory under the per-key cache, named timestamp-pid. */
-export function makePrepareDir(cacheDir: string): string {
-    const name = `${Date.now().toString(16)}-${process.pid.toString(16)}`;
-    const dir = join(cacheDir, name);
-    mkdirSync(dir, { recursive: true });
-    return dir;
-}
-
-/**
- * If <cacheDir>/pkg points to a target whose mtime + maxAge < now, return its
- * realpath. Returns undefined when the link doesn't exist, isn't a symlink,
- * has been removed, or has expired.
- */
-export function getValidCachedPkg(
-    cacheDir: string,
-    maxAgeMinutes: number = DEFAULT_TTL_MIN,
-): string | undefined {
-    const linkPath = join(cacheDir, 'pkg');
-    let stats: Stats;
-    try {
-        stats = lstatSync(linkPath);
-    } catch (err) {
-        if ((err as NodeJS.ErrnoException).code === 'ENOENT') return undefined;
-        throw err;
-    }
-    if (!stats.isSymbolicLink()) return undefined;
-
-    let target: string;
-    try {
-        target = realpathSync(linkPath);
-    } catch {
-        return undefined;
-    }
-
-    const ageMs = Date.now() - stats.mtime.getTime();
-    return ageMs <= maxAgeMinutes * ONE_MINUTE_MS ? target : undefined;
-}
-
-/**
- * Atomically swap `<cacheDir>/pkg` to point at `prepareDir`.
- *
- * Strategy:
- *   1. Create new symlink `<cacheDir>/pkg-<rand>` → prepareDir.
- *   2. `rename(pkg-<rand>, pkg)` — POSIX guarantees rename-over-existing is atomic.
- *
- * Returns the realpath of the new live target. EBUSY/EEXIST indicates a race
- * — a parallel process won, return its realpath.
- */
-export function symlinkSwap(cacheDir: string, prepareDir: string): string {
-    const linkPath = join(cacheDir, 'pkg');
-    const tmpName = `pkg.tmp-${Date.now().toString(16)}-${process.pid.toString(16)}`;
-    const tmpLink = join(cacheDir, tmpName);
-
-    try {
-        symlinkSync(prepareDir, tmpLink, 'dir');
-    } catch (err) {
-        // If we cannot even create the tmp link, give up.
-        throw err;
-    }
-
-    try {
-        renameSync(tmpLink, linkPath);
-    } catch (err) {
-        const code = (err as NodeJS.ErrnoException).code;
-        if (code === 'EBUSY' || code === 'EPERM' || code === 'EEXIST') {
-            // Race lost — clean up our tmp and use whoever won.
-            try { rmSync(tmpLink); } catch {}
-            return realpathSync(linkPath);
-        }
-        throw err;
-    }
-
-    return realpathSync(linkPath);
-}
-
-/** Clean up `<cacheDir>/<oldPrepareDir>` siblings older than `maxAgeMinutes`. */
-export function cleanupStalePrepareDirs(cacheDir: string, _maxAgeMinutes: number = DEFAULT_TTL_MIN): void {
-    // Out of scope for Phase 1 — pnpm has the same TODO. Leaving a stub so
-    // call sites already exist when we do implement it.
-    void cacheDir;
-}
-
-/** Resolve absolute path to the installed package's directory inside cache. */
-export function resolveInstalledPkgDir(cachedRoot: string, pkgName: string): string {
-    return resolve(cachedRoot, 'node_modules', pkgName);
-}

package/src/utils/install-backend-native.ts

@@ -1,363 +0,0 @@
-// Native install backend — GJS-runnable replacement for `npm install`.
-//
-// Pipeline: parse specs → resolve deps via @gjsify/npm-registry packuments and
-// @gjsify/semver → download tarballs in parallel → extract into a flat
-// node_modules/ via @gjsify/tar. Output layout matches `npm install` so the
-// existing `runGjsBundle()` prebuild detection works without branching.
-//
-// Out of scope (deferred to Phase 4): lockfile, peerDependencies validation,
-// lifecycle scripts, git/file specs.
-
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as os from "node:os";
-
-import {
-    Range,
-    SemVer,
-    maxSatisfying,
-} from "@gjsify/semver";
-import {
-    DEFAULT_REGISTRY,
-    fetchPackument,
-    fetchTarball,
-    parseNpmrc,
-    type NpmrcConfig,
-    type Packument,
-    type PackumentVersion,
-} from "@gjsify/npm-registry";
-import { extractTarball } from "@gjsify/tar";
-
-import type { InstallOptions } from "./install-backend.ts";
-
-const DEFAULT_CONCURRENCY = Number(process.env.GJSIFY_INSTALL_CONCURRENCY ?? "8") || 8;
-
-interface ParsedSpec {
-    name: string;
-    range: string;
-}
-
-interface ResolvedNode {
-    name: string;
-    version: string;
-    tarballUrl: string;
-    integrity?: string;
-    dependencies: Record<string, string>;
-    optionalDependencies: Record<string, string>;
-    bin?: string | Record<string, string>;
-}
-
-const LOCKFILE_NAME = "gjsify-lock.json";
-const LOCKFILE_VERSION = 1;
-
-interface LockfileEntry {
-    version: string;
-    resolved: string;
-    integrity?: string;
-    dependencies?: Record<string, string>;
-    bin?: string | Record<string, string>;
-}
-
-interface Lockfile {
-    lockfileVersion: number;
-    /** Top-level specs used to seed this lockfile (preserves user intent). */
-    requested: string[];
-    /** Pinned packages keyed by name. */
-    packages: Record<string, LockfileEntry>;
-}
-
-export async function installPackagesNative(opts: InstallOptions): Promise<void> {
-    if (opts.specs.length === 0) {
-        throw new Error("installPackagesNative: empty specs list");
-    }
-
-    fs.mkdirSync(opts.prefix, { recursive: true });
-    const npmrc = await loadNpmrc(opts);
-    const log = makeLogger(opts.verbose ?? false);
-
-    const lockfilePath = path.join(opts.prefix, LOCKFILE_NAME);
-    const existingLock = readLockfile(lockfilePath);
-
-    let nodes: ResolvedNode[];
-    if (existingLock && (opts.frozen || lockfileMatchesRequest(existingLock, opts.specs))) {
-        log("install: using lockfile (%d package(s))", Object.keys(existingLock.packages).length);
-        nodes = lockfileToNodes(existingLock);
-    } else {
-        if (opts.frozen) {
-            throw new Error(
-                `install: --frozen requested but ${lockfilePath} is missing or stale (specs differ)`,
-            );
-        }
-        log("install: resolving %d top-level spec(s) → %s", opts.specs.length, opts.prefix);
-        nodes = await resolveDeps(opts.specs, npmrc, log);
-        if (opts.lockfile) {
-            writeLockfile(lockfilePath, opts.specs, nodes);
-            log("install: wrote %s (%d entries)", LOCKFILE_NAME, nodes.length);
-        }
-    }
-
-    log("install: downloading %d tarball(s)", nodes.length);
-    await downloadAndExtractAll(nodes, opts.prefix, npmrc, log);
-    await linkBins(nodes, opts.prefix, log);
-    log("install: done");
-}
-
-async function resolveDeps(
-    specs: string[],
-    npmrc: NpmrcConfig,
-    log: Logger,
-): Promise<ResolvedNode[]> {
-    const packumentCache = new Map<string, Promise<Packument>>();
-    const fetchPkg = (name: string): Promise<Packument> => {
-        const cached = packumentCache.get(name);
-        if (cached) return cached;
-        const fresh = fetchPackument(name, { npmrc });
-        packumentCache.set(name, fresh);
-        return fresh;
-    };
-
-    const resolved = new Map<string, ResolvedNode>();
-    const queue: ParsedSpec[] = specs.map(parseSpec);
-
-    while (queue.length > 0) {
-        const spec = queue.shift() as ParsedSpec;
-        if (resolved.has(spec.name)) {
-            // Single-version-per-name policy (npm v6 semantics). Phase 4 v2
-            // (when peer-dep validation lands) revisits this for duplication.
-            continue;
-        }
-        const packument = await fetchPkg(spec.name);
-        const version = pickVersion(packument, spec.range);
-        if (!version) {
-            throw new Error(`No version of ${spec.name} satisfies ${spec.range}`);
-        }
-        const v = packument.versions[version];
-        if (!v) {
-            throw new Error(
-                `Packument for ${spec.name} promised ${version} but no entry exists`,
-            );
-        }
-        const node: ResolvedNode = {
-            name: spec.name,
-            version,
-            tarballUrl: v.dist.tarball,
-            integrity: v.dist.integrity,
-            dependencies: v.dependencies ?? {},
-            optionalDependencies: v.optionalDependencies ?? {},
-            bin: v.bin,
-        };
-        resolved.set(spec.name, node);
-        log("resolve: %s@%s ← %s", spec.name, version, spec.range);
-
-        for (const [depName, depRange] of Object.entries(node.dependencies)) {
-            if (!resolved.has(depName)) queue.push({ name: depName, range: depRange });
-        }
-        for (const [depName, depRange] of Object.entries(node.optionalDependencies)) {
-            if (!resolved.has(depName)) queue.push({ name: depName, range: depRange });
-        }
-    }
-    return Array.from(resolved.values());
-}
-
-function readLockfile(lockfilePath: string): Lockfile | null {
-    if (!fs.existsSync(lockfilePath)) return null;
-    try {
-        const parsed = JSON.parse(fs.readFileSync(lockfilePath, "utf-8")) as Lockfile;
-        if (parsed.lockfileVersion !== LOCKFILE_VERSION) return null;
-        if (!parsed.packages || typeof parsed.packages !== "object") return null;
-        return parsed;
-    } catch {
-        return null;
-    }
-}
-
-function writeLockfile(lockfilePath: string, specs: string[], nodes: ResolvedNode[]): void {
-    const packages: Record<string, LockfileEntry> = {};
-    // Sort for deterministic output (diff-friendly).
-    const sorted = [...nodes].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
-    for (const node of sorted) {
-        packages[node.name] = {
-            version: node.version,
-            resolved: node.tarballUrl,
-            integrity: node.integrity,
-            dependencies:
-                Object.keys(node.dependencies).length > 0 ? node.dependencies : undefined,
-            bin: node.bin,
-        };
-    }
-    const lockfile: Lockfile = {
-        lockfileVersion: LOCKFILE_VERSION,
-        requested: [...specs],
-        packages,
-    };
-    fs.writeFileSync(lockfilePath, JSON.stringify(lockfile, null, 2) + "\n");
-}
-
-function lockfileToNodes(lockfile: Lockfile): ResolvedNode[] {
-    return Object.entries(lockfile.packages).map(([name, entry]) => ({
-        name,
-        version: entry.version,
-        tarballUrl: entry.resolved,
-        integrity: entry.integrity,
-        dependencies: entry.dependencies ?? {},
-        optionalDependencies: {},
-        bin: entry.bin,
-    }));
-}
-
-function lockfileMatchesRequest(lockfile: Lockfile, specs: string[]): boolean {
-    if (lockfile.requested.length !== specs.length) return false;
-    const a = [...lockfile.requested].sort();
-    const b = [...specs].sort();
-    return a.every((v, i) => v === b[i]);
-}
-
-function parseSpec(raw: string): ParsedSpec {
-    if (raw.startsWith("@")) {
-        const slash = raw.indexOf("/");
-        if (slash < 0) throw new Error(`Invalid spec (scoped name without slash): ${raw}`);
-        const at = raw.indexOf("@", slash);
-        if (at < 0) return { name: raw, range: "*" };
-        return { name: raw.slice(0, at), range: raw.slice(at + 1) || "*" };
-    }
-    const at = raw.indexOf("@");
-    if (at < 0) return { name: raw, range: "*" };
-    return { name: raw.slice(0, at), range: raw.slice(at + 1) || "*" };
-}
-
-function pickVersion(packument: Packument, range: string): string | null {
-    // dist-tag fast path: `latest`, `next`, ...
-    if (packument["dist-tags"][range]) return packument["dist-tags"][range];
-
-    // Validate range early so a typo fails loudly.
-    let parsedRange: Range;
-    try {
-        parsedRange = new Range(range);
-    } catch {
-        throw new Error(`Invalid version range for ${packument.name}: ${range}`);
-    }
-
-    const versions = Object.keys(packument.versions).filter((v) => {
-        try {
-            new SemVer(v);
-            return true;
-        } catch {
-            return false;
-        }
-    });
-    return maxSatisfying(versions, parsedRange);
-}
-
-async function downloadAndExtractAll(
-    nodes: ResolvedNode[],
-    prefix: string,
-    npmrc: NpmrcConfig,
-    log: Logger,
-): Promise<void> {
-    const queue = [...nodes];
-    const workers: Array<Promise<void>> = [];
-    const concurrency = Math.max(1, Math.min(DEFAULT_CONCURRENCY, queue.length));
-    for (let i = 0; i < concurrency; i++) {
-        workers.push(worker());
-    }
-    await Promise.all(workers);
-
-    async function worker(): Promise<void> {
-        while (queue.length > 0) {
-            const node = queue.shift();
-            if (!node) return;
-            const dest = path.join(prefix, "node_modules", node.name);
-            log("fetch: %s@%s ← %s", node.name, node.version, node.tarballUrl);
-            const bytes = await fetchTarball(node.tarballUrl, {
-                npmrc,
-                integrity: node.integrity,
-            });
-            fs.rmSync(dest, { recursive: true, force: true });
-            fs.mkdirSync(dest, { recursive: true });
-            await extractTarball(bytes, dest);
-        }
-    }
-}
-
-async function linkBins(nodes: ResolvedNode[], prefix: string, log: Logger): Promise<void> {
-    const binDir = path.join(prefix, "node_modules", ".bin");
-    let created = 0;
-    for (const node of nodes) {
-        if (!node.bin) continue;
-        const map = normalizeBin(node.name, node.bin);
-        if (map.size === 0) continue;
-        fs.mkdirSync(binDir, { recursive: true });
-        for (const [binName, binTarget] of map) {
-            const targetAbs = path.join(prefix, "node_modules", node.name, binTarget);
-            if (!fs.existsSync(targetAbs)) continue;
-            try {
-                fs.chmodSync(targetAbs, 0o755);
-            } catch {
-                /* best effort */
-            }
-            const linkPath = path.join(binDir, binName);
-            fs.rmSync(linkPath, { force: true });
-            const rel = path.relative(binDir, targetAbs);
-            try {
-                fs.symlinkSync(rel, linkPath);
-                created++;
-            } catch {
-                fs.copyFileSync(targetAbs, linkPath);
-                fs.chmodSync(linkPath, 0o755);
-                created++;
-            }
-        }
-    }
-    if (created > 0) log("bin: linked %d entry(ies) under .bin/", created);
-}
-
-function normalizeBin(pkgName: string, bin: string | Record<string, string>): Map<string, string> {
-    const out = new Map<string, string>();
-    if (typeof bin === "string") {
-        // String form is shorthand for `{ <last-segment-of-pkgName>: <bin> }`.
-        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;
-}
-
-async function loadNpmrc(opts: InstallOptions): Promise<NpmrcConfig> {
-    const home = os.homedir();
-    const homeRc = path.join(home, ".npmrc");
-    let parsed: NpmrcConfig = {
-        registry: opts.registry ?? DEFAULT_REGISTRY,
-        scopes: {},
-        authTokens: {},
-        basicAuth: {},
-    };
-    if (fs.existsSync(homeRc)) {
-        try {
-            parsed = parseNpmrc(fs.readFileSync(homeRc, "utf-8"));
-        } catch (e) {
-            // Don't let a busted .npmrc prevent installs from anonymous registries.
-            console.warn(`gjsify install: ignoring malformed ${homeRc}: ${(e as Error).message}`);
-        }
-    }
-    if (opts.registry) {
-        parsed.registry = opts.registry;
-    }
-    return parsed;
-}
-
-type Logger = (fmt: string, ...args: unknown[]) => void;
-
-function makeLogger(verbose: boolean): Logger {
-    if (!verbose) {
-        return () => {
-            /* silent unless verbose */
-        };
-    }
-    return (fmt, ...args) => {
-        const msg = fmt.replace(/%s|%d/g, () => String(args.shift()));
-        process.stderr.write(`gjsify install: ${msg}\n`);
-    };
-}

package/src/utils/install-backend.ts

@@ -1,88 +0,0 @@
-// Install backend abstraction.
-//
-// Default: native backend (resolves packuments via @gjsify/npm-registry,
-// extracts tarballs via @gjsify/tar — no Node, no npm required at runtime).
-// Fallback: `npm install --no-package-lock --no-audit --no-fund --prefix <dir> <specs...>`,
-// for parity with the legacy code path. Switched via
-// `GJSIFY_INSTALL_BACKEND=native|npm`.
-//
-// `gjsify dlx` uses this seam — installing under a cache prefix, with no
-// package.json update to the user's project. The native backend matches that
-// workflow without ever shelling out to Node.
-//
-// `--no-package-lock` keeps the cache prepare dir hermetic; the cache key
-// already covers reproducibility. `--no-audit --no-fund` cuts ~5s off cold runs.
-
-import { spawn } from 'node:child_process';
-import { writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-export interface InstallOptions {
-    /** Directory to install into (npm `--prefix`). Created by caller. */
-    prefix: string;
-    /** npm-resolvable specs: `name`, `name@version`, `git+https://...`, tarball URL, ... */
-    specs: string[];
-    /** Verbose logging passes through `--loglevel verbose`. */
-    verbose?: boolean;
-    /** Optional registry override (writes a temp `.npmrc` in prefix). */
-    registry?: string;
-    /**
-     * Native backend only: write `<prefix>/gjsify-lock.json` after a successful
-     * resolve. When the file exists on next call AND `frozen: true`, the
-     * resolver is skipped and downloads use the pinned tarball URL + integrity.
-     */
-    lockfile?: boolean;
-    /** Use `<prefix>/gjsify-lock.json` as the source of truth — fail if missing. */
-    frozen?: boolean;
-}
-
-const DEFAULT_BACKEND = process.env.GJSIFY_INSTALL_BACKEND ?? 'native';
-
-export async function installPackages(opts: InstallOptions): Promise<void> {
-    if (DEFAULT_BACKEND === 'npm') {
-        return installViaNpm(opts);
-    }
-    const { installPackagesNative } = await import('./install-backend-native.js');
-    return installPackagesNative(opts);
-}
-
-async function installViaNpm({ prefix, specs, verbose, registry }: InstallOptions): Promise<void> {
-    if (specs.length === 0) {
-        throw new Error('installPackages: empty specs list');
-    }
-
-    // Seed an empty package.json so npm doesn't walk up from prefix and pick
-    // up the user's project metadata. Cosmetic name/version only.
-    writeFileSync(
-        join(prefix, 'package.json'),
-        JSON.stringify({ name: 'gjsify-dlx-cache', version: '0.0.0', private: true }, null, 2),
-    );
-
-    if (registry) {
-        writeFileSync(join(prefix, '.npmrc'), `registry=${registry}\n`);
-    }
-
-    const args = [
-        'install',
-        '--no-package-lock',
-        '--no-audit',
-        '--no-fund',
-        '--prefix', prefix,
-        ...(verbose ? ['--loglevel', 'verbose'] : ['--loglevel', 'warn']),
-        ...specs,
-    ];
-
-    await new Promise<void>((resolve, reject) => {
-        const child = spawn('npm', args, { stdio: 'inherit' });
-        child.on('close', (code) => {
-            if (code === 0) resolve();
-            else reject(new Error(`npm install exited with code ${code}`));
-        });
-        child.on('error', (err) => {
-            const msg = (err as NodeJS.ErrnoException).code === 'ENOENT'
-                ? 'npm not found on PATH — install Node.js or set GJSIFY_INSTALL_BACKEND=native (not yet supported)'
-                : `npm install failed: ${err.message}`;
-            reject(new Error(msg));
-        });
-    });
-}