@gjsify/cli 0.52.0 → 0.53.0

package/lib/utils/gjsify-shim.d.ts

@@ -8,6 +8,16 @@
  * undoing the repair one level down.
  */
 export declare function usingSelfShim(): boolean;
+/**
+ * `PATH` as the user's shell sees it: `process.env.PATH` without the self-shim dir.
+ *
+ * The shim is this PROCESS TREE's `gjsify`, never the one the user's next command
+ * runs. `self-update` asked `resolveBinOnPath` who wins PATH and got its own shim
+ * back, the temp copy of the version it had just replaced, so a successful update
+ * inside a workspace reported "`gjsify` on PATH resolves to /tmp/gjsify-shim-…
+ * (v0.51.1)" and exited 1.
+ */
+export declare function pathWithoutSelfShim(pathValue?: string, shimDir?: string | undefined, sep?: string): string;
 /**
  * Does this invocation need its own `gjsify` on PATH, rather than the workspace's
  * npm bin?
@@ -31,6 +41,43 @@ export declare function needsSelfShim(opts: {
  * reuse it instead of creating their own.
  */
 export declare function ensureGjsifyShimOnPath(): void;
+/**
+ * The tree whose `node_modules` holds the running CLI and its prebuilds: the
+ * install prefix above the first `node_modules` segment, or the workspace root
+ * for an in-repo CLI (`packages/infra/cli/dist/cli.gjs.mjs`).
+ */
+export declare function selfShimScanRoot(selfEntry: string): string;
+/**
+ * The env preamble for a shim re-invoking `selfEntry` — {@link buildNativeEnvPreamble}
+ * with the inputs `gjsify install -g` gives it: the prefix to glob at launch, and
+ * the prebuild dirs the walk finds above it (a hoisted ancestor's `node_modules`).
+ */
+export declare function selfShimPreamble(selfEntry: string): string;
+/**
+ * The POSIX `sh` body of the self-shim: re-invoke `target` under `interpreter`.
+ *
+ * On darwin it RE-EXPORTS the running CLI's `DYLD_*` values first. SIP strips every
+ * `DYLD_*` variable when a protected binary is exec'd, and `/bin/sh` — this shim —
+ * is one, so the child `gjs` otherwise starts without the loader path the install
+ * launcher gave the parent (see `buildNativeEnvPreamble`). `GI_TYPELIB_PATH` is not a
+ * `DYLD_*` name and survives, so the child finds a prebuild's typelib and then fails
+ * the bare-leaf `dlopen` it names: `gjsify workspace <pkg> build` died with
+ * `Failed to load shared library 'libgjsifyterminal.dylib'` while the same script run
+ * through the tree's own launcher worked.
+ *
+ * Baking the values is not the snapshot `buildNativeEnvPreamble` warns about: this
+ * shim lives in a temp dir for ONE process tree and carries exactly the environment
+ * that tree's root was started with.
+ */
+export declare function buildSelfShimScript(opts: {
+    interpreter: string;
+    interpreterArgs: readonly string[];
+    target: string;
+    platform?: string;
+    env?: Record<string, string | undefined>;
+}): string;
+/** `export` lines restoring each set `DYLD_*` variable on darwin; `''` elsewhere. */
+export declare function dyldCarryPreamble(platform: string, env: Record<string, string | undefined>): string;
 /**
  * Directory carrying a `node` that runs the file through
  * `gjsify run --node-script`, or null when this host needs none.

package/lib/utils/gjsify-shim.js

@@ -41,10 +41,11 @@
 // nested builds off the GJS bundle.
 import { mkdtempSync, mkdirSync, writeFileSync, chmodSync, existsSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join, delimiter, relative, isAbsolute } from 'node:path';
+import { join, delimiter, relative, isAbsolute, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { isGjs } from '@gjsify/rolldown-plugin-gjsify/runtime';
-import { buildLauncherShims } from './bin-shim.js';
+import { buildLauncherShims, buildNativeEnvPreamble, buildShLauncher, shQuoteArg } from './bin-shim.js';
+import { detectNativePackages } from './detect-native-packages.js';
 import { resolveBinOnPath } from './install-global.js';
 import { findWorkspaceRoot } from './workspace-root.js';
 let _ensured = false;
@@ -61,6 +62,23 @@ let _selfShimActive = false;
 export function usingSelfShim() {
     return _selfShimActive;
 }
+/**
+ * `PATH` as the user's shell sees it: `process.env.PATH` without the self-shim dir.
+ *
+ * The shim is this PROCESS TREE's `gjsify`, never the one the user's next command
+ * runs. `self-update` asked `resolveBinOnPath` who wins PATH and got its own shim
+ * back, the temp copy of the version it had just replaced, so a successful update
+ * inside a workspace reported "`gjsify` on PATH resolves to /tmp/gjsify-shim-…
+ * (v0.51.1)" and exited 1.
+ */
+export function pathWithoutSelfShim(pathValue = process.env.PATH ?? '', shimDir = process.env.GJSIFY_SHIM_DIR, sep = delimiter) {
+    if (!shimDir)
+        return pathValue;
+    return pathValue
+        .split(sep)
+        .filter((entry) => entry !== shimDir)
+        .join(sep);
+}
 /**
  * Does this invocation need its own `gjsify` on PATH, rather than the workspace's
  * npm bin?
@@ -117,23 +135,90 @@ export function ensureGjsifyShimOnPath() {
     // `process.execPath`: the batch member cannot quote an interpreter argument
     // (`<interpreter> "<target>" %*`), so `C:\Program Files\nodejs\node.exe` splits.
     const interpreter = gjs ? process.env.GJS_CONSOLE || 'gjs' : 'node';
-    const interpreterArgs = gjs ? ['-m'] : [];
-    const argv = interpreterArgs.length > 0 ? `${interpreterArgs.join(' ')} ` : '';
-    writeFileSync(shim, `#!/bin/sh\nexec "${interpreter}" ${argv}"${selfEntry}" "$@"\n`, { mode: 0o755 });
+    // Under GJS the shim is the SAME launcher `gjsify install` writes, preamble
+    // included (`selfShimPreamble`). A bare `exec gjs -m` is not enough on a Mac:
+    // it runs behind `/bin/sh`, and SIP strips every `DYLD_*` from a protected
+    // binary's environment, so a nested `gjsify` found its typelibs through the
+    // surviving GI_TYPELIB_PATH and none of their libraries. Reported by the
+    // beifahrer consumer on macOS: `gjsify workspace <pkg> build` died in
+    // `get columns` with "Unsupported type void".
+    const envPreamble = gjs ? selfShimPreamble(selfEntry) : '';
+    writeFileSync(shim, gjs
+        ? buildShLauncher(selfEntry, { isGjsBundle: true, envPreamble, gjs: interpreter })
+        : `#!/bin/sh\nexec "${interpreter}" "${selfEntry}" "$@"\n`, { mode: 0o755 });
     chmodSync(shim, 0o755);
     // cmd.exe and pwsh cannot run the extension-less member: not on PATHEXT, and
     // Windows has no shebang handling. `buildLauncherShims` ports npm's
     // three-sibling answer, including the IF/ELSE ERRORLEVEL handling that
     // `&&`/`||` chaining gets wrong.
     if (!gjs && process.platform === 'win32') {
-        const { cmd, ps1 } = buildLauncherShims({ interpreter, interpreterArgs, target: selfEntry });
+        const { cmd, ps1 } = buildLauncherShims({ interpreter, interpreterArgs: [], target: selfEntry });
         writeFileSync(`${shim}.cmd`, cmd);
         writeFileSync(`${shim}.ps1`, ps1);
     }
     _selfShimActive = true;
     process.env.GJSIFY_SHIM_DIR = dir;
     process.env.PATH = dir + delimiter + (process.env.PATH ?? '');
-    writeNodeShim(dir, gjs, selfEntry);
+    writeNodeShim(dir, gjs, selfEntry, envPreamble);
+}
+/**
+ * The tree whose `node_modules` holds the running CLI and its prebuilds: the
+ * install prefix above the first `node_modules` segment, or the workspace root
+ * for an in-repo CLI (`packages/infra/cli/dist/cli.gjs.mjs`).
+ */
+export function selfShimScanRoot(selfEntry) {
+    // Both separators: the entry is a HOST path, and win32 spells it with a backslash.
+    const at = selfEntry.search(/[\\/]node_modules[\\/]/);
+    if (at > 0)
+        return selfEntry.slice(0, at);
+    return findWorkspaceRoot(dirname(selfEntry)) ?? dirname(selfEntry);
+}
+/**
+ * The env preamble for a shim re-invoking `selfEntry` — {@link buildNativeEnvPreamble}
+ * with the inputs `gjsify install -g` gives it: the prefix to glob at launch, and
+ * the prebuild dirs the walk finds above it (a hoisted ancestor's `node_modules`).
+ */
+export function selfShimPreamble(selfEntry) {
+    let baked = [];
+    try {
+        baked = detectNativePackages(dirname(selfEntry)).map((p) => p.prebuildsDir);
+    }
+    catch {
+        // The walk is filesystem I/O (EACCES on an unreadable node_modules). The
+        // launch-time glob of the scan root still runs; only ancestors go unseen.
+    }
+    return buildNativeEnvPreamble(selfShimScanRoot(selfEntry), baked);
+}
+/**
+ * The POSIX `sh` body of the self-shim: re-invoke `target` under `interpreter`.
+ *
+ * On darwin it RE-EXPORTS the running CLI's `DYLD_*` values first. SIP strips every
+ * `DYLD_*` variable when a protected binary is exec'd, and `/bin/sh` — this shim —
+ * is one, so the child `gjs` otherwise starts without the loader path the install
+ * launcher gave the parent (see `buildNativeEnvPreamble`). `GI_TYPELIB_PATH` is not a
+ * `DYLD_*` name and survives, so the child finds a prebuild's typelib and then fails
+ * the bare-leaf `dlopen` it names: `gjsify workspace <pkg> build` died with
+ * `Failed to load shared library 'libgjsifyterminal.dylib'` while the same script run
+ * through the tree's own launcher worked.
+ *
+ * Baking the values is not the snapshot `buildNativeEnvPreamble` warns about: this
+ * shim lives in a temp dir for ONE process tree and carries exactly the environment
+ * that tree's root was started with.
+ */
+export function buildSelfShimScript(opts) {
+    const argv = opts.interpreterArgs.length > 0 ? `${opts.interpreterArgs.join(' ')} ` : '';
+    const preamble = dyldCarryPreamble(opts.platform ?? process.platform, opts.env ?? process.env);
+    return `#!/bin/sh\n${preamble}exec "${opts.interpreter}" ${argv}"${opts.target}" "$@"\n`;
+}
+/** `export` lines restoring each set `DYLD_*` variable on darwin; `''` elsewhere. */
+export function dyldCarryPreamble(platform, env) {
+    if (platform !== 'darwin')
+        return '';
+    return Object.keys(env)
+        .filter((name) => /^DYLD_[A-Z_]+$/.test(name) && env[name])
+        .sort()
+        .map((name) => `${name}=${shQuoteArg(env[name])}\nexport ${name}\n`)
+        .join('');
 }
 /** Deliberately NOT the shim dir itself — see {@link nodeShimDir}. */
 const NODE_SHIM_SUBDIR = 'node-shim';
@@ -183,7 +268,7 @@ export function nodeShimDir() {
  * resolves NOWHERE, and it is reachable only from a package script's PATH (see
  * {@link nodeShimDir}).
  */
-function writeNodeShim(dir, gjs, selfEntry) {
+function writeNodeShim(dir, gjs, selfEntry, envPreamble) {
     if (!gjs)
         return;
     const sub = join(dir, NODE_SHIM_SUBDIR);
@@ -199,11 +284,15 @@ function writeNodeShim(dir, gjs, selfEntry) {
     // `--node-script` can honour, and yargs would take `--test` FOR the script
     // path (`unknown-options-as-args` turns an unknown flag into a positional).
     writeFileSync(shim, '#!/bin/sh\n' +
+        // Same SIP hop as the self-shim — see `buildSelfShimScript`.
+        dyldCarryPreamble(process.platform, process.env) +
         'case "$1" in\n' +
         '  -*) echo "gjsify: this host has no node; the gjsify shim runs a SCRIPT FILE only" >&2\n' +
         '      echo "gjsify: got: node $*" >&2\n' +
         '      exit 127 ;;\n' +
         'esac\n' +
+        // The same hop as the `gjsify` shim, so the same preamble.
+        envPreamble +
         `exec "${interpreter}" -m "${selfEntry}" run --node-script "$@"\n`, { mode: 0o755 });
     chmodSync(shim, 0o755);
 }

package/lib/utils/install-backend-native.d.ts

@@ -22,6 +22,12 @@ export interface ResolvedNode {
     /** Ranges keyed by name, as published. */
     dependencies: Record<string, string>;
     optionalDependencies: Record<string, string>;
+    /** As published; absent when the version declares none. Read through {@link requiredPeerEntries}. */
+    peerDependencies?: Record<string, string>;
+    /** As published — `optional: true` here is what keeps a peer from being installed. */
+    peerDependenciesMeta?: Record<string, {
+        optional?: boolean;
+    }>;
     bin?: string | Record<string, string>;
     /**
      * The version's `os`/`cpu`/`libc` declaration, as published. Recorded here
@@ -156,6 +162,17 @@ export declare function warnMissingNativeBuilds(nodes: ResolvedNode[], prefix: s
  * `dependencies` entry to override), covered by {@link resolveDeps}'s second queue loop.
  */
 export declare function requiredDepEntries(node: Pick<ResolvedNode, 'dependencies' | 'optionalDependencies'>): [string, string][];
+/**
+ * A node's REQUIRED peer edges: its `peerDependencies` minus those
+ * `peerDependenciesMeta` marks `optional` (npm ≥ 7 installs the rest and skips
+ * these) and minus any name it also lists as a dependency — that edge is walked
+ * from the node itself by {@link requiredDepEntries}, or is optional because the
+ * publisher said so in `optionalDependencies`.
+ *
+ * Shared by the resolve walk and the optionality fixpoint, for the reason
+ * {@link requiredDepEntries} is: two readings of one manifest are two answers.
+ */
+export declare function requiredPeerEntries(node: Pick<ResolvedNode, 'dependencies' | 'optionalDependencies' | 'peerDependencies' | 'peerDependenciesMeta'>): [string, string][];
 /**
  * Recompute every node's `optional` flag as a FIXPOINT over the placed graph. The
  * only writer of the final flag; whatever the nodes arrive carrying is an input
@@ -163,7 +180,8 @@ export declare function requiredDepEntries(node: Pick<ResolvedNode, 'dependencie
  * file on the lockfile path) and is overwritten unconditionally.
  *
  * DEFINITION: a node is REQUIRED iff reachable from `requiredNames` through
- * REQUIRED edges alone ({@link requiredDepEntries}); every other node is optional.
+ * REQUIRED edges alone ({@link requiredDepEntries} plus {@link requiredPeerEntries} —
+ * a peer npm installs is as mandatory as a dependency); every other node is optional.
  * Optionality is therefore INHERITED — a plain dependency OF an optional package is
  * still optional, which is what npm's `optionalSet` computes.
  *

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

@@ -45,8 +45,20 @@
 //      (v4); without it the fresh-resolve and lockfile paths disagree about one
 //      tree.
 //
-// Out of scope (still deferred): peerDependencies validation, lifecycle scripts,
-// git/file specs.
+// PEER DEPENDENCIES follow npm ≥ 7: every peer NOT marked optional in
+// `peerDependenciesMeta` is installed where the dependent resolves it — as its
+// SIBLING (queued from the dependent's parent, so the dependent and whatever
+// requires it share one instance), reusing any visible copy whose version
+// satisfies the range. Optional peers are never installed, exactly as npm skips
+// them; ADR 0020's `@gjsify/rolldown-native` depends on that. The defect this
+// closes: `wxt` declares `vite` as a required peer, `gjsify install` exited 0
+// without it, and `wxt prepare` died with "Builder not found". A peer edge is a
+// REQUIRED edge for the optionality fixpoint ({@link requiredPeerEntries}), so
+// the lockfile records the peer maps and marks a peer-aware resolve
+// (`Lockfile.peersResolved` says why that is a marker and not a version bump).
+//
+// Out of scope (still deferred): lifecycle scripts, git/file specs, and npm's
+// strict-peer-deps ERESOLVE (a conflicting peer warns, see `resolveDeps`).
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
@@ -172,6 +184,7 @@ async function installPackagesNativeLocked(opts, npmrc, log) {
     else if (!opts.refreshLockfile &&
         existingLock &&
         existingLock.lockfileVersion === LOCKFILE_VERSION &&
+        existingLock.peersResolved === true &&
         lockfileMatchesRequest(existingLock, opts.specs)) {
         log('install: using lockfile (%d package(s))', Object.keys(existingLock.packages).length);
         nodes = lockfileToNodes(existingLock);
@@ -179,6 +192,9 @@ async function installPackagesNativeLocked(opts, npmrc, log) {
     else {
         // A resolve has to run (new/changed/removed dep, or no lockfile yet).
         //
+        // So does a lockfile without `peersResolved`: it may lack a required peer
+        // (Lockfile.peersResolved).
+        //
         // A pre-v4 lockfile lands here too even when it matches the request: each
         // bump added something the verdict is recomputed FROM, so a file lacking it
         // cannot be consumed verbatim — pre-v3 entries carry no platform
@@ -533,7 +549,7 @@ optionalSpecs) {
     // `workspaceInstall` produces when two workspaces declare incompatible ranges of
     // the same external dep) all compete for the single root slot and the resolver
     // silently keeps one version for everyone. Per-workspace dedup is Phase D.8
-    // (status/open-todos.md); until it lands the conflict is surfaced loudly after
+    // (status/open-todos/README.md); until it lands the conflict is surfaced loudly after
     // the resolve (see emitTopLevelConflictWarnings).
     const topLevelRanges = new Map();
     const queue = specs.map(parseSpec).map((s) => {
@@ -601,6 +617,23 @@ optionalSpecs) {
                 // {@link computeOptionalFlags} is the only writer of the final flag.
                 continue;
             }
+            // A peer must live in ONE directory — beside its dependent. If that slot
+            // already holds a version outside the range, a private copy would give the
+            // dependent a different instance from its requester, which is the thing a
+            // peer exists to prevent. npm ≥ 7 raises ERESOLVE here in strict mode and,
+            // non-strict (`--force`, or a conflict below the root), warns "overriding
+            // peer dependency" and keeps the existing copy. We take the lenient answer:
+            // warn, keep it, install nothing.
+            if (edge.peerOf) {
+                const slot = edge.from === null ? `node_modules/${edge.name}` : `${edge.from}/node_modules/${edge.name}`;
+                const occupant = byPath.get(slot);
+                if (occupant) {
+                    console.warn(`[gjsify] warning: peer dependency conflict: ${edge.peerOf.name}@${edge.peerOf.version} ` +
+                        `wants ${edge.name}@${edge.range}, but ${occupant.version} is installed at ` +
+                        `${occupant.installPath} — keeping it (npm's non-strict behaviour).`);
+                    continue;
+                }
+            }
             // No compatible placement. Resolve a version, preferring one already
             // pinned when it satisfies the range so an add does not bump unchanged
             // deps.
@@ -629,6 +662,8 @@ optionalSpecs) {
                     installPath,
                     dependencies: v.dependencies ?? {},
                     optionalDependencies: v.optionalDependencies ?? {},
+                    peerDependencies: nonEmpty(v.peerDependencies),
+                    peerDependenciesMeta: nonEmpty(v.peerDependenciesMeta),
                     bin: v.bin,
                     // Complete as published: `fetchPkg` reads the FULL document, so all
                     // three fields come from one body — no second fetch, no heuristic.
@@ -653,6 +688,20 @@ optionalSpecs) {
                     name: `${edge.name}@${version}`,
                 });
                 if (!skipDeps) {
+                    // Required peers FIRST, so the peer claims its slot beside the
+                    // dependent before the dependent's own subtree can hoist an
+                    // incompatible copy of the same name into it. Queued from the PARENT
+                    // (`Edge.peerOf`); optional peers are never queued, npm ≥ 7 skips them.
+                    const parent = parentInstallPath(installPath);
+                    for (const [peerName, peerRange] of requiredPeerEntries(node)) {
+                        queue.push({
+                            from: parent,
+                            name: peerName,
+                            range: applyOverride(peerName, peerRange),
+                            required: !node.optional,
+                            peerOf: node,
+                        });
+                    }
                     // REQUIRED edges only — a name this package also lists in
                     // `optionalDependencies` is queued once by the loop below, as
                     // optional (header note, invariant 3). Queuing it here too would
@@ -693,7 +742,9 @@ optionalSpecs) {
                     // `assertRequiredEdgesResolved` re-judges every entry against the
                     // fixpoint flags, so a genuinely required dependency cannot go missing
                     // just because BFS reached it through an optional edge first.
-                    skippedEdges.add(edgeKey(edge.from, edge.name));
+                    // A peer edge is keyed by its DEPENDENT, not by `from`: the dependent
+                    // is the requester whose final optionality decides the verdict.
+                    skippedEdges.add(edgeKey(edge.peerOf?.installPath ?? edge.from, edge.name));
                     log('resolve: optional dep %s@%s skipped (%s)', edge.name, edge.range, errMsg(e));
                     continue;
                 }
@@ -798,6 +849,27 @@ export function requiredDepEntries(node) {
     }
     return entries;
 }
+/**
+ * A node's REQUIRED peer edges: its `peerDependencies` minus those
+ * `peerDependenciesMeta` marks `optional` (npm ≥ 7 installs the rest and skips
+ * these) and minus any name it also lists as a dependency — that edge is walked
+ * from the node itself by {@link requiredDepEntries}, or is optional because the
+ * publisher said so in `optionalDependencies`.
+ *
+ * Shared by the resolve walk and the optionality fixpoint, for the reason
+ * {@link requiredDepEntries} is: two readings of one manifest are two answers.
+ */
+export function requiredPeerEntries(node) {
+    const entries = [];
+    for (const [name, range] of Object.entries(node.peerDependencies ?? {})) {
+        if (node.peerDependenciesMeta?.[name]?.optional === true)
+            continue;
+        if (name in node.dependencies || name in node.optionalDependencies)
+            continue;
+        entries.push([name, range]);
+    }
+    return entries;
+}
 /**
  * Recompute every node's `optional` flag as a FIXPOINT over the placed graph. The
  * only writer of the final flag; whatever the nodes arrive carrying is an input
@@ -805,7 +877,8 @@ export function requiredDepEntries(node) {
  * file on the lockfile path) and is overwritten unconditionally.
  *
  * DEFINITION: a node is REQUIRED iff reachable from `requiredNames` through
- * REQUIRED edges alone ({@link requiredDepEntries}); every other node is optional.
+ * REQUIRED edges alone ({@link requiredDepEntries} plus {@link requiredPeerEntries} —
+ * a peer npm installs is as mandatory as a dependency); every other node is optional.
  * Optionality is therefore INHERITED — a plain dependency OF an optional package is
  * still optional, which is what npm's `optionalSet` computes.
  *
@@ -861,7 +934,7 @@ export function computeOptionalFlags(nodes, requiredNames, log) {
         const node = byPath.get(installPath);
         if (!node)
             continue;
-        for (const [depName] of requiredDepEntries(node)) {
+        for (const [depName] of [...requiredDepEntries(node), ...requiredPeerEntries(node)]) {
             // Resolve the edge the way the REQUESTER will at runtime — through
             // the ancestor `node_modules` chain — so a nested copy is credited
             // to the requester that nested it and the hoisted one is not
@@ -952,7 +1025,7 @@ function assertRequiredEdgesResolved(nodes, skippedEdges) {
  * (dist-tags like `latest`) cannot be compared and are skipped.
  *
  * This makes the single-root-slot behaviour honest rather than silent; the real fix
- * is a per-workspace dedup pass, Phase D.8 (status/open-todos.md).
+ * is a per-workspace dedup pass, Phase D.8 (status/open-todos/README.md).
  */
 function emitTopLevelConflictWarnings(topLevelRanges, root) {
     for (const [name, ranges] of topLevelRanges) {
@@ -1082,6 +1155,11 @@ function findVisible(requesterPath, name, byPath) {
     }
     return null;
 }
+/** The `installPath` whose `node_modules` holds this one; null for a root placement. */
+function parentInstallPath(installPath) {
+    const idx = installPath.lastIndexOf('/node_modules/');
+    return idx < 0 ? null : installPath.slice(0, idx);
+}
 /**
  * Where to install `name@version` for a request from `requesterPath`: hoist to
  * `node_modules/<name>` when the root slot is empty or already holds this version,
@@ -1142,6 +1220,8 @@ function writeLockfile(lockfilePath, specs, nodes) {
             // `computeOptionalFlags` runs on the lockfile path too and cannot recompute
             // what the file does not carry (v4, header note invariant 3).
             optionalDependencies: Object.keys(node.optionalDependencies).length > 0 ? node.optionalDependencies : undefined,
+            peerDependencies: nonEmpty(node.peerDependencies),
+            peerDependenciesMeta: nonEmpty(node.peerDependenciesMeta),
             bin: node.bin,
             // The DECLARATION, never the verdict: `inert` is per-host and deliberately
             // absent from the file, since a lockfile recording which packages the
@@ -1156,12 +1236,16 @@ function writeLockfile(lockfilePath, specs, nodes) {
         lockfileVersion: LOCKFILE_VERSION,
         requested: [...specs],
         packages,
+        peersResolved: true,
     };
     // Atomic tmp+rename so a crash mid-write, or a reader racing the writer, can never
     // observe a torn gjsify-lock.json — `--immutable` would otherwise hard-fail on the
     // corrupt file with a misleading error.
     atomicWriteStrict(lockfilePath, JSON.stringify(lockfile, null, 2) + '\n');
 }
+function nonEmpty(map) {
+    return map && Object.keys(map).length > 0 ? map : undefined;
+}
 /**
  * The lockfile-preservation oracle: `name → every version currently pinned` (a name
  * can appear at more than one path/version when the tree nested a conflicting copy).
@@ -1214,6 +1298,8 @@ function lockfileToNodes(lockfile) {
             // blocks reads as required here. `--immutable` consumes it anyway — see
             // READABLE_LOCKFILE_VERSIONS.
             optionalDependencies: entry.optionalDependencies ?? {},
+            peerDependencies: entry.peerDependencies,
+            peerDependenciesMeta: entry.peerDependenciesMeta,
             bin: entry.bin,
             // Rebuilt from the recorded declaration so `applyPlatformFilter` reaches the
             // SAME verdict here as on the fresh-resolve path, for THIS host — generally

package/lib/utils/install-lock.js

@@ -17,8 +17,8 @@
 // `owner.json` inside records pid + start time for staleness checks.
 //
 // Staleness — a crashed install cannot release its lock, so contenders steal when
-//   (a) the owner pid is provably dead (`/proc/<pid>` on Linux, readable under Node and GJS
-//       alike; a kill(0) probe covers non-/proc Nodes), or
+//   (a) the owner pid is provably dead (`isPidAlive` in `process-table.ts`: `/proc/<pid>` where
+//       procfs exists, a signal-0 probe elsewhere), or
 //   (b) the lock outlives GJSIFY_INSTALL_LOCK_STALE_MS (default 35 min — just above the 30-min
 //       install budget, so a budget-bound install always exits before its lock can be stolen out
 //       from under it), or
@@ -31,8 +31,9 @@
 //
 // GJSIFY_INSTALL_LOCK=0 disables locking entirely — for a network filesystem with broken
 // rename/mkdir atomicity, or an outer tool that already serializes installs.
-import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync, } from 'node:fs';
+import { mkdirSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
+import { isPidAlive } from './process-table.js';
 const LOCK_DIR_NAME = '.gjsify-install-lock';
 const OWNER_FILE = 'owner.json';
 /** Default staleness budget — see the header comment for why 35 min. */
@@ -60,28 +61,6 @@ function lockingDisabled() {
     const trimmed = flag.trim();
     return trimmed === '0' || trimmed === 'false';
 }
-/**
- * Is `pid` a live process on this machine?
- *
- * `/proc/<pid>` is the reliable cross-runtime probe on Linux, identical under Node and GJS;
- * elsewhere a signal-0 probe (ESRCH dead, EPERM alive-but-foreign). The GJS `process.kill`
- * polyfill shells out and cannot report ESRCH, but GJS only runs on /proc platforms in practice,
- * so the fallback branch is Node's. Unknown outcomes count as ALIVE — never steal a lock that
- * cannot be proven abandoned; the mtime staleness budget still applies.
- */
-function isPidAlive(pid) {
-    // `existsSync` never throws by contract: Node returns false on any error, and the GJS shim is
-    // a typeof guard + Gio `query_exists`, neither with a throw path in the GIR.
-    if (existsSync('/proc/self'))
-        return existsSync(`/proc/${pid}`);
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (err) {
-        return err.code === 'EPERM';
-    }
-}
 function mtimeMs(path) {
     try {
         return statSync(path).mtimeMs;

package/lib/utils/native-skip-scan.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The Prettier parser napi oxfmt would format `fileName` with, or `null` when
+ * the native build formats it itself or no oxfmt formats it. `svelte` counts
+ * only when the config enables it, as in oxfmt.
+ */
+export declare function externalParserFor(fileName: string, svelteEnabled?: boolean): string | null;
+export interface NativeSkipScanOptions {
+    /** The `--config` handed to oxfmt. Absent → discovery, as in oxfmt. */
+    configPath?: string;
+}
+export interface NativeSkipScanResult {
+    /** Files napi oxfmt would format that the native build skips. */
+    skipped: string[];
+    /** Files the walk hands to oxfmt's classifier. */
+    total: number;
+}
+/** Walk `paths` the way oxfmt does and report what the native build skips. */
+export declare function scanForNativeSkips(paths: string[], cwd?: string, options?: NativeSkipScanOptions): NativeSkipScanResult;
+/** JSON with comments and trailing commas; string contents are never touched. */
+export declare function parseJsonc(text: string): unknown;