@andersbakken/fisk 5.0.12 → 5.0.14

package/builder/VM_runtime.js

@@ -3027,20 +3027,18 @@ var output = {
 
 var fs = libExports;
 
-// Padded canonical prefixes for DWARF path patching. The fisk client scans
-// compiled objects for these byte patterns and overwrites them in-place with
-// the real paths. Because the replacement is always shorter, a NUL terminator
-// followed by NUL fill fits inside the original region. This works on both ELF
-// objects and LTO bitcode.
-//
-// The length is PATH_MAX so any path the client could legally hand us fits
-// without truncation.
-// Keep in sync with FISK_PAD_LENGTH in src/client/FiskPathPatcher.cpp.
-const FISK_PAD_LENGTH = 4096;
-const FISK_NAME_PAD = "/fisk-name" + "_".repeat(FISK_PAD_LENGTH - "/fisk-name".length);
-const FISK_CDIR_PAD = "/fisk-cdir" + "_".repeat(FISK_PAD_LENGTH - "/fisk-cdir".length);
+// Flags asking the compiler to record its own argv, mapped to the negation the
+// same compiler spells it with. -g* forms land in DW_AT_producer, -f* forms in a
+// .GCC.command.line section; clang uses the command-line names and also accepts
+// the gcc-switches ones as aliases.
+const RECORD_FLAG_NEGATIONS = {
+    "-grecord-command-line": "-gno-record-command-line",
+    "-frecord-command-line": "-fno-record-command-line",
+    "-grecord-gcc-switches": "-gno-record-gcc-switches",
+    "-frecord-gcc-switches": "-fno-record-gcc-switches"
+};
 class Compile extends EventEmitter__default["default"] {
-    constructor(args, argv0, dir, debug, sourceFileName, paddedPaths) {
+    constructor(args, argv0, dir, debug, sourceFileName, { clientSourcePath, clientCwd } = {}) {
         super();
         if (!args || !args.length || !dir || !argv0) {
             console.error(argv0, args, dir);
@@ -3165,25 +3163,48 @@ class Compile extends EventEmitter__default["default"] {
             throw new Error("No sourcefile");
         }
         const sourceFileInDir = path__default["default"].join(dir, sourceFileName || path__default["default"].basename(sourcePath));
-        if (paddedPaths) {
-            // -grecord-command-line embeds our own argv verbatim into
-            // DW_AT_producer, which would (a) add two PATH_MAX pads to every CU
-            // and (b) leave the builder's /compiles path in the producer, where
-            // the client's byte scan would hit the embedded pad and NUL-truncate
-            // the rest of the recorded command line. The recorded line would be
-            // the builder's rewritten argv anyway -- not the client's -- so drop
-            // it rather than record something both wrong and mangled.
-            for (let i = args.length - 1; i >= 0; --i) {
-                if (args[i] === "-grecord-command-line" || args[i] === "-frecord-command-line") {
-                    args.splice(i, 1);
+        // Bake the client's real paths into the object instead of emitting the
+        // builder's /compiles path for the client to rewrite afterwards. The
+        // client folds these paths into its object-cache key, so a cached object
+        // is only ever handed to a client that wants exactly these values.
+        //
+        // This is the only approach that covers LTO: with -flto the output is
+        // bitcode, which no ELF-level patcher can load. It also needs no help
+        // for compressed debug sections or for gcc, both of which defeat a byte
+        // scan over the finished object.
+        if (clientSourcePath && clientCwd) {
+            // -grecord-command-line (clang) / -frecord-gcc-switches (gcc) embed
+            // our own argv verbatim into DW_AT_producer or .GCC.command.line,
+            // which would leave the builder's /compiles path in there. The
+            // recorded line is our rewritten argv rather than the client's
+            // anyway, so it is misleading as well as leaky -- turn it off.
+            //
+            // Negate each flag in place rather than dropping it and appending one
+            // fixed negation: whichever compiler accepted the positive spelling
+            // necessarily accepts its own negation, whereas a fixed flag is a
+            // guess about the compiler.
+            for (let i = 0; i < args.length; ++i) {
+                const negation = RECORD_FLAG_NEGATIONS[args[i]];
+                if (negation) {
+                    args[i] = negation;
                 }
             }
-            args.push("-gno-record-command-line");
-            // The more specific source-file rule must come last: both clang and
-            // gcc let a later -fdebug-prefix-map win over an earlier one, and
-            // the directory rule is a prefix of the source-file rule.
-            args.push(`-fdebug-prefix-map=${dir}=${FISK_CDIR_PAD}`);
-            args.push(`-fdebug-prefix-map=${sourceFileInDir}=${FISK_NAME_PAD}`);
+            // -fdebug-prefix-map only, for both compilers. clang also has
+            // -Xclang -main-file-name / -Xclang -fdebug-compilation-dir, which
+            // set the two values outright with no rule-precedence subtlety, but
+            // those are cc1 internals reached through -Xclang and carry no
+            // cross-version compatibility guarantee. -fdebug-prefix-map is a
+            // driver flag that predates every compiler fisk supports (gcc 4.3,
+            // clang 3.8), so it cannot fail on an older toolchain.
+            //
+            // The directory rule comes first and the more specific source-file
+            // rule last: both compilers let a later mapping win, and the
+            // directory is a prefix of the file. On gcc the file rule is inert --
+            // gcc takes DW_AT_name from the #line markers in the preprocessed
+            // source, which already name the client's file -- but it is harmless
+            // there and needed for clang.
+            args.push(`-fdebug-prefix-map=${dir}=${clientCwd}`);
+            args.push(`-fdebug-prefix-map=${sourceFileInDir}=${clientSourcePath}`);
         }
         if (!hasDashX) {
             switch (path__default["default"].extname(sourcePath)) {
@@ -3771,7 +3792,10 @@ process.on("message", (msg) => {
                 if (argv.debug) {
                     console.log("Creating new compile", msg.commandLine, msg.argv0, msg.dir);
                 }
-                const compile = new Compile(msg.commandLine, msg.argv0, msg.dir, argv.debug, msg.sourceFileName, msg.paddedPaths);
+                const compile = new Compile(msg.commandLine, msg.argv0, msg.dir, argv.debug, msg.sourceFileName, {
+                    clientSourcePath: msg.clientSourcePath,
+                    clientCwd: msg.clientCwd
+                });
                 // console.log("running thing", msg.commandLine);
                 compile.on("stdout", (data) => {
                     send({ type: "compileStdOut", id: msg.id, data: data });

package/builder/fisk-builder.js

@@ -8171,7 +8171,6 @@ class Job extends EventEmitter__default["default"] {
         this.sha1 = data.sha1;
         this.id = data.id;
         this.builderIp = data.builderIp;
-        this.paddedPaths = data.paddedPaths;
         this.supportsCompressedResponse = data.supportsCompressedResponse;
     }
     get readyState() {
@@ -54955,7 +54954,6 @@ class Server extends EventEmitter__default["default"] {
                     sourcePath: String(req.headers["x-fisk-sourcefile"]),
                     user: String(req.headers["x-fisk-user"]),
                     supportsCompressedResponse: req.headers["x-fisk-supports-compressed-response"] === "true",
-                    paddedPaths: req.headers["x-fisk-padded-paths"] === "true",
                     ws
                 });
                 break;
@@ -54990,6 +54988,7 @@ class Server extends EventEmitter__default["default"] {
                     client.compressed = json.compressed;
                     client.commandLine = json.commandLine;
                     client.argv0 = json.argv0;
+                    client.cwd = json.cwd;
                     client.connectTime = connectTime;
                     client.wait = json.wait;
                     this.emit("job", client);
@@ -55051,13 +55050,14 @@ class Server extends EventEmitter__default["default"] {
 }
 
 class CompileJob extends EventEmitter__default["default"] {
-    constructor(commandLine, argv0, id, vm, sourcePath, paddedPaths) {
+    constructor(commandLine, argv0, id, vm, sourcePath, clientCwd) {
         super();
         this.commandLine = commandLine;
         this.argv0 = argv0;
         this.id = id;
         this.vm = vm;
-        this.paddedPaths = paddedPaths;
+        this.sourcePath = sourcePath;
+        this.clientCwd = clientCwd;
         this.dir = path__default["default"].join(vm.root, "compiles", String(this.id));
         this.vmDir = path__default["default"].join("/", "compiles", String(this.id));
         this.sourceFileName = sourcePath ? path__default["default"].basename(sourcePath) : "sourcefile";
@@ -55088,7 +55088,16 @@ class CompileJob extends EventEmitter__default["default"] {
         this.startCompile = Date.now();
         fs$3.closeSync(this.fd);
         this.fd = undefined;
-        this.vm.child.send({ type: "compile", commandLine: this.commandLine, argv0: this.argv0, id: this.id, dir: this.vmDir, sourceFileName: this.sourceFileName, paddedPaths: this.paddedPaths }, this.sendCallback.bind(this));
+        this.vm.child.send({
+            type: "compile",
+            commandLine: this.commandLine,
+            argv0: this.argv0,
+            id: this.id,
+            dir: this.vmDir,
+            sourceFileName: this.sourceFileName,
+            clientSourcePath: this.sourcePath,
+            clientCwd: this.clientCwd
+        }, this.sendCallback.bind(this));
     }
     cancel() {
         this.vm.child.send({ type: "cancel", id: this.id }, this.sendCallback.bind(this));
@@ -55199,8 +55208,8 @@ class VM extends EventEmitter__default["default"] {
             }
         });
     }
-    startCompile(commandLine, argv0, id, sourcePath, paddedPaths) {
-        const compile = new CompileJob(commandLine, argv0, id, this, sourcePath, paddedPaths);
+    startCompile(commandLine, argv0, id, sourcePath, cwd) {
+        const compile = new CompileJob(commandLine, argv0, id, this, sourcePath, cwd);
         this.compiles[compile.id] = compile;
         // console.log("startCompile " + compile.id);
         return compile;
@@ -55211,7 +55220,10 @@ class VM extends EventEmitter__default["default"] {
 }
 
 const Version = 5;
-const ObjectCacheFormatVersion = 5;
+// 6: objects now carry the client's real source path and compilation dir,
+// baked in at compile time instead of the builder's /compiles paths, and the
+// stored response no longer keeps the paths the client used to patch with.
+const ObjectCacheFormatVersion = 6;
 function cacheDir(option) {
     let dir = option("cache-dir");
     if (!dir) {
@@ -55265,9 +55277,16 @@ function validateObjectCache(option) {
     buf.writeUInt32BE(ObjectCacheFormatVersion);
     fs$3.writeFileSync(file, buf);
 }
-function common$2(option) {
+// Only the builder keeps an object cache on disk. The scheduler tracks which
+// builder holds which sha1 in memory, and the daemon uses cacheDir purely for
+// the default socket path -- validating an object cache for either created a
+// directory they never read and, on a format bump, tried to destroy one they do
+// not necessarily own.
+function common$2(option, hasObjectCache = false) {
     validateCache(option);
-    validateObjectCache(option);
+    if (hasObjectCache) {
+        validateObjectCache(option);
+    }
     return {
         cacheDir: cacheDir.bind(undefined, option),
         Version,
@@ -60125,25 +60144,25 @@ if (process.argv.includes("--help") || process.argv.includes("-h")) {
     console.log(`Usage: fisk-builder [options]
 
 Options:
-  --scheduler=URL              Scheduler URL (default: localhost:8097)
-  --port=PORT                  Listen port (default: 8096)
-  --slots=N                    Number of compile slots
-  --debug                      Enable debug logging
-  --object-cache-size=SIZE     Object cache size (e.g. "10gb")
-  --object-cache-dir=PATH      Object cache directory
-  --object-cache-purge-size=N  Size to purge cache down to
+  --scheduler=URL                Scheduler URL (default: localhost:8097)
+  --port=PORT                    Listen port (default: 8096)
+  --slots=N                      Number of compile slots
+  --debug                        Enable debug logging
+  --object-cache-size=SIZE       Object cache size (e.g. "10gb")
+  --object-cache-dir=PATH        Object cache directory
+  --object-cache-purge-size=N    Size to purge cache down to
   --restart-on-new-environments  Restart when new environments arrive
-  --name=NAME                  Builder name
-  --hostname=HOST              Builder hostname (default: os.hostname())
-  --labels=LABELS              Builder labels
-  --npm-version-file=PATH      Path to npm version file
-  --keep-compiles              Keep compile directories after completion
-  --vm-user=USER               User for VM processes
-  --inform-delay=MS            Delay before informing scheduler (default: 5000)
-  --quit-on-error-delay=MS     Delay before quitting on error
-  --loadInterval=MS            Load reporting interval (default: 1000)
-  --backlog=N                  Listen backlog (default: 50)
-  --cache-dir=PATH             Cache directory (default: ~/.cache/fisk/builder)
+  --name=NAME                    Builder name
+  --hostname=HOST                Builder hostname (default: os.hostname())
+  --labels=LABELS                Builder labels
+  --npm-version-file=PATH        Path to npm version file
+  --keep-compiles                Keep compile directories after completion
+  --vm-user=USER                 User for VM processes
+  --inform-delay=MS              Delay before informing scheduler (default: 5000)
+  --quit-on-error-delay=MS       Delay before quitting on error
+  --loadInterval=MS              Load reporting interval (default: 1000)
+  --backlog=N                    Listen backlog (default: 50)
+  --cache-dir=PATH               Cache directory (default: ~/.cache/fisk/builder)
 
 Config files: ~/.config/fisk/builder.conf, /etc/xdg/fisk/builder.conf
 Environment variables: FISK_BUILDER_SCHEDULER, FISK_BUILDER_PORT, etc.`);
@@ -60154,7 +60173,7 @@ const option = createOptions({
     noApplicationPath: true,
     additionalFiles: ["fisk/builder.conf.override"]
 });
-const common = common$2(option);
+const common = common$2(option, true);
 if (process.getuid() !== 0) {
     console.error("fisk builder needs to run as root to be able to chroot");
     process.exit(1);
@@ -60922,7 +60941,7 @@ server.on("job", (job) => {
             console.log("Starting job", j.id, jobJob.sourcePath, "for", jobJob.ip, jobJob.name, "wait", jobJob.wait);
             assert__default["default"](jobJob.commandLine, "Must have commandLine");
             assert__default["default"](jobJob.argv0, "Must have argv0");
-            j.op = vm.startCompile(jobJob.commandLine, jobJob.argv0, jobJob.id, jobJob.sourcePath, jobJob.paddedPaths);
+            j.op = vm.startCompile(jobJob.commandLine, jobJob.argv0, jobJob.id, jobJob.sourcePath, jobJob.cwd);
             if (j.buffer) {
                 j.op.feed(j.buffer);
                 j.buffer = undefined;
@@ -60988,8 +61007,13 @@ server.on("job", (job) => {
                     success: event.success,
                     exitCode: event.exitCode,
                     sha1: jobJob.sha1,
-                    sourcePath: path__default["default"].join(j.op.vmDir, j.op.sourceFileName),
-                    originalSourcePath: jobJob.sourcePath,
+                    // Just the basename. This goes into the object cache and is
+                    // replayed on every hit, so it has to still mean something
+                    // later: the /compiles/<id> directory belongs to this one
+                    // job's chroot, and the requesting client's own path belongs
+                    // to whichever client happened to compile it first. Only the
+                    // file name survives being shared.
+                    sourcePath: j.op.sourceFileName,
                     stderr: j.stderr,
                     stdout: j.stdout
                 };

package/daemon/fisk-daemon.js

@@ -2,62 +2,30 @@
 'use strict';
 
 var crypto = require('crypto');
-var child_process = require('child_process');
-var require$$1 = require('fs');
-var require$$4 = require('util');
-var path$h = require('path');
 var EventEmitter = require('events');
+var require$$1 = require('fs');
 var require$$0 = require('constants');
 var require$$0$1 = require('stream');
+var require$$4 = require('util');
 var assert$1 = require('assert');
+var path$h = require('path');
 var os$1 = require('os');
 var net = require('net');
 var require$$1$1 = require('module');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
-var require$$4__default = /*#__PURE__*/_interopDefaultLegacy(require$$4);
-var path__default = /*#__PURE__*/_interopDefaultLegacy(path$h);
 var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
+var require$$1__default = /*#__PURE__*/_interopDefaultLegacy(require$$1);
 var require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0);
 var require$$0__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$0$1);
+var require$$4__default = /*#__PURE__*/_interopDefaultLegacy(require$$4);
 var assert__default = /*#__PURE__*/_interopDefaultLegacy(assert$1);
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path$h);
 var os__default = /*#__PURE__*/_interopDefaultLegacy(os$1);
 var net__default = /*#__PURE__*/_interopDefaultLegacy(net);
 var require$$1__default$1 = /*#__PURE__*/_interopDefaultLegacy(require$$1$1);
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __awaiter(thisArg, _arguments, P, generator) {
-  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-  return new (P || (P = Promise))(function (resolve, reject) {
-      function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-      function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-      function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-      step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-  var e = new Error(message);
-  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-const execFileAsync = require$$4.promisify(child_process.execFile);
 // Fingerprinting strategy:
 //
 // A compiler's "identity" for distributed-compile purposes is the set of
@@ -85,8 +53,17 @@ const execFileAsync = require$$4.promisify(child_process.execFile);
 // macros. Those strings are frozen at compiler-build time, not install
 // time, so they are identical across machines that installed the same
 // compiler package.
+//
+// Who runs the probes:
+//
+// The daemon never executes a compiler. The compiler generally lives inside
+// the client's container and its path does not resolve in the daemon's mount
+// namespace, so the daemon cannot stat it let alone run it. Instead the daemon
+// asks one client to run the probes and send the raw output back, and the
+// daemon does the parsing and hashing here. Keeping canonicalisation on this
+// side means there is exactly one implementation of it -- a second one in the
+// client would eventually diverge and silently break client/builder matching.
 const PROBE_TIMEOUT_MS = 10000;
-const PROBE_MAX_BUFFER = 4 * 1024 * 1024;
 const PROBES = [
     { label: "dumpmachine", args: ["-dumpmachine"], required: true },
     { label: "dumpversion", args: ["-dumpversion"], required: true },
@@ -94,23 +71,6 @@ const PROBES = [
     { label: "builtins-c", args: ["-x", "c", "-E", "-dM", "/dev/null"], required: true },
     { label: "builtins-cxx", args: ["-x", "c++", "-E", "-dM", "/dev/null"], required: true }
 ];
-function runProbe(exec, probe) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const { stdout, stderr } = yield execFileAsync(exec, [...probe.args], {
-                timeout: PROBE_TIMEOUT_MS,
-                maxBuffer: PROBE_MAX_BUFFER
-            });
-            return `${stdout}${stderr}`;
-        }
-        catch (err) {
-            if (probe.required) {
-                throw new Error(`Probe '${probe.label}' failed for ${exec}: ${err instanceof Error ? err.message : String(err)}`);
-            }
-            return null;
-        }
-    });
-}
 // Emulate the C++ sscanf cascade "%d.%d.%d" -> "%d.%d" -> "%d".
 function parseVersion(text) {
     const three = /^(\d+)\.(\d+)\.(\d+)/.exec(text);
@@ -182,19 +142,26 @@ function versionFromMacros(macros, type) {
     }
     return { major: 0, minor: 0, patch: 0 };
 }
-function gatherProbes(exec) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const results = yield Promise.all(PROBES.map((p) => runProbe(exec, p)));
-        const [dumpmachine, dumpversion, dumpfullversion, builtinsC, builtinsCxx] = results;
-        // The required probes cannot be null because runProbe would have thrown.
-        return {
-            dumpmachine: (dumpmachine !== null && dumpmachine !== void 0 ? dumpmachine : "").trim(),
-            dumpversion: (dumpversion !== null && dumpversion !== void 0 ? dumpversion : "").trim(),
-            dumpfullversion: dumpfullversion === null ? null : dumpfullversion.trim(),
-            builtinsC: builtinsC !== null && builtinsC !== void 0 ? builtinsC : "",
-            builtinsCxx: builtinsCxx !== null && builtinsCxx !== void 0 ? builtinsCxx : ""
-        };
-    });
+// Turn a client's reported results into the shape the fingerprint wants,
+// failing if a required probe is missing. A client that reports nothing for a
+// required probe is telling us it could not identify the compiler, which must
+// not silently become a fingerprint of empty strings -- every such compiler
+// would hash the same.
+function toProbeOutputs(results) {
+    for (const probe of PROBES) {
+        if (probe.required && !results[probe.label]) {
+            throw new Error(`Required probe '${probe.label}' produced no output`);
+        }
+    }
+    const value = (label) => { var _a; return (_a = results[label]) !== null && _a !== void 0 ? _a : ""; };
+    const full = results.dumpfullversion;
+    return {
+        dumpmachine: value("dumpmachine").trim(),
+        dumpversion: value("dumpversion").trim(),
+        dumpfullversion: full ? full.trim() : null,
+        builtinsC: value("builtins-c"),
+        builtinsCxx: value("builtins-cxx")
+    };
 }
 // Build the canonical fingerprint blob whose SHA becomes the compiler hash.
 // Fields are separated by NUL to avoid ambiguity if any probe output
@@ -218,76 +185,163 @@ function canonicalFingerprint(p) {
     ];
     return Buffer.from(parts.join("\0"), "utf8");
 }
-function createCompilerInfo(exec) {
+function createCompilerInfo(results) {
     var _a;
-    return __awaiter(this, void 0, void 0, function* () {
-        const probes = yield gatherProbes(exec);
-        const type = detectTypeFromMacros(probes.builtinsC);
-        const versionFromMac = versionFromMacros(probes.builtinsC, type);
-        const version = versionFromMac.major !== 0
-            ? versionFromMac
-            : parseVersion((_a = probes.dumpfullversion) !== null && _a !== void 0 ? _a : probes.dumpversion);
-        const blob = canonicalFingerprint(probes);
-        const hash = crypto.createHash("sha1").update(blob).digest("hex").toUpperCase();
-        // `input` is retained for debug/traceability: it lets a human see what
-        // went into the hash without needing to re-probe the compiler. Keep it
-        // small: just the identifying strings, not the full macro dumps.
-        const input = [
-            `type=${type}`,
-            `target=${probes.dumpmachine}`,
-            `version=${version.major}.${version.minor}.${version.patch}`,
-            `dumpversion=${probes.dumpversion}`,
-            probes.dumpfullversion ? `dumpfullversion=${probes.dumpfullversion}` : ""
-        ]
-            .filter((s) => s.length > 0)
-            .join("\n");
-        return { hash, input, type, version };
-    });
-}
-class CompilerInfoCache {
-    constructor() {
+    const probes = toProbeOutputs(results);
+    const type = detectTypeFromMacros(probes.builtinsC);
+    const versionFromMac = versionFromMacros(probes.builtinsC, type);
+    const version = versionFromMac.major !== 0
+        ? versionFromMac
+        : parseVersion((_a = probes.dumpfullversion) !== null && _a !== void 0 ? _a : probes.dumpversion);
+    const blob = canonicalFingerprint(probes);
+    const hash = crypto.createHash("sha1").update(blob).digest("hex").toUpperCase();
+    // `input` is retained for debug/traceability: it lets a human see what
+    // went into the hash without needing to re-probe the compiler. Keep it
+    // small: just the identifying strings, not the full macro dumps.
+    const input = [
+        `type=${type}`,
+        `target=${probes.dumpmachine}`,
+        `version=${version.major}.${version.minor}.${version.patch}`,
+        `dumpversion=${probes.dumpversion}`,
+        probes.dumpfullversion ? `dumpfullversion=${probes.dumpfullversion}` : ""
+    ]
+        .filter((s) => s.length > 0)
+        .join("\n");
+    return { hash, input, type, version };
+}
+// A client-supplied key must not be trusted to be small: it lands in a Map
+// that lives as long as the daemon.
+const MAX_KEY_LENGTH = 256;
+function clearTimer(entry) {
+    if (entry.timer) {
+        clearTimeout(entry.timer);
+        entry.timer = undefined;
+    }
+}
+// Caches compiler fingerprints, obtaining them from clients rather than by
+// running anything.
+//
+// The key is opaque here and comes from the client -- it identifies "the same
+// compiler file" well enough to decide whether to re-probe. It deliberately is
+// not the fingerprint: we need something cheap to compute *before* probing.
+//
+// Only one client is asked per key. Everyone else waits on the same answer,
+// which is what keeps a cold parallel build from probing the same compiler
+// once per job. Callers get a promise, so the daemon's existing "await the
+// info, then hand back a slot" flow already holds those clients' slots for
+// the duration without any extra slot bookkeeping.
+class CompilerInfoStore {
+    constructor(timeoutMs = PROBE_TIMEOUT_MS * 2, log = () => {
+        /* quiet by default */
+    }) {
+        this.timeoutMs = timeoutMs;
+        this.log = log;
         this.cache = new Map();
         this.pending = new Map();
     }
-    get(compilerPath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (typeof compilerPath !== "string" || compilerPath.length === 0) {
-                throw new Error("CompilerInfoCache.get: compilerPath must be a non-empty string");
-            }
-            // Resolve symlinks so that /usr/bin/clang and /usr/bin/clang-18
-            // (when the former is a symlink to the latter) share a cache entry.
-            const absPath = yield require$$1.promises.realpath(path__default["default"].resolve(compilerPath));
-            const stat = yield require$$1.promises.stat(absPath);
-            const key = `${absPath}:${stat.mtimeMs}`;
-            const cached = this.cache.get(key);
-            if (cached) {
-                return cached;
+    get(key, requester) {
+        if (typeof key !== "string" || key.length === 0 || key.length > MAX_KEY_LENGTH) {
+            return Promise.reject(new Error("compiler key must be a non-empty string of sane length"));
+        }
+        const cached = this.cache.get(key);
+        if (cached) {
+            return Promise.resolve(cached);
+        }
+        return new Promise((resolve, reject) => {
+            let entry = this.pending.get(key);
+            if (!entry) {
+                entry = { waiters: [], triedIds: new Set() };
+                this.pending.set(key, entry);
             }
-            const inflight = this.pending.get(key);
-            if (inflight) {
-                return inflight;
+            entry.waiters.push({ requester, resolve, reject });
+            // Someone is already probing this compiler; just wait for them.
+            if (entry.electedId === undefined) {
+                this.elect(key, entry);
             }
-            const compute = CompilerInfoCache.compute(absPath).then((info) => {
-                this.cache.set(key, info);
-                return info;
-            });
-            this.pending.set(key, compute);
-            // Clean up the pending map on both success and failure so a failed
-            // lookup doesn't wedge the key forever.
-            compute
-                .finally(() => {
-                this.pending.delete(key);
-            })
-                .catch(() => {
-                /* rejection observed by caller via the returned promise */
-            });
-            return compute;
         });
     }
-    static compute(absPath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return createCompilerInfo(absPath);
-        });
+    // The elected client reported probe output.
+    provide(key, results) {
+        const entry = this.pending.get(key);
+        let info;
+        try {
+            info = createCompilerInfo(results);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.log("compilerInfo for", key, "was unusable:", message);
+            if (entry) {
+                this.reelect(key, entry, message);
+            }
+            return;
+        }
+        this.cache.set(key, info);
+        if (!entry) {
+            return;
+        }
+        this.finish(key, entry);
+        for (const waiter of entry.waiters) {
+            waiter.resolve(info);
+        }
+    }
+    // The elected client could not probe the compiler.
+    fail(key, error) {
+        const entry = this.pending.get(key);
+        if (entry) {
+            this.reelect(key, entry, error);
+        }
+    }
+    // A client went away. If it owed us an answer, ask someone else.
+    clientGone(requester) {
+        for (const [key, entry] of this.pending) {
+            entry.waiters = entry.waiters.filter((w) => w.requester.id !== requester.id);
+            if (entry.electedId === requester.id) {
+                this.reelect(key, entry, "client disconnected before reporting compiler info");
+            }
+            else if (!entry.waiters.length) {
+                this.finish(key, entry);
+            }
+        }
+    }
+    elect(key, entry) {
+        var _a, _b;
+        const next = entry.waiters.find((w) => !entry.triedIds.has(w.requester.id));
+        if (!next) {
+            // Nobody left who has not already failed us.
+            const waiters = entry.waiters;
+            this.finish(key, entry);
+            const err = new Error("no client could provide compiler info");
+            for (const waiter of waiters) {
+                waiter.reject(err);
+            }
+            return;
+        }
+        entry.electedId = next.requester.id;
+        entry.triedIds.add(next.requester.id);
+        entry.timer = setTimeout(() => {
+            this.log("compilerInfo probe timed out for", key, "client", next.requester.id);
+            this.reelect(key, entry, "timed out waiting for compiler info");
+        }, this.timeoutMs);
+        // Do not let a pending probe hold the process open.
+        (_b = (_a = entry.timer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+        this.log("asking client", next.requester.id, "to probe compiler", key);
+        try {
+            next.requester.requestCompilerInfo(key, PROBES, PROBE_TIMEOUT_MS);
+        }
+        catch (err) {
+            this.log("failed to ask client", next.requester.id, err);
+            this.reelect(key, entry, "could not ask client to probe");
+        }
+    }
+    reelect(key, entry, why) {
+        this.log("re-electing for", key, "-", why);
+        clearTimer(entry);
+        entry.electedId = undefined;
+        this.elect(key, entry);
+    }
+    finish(key, entry) {
+        clearTimer(entry);
+        this.pending.delete(key);
     }
 }
 
@@ -3762,7 +3816,10 @@ class Slots extends EventEmitter__default["default"] {
 }
 
 const Version = 5;
-const ObjectCacheFormatVersion = 5;
+// 6: objects now carry the client's real source path and compilation dir,
+// baked in at compile time instead of the builder's /compiles paths, and the
+// stored response no longer keeps the paths the client used to patch with.
+const ObjectCacheFormatVersion = 6;
 function cacheDir(option) {
     let dir = option("cache-dir");
     if (!dir) {
@@ -3816,9 +3873,16 @@ function validateObjectCache(option) {
     buf.writeUInt32BE(ObjectCacheFormatVersion);
     fs.writeFileSync(file, buf);
 }
-function common$1(option) {
+// Only the builder keeps an object cache on disk. The scheduler tracks which
+// builder holds which sha1 in memory, and the daemon uses cacheDir purely for
+// the default socket path -- validating an object cache for either created a
+// directory they never read and, on a format bump, tried to destroy one they do
+// not necessarily own.
+function common$1(option, hasObjectCache = false) {
     validateCache(option);
-    validateObjectCache(option);
+    if (hasObjectCache) {
+        validateObjectCache(option);
+    }
     return {
         cacheDir: cacheDir.bind(undefined, option),
         Version,
@@ -4536,7 +4600,9 @@ const localSlotCount = option.int("local-slots", 0);
 const localSlots = new Slots(localSlotCount, "local", debug);
 const localSlotsMaxLoad = option("local-slots-max-load") || 0;
 console.log(`cpp slots: ${cppSlots.capacity}, compile slots: ${compileSlots.capacity}, local slots: ${localSlots.capacity}, local max load: ${localSlotsMaxLoad}`);
-const compilerInfoCache = new CompilerInfoCache();
+const compilerInfoStore = new CompilerInfoStore(undefined, (...args) => {
+    console.log("compilerInfo:", ...args);
+});
 const slotSubscribers = [];
 function slotsInfo() {
     return {
@@ -4659,18 +4725,27 @@ server.on("compile", (compile) => {
             compileSlots.release(compile.id);
         }
     });
+    // The daemon cannot see, let alone run, the compiler: it usually lives in
+    // the client's container. Clients identify it with a key they compute
+    // themselves and run the probes on our behalf when asked.
+    const requester = {
+        id: compile.id,
+        requestCompilerInfo(key, probes, timeoutMs) {
+            compile.send({ type: "compilerInfoRequest", key, probes, timeoutMs });
+        }
+    };
     compile.on("acquireSlot", (msg) => {
         console.log("acquireSlot", msg);
-        const compilerPath = msg && typeof msg.compiler === "string" && msg.compiler.length > 0 ? msg.compiler : null;
-        const infoResult = compilerPath
-            ? compilerInfoCache.get(compilerPath).then((info) => ({ info, error: null }), (err) => {
+        const compilerKey = msg && typeof msg.compilerKey === "string" && msg.compilerKey.length > 0 ? msg.compilerKey : null;
+        const infoResult = compilerKey
+            ? compilerInfoStore.get(compilerKey, requester).then((info) => ({ info, error: null }), (err) => {
                 const message = err instanceof Error ? err.message : String(err);
                 if (debug) {
-                    console.log("acquireSlot -> compilerInfoCache failed", compilerPath, message);
+                    console.log("acquireSlot -> compilerInfoStore failed", compilerKey, message);
                 }
                 return { info: null, error: message };
             })
-            : Promise.resolve({ info: null, error: "acquireSlot missing compiler path" });
+            : Promise.resolve({ info: null, error: "acquireSlot missing compiler key" });
         infoResult
             .then(({ info, error }) => {
             if (compileClosed) {
@@ -4710,6 +4785,22 @@ server.on("compile", (compile) => {
             console.error("acquireSlot handler failed unexpectedly", err);
         });
     });
+    compile.on("compilerInfoResponse", (msg) => {
+        const key = msg && typeof msg.key === "string" ? msg.key : "";
+        if (!key) {
+            console.error("compilerInfoResponse without a key from", compile.id);
+            return;
+        }
+        if (typeof (msg === null || msg === void 0 ? void 0 : msg.error) === "string" && msg.error.length) {
+            compilerInfoStore.fail(key, msg.error);
+            return;
+        }
+        if (!(msg === null || msg === void 0 ? void 0 : msg.results) || typeof msg.results !== "object") {
+            compilerInfoStore.fail(key, "compilerInfoResponse without results");
+            return;
+        }
+        compilerInfoStore.provide(key, msg.results);
+    });
     compile.on("releaseLocalSlot", () => {
         if (debug) {
             console.log("releaseLocalSlot");
@@ -4725,6 +4816,8 @@ server.on("compile", (compile) => {
             console.error("Got error from fiskc", compile.id, compile.pid, err);
         }
         compileClosed = true;
+        // If this client owed us compiler info, hand the job to another waiter.
+        compilerInfoStore.clientGone(requester);
         if (requestedCppSlot) {
             requestedCppSlot = false;
             cppSlots.release(compile.id);
@@ -4743,6 +4836,8 @@ server.on("compile", (compile) => {
             console.log("got end from", compile.id, compile.pid);
         }
         compileClosed = true;
+        // If this client owed us compiler info, hand the job to another waiter.
+        compilerInfoStore.clientGone(requester);
         if (requestedCppSlot) {
             requestedCppSlot = false;
             cppSlots.release(compile.id);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@andersbakken/fisk",
-    "version": "5.0.12",
+    "version": "5.0.14",
     "description": "Fisk, a distributed compile system",
     "scripts": {
         "lint": "eslint . --ext .ts",

package/scheduler/fisk-scheduler.js

@@ -56152,6 +56152,9 @@ class Server extends require$$0__default$2["default"] {
             ws.close();
             return;
         }
+        // Exact match: this is a wire format, not a compatibility surface. A peer
+        // on a different version is not something to negotiate with, and NaN from
+        // a missing or unparseable header fails this comparison too.
         const configVersion = parseInt(header(req, "x-fisk-config-version") || "");
         if (configVersion !== this.configVersion) {
             ws.send(`{"error": "Bad config version, expected ${this.configVersion}, got ${configVersion}"}`);
@@ -56418,7 +56421,10 @@ class Server extends require$$0__default$2["default"] {
 }
 
 const Version = 5;
-const ObjectCacheFormatVersion = 5;
+// 6: objects now carry the client's real source path and compilation dir,
+// baked in at compile time instead of the builder's /compiles paths, and the
+// stored response no longer keeps the paths the client used to patch with.
+const ObjectCacheFormatVersion = 6;
 function cacheDir(option) {
     let dir = option("cache-dir");
     if (!dir) {
@@ -56472,9 +56478,16 @@ function validateObjectCache(option) {
     buf.writeUInt32BE(ObjectCacheFormatVersion);
     fs$4.writeFileSync(file, buf);
 }
-function common$1(option) {
+// Only the builder keeps an object cache on disk. The scheduler tracks which
+// builder holds which sha1 in memory, and the daemon uses cacheDir purely for
+// the default socket path -- validating an object cache for either created a
+// directory they never read and, on a format bump, tried to destroy one they do
+// not necessarily own.
+function common$1(option, hasObjectCache = false) {
     validateCache(option);
-    validateObjectCache(option);
+    if (hasObjectCache) {
+        validateObjectCache(option);
+    }
     return {
         cacheDir: cacheDir.bind(undefined, option),
         Version,
@@ -57998,7 +58011,32 @@ const option = options({
 const common = common$1(option);
 let nextCommandId = 0;
 const server = new Server(option, common.Version);
-const clientMinimumVersion = "5.0.6";
+// 5.0.14 is the first client that folds its debug paths into the object cache
+// key and asks the builder to bake those paths in at compile time. An older
+// client produces objects carrying the builder's /compiles paths -- unpatchable
+// for LTO bitcode -- and, because it does not key on those paths, stores them
+// under a key up-to-date clients also use. One stale client therefore poisons
+// everyone's backtraces, so it is refused rather than allowed to contribute.
+const clientMinimumVersion = "5.0.14";
+// compareVersions throws on an empty or malformed version rather than returning
+// an ordering, and npmVersion is "" for any client that sends no
+// x-fisk-npm-version header. Thrown out of the compile handler that would be a
+// silent hang: uncaughtException keeps the scheduler up, but the request is
+// abandoned half-handled, so the client waits for a reply that never comes
+// instead of being told to update. A version we cannot read is not >= the
+// minimum, so treat it as too old and reject it properly.
+function clientTooOld(npmVersion) {
+    if (!npmVersion) {
+        return true;
+    }
+    try {
+        return compareVersions(clientMinimumVersion, npmVersion) >= 1;
+    }
+    catch (err) {
+        console.error(`Unparseable client npm version: "${npmVersion}"`, err);
+        return true;
+    }
+}
 const serverStartTime = Date.now();
 // A stalled event loop stops calling accept(), the listen backlog fills and the
 // kernel then silently drops SYNs, which clients see as a connect timeout rather
@@ -58848,7 +58886,7 @@ function requestEnvironment(compile) {
     return true;
 }
 server.on("clientVerify", (clientVerify) => {
-    if (compareVersions(clientMinimumVersion, clientVerify.npmVersion) >= 1) {
+    if (clientTooOld(clientVerify.npmVersion)) {
         clientVerify.send("version_mismatch", { minimum_version: `${clientMinimumVersion}` });
     }
     else {
@@ -58859,7 +58897,7 @@ server.on("compile", (compile) => {
     compile.on("log", (event) => {
         addLogFile({ source: "client", ip: compile.ip, contents: event.message });
     });
-    if (compareVersions(clientMinimumVersion, compile.npmVersion) >= 1) {
+    if (clientTooOld(compile.npmVersion)) {
         ++jobsFailed;
         compile.send("version_mismatch", { minimum_version: `${clientMinimumVersion}` });
         return;