@perryts/perry 0.5.1220 → 0.5.1519

package/README.md

@@ -23,13 +23,26 @@ Installing picks the right prebuilt binary for your platform automatically — `
 | Linux x64 (musl / Alpine) | `@perryts/perry-linux-x64-musl` |
 | Linux arm64 (musl / Alpine) | `@perryts/perry-linux-arm64-musl` |
 | Windows x64 | `@perryts/perry-win32-x64` |
+| Windows arm64 | `@perryts/perry-win32-arm64` |
+
+### Linux: glibc version
+
+The glibc packages are built against a glibc 2.31 sysroot, so they need **glibc ≥ 2.31**. That covers Ubuntu 20.04+, Debian 11+, RHEL 9+ and Amazon Linux 2023 with the native glibc build. On an older glibc the launcher automatically runs the fully-static musl build instead, which has no libc dependency ([#6298](https://github.com/PerryTS/perry/issues/6298), [#6351](https://github.com/PerryTS/perry/issues/6351)). It prints a one-time notice when it does; set `PERRY_NO_FALLBACK_NOTICE=1` to silence it.
+
+npm only installs the musl package when it thinks the machine is musl-based, so on an old-glibc host you have to ask for it once:
+
+```bash
+npm install --force @perryts/perry-linux-x64-musl   # or -arm64-musl
+```
+
+The launcher tells you this (with the exact command) instead of letting the binary fail in the dynamic loader. The static build is the same compiler; the one thing it cannot do is build `perry/ui` GTK4 desktop apps. The glibc package includes GTK4 support, whose system development libraries must be available when linking a UI app.
 
 ## Host requirements
 
 Perry produces native binaries by linking its runtime and stdlib (shipped as static archives in the platform package) into your code. That link step uses your system C toolchain, so you need:
 
 - **macOS** — Xcode Command Line Tools (`xcode-select --install`)
-- **Linux** — `gcc` or `clang` (e.g. `apt install build-essential` on Debian/Ubuntu, `apk add build-base` on Alpine)
+- **Linux** — `gcc` or `clang` (e.g. `apt install build-essential` on Debian/Ubuntu, `apk add build-base` on Alpine), plus **clang ≥ 15**: codegen emits opaque-pointer LLVM IR, which clang 14 and older reject with `error: expected type`. Ubuntu 22.04 defaults to clang 14 — `apt install clang-15` and `export PERRY_LLVM_CLANG=/usr/bin/clang-15`.
 - **Windows** — MSVC / Visual Studio Build Tools with the C++ workload
 
 Node.js 16 or later is required for the wrapper itself.

package/bin/detect.cjs

@@ -0,0 +1,137 @@
+"use strict";
+// Platform detection for the @perryts/perry launcher.
+//
+// Split out of bin/perry.js so the resolution rules can be exercised directly
+// (see ../test/detect.test.js) with a synthetic host description instead of
+// whatever machine happens to run the tests.
+
+const PLATFORM_PACKAGES = {
+  "darwin-arm64": "@perryts/perry-darwin-arm64",
+  "darwin-x64": "@perryts/perry-darwin-x64",
+  "linux-arm64": "@perryts/perry-linux-arm64",
+  "linux-arm64-musl": "@perryts/perry-linux-arm64-musl",
+  "linux-x64": "@perryts/perry-linux-x64",
+  "linux-x64-musl": "@perryts/perry-linux-x64-musl",
+  "win32-x64": "@perryts/perry-win32-x64",
+  "win32-arm64": "@perryts/perry-win32-arm64",
+};
+
+// Minimum glibc the prebuilt *glibc* Linux binaries can run on.
+//
+// KEEP IN SYNC WITH THE BUILDER IMAGE. `.github/workflows/release-packages.yml`
+// builds both GNU targets in architecture-matched glibc 2.31 containers.
+// The release build checks the final ELF symbol versions and runs a compile
+// smoke test inside that container before packaging it (#6351).
+//
+// A binary only requires the glibc version whose symbols it actually pulls in,
+// so this is an upper bound: it is the version of the builder image, and the
+// safe assumption is that the binary needs all of it. If the release matrix
+// moves to a different base image, update this constant in the same commit —
+// otherwise hosts that *could* run the glibc build get silently pushed onto the
+// static build (too high a value), or hosts that can't get the loader error back
+// (too low a value).
+const GLIBC_BUILD_FLOOR = "2.31";
+
+// Compare two dotted numeric versions ("2.35", "2.39.1"). Returns <0, 0, >0.
+// Non-numeric components sort as 0 — glibc versions are always numeric, and a
+// garbage value should not be read as "newer than the floor".
+function compareVersions(a, b) {
+  const pa = String(a).split(".");
+  const pb = String(b).split(".");
+  const len = Math.max(pa.length, pb.length);
+  for (let i = 0; i < len; i++) {
+    const na = parseInt(pa[i], 10) || 0;
+    const nb = parseInt(pb[i], 10) || 0;
+    if (na !== nb) return na - nb;
+  }
+  return 0;
+}
+
+// Read the host description this module reasons about. `glibcVersionRuntime` is
+// what Node itself uses for the `libc` field of optional deps: a version string
+// on glibc, and empty/absent on musl.
+function readHost() {
+  const host = {
+    platform: process.platform,
+    arch: process.arch,
+    hasGlibcField: false,
+    glibcVersionRuntime: undefined,
+    osRelease: null,
+  };
+  try {
+    const header = process.report && process.report.getReport().header;
+    if (header && "glibcVersionRuntime" in header) {
+      host.hasGlibcField = true;
+      host.glibcVersionRuntime = header.glibcVersionRuntime;
+    }
+  } catch (_) {
+    /* process.report unavailable — fall back to /etc/os-release below. */
+  }
+  try {
+    host.osRelease = require("fs").readFileSync("/etc/os-release", "utf8");
+  } catch (_) {
+    /* not Linux, or no os-release — leave null. */
+  }
+  return host;
+}
+
+function isMusl(host) {
+  if (host.platform !== "linux") return false;
+  // Node reports an empty glibc version on musl. This is the same signal npm
+  // uses for the `libc` selector, so it agrees with what npm installed.
+  if (host.hasGlibcField) return !host.glibcVersionRuntime;
+  // No report header (very old Node, or a hardened runtime): sniff os-release.
+  if (host.osRelease) return /\bID=alpine\b|\bmusl\b/i.test(host.osRelease);
+  return false;
+}
+
+function glibcVersion(host) {
+  if (host.platform !== "linux") return null;
+  if (!host.hasGlibcField) return null;
+  const v = host.glibcVersionRuntime;
+  return typeof v === "string" && /^\d+(\.\d+)*$/.test(v) ? v : null;
+}
+
+// Resolve a host to the ordered list of platform packages that could serve it.
+//
+// `candidates[0]` is the preferred package; later entries are tried only if the
+// preferred one is not installed. `reason` explains the choice:
+//
+//   "native"        — the plain os-arch build is the right one
+//   "musl"          — musl libc host (Alpine/distroless): the static build
+//   "glibc-too-old" — glibc host whose glibc predates the builder image, so the
+//                     glibc build's loader would reject it (#6298). The musl
+//                     build is fully static, so it runs here.
+function detectPlatform(host) {
+  const base = `${host.platform}-${host.arch}`;
+
+  if (host.platform !== "linux") {
+    return { candidates: [base], reason: "native", glibc: null };
+  }
+
+  if (isMusl(host)) {
+    // Fall back to the glibc package: some glibc systems (custom kernels, odd
+    // container images) report an empty glibcVersionRuntime and land here by
+    // mistake — see #116 / v0.5.118. If the musl package really isn't there,
+    // the glibc one is the better guess than a hard failure.
+    return { candidates: [`${base}-musl`, base], reason: "musl", glibc: null };
+  }
+
+  const glibc = glibcVersion(host);
+  if (glibc && compareVersions(glibc, GLIBC_BUILD_FLOOR) < 0) {
+    // Deliberately no glibc fallback: that binary physically cannot load here.
+    return { candidates: [`${base}-musl`], reason: "glibc-too-old", glibc };
+  }
+
+  return { candidates: [base], reason: "native", glibc };
+}
+
+module.exports = {
+  PLATFORM_PACKAGES,
+  GLIBC_BUILD_FLOOR,
+  compareVersions,
+  detectPlatform,
+  glibcVersion,
+  isMusl,
+  readHost,
+};

package/bin/perry.js

@@ -5,62 +5,51 @@
 // optional-dependency packages that npm picks by os/cpu/libc.
 
 const { spawn } = require("child_process");
+const {
+  PLATFORM_PACKAGES,
+  GLIBC_BUILD_FLOOR,
+  detectPlatform,
+  readHost,
+} = require("./detect.cjs");
 
-const PLATFORM_PACKAGES = {
-  "darwin-arm64": "@perryts/perry-darwin-arm64",
-  "darwin-x64": "@perryts/perry-darwin-x64",
-  "linux-arm64": "@perryts/perry-linux-arm64",
-  "linux-arm64-musl": "@perryts/perry-linux-arm64-musl",
-  "linux-x64": "@perryts/perry-linux-x64",
-  "linux-x64-musl": "@perryts/perry-linux-x64-musl",
-  "win32-x64": "@perryts/perry-win32-x64",
-};
-
-function isMusl() {
-  if (process.platform !== "linux") return false;
-  try {
-    const header = process.report && process.report.getReport().header;
-    if (header && "glibcVersionRuntime" in header) {
-      return !header.glibcVersionRuntime;
-    }
-  } catch (_) {}
-  try {
-    const release = require("fs").readFileSync("/etc/os-release", "utf8");
-    return /\bID=alpine\b|\bmusl\b/i.test(release);
-  } catch (_) {}
-  return false;
-}
+const host = readHost();
+const detected = detectPlatform(host);
+const binName = process.platform === "win32" ? "perry.exe" : "perry";
 
-function detectKey() {
-  let key = `${process.platform}-${process.arch}`;
-  if (process.platform === "linux" && isMusl()) key += "-musl";
-  return key;
+// Walk the candidate packages in preference order. On Linux the first entry may
+// be the fully-static musl build (musl host, or a glibc host older than the one
+// the glibc binaries were built on — #6298); everywhere else there is exactly
+// one candidate and this loop is the old single require.resolve.
+let binPath = null;
+let usedKey = null;
+const resolveErrors = [];
+for (const key of detected.candidates) {
+  const pkg = PLATFORM_PACKAGES[key];
+  if (!pkg) continue;
+  try {
+    binPath = require.resolve(`${pkg}/bin/${binName}`);
+    usedKey = key;
+    break;
+  } catch (err) {
+    resolveErrors.push(`${pkg}: ${err.message}`);
+  }
 }
 
-const key = detectKey();
-const pkg = PLATFORM_PACKAGES[key];
-if (!pkg) {
-  console.error(
-    `[perry] No prebuilt binary for ${key}.\n` +
-      `Supported: ${Object.keys(PLATFORM_PACKAGES).join(", ")}\n` +
-      `File an issue: https://github.com/PerryTS/perry/issues`
-  );
+if (!binPath) {
+  reportResolutionFailure();
   process.exit(1);
 }
 
-const binName = process.platform === "win32" ? "perry.exe" : "perry";
-let binPath;
-try {
-  binPath = require.resolve(`${pkg}/bin/${binName}`);
-} catch (err) {
-  console.error(
-    `[perry] The ${pkg} package is not installed.\n` +
-      `This usually means npm skipped the optional dependency for ${key}.\n` +
-      `Try: npm install --force ${pkg}\n` +
-      `Or reinstall @perryts/perry with a matching npm (\u22658.12) so os/cpu/libc selectors apply.\n` +
-      `Underlying error: ${err.message}`
+// Tell the user once — not on every invocation — when they are not running the
+// binary their platform string implies.
+if (detected.reason === "glibc-too-old" && usedKey.endsWith("-musl")) {
+  noticeOnce(
+    `[perry] glibc ${detected.glibc} is older than the prebuilt glibc binary requires ` +
+      `(>= ${GLIBC_BUILD_FLOOR}), so Perry is running its fully-static Linux build ` +
+      `(${PLATFORM_PACKAGES[usedKey]}).\n` +
+      `[perry] Same compiler; the static build cannot produce perry/ui (GTK4) apps. ` +
+      `Set PERRY_NO_FALLBACK_NOTICE=1 to silence this. Details: https://github.com/PerryTS/perry/issues/6298`
   );
-  process.exit(1);
 }
 
 const child = spawn(binPath, process.argv.slice(2), { stdio: "inherit" });
@@ -87,3 +76,90 @@ child.on("error", (err) => {
   console.error(`[perry] Failed to spawn ${binPath}: ${err.message}`);
   process.exit(1);
 });
+
+// --- helpers ---------------------------------------------------------------
+
+// Print `msg` at most once per (version, platform key) on this machine. The
+// stamp lives in the temp dir, so it comes back after a reboot/cleanup — that's
+// deliberate: the message is worth seeing again occasionally, just not on every
+// single `perry` invocation in a build loop.
+function noticeOnce(msg) {
+  if (process.env.PERRY_NO_FALLBACK_NOTICE) return;
+  const fs = require("fs");
+  const path = require("path");
+  const os = require("os");
+  let version = "unknown";
+  try {
+    version = require("../package.json").version;
+  } catch (_) {}
+  const stamp = path.join(
+    os.tmpdir(),
+    `perry-static-fallback-${version}-${usedKey}.stamp`
+  );
+  try {
+    // "wx" fails with EEXIST if we already printed this.
+    fs.closeSync(fs.openSync(stamp, "wx"));
+  } catch (err) {
+    if (err && err.code === "EEXIST") return;
+    // Any other stamp problem (read-only tmp, etc.) — print, don't crash.
+  }
+  console.error(msg);
+}
+
+function reportResolutionFailure() {
+  const key = detected.candidates[0];
+  const pkg = PLATFORM_PACKAGES[key];
+
+  if (!pkg) {
+    console.error(
+      `[perry] No prebuilt binary for ${key}.\n` +
+        `Supported: ${Object.keys(PLATFORM_PACKAGES).join(", ")}\n` +
+        `File an issue: https://github.com/PerryTS/perry/issues`
+    );
+    return;
+  }
+
+  let version = "";
+  try {
+    version = `@${require("../package.json").version}`;
+  } catch (_) {}
+
+  if (detected.reason === "glibc-too-old") {
+    // npm skipped the musl package because this host is glibc — its `libc`
+    // selector says "musl". Without --force npm refuses to install it here, so
+    // spell the command out rather than leaving the user with a loader error.
+    console.error(
+      `[perry] This system has glibc ${detected.glibc}, but Perry's prebuilt Linux binary\n` +
+        `        needs glibc >= ${GLIBC_BUILD_FLOOR} (it is built on a glibc 2.31 sysroot). Running it would fail\n` +
+        `        in the dynamic loader with "GLIBC_${GLIBC_BUILD_FLOOR} not found".\n` +
+        `\n` +
+        `        Perry also ships a fully-static Linux build that needs no glibc at all, but\n` +
+        `        npm skipped it here because that package is tagged libc: ["musl"]. Install it\n` +
+        `        the same way you installed perry:\n` +
+        `\n` +
+        `          if perry is GLOBAL (npm i -g @perryts/perry):\n` +
+        `            npm install -g --force ${pkg}${version}\n` +
+        `\n` +
+        `          if perry is a PROJECT dependency:\n` +
+        `            npm install --force ${pkg}${version}\n` +
+        `\n` +
+        `        ...then re-run perry — this launcher picks it up automatically.\n` +
+        `\n` +
+        `        Or install outside npm (this picks the static build for you):\n` +
+        `            curl -fsSL https://perryts.com/install.sh | sh\n` +
+        `\n` +
+        `        Tracking: https://github.com/PerryTS/perry/issues/6298`
+    );
+    return;
+  }
+
+  console.error(
+    `[perry] The ${pkg} package is not installed.\n` +
+      `This usually means npm skipped the optional dependency for ${key}.\n` +
+      `Install it the same way you installed perry:\n` +
+      `  global:  npm install -g --force ${pkg}${version}\n` +
+      `  project: npm install --force ${pkg}${version}\n` +
+      `Or reinstall @perryts/perry with a matching npm (≥8.12) so os/cpu/libc selectors apply.\n` +
+      `Underlying error: ${resolveErrors.join("; ")}`
+  );
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@perryts/perry",
-  "version": "0.5.1220",
+  "version": "0.5.1519",
   "description": "Native TypeScript compiler. Compiles TypeScript source directly to native executables via LLVM.",
   "bin": {
     "perry": "bin/perry.js"
@@ -11,13 +11,12 @@
     "LICENSE"
   ],
   "optionalDependencies": {
-    "@perryts/perry-darwin-arm64":     "0.5.1220",
-    "@perryts/perry-darwin-x64":       "0.5.1220",
-    "@perryts/perry-linux-x64":        "0.5.1220",
-    "@perryts/perry-linux-arm64":      "0.5.1220",
-    "@perryts/perry-linux-x64-musl":   "0.5.1220",
-    "@perryts/perry-linux-arm64-musl": "0.5.1220",
-    "@perryts/perry-win32-x64":        "0.5.1220"
+    "@perryts/perry-darwin-arm64":     "0.5.1519",
+    "@perryts/perry-darwin-x64":       "0.5.1519",
+    "@perryts/perry-linux-x64":        "0.5.1519",
+    "@perryts/perry-linux-arm64":      "0.5.1519",
+    "@perryts/perry-win32-x64":        "0.5.1519",
+    "@perryts/perry-win32-arm64":      "0.5.1519"
   },
   "keywords": [
     "typescript",