@gjsify/cli 0.29.0 → 0.31.0

package/lib/utils/install-backend-native.js

@@ -1766,7 +1766,7 @@ function readShebang(file) {
  * the same set from the same templates. See `./bin-shim.ts`.
  */
 export function writeBinEntry(opts) {
-    const { binDir, binName, targetAbs, gjs } = opts;
+    const { binDir, binName, targetAbs, gjs, nodeFallbackAbs } = opts;
     const platform = opts.platform ?? process.platform;
     const linkPath = path.join(binDir, binName);
     if (gjs) {
@@ -1775,7 +1775,7 @@ export function writeBinEntry(opts) {
         // plain symlink (or npm's three-file shim) under this very name.
         for (const stale of [linkPath, `${linkPath}.cmd`, `${linkPath}.ps1`])
             rmWithRetry(stale);
-        fs.writeFileSync(linkPath, buildShLauncher(targetAbs, { envPreamble: gjs.envPreamble, isGjsBundle: isBundle }));
+        fs.writeFileSync(linkPath, buildShLauncher(targetAbs, { envPreamble: gjs.envPreamble, isGjsBundle: isBundle, nodeFallbackAbs }));
         try {
             fs.chmodSync(linkPath, 0o755);
         }
@@ -1793,6 +1793,7 @@ export function writeBinEntry(opts) {
                 interpreterArgs: ['-m'],
                 target: targetAbs,
                 prependEnv,
+                fallback: nodeFallbackAbs === undefined ? undefined : { interpreter: 'node', target: nodeFallbackAbs },
             });
             fs.writeFileSync(`${linkPath}.cmd`, shims.cmd);
             fs.writeFileSync(`${linkPath}.ps1`, shims.ps1);
@@ -1872,11 +1873,16 @@ async function linkBins(nodes, prefix, log) {
             catch {
                 /* best effort */
             }
+            // Only a fallback that EXISTS is worth writing: a launcher naming a
+            // missing Node entry would trade exit 127 for a different exit 127.
+            const fallbackRel = picked.nodeFallback?.get(binName);
+            const fallbackAbs = fallbackRel === undefined ? undefined : path.join(pkgDir, fallbackRel);
             writeBinEntry({
                 binDir,
                 binName,
                 targetAbs,
                 gjs: picked.isGjsBin ? gjsEnvForPrefix() : undefined,
+                nodeFallbackAbs: fallbackAbs !== undefined && fs.existsSync(fallbackAbs) ? fallbackAbs : undefined,
             });
             created++;
         }

package/lib/utils/install-global.d.ts

@@ -29,8 +29,36 @@ export declare function defaultGlobalLayout(): GlobalLayout;
  * story already degrades on Node.
  */
 export declare const GJS_ENGINE_PACKAGES: readonly ["@gjsify/rolldown-native", "@gjsify/lightningcss-native", "@gjsify/oxfmt-native"];
-/** True when `<prefix>/node_modules/@gjsify/rolldown-native` is laid down. */
-export declare function hasBundlerEngineInstalled(prefix: string): boolean;
+/**
+ * The one engine whose absence is fatal rather than degrading: `gjsify build`
+ * has no fallback under GJS. Named separately because two different questions
+ * ("what do we install") and ("is a build possible") want different sets.
+ */
+export declare const BUNDLER_ENGINE_PACKAGE = "@gjsify/rolldown-native";
+/**
+ * True when a bundler engine `gjsify build` can actually LOAD is reachable from
+ * `dir`.
+ *
+ * This used to `existsSync` the bridge's own `package.json` and stop there. That
+ * answer was correct before ADR 0017 and is wrong after it: the bridge is now
+ * pure TypeScript (`files: ["lib", "meson.build", "src/rust", "src/vala"]`) and
+ * the binary lives in a per-target child (`@gjsify/rolldown-native-<os>-<arch>`).
+ * So "bridge present, child missing" reported `true` — which is why
+ * `self-update`'s repair gate could say "Already up to date" about a prefix whose
+ * engine cannot load. A live defect, not a hypothetical one.
+ *
+ * Asks `detectNativePackages` instead, which is the same walk-up
+ * `findRolldownNativeDir` performs at BUILD time. That matters more than the
+ * shortcut it replaces: an installer that disagrees with the builder about
+ * whether the engine is present is worse than one that is merely slow. It also
+ * makes the gjsify monorepo a no-op — the workspace symlink resolves — which is
+ * what keeps ADR 0001's non-destructive invariant safe from a registry copy
+ * landing on top of `packages/infra/rolldown-native`.
+ *
+ * `dir` is a prefix for a global install and a project root for a project one;
+ * the walk handles both.
+ */
+export declare function hasBundlerEngineInstalled(dir: string): boolean;
 /**
  * Best-effort install of the GJS-native engine packages into a global prefix.
  *

package/lib/utils/install-global.js

@@ -23,7 +23,7 @@
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
-import { detectNativePackages } from './detect-native-packages.js';
+import { detectHostLibc, detectNativePackages, hostPlatformTokens, platformPackageName, } from './detect-native-packages.js';
 import { buildLauncherShims, buildNativeEnvPreamble, buildShLauncher, isGjsBundlePath, parseShebang, pickBinMap, } from './bin-shim.js';
 /**
  * Compute the canonical global install layout for the current user. Honours
@@ -63,9 +63,43 @@ export const GJS_ENGINE_PACKAGES = [
     '@gjsify/lightningcss-native',
     '@gjsify/oxfmt-native',
 ];
-/** True when `<prefix>/node_modules/@gjsify/rolldown-native` is laid down. */
-export function hasBundlerEngineInstalled(prefix) {
-    return fs.existsSync(path.join(prefix, 'node_modules', '@gjsify/rolldown-native', 'package.json'));
+/**
+ * The one engine whose absence is fatal rather than degrading: `gjsify build`
+ * has no fallback under GJS. Named separately because two different questions
+ * ("what do we install") and ("is a build possible") want different sets.
+ */
+export const BUNDLER_ENGINE_PACKAGE = '@gjsify/rolldown-native';
+/**
+ * True when a bundler engine `gjsify build` can actually LOAD is reachable from
+ * `dir`.
+ *
+ * This used to `existsSync` the bridge's own `package.json` and stop there. That
+ * answer was correct before ADR 0017 and is wrong after it: the bridge is now
+ * pure TypeScript (`files: ["lib", "meson.build", "src/rust", "src/vala"]`) and
+ * the binary lives in a per-target child (`@gjsify/rolldown-native-<os>-<arch>`).
+ * So "bridge present, child missing" reported `true` — which is why
+ * `self-update`'s repair gate could say "Already up to date" about a prefix whose
+ * engine cannot load. A live defect, not a hypothetical one.
+ *
+ * Asks `detectNativePackages` instead, which is the same walk-up
+ * `findRolldownNativeDir` performs at BUILD time. That matters more than the
+ * shortcut it replaces: an installer that disagrees with the builder about
+ * whether the engine is present is worse than one that is merely slow. It also
+ * makes the gjsify monorepo a no-op — the workspace symlink resolves — which is
+ * what keeps ADR 0001's non-destructive invariant safe from a registry copy
+ * landing on top of `packages/infra/rolldown-native`.
+ *
+ * `dir` is a prefix for a global install and a project root for a project one;
+ * the walk handles both.
+ */
+export function hasBundlerEngineInstalled(dir) {
+    const names = new Set(detectNativePackages(dir).map((p) => p.name));
+    if (names.has(BUNDLER_ENGINE_PACKAGE))
+        return true;
+    // The per-target child is the thing that actually carries the binary, so its
+    // presence is the honest positive answer even when the umbrella is absent.
+    const libc = detectHostLibc(process.platform);
+    return hostPlatformTokens(process.platform, process.arch, libc).some((token) => names.has(platformPackageName(BUNDLER_ENGINE_PACKAGE, token)));
 }
 /**
  * Best-effort install of the GJS-native engine packages into a global prefix.
@@ -198,10 +232,19 @@ export function linkGlobalBins(packageNames, layout) {
             // then tries to parse JavaScript as shell. Plain Node scripts
             // with shebangs (lib/index.js) keep the direct-exec path.
             const isGjsBundle = isGjsBundlePath(targetAbs);
+            // A global install extracts the WHOLE package, so when it declares
+            // an npm `bin` beside its `gjsify.bin` that entry is on disk here
+            // too and the launcher can fall back to it on a host without `gjs`
+            // — the same fix as the project-local backend. Guarded on existence
+            // rather than assumed: naming a missing Node entry would only trade
+            // one exit 127 for another. See `pickBinMap`.
+            const fallbackRel = picked.nodeFallback?.get(binName);
+            const fallbackCandidate = fallbackRel === undefined ? undefined : path.join(pkgDir, fallbackRel);
+            const nodeFallbackAbs = fallbackCandidate !== undefined && fs.existsSync(fallbackCandidate) ? fallbackCandidate : undefined;
             // Only GJS bundles need the GI typelib search path. Plain Node
             // scripts ignore GI_TYPELIB_PATH, so skipping the preamble there
             // keeps the launcher minimal.
-            fs.writeFileSync(linkPath, buildShLauncher(targetAbs, { envPreamble, isGjsBundle }));
+            fs.writeFileSync(linkPath, buildShLauncher(targetAbs, { envPreamble, isGjsBundle, nodeFallbackAbs }));
             fs.chmodSync(linkPath, 0o755);
             // Windows runs neither an extension-less file nor a `#!` line, so
             // the `sh` launcher above is only reachable from git-bash/MSYS/WSL.
@@ -224,6 +267,9 @@ export function linkGlobalBins(packageNames, layout) {
                         interpreterArgs: ['-m'],
                         target: targetAbs,
                         prependEnv,
+                        fallback: nodeFallbackAbs === undefined
+                            ? undefined
+                            : { interpreter: 'node', target: nodeFallbackAbs },
                     })
                     : buildLauncherShims({
                         interpreter: shebang?.prog || 'node',

package/lib/utils/oxc-resolve.d.ts

@@ -69,7 +69,7 @@ export declare function shouldUseNativeOxfmt(): Promise<boolean>;
  *
  * oxlint: always spawned via its Node ESM launcher on a real Node host
  * (`nodeBinary()`: `process.execPath` under Node, PATH `node` under the GJS
- * bundle where `process.execPath` is the bundle itself) so the JS plugin host
+ * bundle where `process.execPath` is the `gjs` interpreter) so the JS plugin host
  * is available — required for the `jsPlugins`-wired `gjsify/register-class-order`
  * rule. Under GJS a `node` on PATH is required (oxlint has no native bridge
  * yet); its absence surfaces as a clear OxcNotFoundError, never a hang.

package/lib/utils/oxc-resolve.js

@@ -53,6 +53,7 @@ import { pathToFileURL } from 'node:url';
 import { hostLibc } from './platform-check.js';
 import { findWorkspaceRoot } from './workspace-root.js';
 import { resolveNpmPackage } from './resolve-npm-package.js';
+import { activateNativePrebuilds } from './gi-search-path.js';
 import { nodeBinary } from './run-node.js';
 import { spawnToCompletion } from './spawn.js';
 import { isGjs, gjsExit } from '@gjsify/rolldown-plugin-gjsify/runtime';
@@ -245,6 +246,10 @@ async function tryLoadNativeOxfmt() {
         if (!isGjs())
             return null;
         try {
+            // Same reason as `bundler-pick.ts`'s `tryLoadNative()`: put the
+            // prebuild on girepository's own search paths so the bridge loads
+            // without the `gjsify` launcher having exported anything. ADR 0021.
+            activateNativePrebuilds();
             const specifier = '@gjsify/oxfmt-native';
             const resolved = resolveNpmPackage(specifier, { bundleUrl: import.meta.url }) ??
                 createRequire(import.meta.url).resolve(specifier);
@@ -293,7 +298,7 @@ export async function shouldUseNativeOxfmt() {
  *
  * oxlint: always spawned via its Node ESM launcher on a real Node host
  * (`nodeBinary()`: `process.execPath` under Node, PATH `node` under the GJS
- * bundle where `process.execPath` is the bundle itself) so the JS plugin host
+ * bundle where `process.execPath` is the `gjs` interpreter) so the JS plugin host
  * is available — required for the `jsPlugins`-wired `gjsify/register-class-order`
  * rule. Under GJS a `node` on PATH is required (oxlint has no native bridge
  * yet); its absence surfaces as a clear OxcNotFoundError, never a hang.
@@ -323,11 +328,10 @@ export async function runOxc(tool, args, opts = {}) {
 /**
  * Spawn an oxc tool via its Node ESM launcher (`node_modules/<tool>/bin/…`) on
  * a real Node host. CRITICAL: use `nodeBinary()`, not `process.execPath`
- * directly — under the committed GJS bundle `process.execPath` is the CLI
- * bundle path (`gjs`/the `.mjs`), so spawning it re-executes the CLI with the
- * launcher as its first positional (yargs prints top-level help) and the parent
- * hangs waiting on a child that never does the intended work. `nodeBinary()`
- * resolves to PATH `node` under GJS, so the launcher runs on Node as required.
+ * directly — under GJS `process.execPath` is the `gjs` interpreter, so spawning
+ * it runs the Node ESM launcher under GJS, where the plugin host does not exist.
+ * `nodeBinary()` resolves to PATH `node` under GJS, so the launcher runs on Node
+ * as required.
  *
  * `completion: 'return'`: `lint` / `format` / `fix` hand the tool's exit code
  * to `setOxcExitCode`, which deliberately does NOT terminate the process on a

package/lib/utils/run-lifecycle-script.js

@@ -7,8 +7,28 @@
 // behaves like `yarn run` / `npm run`. That's wrong for the embedded use
 // case where pack/publish needs the lifecycle script to finish, then keep
 // running its own logic. This helper resolves to a Promise that settles
-// when the child exits — no process.exit, no GLib-mainloop intermingling
-// from `ensureMainLoop`.
+// when the child exits.
+//
+// ## Not calling `process.exit()` is what ARMED the hang, not what avoided it
+//
+// This header used to end "no process.exit, no GLib-mainloop intermingling
+// from `ensureMainLoop`". The second half was exactly backwards, and it is why
+// nobody looked here for #1010.
+//
+// `@gjsify/child_process`'s async `spawn()` calls `ensureMainLoop()`
+// unconditionally — the caller has no say. That arms a GJS main-loop hook whose
+// blocking `g_main_loop_run()` only `process.exit()` tears down. So a helper
+// that spawns asynchronously and deliberately does NOT exit leaves the loop
+// armed forever: `gjsify pack` on a package with a `prepack` wrote its tarball,
+// printed its complete JSON, and then parked at 0% CPU until killed at 5m30s.
+// A package with no lifecycle script exited in under a second, and the same
+// pack under Node exited in 0.68s.
+//
+// `utils/spawn.ts` already owns that contract and makes every call site DECLARE
+// which side of it they are on. This helper was the one spawn in the CLI that
+// bypassed it — the seventh of the "six near-identical wrappers" that file was
+// written to consolidate. It now goes through it with `completion: 'return'`,
+// which is what "settle, then keep running our own logic" means.
 //
 // Matches yarn / npm script semantics:
 //   - `shell: true` so `&&` / `|` / env-var refs work
@@ -16,8 +36,8 @@
 //   - `npm_lifecycle_event` / `npm_package_name` / `npm_package_version`
 //     env vars set
 //   - FORCE_COLOR=1 default unless caller overrides
-import { spawn } from 'node:child_process';
 import { delimiter, join } from 'node:path';
+import { describeExit, spawnToCompletion } from './spawn.js';
 import { findWorkspaceRoot } from './workspace-root.js';
 /**
  * Run a lifecycle script defined in `pkg.scripts[name]` from `wsDir`.
@@ -52,28 +72,24 @@ export async function runLifecycleScript(wsDir, pkg, name, opts = {}) {
         npm_package_version: pkg.version ?? '',
         ...opts.env,
     };
-    // `'inherit-stderr'` is our extension on top of node's stdio modes —
-    // child stdin inherits, child stdout → parent's stderr (fd 2), child
-    // stderr → parent's stderr. Used by `gjsify pack --json` so the
-    // prepack's log lines don't get interleaved with the JSON we emit on
-    // parent stdout. `spawn`'s `stdio` accepts numeric fds in array form
-    // and routes the child's matching stream to that fd.
-    const stdioConfig = opts.stdio === 'inherit-stderr' ? ['inherit', 2, 2] : (opts.stdio ?? 'inherit');
-    await new Promise((resolveOk, reject) => {
-        const child = spawn(literal, [], {
-            cwd: wsDir,
-            env: env,
-            stdio: stdioConfig,
-            shell: true,
-        });
-        child.on('close', (code) => {
-            if (code === 0)
-                resolveOk();
-            else {
-                reject(new Error(`gjsify lifecycle-script: "${name}" in ${wsDir} exited with code ${code}`));
-            }
-        });
-        child.on('error', reject);
+    // `'ignore'` has no `spawnToCompletion` equivalent and no call site in the
+    // tree; folding it onto `'inherit'` would silently start printing where a
+    // caller asked for silence, so it is rejected rather than approximated.
+    if (opts.stdio === 'ignore') {
+        throw new Error('gjsify lifecycle-script: stdio "ignore" is not supported — see utils/spawn.ts');
+    }
+    const result = await spawnToCompletion(literal, [], {
+        // The whole point of this helper: pack/publish waits for the script and
+        // then keeps running. Under GJS that is the blocking path, which is what
+        // keeps the armed main loop from outliving us — see the header.
+        completion: 'return',
+        cwd: wsDir,
+        env: env,
+        shell: true,
+        stdio: opts.stdio === 'inherit-stderr' ? 'inherit-stderr' : opts.stdio === 'pipe' ? 'pipe' : 'inherit',
     });
+    if (result.code !== 0) {
+        throw new Error(`gjsify lifecycle-script: "${name}" in ${wsDir} exited with ${describeExit(result)}`);
+    }
     return true;
 }

package/lib/utils/spawn.d.ts

@@ -33,8 +33,24 @@ export interface SpawnToCompletionOptions {
      * `'inherit'` (default) forwards the parent's stdio. `'pipe'` gives the
      * caller `child.stdout` / `child.stderr` via {@link onSpawn} — only
      * meaningful together with `completion: 'exit'` (see {@link onSpawn}).
+     *
+     * `'inherit-stderr'` inherits, but routes the child's **stdout to the
+     * parent's stderr**. For a parent whose own stdout is a machine-readable
+     * stream: `gjsify pack --json` emits JSON there, and a lifecycle script's
+     * log lines interleaved into it make the result unparseable for every
+     * caller that pipes it into `JSON.parse`.
+     */
+    stdio?: 'inherit' | 'pipe' | 'inherit-stderr';
+    /**
+     * Run `cmd` through the platform shell, so `&&`, `|` and env-var
+     * references work. `cmd` is then a whole command LINE and `args` must be
+     * empty — that is npm/yarn script semantics.
+     *
+     * Skips the win32 command rewrite by design, per this file's own rule:
+     * Node routes a `shell: true` spawn through `%COMSPEC%`, which finds
+     * `.cmd` shims on its own, so rewriting the string would corrupt it.
      */
-    stdio?: 'inherit' | 'pipe';
+    shell?: boolean;
     /**
      * Invoked synchronously with the live `ChildProcess` right after a
      * successful async spawn — the seam for kill-tracking registries and for

package/lib/utils/spawn.js

@@ -133,34 +133,51 @@ function mustBlock(opts) {
  */
 export function spawnToCompletion(cmd, args, opts) {
     const env = resolveEnv(opts);
+    // A shell invocation is a command LINE, not an argv, so the win32 rewrite
+    // must not touch it — see `SpawnToCompletionOptions.shell`.
+    const invocation = opts.shell
+        ? { cmd, args: [...args], windowsVerbatimArguments: false }
+        : forWin32(cmd, args, env);
     if (mustBlock(opts)) {
         // `'inherit'` is NOT forwarded through `@gjsify/child_process`'s GJS
         // spawnSync path (it drives a private main context via
         // `communicateWithTimeout`), so the child's diagnostics would be
         // silently dropped. Capture them and re-emit after the child exits.
         // stdin stays inherited so an interactive child still reads the tty.
-        const win = forWin32(cmd, args, env);
-        const r = spawnSync(win.cmd, win.args, {
+        const r = spawnSync(invocation.cmd, invocation.args, {
             stdio: ['inherit', 'pipe', 'pipe'],
             cwd: opts.cwd,
             env,
+            shell: opts.shell,
             maxBuffer: opts.maxBuffer ?? DEFAULT_MAX_BUFFER,
-            windowsVerbatimArguments: win.windowsVerbatimArguments,
+            windowsVerbatimArguments: invocation.windowsVerbatimArguments,
         });
         if (r.error)
             return Promise.reject(mapSpawnError(r.error, opts));
+        // The captured stdout goes to the parent's STDERR under
+        // `'inherit-stderr'` — same destination the streaming path routes it to,
+        // so the two agree on where a lifecycle script's chatter lands.
+        const out = opts.stdio === 'inherit-stderr' ? process.stderr : process.stdout;
         if (r.stdout && r.stdout.length > 0)
-            process.stdout.write(r.stdout);
+            out.write(r.stdout);
         if (r.stderr && r.stderr.length > 0)
             process.stderr.write(r.stderr);
         return Promise.resolve({ code: r.status, signal: r.signal ?? null });
     }
     return new Promise((resolvePromise, reject) => {
-        const win = forWin32(cmd, args, env);
+        const win = invocation;
         const spawnOpts = {
             cwd: opts.cwd,
-            stdio: opts.stdio === 'pipe' ? ['ignore', 'pipe', 'pipe'] : 'inherit',
+            // Numeric fds route the child's matching stream to that fd, so
+            // `['inherit', 2, 2]` is stdin inherited, stdout AND stderr → fd 2.
+            stdio: opts.stdio === 'pipe'
+                ? ['ignore', 'pipe', 'pipe']
+                : opts.stdio === 'inherit-stderr'
+                    ? ['inherit', 2, 2]
+                    : 'inherit',
         };
+        if (opts.shell)
+            spawnOpts.shell = true;
         if (env)
             spawnOpts.env = env;
         if (win.windowsVerbatimArguments)

package/lib/utils/stdin.d.ts

@@ -1,19 +1,9 @@
 /**
  * Read the whole of stdin as UTF-8. Works on Node and under the GJS bundle.
  *
- * Branches on WHICH RUNTIME CAN WORK, not on which capability is present. The
- * distinction matters because the two branches are not interchangeable:
- * `readFileSync(0)` is correct on Node/Bun/Deno and can NEVER work under GJS —
- * `@gjsify/fs` has no numeric-fd path, so the `0` is coerced to a relative
- * PATH and the call opens `./0`. A GJS run that reaches that line is already
- * lost, so using it as GJS's fallback only converts a clear failure into
- * `ENOENT … read '0'`, which is what a capability probe returning a false
- * negative did.
- *
- * So: the presence of `imports.gi` decides. On GJS both GJS readers are tried
- * and a failure THROWS with what was attempted; the Node reader is never
- * reached. Off GJS there is no gi namespace and `readFileSync(0)` is the only
- * and correct answer.
+ * Synchronous on purpose: the callers are CLI argument-parsing paths that run
+ * before any main loop exists, and the async `process.stdin` route carries the
+ * documented resume/pause races (see `utils/prompt.ts`).
  */
 export declare function readStdinText(): string;
 /**

package/lib/utils/stdin.js

@@ -1,119 +1,40 @@
 // SPDX-License-Identifier: MIT
 // Read ALL of stdin, on Node AND inside the committed GJS bundles.
 //
-// `readFileSync(0, 'utf-8')` is the Node idiom for "slurp stdin", and it is
-// what `gjsify affected --changed-from-stdin` used. It does NOT survive the
-// GJS bundle: `@gjsify/fs` has no numeric-file-descriptor path, so the `0` is
-// coerced to a PATH and the call opens the relative file `./0` — every GJS
-// caller died with
+// `readFileSync(0, 'utf-8')` is the Node idiom for "slurp stdin". It used NOT to
+// survive the GJS bundle: `@gjsify/fs` had no numeric-file-descriptor path, so
+// the `0` was coerced to a PATH and the call opened the relative file `./0` —
+// every GJS caller died with
 //
 //     Error: ENOENT: … read '0'   (readStdinLines → readFileSync)
 //
 // which silently disabled the ONE fixture-driven entry point AGENTS.md
 // documents for testing the CI classifier (`--changed-from-stdin`).
 //
-// Under GJS we therefore read fd 0 through `GioUnix.InputStream`. Two
-// deliberate choices:
+// THE GAP IS CLOSED AT THE CORE, so the workaround is gone: `@gjsify/fs` maps
+// the parent-supplied descriptors 0/1/2 onto the process's own Unix streams
+// (`packages/node/fs/src/std-fd.ts`, reached from `readFileSync` through
+// `sync.ts`), which makes the Node idiom mean the same thing under GJS. This
+// module used to carry two GJS-only readers for that gap — a
+// `GioUnix.InputStream` chunk loop and a `/dev/stdin` `Gio.File` fallback —
+// plus a runtime branch to choose between them. All three were consumer-side
+// repair for a missing core capability.
 //
-//   - `globalThis.imports.gi.GioUnix` rather than a `gi://GioUnix` import.
-//     `packages/infra/cli/lib/**` is ALSO the Node entry point of
-//     `@gjsify/cli` (`bin: lib/index.js`); a static `gi://` import anywhere
-//     reachable from it breaks `gjsify` on Node, and a dynamic one would need
-//     an `@girs/giounix-2.0` type dependency the CLI does not otherwise have.
-//     The legacy `imports.gi` form is the sanctioned GJS-bootstrap escape
-//     hatch (AGENTS.md "Reading globals", exception 4) and adds NO new typelib
-//     to the classifier bundle — `gi://GioUnix?version=2.0` is already in its
-//     import graph via `@gjsify/fs`.
-//   - a synchronous read. The callers are CLI argument-parsing paths that run
-//     before any main loop exists, and the async `process.stdin` route carries
-//     the documented resume/pause races (see `utils/prompt.ts`).
+// Anything re-adding a GJS branch HERE is re-adding the workaround. If stdin
+// misbehaves under GJS the defect is in `@gjsify/fs` and belongs there, with a
+// test — that is what made the branch removable in the first place
+// (`packages/node/fs/src/fd-ops.spec.ts` + `tests/e2e/fs-std-fd`, which needs a
+// real pipe and so cannot live in a unit spec).
 import { readFileSync } from 'node:fs';
-const CHUNK = 64 * 1024;
-/** Read fd 0 to EOF under GJS via GioUnix (no `@gjsify/fs` fd support needed). */
-function readStdinTextGioUnix() {
-    const gi = giNamespace();
-    const GioUnix = gi?.GioUnix;
-    if (typeof GioUnix?.InputStream !== 'function') {
-        throw new Error('GioUnix.InputStream is unavailable');
-    }
-    const stream = new GioUnix.InputStream({ fd: 0, close_fd: false });
-    const chunks = [];
-    let total = 0;
-    for (;;) {
-        const bytes = stream.read_bytes(CHUNK, null);
-        if (bytes.get_size() === 0)
-            break;
-        const arr = bytes.toArray();
-        chunks.push(arr);
-        total += arr.length;
-    }
-    if (total === 0)
-        return '';
-    const buf = new Uint8Array(total);
-    let offset = 0;
-    for (const c of chunks) {
-        buf.set(c, offset);
-        offset += c.length;
-    }
-    return new TextDecoder().decode(buf);
-}
-/**
- * Read stdin under GJS through Gio ALONE, without GioUnix.
- *
- * `/dev/stdin` is fd 0 by another name, and `Gio` is present in every bundle
- * that can reach this code at all. This exists because the GioUnix route has
- * been observed to be unavailable on a host where it should have worked, and a
- * second independent mechanism is cheaper than another round of guessing.
- */
-function readStdinTextGioFile() {
-    const gi = giNamespace();
-    const Gio = gi?.Gio;
-    if (!Gio?.File)
-        throw new Error('Gio.File is unavailable');
-    const [ok, contents] = Gio.File.new_for_path('/dev/stdin').load_contents(null);
-    if (!ok)
-        throw new Error('Gio.File.load_contents("/dev/stdin") returned false');
-    return new TextDecoder().decode(contents);
-}
-/**
- * The GJS `imports.gi` namespace, or `undefined` when not running on GJS.
- * Same optional-chained probe as `isGjs()` — off GJS `imports` is simply
- * absent and the read yields `undefined`; there is no throw path.
- */
-function giNamespace() {
-    return globalThis.imports?.gi;
-}
 /**
  * Read the whole of stdin as UTF-8. Works on Node and under the GJS bundle.
  *
- * Branches on WHICH RUNTIME CAN WORK, not on which capability is present. The
- * distinction matters because the two branches are not interchangeable:
- * `readFileSync(0)` is correct on Node/Bun/Deno and can NEVER work under GJS —
- * `@gjsify/fs` has no numeric-fd path, so the `0` is coerced to a relative
- * PATH and the call opens `./0`. A GJS run that reaches that line is already
- * lost, so using it as GJS's fallback only converts a clear failure into
- * `ENOENT … read '0'`, which is what a capability probe returning a false
- * negative did.
- *
- * So: the presence of `imports.gi` decides. On GJS both GJS readers are tried
- * and a failure THROWS with what was attempted; the Node reader is never
- * reached. Off GJS there is no gi namespace and `readFileSync(0)` is the only
- * and correct answer.
+ * Synchronous on purpose: the callers are CLI argument-parsing paths that run
+ * before any main loop exists, and the async `process.stdin` route carries the
+ * documented resume/pause races (see `utils/prompt.ts`).
  */
 export function readStdinText() {
-    if (!giNamespace())
-        return readFileSync(0, 'utf-8');
-    const attempts = [];
-    for (const read of [readStdinTextGioUnix, readStdinTextGioFile]) {
-        try {
-            return read();
-        }
-        catch (err) {
-            attempts.push(`${read.name}: ${err.message}`);
-        }
-    }
-    throw new Error(`gjsify: cannot read stdin under GJS. Tried ${attempts.join('; ')}. ` +
-        'Pass the input as an argument instead (e.g. --base <ref> rather than --changed-from-stdin).');
+    return readFileSync(0, 'utf-8');
 }
 /**
  * Read stdin and split it into trimmed, non-empty lines. Accepts LF and CRLF

package/lib/utils/system-gi.js

@@ -87,7 +87,16 @@
 // bundle's first line runs.
 import { spawnSync } from 'node:child_process';
 import { statSync } from 'node:fs';
-import { basename, dirname, join } from 'node:path';
+// POSIX path semantics, not the HOST's. This function answers a question about
+// a darwin filesystem — `platform` is a PARAMETER, so the host running the code
+// may be any of the three. Node's default `join`/`dirname`/`basename` follow the
+// host, so on win32 `join('/usr/local/lib', 'girepository-1.0')` becomes
+// `\usr\local\lib\girepository-1.0` and never matches the darwin path the
+// caller (or the injected `existsDir`) is holding. Measured on the Windows leg:
+// three `systemGiLibraryDirs` specs returned `[]` where they assert a prefix.
+// `PROBED_GI_LIBDIRS` is darwin-only, so POSIX is always the right dialect here.
+import { posix } from 'node:path';
+const { basename, dirname, join } = posix;
 /**
  * Prefixes a macOS GI stack is installed under in practice — probed, never
  * assumed: each is accepted only when it actually holds a `girepository-1.0/`.