@crustjs/crust 0.5.6 → 0.6.1

package/README.md

@@ -16,7 +16,7 @@ crust build --artifact binary    # stage standalone binaries in .crust/
 crust publish                    # publish what crust build staged
 ```
 
-Every build selects its artifact with `--artifact` or `"crust": { "artifact": "package" | "binary" }` in package.json. Runtime packages for the `deno` runtime are experimental: they need deno 2.5.0 or newer to build, and consumers run them with `deno run npm:<package>/<command>` or `deno install -g`, choosing the permissions themselves.
+Every build selects its artifact with `--artifact` or `"crust": { "artifact": "package" | "binary" }` in package.json.
 
 The same build is available to release scripts:
 

package/bin/crust.js

@@ -1,12 +1,18 @@
 #!/usr/bin/env node
 // Auto-generated by crust build -- do not edit
-import { spawn } from "node:child_process";
-import { chmodSync, existsSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import process from "node:process";
-import { fileURLToPath } from "node:url";
-
 const NAME = "crust";
+if (typeof process.getBuiltinModule !== "function" ||
+	(process.platform !== "win32" && typeof process.execve !== "function")) {
+	console.error("[" + NAME + "] Requires Node.js >=24 (found " + process.version + ").");
+	process.exit(1);
+}
+
+// Builtins come from process.getBuiltinModule (cheaper than imports) and never from
+// node:process: importing it touches stdio, which leaves the shared terminal and pipes
+// non-blocking for the binary after execve.
+const { chmodSync, closeSync, existsSync, openSync, readSync } = process.getBuiltinModule("node:fs");
+const { resolve } = process.getBuiltinModule("node:path");
+
 const PLATFORMS = {
 	"linux-x64": {
 		"packagePathSegment": "crust-linux-x64",
@@ -57,10 +63,20 @@ const PLATFORMS = {
 		"binaryFilename": "crust-bun-windows-arm64.exe"
 	}
 };
-const dir = dirname(fileURLToPath(import.meta.url));
+const dir = import.meta.dirname;
 
-// Same check as Bun's own npm installer: glibc reports its version, musl does not.
 function isMusl() {
+	// The first 2 KB of Node's ELF image hold its interpreter path (detect-libc reads the same
+	// span), which names its libc without the milliseconds a diagnostic report costs on every start.
+	try {
+		const fd = openSync("/proc/self/exe", "r");
+		const head = Buffer.alloc(2048);
+		const interpreter = head.toString("latin1", 0, readSync(fd, head, 0, head.length, 0));
+		closeSync(fd);
+		if (interpreter.includes("/ld-musl-")) return true;
+		if (interpreter.includes("/ld-linux-")) return false;
+	} catch {}
+	// Same check as Bun's own npm installer: glibc reports its version, musl does not.
 	try {
 		const report = process.report?.getReport();
 		if (report?.header) return report.header.glibcVersionRuntime === undefined;
@@ -98,32 +114,49 @@ if (!binPath) {
 	process.exit(1);
 }
 
-if (process.platform !== "win32") {
+if (process.platform === "win32") {
+	launchWindows(binPath);
+} else {
 	try {
 		chmodSync(binPath, 0o755);
 	} catch {
-		// Ignore permission adjustment failures and let spawn surface real errors.
+		// Ignore permission adjustment failures and let execve surface real errors.
 	}
+	// Become the binary: one process, so signals and exit status reach it with no relay.
+	// Node ignores SIGPIPE and SIGXFSZ, and ignored signals survive execve; handled ones reset.
+	// Ignores Node inherited (nohup's SIGHUP) were reset at its startup, so none pass on.
+	process.on("SIGPIPE", () => {});
+	process.on("SIGXFSZ", () => {});
+	// Early execve versions (e.g. Node 24.0.0) default to an empty environment.
+	process.execve(binPath, [binPath, ...process.argv.slice(2)], process.env);
 }
 
-const child = spawn(binPath, process.argv.slice(2), {
-	stdio: "inherit",
-});
-
-child.on("error", (error) => {
-	console.error("[" + NAME + "] Failed to launch binary: " + error.message);
-	process.exit(1);
-});
-
-child.on("exit", (code, signal) => {
-	if (signal) {
-		try {
-			process.kill(process.pid, signal);
-		} catch {
-			process.exit(1);
+// Windows has no execve. Its console delivers Ctrl-C to the binary directly, and
+// child.kill("SIGINT") would hard-terminate it, so SIGINT is never forwarded.
+function launchWindows(binPath) {
+	const { spawn } = process.getBuiltinModule("node:child_process");
+	const child = spawn(binPath, process.argv.slice(2), { stdio: "inherit" });
+	const forward = (signal) => child.kill(signal);
+	const ignore = () => {};
+	process.on("SIGINT", ignore);
+	process.on("SIGTERM", forward);
+	process.on("SIGHUP", forward);
+	child.on("error", (error) => {
+		console.error("[" + NAME + "] Failed to launch binary: " + error.message);
+		process.exit(1);
+	});
+	child.on("exit", (code, signal) => {
+		process.off("SIGINT", ignore);
+		process.off("SIGTERM", forward);
+		process.off("SIGHUP", forward);
+		if (signal) {
+			try {
+				process.kill(process.pid, signal);
+			} catch {
+				process.exit(1);
+			}
+			return;
 		}
-		return;
-	}
-
-	process.exit(code ?? 0);
-});
+		process.exit(code ?? 0);
+	});
+}

package/dist/index.d.ts

@@ -1,5 +1,10 @@
 import { BuildReport, BuildReport as BuildReport$1 } from "@crustjs/core";
-//#region src/distribute.d.ts
+declare const BUN_TARGET_NAMES: readonly ["bun-linux-x64", "bun-linux-arm64", "bun-linux-x64-musl", "bun-linux-arm64-musl", "bun-darwin-x64", "bun-darwin-arm64", "bun-windows-x64", "bun-windows-arm64"];
+type BunTarget = (typeof BUN_TARGET_NAMES)[number];
+declare const NODE_TARGET_NAMES: readonly ["linux-x64", "linux-arm64", "darwin-x64", "darwin-arm64", "win-x64", "win-arm64"];
+type NodeTarget = (typeof NODE_TARGET_NAMES)[number];
+/** `--target` value that stands for this machine's canonical target. */
+declare const HOST_TARGET = "host";
 /**
  * What one build distributes: a runtime `package` (a root-only JavaScript
  * bundle that needs the runtime installed) or standalone `binary` executables
@@ -31,8 +36,6 @@ type BuildArtifact = {
   path: string;
   command: string;
 };
-//#endregion
-//#region src/build.d.ts
 /** Options of the programmatic {@link build}; `crust build` maps its flags onto them. */
 type BuildOptions = {
   /** Project root whose package.json `bin` and `crust` are read. Default: `process.cwd()`. */
@@ -47,13 +50,20 @@ type BuildOptions = {
   /**
    * Canonical compiler targets, or `"host"` for this machine. Overrides
    * package.json `crust.targets`; omit both to stage every target of the
-   * binary compiler. Rejected for runtime packages.
+   * binary compiler. Rejected for runtime packages. Known names are completion
+   * hints only; any string is checked at build time.
    */
-  targets?: readonly string[];
-  /** Env files inlining `PUBLIC_*` build-time constants, resolved against `cwd`. Rejected for deno. */
+  targets?: readonly (BunTarget | NodeTarget | typeof HOST_TARGET | (string & {}))[];
+  /** Env files inlining `PUBLIC_*` build-time constants, resolved against `cwd`. */
   envFiles?: readonly string[];
-  /** Minify the output. Default: true for bun and node; an explicit `true` is rejected for deno. */
+  /** Minify the output. Default: true. */
   minify?: boolean;
+  /**
+   * Precompile Bun standalone executables to bytecode for faster startup. Default:
+   * true for bun binaries; an explicit `true` is rejected for other runtimes and for
+   * runtime packages, whose consumer runtime may not read Bun bytecode.
+   */
+  bytecode?: boolean;
   /** Materialize Command Snapshots and run Extension build hooks before compiling. Default: true. */
   validate?: boolean;
   /** Receives each progress line `crust build` would print; silent when omitted. Warnings arrive as `"stderr"`. */
@@ -76,10 +86,8 @@ type BuildResult = {
  * come from `bin`; the runtime, artifact, Bun plugins, extra directories, and
  * external dependencies from package.json `crust`. Bundling and Command
  * Snapshots run in bun subprocesses (bun on PATH, or the running Bun
- * executable), so this works under Node as well when Bun is installed; Deno
- * binaries and Deno runtime packages (experimental, deno 2.5.0 or newer) need
- * deno on PATH, and Node binaries a node on PATH that Crust's tsdown can build
- * executables with.
+ * executable), so this works under Node as well when Bun is installed; Node
+ * binaries need a node on PATH that Crust's tsdown can build executables with.
  *
  * Throws on any failure. Planning and compiler-selection failures (bad
  * options or package.json, a missing or hung compiler, an engines mismatch) leave the
@@ -89,5 +97,4 @@ type BuildResult = {
  * process may leave `.crust.lock`; remove it only when no build is running.
  */
 export declare function build(options?: BuildOptions): Promise<BuildResult>;
-//#endregion
 export type { BuildArtifact, BuildOptions, BuildReport, BuildResult };