@rightkit/release 0.2.108 → 0.2.110

package/build-release.mjs

@@ -33,7 +33,7 @@ import { resolveTargetRoot } from "./cargo-target.mjs";
 import { assertNsisInPlaceUpgradeContract } from "./nsis-upgrade-contract.mjs";
 import { buildPathPrefix, collectPreflight, formatPreflight, preflightFailures } from "./preflight.mjs";
 import { assertCleanSource } from "./source-gate.mjs";
-import { acquireHeavyWorkSlot, heavyCommandEnvironment, terminateProcessTree } from "./heavy-command.mjs";
+import { acquireHeavyWorkSlot, heavyCommandEnvironment, summarizePreBrokerWaits, terminateProcessTree } from "./heavy-command.mjs";
 import { processGroupCpuSeconds } from "./process-liveness.mjs";
 import { cancelAndReapManagedRequest, firstManagedRequestId, releaseProgressLimits } from "./progress-control.mjs";
 
@@ -268,6 +268,9 @@ try {
     suiteSlot = acquireSuiteBuildSlot({ layout: sharedLayout, pid: process.pid, argv: process.argv, waitMs: Number(process.env.BUILD_GUARD_WAIT_SECS ?? 900) * 1000 });
     cacheLease = acquireCacheLease({ layout: sharedLayout, pid: process.pid, argv: process.argv });
   }
+  // Pre-broker wait attribution: every layer, ms, and blocker identity (Step 1 instrumentation).
+  const preBrokerWaits = summarizePreBrokerWaits({ heavySlot, suiteSlot, heavyOwnerInherited: process.env.RIGHTSUITE_HEAVY_WORK_OWNER === "1" });
+  console.error(`[right-release] pre-broker waits: ${preBrokerWaits.summary}`);
   throwIfInterrupted();
   const releaseId = `${config.app}-${config.version}-${shortCommit}`;
   const platformDir = platform === "win" ? "windows" : "mac";
@@ -323,6 +326,7 @@ try {
         for (const command of target.preflight?.commands ?? []) runChecked(command.cmd, command.args ?? [], path.resolve(appRoot, command.cwd ?? "."), env);
         if (buildRoot) mkdirSync(buildRoot, { recursive: true });
         mkdirSync(stateRoot, { recursive: true });
+        writeJson(path.join(stateRoot, "release-waits.json"), { schema: 1, recordedAt: new Date().toISOString(), ...preBrokerWaits });
         if (buildRoot) writeJson(path.join(buildRoot, "release-inputs.lock.json"), lockPayload);
         writeJson(path.join(stateRoot, "release-inputs.lock.json"), lockPayload);
         checkpoint(stateRoot, "preflight_complete");

package/cache-policy.mjs

@@ -213,12 +213,15 @@ export function acquireSuiteBuildSlot({ layout, pid = process.pid, argv = proces
   requireLayout(layout);
   const started = Date.now();
   const payload = { schema: CACHE_SCHEMA, pid: Number(pid), argv: [...argv], createdAt: iso(now) };
+  const waits = { layer: "suite-build-slot", waitMs: 0, blockers: [] };
   for (;;) {
     try {
       acquireAtomicLock(layout.suiteSlotPath, payload, "suite build slot", new Date());
-      return releaseFor(layout.suiteSlotPath, payload);
+      waits.waitMs = Date.now() - started;
+      return Object.assign(releaseFor(layout.suiteSlotPath, payload), { waits });
     } catch (error) {
       if (!/active/i.test(error.message)) throw error;
+      if (!waits.blockers.includes(error.message)) waits.blockers.push(error.message);
       if (Date.now() - started >= waitMs) throw new Error(`${error.message}; suite build slot timed out after ${waitMs}ms without alternate-target fallback`);
       sleep(Math.min(250, Math.max(1, waitMs - (Date.now() - started))));
     }

package/development.mjs

@@ -5,7 +5,8 @@ import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { assertPrimaryReleaseCheckout } from "./release-invocation.mjs";
 import { assertReleaseExecutionAllowed } from "./execution-policy.mjs";
-import { managedRuntimeClient, runCargoSync } from "./managed-cargo.mjs";
+import { acquireManagedRunLease, managedRuntimeClient, runCargoSync } from "./managed-cargo.mjs";
+import { BUNDLE_MARKERS, bundleMarkerBuffer, readTauriBundleMarkers } from "./tauri-bundle-marker.mjs";
 import { installPortableDevelopment } from "./portable-development.mjs";
 
 export const DEVELOPMENT_PROFILE = "release-iterate";
@@ -61,25 +62,30 @@ export function runDevelopment({ root, platform, config, buildOnly = false, dryR
   const target = validateDevelopmentConfig(config, platform);
   const repoRoot = git(root, ["rev-parse", "--show-toplevel"]);
   assertPrimaryReleaseCheckout(repoRoot, env);
+  if (dryRun) return { built: false, installed: false, plan: { build: target.build, install: buildOnly ? null : target.install ?? null, profile: DEVELOPMENT_PROFILE } };
   assertReleaseExecutionAllowed({ cwd: repoRoot, environment: env, command: `right-release dev --platform ${platform}` });
   const childEnv = developmentEnvironment(env);
-  if (dryRun) return { built: false, installed: false, plan: { build: target.build, install: buildOnly ? null : target.install ?? null, profile: DEVELOPMENT_PROFILE } };
-  for (const command of target.build) execute(command, { root, env: childEnv, dryRun, run, label: "build" });
-  if (buildOnly || !target.install) return { built: true, installed: false };
-  install(target.install, { root, platform, env: childEnv, run });
-  return { built: true, installed: true };
+  // One lease spans every managed request this run makes, so a broker cutover cannot land between them.
+  const lease = acquireManagedRunLease({ command: `right-release dev --platform ${platform}`, env });
+  try {
+    const startedMs = Date.now();
+    for (const command of target.build) execute(command, { root, env: childEnv, dryRun, run, label: "build" });
+    if (buildOnly || !target.install) return { built: true, installed: false };
+    install(target.install, { root, platform, env: childEnv, run, sinceMs: startedMs });
+    return { built: true, installed: true };
+  } finally { lease.release(); }
 }
 
 export function assertNativeDevelopmentHost(platform, host = process.platform) {
   if ((platform === "win" && host !== "win32") || (platform === "mac" && host !== "darwin")) throw new Error(`development target ${platform} requires its native host`);
 }
 
-function install(descriptor, { root, platform, env, run }) {
+function install(descriptor, { root, platform, env, run, sinceMs = null }) {
   if (descriptor.kind === "command") return execute(descriptor, { root, env, run, label: "install" });
   if (descriptor.kind === "portable") return installPortableDevelopment(descriptor, { root, platform: platform === "win" ? "win32" : "darwin", env });
   if (platform === "win") {
     if (!descriptor.expectedInstalledPath) throw new Error("Windows Tauri installer requires expectedInstalledPath for installed verification");
-    const { bundleRoot, installer: app } = resolveTauriBundleDirectory(descriptor, { root, platform, env });
+    const { bundleRoot, installer: app } = resolveTauriBundleDirectory(descriptor, { root, platform, env, sinceMs });
     const built = path.resolve(bundleRoot, "..", "..", path.basename(descriptor.expectedInstalledPath));
     assertNonEmptyExecutable(built);
     const result = run(app, ["/S"], { cwd: root, env, stdio: "inherit", windowsHide: true, shell: false });
@@ -119,7 +125,7 @@ export function resolveTauriArtifact(descriptor, { root, platform, env = process
   return resolveTauriBundleDirectory(descriptor, { root, platform, env, runCargo }).installer;
 }
 
-export function resolveTauriBundleDirectory(descriptor, { root, platform, env = process.env, runCargo = runCargoSync }) {
+export function resolveTauriBundleDirectory(descriptor, { root, platform, env = process.env, runCargo = runCargoSync, sinceMs = null }) {
   const bundleRoot = descriptor.bundleDirectory
     ? path.resolve(root, descriptor.bundleDirectory)
     : resolveBundleRoot(descriptor, { root, env, runCargo });
@@ -127,8 +133,11 @@ export function resolveTauriBundleDirectory(descriptor, { root, platform, env =
   const entries = readdirSync(bundleRoot, { withFileTypes: true });
   const candidates = platform === "mac"
     ? entries.filter((entry) => entry.isDirectory() && entry.name === `${descriptor.productName}.app`).map((entry) => path.join(bundleRoot, entry.name))
-    : entries.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".exe") && entry.name.toLowerCase().includes("setup")).map((entry) => path.join(bundleRoot, entry.name));
-  if (candidates.length !== 1) throw new Error(`expected exactly one ${platform} Tauri installer for ${descriptor.productName} in ${bundleRoot}; found ${candidates.length}`);
+    // Older installers are kept for history: select this product's installer written by this run.
+    : entries.filter((entry) => entry.isFile() && entry.name.toLowerCase().endsWith(".exe") && entry.name.toLowerCase().includes("setup") && entry.name.startsWith(`${descriptor.productName}_`))
+      .map((entry) => path.join(bundleRoot, entry.name))
+      .filter((file) => sinceMs === null || statSync(file).mtimeMs >= sinceMs);
+  if (candidates.length !== 1) throw new Error(`expected exactly one ${platform} Tauri installer for ${descriptor.productName} in ${bundleRoot}${sinceMs === null ? "" : " written by this run"}; found ${candidates.length}`);
   if (!statSync(candidates[0]).isFile() && platform === "win") throw new Error(`installer is not a file: ${candidates[0]}`);
   return { bundleRoot, installer: candidates[0] };
 }
@@ -136,9 +145,17 @@ export function resolveTauriBundleDirectory(descriptor, { root, platform, env =
 export function assertInstalledExecutableMatches(built, installed, read = readFileSync) {
   assertNonEmptyExecutable(built);
   assertNonEmptyExecutable(installed);
-  const digest = (file) => createHash("sha256").update(read(file)).digest("hex");
+  const digest = (file) => createHash("sha256").update(withUnknownBundleMarker(file, read)).digest("hex");
   if (digest(built) !== digest(installed)) throw new Error(`installed executable does not match this dev build: ${installed}`);
 }
+// Tauri's NSIS bundler rewrites the packaged copy's bundle marker UNK -> NSS; compare both copies as UNK.
+function withUnknownBundleMarker(file, read) {
+  const bytes = Buffer.from(read(file));
+  const nsis = readTauriBundleMarkers(file, { read: () => bytes }).markers.nsis ?? [];
+  if (nsis.length > 1) throw new Error(`installed executable verification failed: ${nsis.length} NSIS bundle markers in ${file}`);
+  if (nsis.length === 1) bundleMarkerBuffer(BUNDLE_MARKERS.unknown).copy(bytes, nsis[0]);
+  return bytes;
+}
 function assertNonEmptyExecutable(file) { if (!existsSync(file) || !statSync(file).isFile() || statSync(file).size === 0) throw new Error(`installed executable verification failed: missing or empty file ${file}`); }
 
 function resolveBundleRoot(descriptor, { root, env, runCargo }) {

package/heavy-command.mjs

@@ -220,6 +220,19 @@ function spawnOwnerWatcher(details) {
   watcher.unref();
 }
 
+export function summarizePreBrokerWaits({ heavySlot, suiteSlot, heavyOwnerInherited = false } = {}) {
+  const heavy = heavySlot?.waits ?? null;
+  const suite = suiteSlot?.waits ?? null;
+  const layers = [
+    heavy ? { layer: "heavy-work-slot", ms: (heavy.slotWaitMs ?? 0) + (heavy.resourceWaitMs ?? 0), slotWaitMs: heavy.slotWaitMs ?? 0, resourceWaitMs: heavy.resourceWaitMs ?? 0, blockers: heavy.slotBlockers ?? [], resourceBlockers: heavy.resourceBlockers ?? [] }
+      : { layer: "heavy-work-slot", ms: 0, skipped: heavyOwnerInherited ? "slot owned by parent heavy-command" : "not acquired" },
+    suite ? { layer: "suite-build-slot", ms: suite.waitMs ?? 0, blockers: suite.blockers ?? [] } : { layer: "suite-build-slot", ms: 0, skipped: "inactive (non-shared cache mode)" },
+  ];
+  const totalMs = layers.reduce((sum, layer) => sum + layer.ms, 0);
+  const summary = `${layers.map((layer) => `${layer.layer}=${layer.ms}ms${layer.skipped ? ` (${layer.skipped})` : ""}${layer.blockers?.length ? ` blocked-by ${layer.blockers.map((b) => typeof b === "string" ? b : `pid ${b.pid ?? "starting"}`).join(",")}` : ""}`).join("; ")}; total=${totalMs}ms`;
+  return { layers, totalMs, summary, brokerQueue: "see broker receipt waits.brokerQueue (queueMs + blockers)" };
+}
+
 export function acquireHeavyWorkSlot({
   root = heavyWorkRoot(), pid = process.pid, argv = process.argv, waitMs = Number(process.env.BUILD_GUARD_WAIT_SECS ?? 900) * 1000,
   pollMs = 1000, alive = processAlive, pause = sleep, snapshot = systemResourceSnapshot,
@@ -232,16 +245,24 @@ export function acquireHeavyWorkSlot({
   const token = randomUUID();
   const started = Date.now();
   let lastReport = 0;
+  // Wait attribution: who held the slot, and how long each layer made us wait.
+  const waits = { layer: "heavy-work-slot", slotWaitMs: 0, slotBlockers: [], resourceWaitMs: 0, resourceBlockers: [], totalMs: 0 };
+  const noteSlotBlocker = (owner) => {
+    const identity = owner ? { pid: owner.pid ?? null, argv: Array.isArray(owner.argv) ? owner.argv.slice(0, 8).join(" ").slice(0, 200) : null, since: owner.createdAt ?? null } : { pid: null, argv: null, since: null, starting: true };
+    if (!waits.slotBlockers.some((entry) => entry.pid === identity.pid && entry.since === identity.since)) waits.slotBlockers.push(identity);
+  };
   for (;;) {
     try {
       mkdirSync(lockDir);
       const fd = openSync(path.join(lockDir, "owner.json"), "wx");
       writeFileSync(fd, `${JSON.stringify({ schema: 1, pid: Number(pid), ownerStartedAtMs: startedAt(pid), token, argv: [...argv], createdAt: new Date().toISOString() })}\n`);
       closeSync(fd);
+      waits.slotWaitMs = Date.now() - started;
       break;
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
       const owner = readOwner(lockDir);
+      noteSlotBlocker(owner);
       const incompleteAge = (() => { try { return Date.now() - statSync(lockDir).mtimeMs; } catch { return 0; } })();
       if (owner ? sweepTrackedHeavyWorkOrphan({ root, alive, startedAt, terminate, log }) : incompleteAge > 10_000) {
         if (!owner) rmSync(lockDir, { recursive: true, force: true });
@@ -253,11 +274,14 @@ export function acquireHeavyWorkSlot({
     }
   }
 
+  const resourceStarted = Date.now();
   for (;;) {
     const current = snapshot();
     const blockers = resourceBlockers(current, { minFreePercent, maxCpuLoadPercent });
+    for (const blocker of blockers) if (!waits.resourceBlockers.includes(blocker)) waits.resourceBlockers.push(blocker);
     if (blockers.length === 0) {
-      log(`admitted ${formatResourceSnapshot(current)} jobs=${heavyCommandEnvironment().CARGO_BUILD_JOBS}`);
+      waits.resourceWaitMs = Date.now() - resourceStarted; waits.totalMs = Date.now() - started;
+      log(`admitted ${formatResourceSnapshot(current)} jobs=${heavyCommandEnvironment().CARGO_BUILD_JOBS} waited slot=${waits.slotWaitMs}ms resource=${waits.resourceWaitMs}ms${waits.slotBlockers.length ? ` blockers=${waits.slotBlockers.map((entry) => `pid ${entry.pid ?? "starting"}`).join(",")}` : ""}`);
       break;
     }
     if (Date.now() - started >= waitMs) {
@@ -269,6 +293,7 @@ export function acquireHeavyWorkSlot({
   }
   return {
     root,
+    waits,
     trackChild(childPid, childCommand = "") {
       const owner = readOwner(lockDir);
       if (owner?.token !== token) throw new Error("heavy-work slot ownership changed before child tracking");

package/managed-cargo.mjs

@@ -1,29 +1,47 @@
-import { existsSync } from "node:fs";
-import path from "node:path";
-import { spawnSync } from "./background-process.mjs";
-
-export function managedRuntimeClient(env = process.env, platform = process.platform, exists = existsSync) {
-  const roots = [env.RIGHTKIT_MANAGED_ROOT, env.RIGHTKIT_EXTERNAL_ROOT,
-    platform === "win32" ? "D:\\.rightkit-managed" : platform === "darwin" ? "/Volumes/D/.rightkit-managed" : undefined]
-    .filter((root) => typeof root === "string" && root.length > 0);
-  for (const root of roots) {
-    const client = path.join(root, "runtime-current", "build-control-clients", "src", "rightkit.mjs");
-    if (exists(client)) return client;
-  }
-  return undefined;
-}
-
-function managedHost(env) {
-  return Boolean(env.RIGHTKIT_BUILD_BROKER_SOCKET)
-    || /(?:^|[;:])[^;:]*[/\\](?:\.rightkit-managed|rightkitmanagedagent)[/\\]agent-bin(?:[;:]|$)/i.test(String(env.PATH ?? ""));
-}
-
-export function runCargoSync(args, options = {}) {
-  const env = options.env ?? process.env;
-  const client = managedRuntimeClient(env);
-  if (client) return spawnSync(process.execPath, [client, "cargo", ...args], { ...options, cwd: process.cwd() });
-  if (managedHost(env) && process.platform === "win32") {
-    return { status: null, stdout: "", stderr: "", error: new Error("installed RightKit runtime client is unavailable for managed Cargo metadata") };
-  }
-  return spawnSync("cargo", args, options);
-}
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { spawnSync } from "./background-process.mjs";
+
+export function managedRuntimeClient(env = process.env, platform = process.platform, exists = existsSync) {
+  const roots = [env.RIGHTKIT_MANAGED_ROOT, env.RIGHTKIT_EXTERNAL_ROOT,
+    platform === "win32" ? "D:\\.rightkit-managed" : platform === "darwin" ? "/Volumes/D/.rightkit-managed" : undefined]
+    .filter((root) => typeof root === "string" && root.length > 0);
+  for (const root of roots) {
+    const client = path.join(root, "runtime-current", "build-control-clients", "src", "rightkit.mjs");
+    if (exists(client)) return client;
+  }
+  return undefined;
+}
+
+/** Hold a client-run lease that blocks broker runtime cutover until release() (see
+ * proveDevelopmentRunsDrained). No managed runtime → no lease; lease I/O failure warns and proceeds. */
+export function acquireManagedRunLease({ command, env = process.env, platform = process.platform, exists = existsSync, pid = process.pid } = {}) {
+  const client = managedRuntimeClient(env, platform, exists);
+  if (!client) return { path: null, release() {} };
+  const runs = path.join(path.dirname(path.dirname(path.dirname(path.dirname(client)))), "rightkit-build-control", "global", "runs");
+  const file = path.join(runs, `${pid}-${randomUUID()}.json`);
+  try {
+    mkdirSync(runs, { recursive: true });
+    writeFileSync(file, `${JSON.stringify({ pid, command, startedAt: new Date().toISOString() })}\n`, { flag: "wx" });
+  } catch (error) {
+    console.warn(`right-release: could not record managed run lease (${error.message}); runtime cutover is not blocked for this run`);
+    return { path: null, release() {} };
+  }
+  return { path: file, release() { rmSync(file, { force: true }); } };
+}
+
+function managedHost(env) {
+  return Boolean(env.RIGHTKIT_BUILD_BROKER_SOCKET)
+    || /(?:^|[;:])[^;:]*[/\\](?:\.rightkit-managed|rightkitmanagedagent)[/\\]agent-bin(?:[;:]|$)/i.test(String(env.PATH ?? ""));
+}
+
+export function runCargoSync(args, options = {}) {
+  const env = options.env ?? process.env;
+  const client = managedRuntimeClient(env);
+  if (client) return spawnSync(process.execPath, [client, "cargo", ...args], { ...options, cwd: process.cwd() });
+  if (managedHost(env) && process.platform === "win32") {
+    return { status: null, stdout: "", stderr: "", error: new Error("installed RightKit runtime client is unavailable for managed Cargo metadata") };
+  }
+  return spawnSync("cargo", args, options);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rightkit/release",
-  "version": "0.2.108",
+  "version": "0.2.110",
   "description": "Portable release CLI/SDK with fail-closed public GitHub Releases and private R2 + RightApps distribution.",
   "license": "MIT OR Apache-2.0",
   "type": "module",

package/preflight.mjs

@@ -174,6 +174,8 @@ export function collectPreflight({
   targetLink,
   minFreeGb = 25,
   env = process.env,
+  versionProbe = commandVersion,
+  isBrokerManagedHost = brokerManagedHost,
 } = {}) {
   const checks = [];
   const windows = platform === "win" || platform === "win32";
@@ -257,12 +259,16 @@ export function collectPreflight({
     }
   }
 
-  const sccache = commandVersion("sccache");
-  checks.push(
-    sccache
-      ? ok("sccache", sccache)
-      : warn("sccache", "sccache not found; the shared cache will compile without a compiler cache", "cargo install sccache --locked"),
-  );
+  if (isBrokerManagedHost(env)) {
+    checks.push(ok("compiler-cache", "broker-managed; compiler-cache selection and status are recorded in build receipts"));
+  } else {
+    const sccache = versionProbe("sccache");
+    checks.push(
+      sccache
+        ? ok("sccache", `${sccache} visible on shell PATH`)
+        : warn("sccache", "sccache was not found by this shell PATH probe; cache availability is not determined here", null),
+    );
+  }
 
   if (appRoot) {
     const free = freeDiskGb(appRoot);

package/rightkit-versions.json

@@ -18,11 +18,11 @@
     "@rightkit/hooks": "0.1.1",
     "@rightkit/legal": "0.3.1",
     "@rightkit/legal-ui": "0.1.1",
-    "@rightkit/license": "0.1.7",
+    "@rightkit/license": "0.1.8",
     "@rightkit/logs": "0.1.4",
     "@rightkit/platform-ui": "0.1.1",
     "@rightkit/qa": "0.2.1",
-    "@rightkit/release": "0.2.108",
+    "@rightkit/release": "0.2.110",
     "@rightkit/tauri": "0.1.1",
     "@rightkit/updates": "0.2.4"
   },
@@ -68,7 +68,8 @@
       "0.3.0"
     ],
     "@rightkit/license": [
-      "0.1.6"
+      "0.1.6",
+      "0.1.7"
     ],
     "@rightkit/release": [
       "0.2.22",
@@ -117,7 +118,9 @@
       "0.2.104",
       "0.2.105",
       "0.2.106",
-      "0.2.107"
+      "0.2.107",
+      "0.2.108",
+      "0.2.109"
     ],
     "@rightkit/qa": [
       "0.1.0",