@camstack/server 1.1.70 → 1.1.72

package/dist/server-root/index.js

@@ -74,31 +74,41 @@ var require_dist = __commonJS({
     var src_exports = {};
     __export2(src_exports, {
       AGENT_ROOT_SPEC: /* @__PURE__ */ __name(() => AGENT_ROOT_SPEC, "AGENT_ROOT_SPEC"),
+      CURRENT_DIRNAME: /* @__PURE__ */ __name(() => CURRENT_DIRNAME, "CURRENT_DIRNAME"),
       DEV_UPLOADS_DIRNAME: /* @__PURE__ */ __name(() => DEV_UPLOADS_DIRNAME, "DEV_UPLOADS_DIRNAME"),
       DEV_UPLOADS_KEEP_COUNT: /* @__PURE__ */ __name(() => DEV_UPLOADS_KEEP_COUNT, "DEV_UPLOADS_KEEP_COUNT"),
       DEV_UPLOAD_MANIFEST_FILE: /* @__PURE__ */ __name(() => DEV_UPLOAD_MANIFEST_FILE, "DEV_UPLOAD_MANIFEST_FILE"),
       HOST_EXTERNAL_SPECIFIERS: /* @__PURE__ */ __name(() => HOST_EXTERNAL_SPECIFIERS, "HOST_EXTERNAL_SPECIFIERS"),
       HUB_ROOT_SPEC: /* @__PURE__ */ __name(() => HUB_ROOT_SPEC2, "HUB_ROOT_SPEC"),
+      PENDING_ROOT_SWAP_FILE: /* @__PURE__ */ __name(() => PENDING_ROOT_SWAP_FILE, "PENDING_ROOT_SWAP_FILE"),
+      REQUIRED_NATIVE_PACKAGES: /* @__PURE__ */ __name(() => REQUIRED_NATIVE_PACKAGES, "REQUIRED_NATIVE_PACKAGES"),
       RESTART_INTENT_FILE: /* @__PURE__ */ __name(() => RESTART_INTENT_FILE, "RESTART_INTENT_FILE"),
       RootUpdateService: /* @__PURE__ */ __name(() => RootUpdateService, "RootUpdateService"),
       SERVER_ROOT_DIRNAME: /* @__PURE__ */ __name(() => SERVER_ROOT_DIRNAME, "SERVER_ROOT_DIRNAME"),
       SERVER_ROOT_STATE_FILE: /* @__PURE__ */ __name(() => SERVER_ROOT_STATE_FILE, "SERVER_ROOT_STATE_FILE"),
+      applyPendingRootSwap: /* @__PURE__ */ __name(() => applyPendingRootSwap, "applyPendingRootSwap"),
+      clearPendingRootSwap: /* @__PURE__ */ __name(() => clearPendingRootSwap, "clearPendingRootSwap"),
       clearRestartIntentMarker: /* @__PURE__ */ __name(() => clearRestartIntentMarker, "clearRestartIntentMarker"),
       compareSemver: /* @__PURE__ */ __name(() => compareSemver, "compareSemver"),
+      currentDir: /* @__PURE__ */ __name(() => currentDir, "currentDir"),
+      currentEntryPath: /* @__PURE__ */ __name(() => currentEntryPath, "currentEntryPath"),
       detectWorkspaceRoot: /* @__PURE__ */ __name(() => detectWorkspaceRoot, "detectWorkspaceRoot"),
       devChannelEpoch: /* @__PURE__ */ __name(() => devChannelEpoch, "devChannelEpoch"),
       devUploadManifestPath: /* @__PURE__ */ __name(() => devUploadManifestPath, "devUploadManifestPath"),
       devUploadVersionDir: /* @__PURE__ */ __name(() => devUploadVersionDir, "devUploadVersionDir"),
       devUploadsDir: /* @__PURE__ */ __name(() => devUploadsDir, "devUploadsDir"),
       emptyServerRootState: /* @__PURE__ */ __name(() => emptyServerRootState, "emptyServerRootState"),
+      findMissingNativePrebuilds: /* @__PURE__ */ __name(() => findMissingNativePrebuilds, "findMissingNativePrebuilds"),
       isDevChannelVersion: /* @__PURE__ */ __name(() => isDevChannelVersion, "isDevChannelVersion"),
       isHostExternal: /* @__PURE__ */ __name(() => isHostExternal, "isHostExternal"),
       isServerRootState: /* @__PURE__ */ __name(() => isServerRootState, "isServerRootState"),
+      migrateToSingleCopy: /* @__PURE__ */ __name(() => migrateToSingleCopy, "migrateToSingleCopy"),
       minNodeMajorOf: /* @__PURE__ */ __name(() => minNodeMajorOf, "minNodeMajorOf"),
+      pendingRootSwapPath: /* @__PURE__ */ __name(() => pendingRootSwapPath, "pendingRootSwapPath"),
       planBoot: /* @__PURE__ */ __name(() => planBoot, "planBoot"),
       readDevUploadManifest: /* @__PURE__ */ __name(() => readDevUploadManifest, "readDevUploadManifest"),
+      readPendingRootSwap: /* @__PURE__ */ __name(() => readPendingRootSwap, "readPendingRootSwap"),
       readRestartIntentMarker: /* @__PURE__ */ __name(() => readRestartIntentMarker, "readRestartIntentMarker"),
-      readSeedVersion: /* @__PURE__ */ __name(() => readSeedVersion, "readSeedVersion"),
       readServerRootState: /* @__PURE__ */ __name(() => readServerRootState, "readServerRootState"),
       registerActiveRootResolver: /* @__PURE__ */ __name(() => registerActiveRootResolver, "registerActiveRootResolver"),
       restartIntentMarkerPath: /* @__PURE__ */ __name(() => restartIntentMarkerPath, "restartIntentMarkerPath"),
@@ -106,11 +116,15 @@ var require_dist = __commonJS({
       rootPackageDir: /* @__PURE__ */ __name(() => rootPackageDir2, "rootPackageDir"),
       runNodeStarter: /* @__PURE__ */ __name(() => runNodeStarter, "runNodeStarter"),
       serverRootDir: /* @__PURE__ */ __name(() => serverRootDir, "serverRootDir"),
+      stagingDirPath: /* @__PURE__ */ __name(() => stagingDirPath, "stagingDirPath"),
       stateFilePath: /* @__PURE__ */ __name(() => stateFilePath, "stateFilePath"),
+      sweepTransientRootDirs: /* @__PURE__ */ __name(() => sweepTransientRootDirs, "sweepTransientRootDirs"),
+      validateClosureDir: /* @__PURE__ */ __name(() => validateClosureDir, "validateClosureDir"),
       validateVersionDir: /* @__PURE__ */ __name(() => validateVersionDir, "validateVersionDir"),
       versionDir: /* @__PURE__ */ __name(() => versionDir, "versionDir"),
       versionsDir: /* @__PURE__ */ __name(() => versionsDir, "versionsDir"),
       writeDevUploadManifest: /* @__PURE__ */ __name(() => writeDevUploadManifest, "writeDevUploadManifest"),
+      writePendingRootSwap: /* @__PURE__ */ __name(() => writePendingRootSwap, "writePendingRootSwap"),
       writeRestartIntentMarker: /* @__PURE__ */ __name(() => writeRestartIntentMarker, "writeRestartIntentMarker"),
       writeServerRootState: /* @__PURE__ */ __name(() => writeServerRootState, "writeServerRootState")
     });
@@ -316,13 +330,12 @@ var require_dist = __commonJS({
       return Number.isNaN(major) ? null : major;
     }
     __name(minNodeMajorOf, "minNodeMajorOf");
-    function validateVersionDir(rootDir, version, nodeMajor, spec) {
-      const vDir = versionDir(rootDir, version);
-      const entry = rootEntryPath2(vDir, spec);
+    function validateClosureDir(closureDir, nodeMajor, spec, expectedVersion) {
+      const entry = rootEntryPath2(closureDir, spec);
       if (!fs2.existsSync(entry)) {
         return `root entry missing: ${entry}`;
       }
-      const pkgJsonPath = path2.join(rootPackageDir2(vDir, spec), "package.json");
+      const pkgJsonPath = path2.join(rootPackageDir2(closureDir, spec), "package.json");
       let pkg;
       try {
         const raw = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
@@ -336,8 +349,8 @@ var require_dist = __commonJS({
       if (pkg["name"] !== spec.packageName) {
         return `package name mismatch: expected ${spec.packageName}, got ${String(pkg["name"])}`;
       }
-      if (pkg["version"] !== version) {
-        return `package version mismatch: dir says ${version}, package.json says ${String(pkg["version"])}`;
+      if (expectedVersion !== void 0 && pkg["version"] !== expectedVersion) {
+        return `package version mismatch: expected ${expectedVersion}, package.json says ${String(pkg["version"])}`;
       }
       const engines = pkg["engines"];
       if (typeof engines === "object" && engines !== null) {
@@ -351,7 +364,13 @@ var require_dist = __commonJS({
       }
       return null;
     }
+    __name(validateClosureDir, "validateClosureDir");
+    function validateVersionDir(rootDir, version, nodeMajor, spec) {
+      return validateClosureDir(versionDir(rootDir, version), nodeMajor, spec, version);
+    }
     __name(validateVersionDir, "validateVersionDir");
+    var fs3 = __toESM2(require("fs"));
+    var path3 = __toESM2(require("path"));
     function parse(version) {
       const dashIdx = version.indexOf("-");
       const base = dashIdx === -1 ? version : version.slice(0, dashIdx);
@@ -384,142 +403,344 @@ var require_dist = __commonJS({
       return 0;
     }
     __name(compareSemver, "compareSemver");
-    function planBoot(state, isValidVersion, now, seedVersion = null) {
-      if (state === null) {
-        return {
-          kind: "baked",
-          reason: "no server-root state",
-          stateToWrite: null
-        };
+    var CURRENT_DIRNAME = "current";
+    var PENDING_ROOT_SWAP_FILE = ".pending-root-swap.json";
+    var LEGACY_FRAMEWORK_MARKERS = [
+      ".pending-framework-swap.json",
+      ".framework-swap-confirm.json"
+    ];
+    function currentDir(rootDir) {
+      return path3.join(rootDir, CURRENT_DIRNAME);
+    }
+    __name(currentDir, "currentDir");
+    function currentEntryPath(rootDir, spec) {
+      return rootEntryPath2(currentDir(rootDir), spec);
+    }
+    __name(currentEntryPath, "currentEntryPath");
+    function stagingDirPath(rootDir, target, pid, now) {
+      return path3.join(rootDir, `.staging-${target}-${pid}-${now}`);
+    }
+    __name(stagingDirPath, "stagingDirPath");
+    function pendingRootSwapPath(rootDir) {
+      return path3.join(rootDir, PENDING_ROOT_SWAP_FILE);
+    }
+    __name(pendingRootSwapPath, "pendingRootSwapPath");
+    function isPendingRootSwap(v) {
+      if (typeof v !== "object" || v === null) return false;
+      const m = v;
+      return m["schemaVersion"] === 1 && typeof m["version"] === "string" && typeof m["stagingPath"] === "string" && typeof m["requestedAtMs"] === "number";
+    }
+    __name(isPendingRootSwap, "isPendingRootSwap");
+    function readPendingRootSwap(rootDir) {
+      try {
+        const raw = JSON.parse(fs3.readFileSync(pendingRootSwapPath(rootDir), "utf-8"));
+        return isPendingRootSwap(raw) ? raw : null;
+      } catch {
+        return null;
       }
-      let next = state;
-      let changed = false;
-      if (next.pendingBoot !== null) {
-        const pending = next.pendingBoot;
-        if (pending.bootAttempts >= 1) {
-          next = {
-            ...next,
-            pendingBoot: null,
-            rolledBack: {
-              fromVersion: pending.version,
-              toVersion: next.currentVersion,
-              atMs: now(),
-              reason: "probation boot did not reach ready \u2014 rolled back"
-            }
-          };
-          changed = true;
-        } else if (!isValidVersion(pending.version)) {
-          next = {
-            ...next,
-            pendingBoot: null,
-            rolledBack: {
-              fromVersion: pending.version,
-              toVersion: next.currentVersion,
-              atMs: now(),
-              reason: "staged version failed validation"
-            }
-          };
-          changed = true;
-        } else {
+    }
+    __name(readPendingRootSwap, "readPendingRootSwap");
+    function writePendingRootSwap(rootDir, marker) {
+      fs3.mkdirSync(rootDir, {
+        recursive: true
+      });
+      const target = pendingRootSwapPath(rootDir);
+      const tmp = `${target}.tmp`;
+      fs3.writeFileSync(tmp, JSON.stringify(marker, null, 2), "utf-8");
+      fs3.renameSync(tmp, target);
+    }
+    __name(writePendingRootSwap, "writePendingRootSwap");
+    function clearPendingRootSwap(rootDir) {
+      try {
+        fs3.rmSync(pendingRootSwapPath(rootDir), {
+          force: true
+        });
+      } catch {
+      }
+    }
+    __name(clearPendingRootSwap, "clearPendingRootSwap");
+    var REQUIRED_NATIVE_PACKAGES = [
+      "better-sqlite3",
+      "sharp",
+      "node-av"
+    ];
+    var NATIVE_SEARCH_DIRS = {
+      "better-sqlite3": [
+        "better-sqlite3"
+      ],
+      sharp: [
+        "sharp",
+        "@img"
+      ],
+      "node-av": [
+        "node-av",
+        "@seydx"
+      ]
+    };
+    function hasDotNode(dir, maxDepth) {
+      let entries;
+      try {
+        entries = fs3.readdirSync(dir, {
+          withFileTypes: true
+        });
+      } catch {
+        return false;
+      }
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith(".node")) return true;
+      }
+      if (maxDepth <= 0) return false;
+      for (const entry of entries) {
+        if (entry.isDirectory() && hasDotNode(path3.join(dir, entry.name), maxDepth - 1)) return true;
+      }
+      return false;
+    }
+    __name(hasDotNode, "hasDotNode");
+    function findMissingNativePrebuilds(closureDir) {
+      const nm = path3.join(closureDir, "node_modules");
+      const missing = [];
+      for (const pkg of REQUIRED_NATIVE_PACKAGES) {
+        const searchDirs = NATIVE_SEARCH_DIRS[pkg] ?? [
+          pkg
+        ];
+        const found = searchDirs.some((rel) => hasDotNode(path3.join(nm, ...rel.split("/")), 4));
+        if (!found) missing.push(pkg);
+      }
+      return missing;
+    }
+    __name(findMissingNativePrebuilds, "findMissingNativePrebuilds");
+    function rmrf(target) {
+      try {
+        fs3.rmSync(target, {
+          recursive: true,
+          force: true
+        });
+      } catch {
+      }
+    }
+    __name(rmrf, "rmrf");
+    function errMsg(err) {
+      return err instanceof Error ? err.message : String(err);
+    }
+    __name(errMsg, "errMsg");
+    function applyPendingRootSwap(rootDir, spec, nodeMajor, now, log) {
+      const marker = readPendingRootSwap(rootDir);
+      if (marker === null) return {
+        applied: false,
+        version: null,
+        reason: "no pending swap"
+      };
+      const staging = marker.stagingPath;
+      const dest = currentDir(rootDir);
+      const invalid = validateClosureDir(staging, nodeMajor, spec, marker.version);
+      if (invalid !== null) {
+        if (!fs3.existsSync(staging) && validateClosureDir(dest, nodeMajor, spec, marker.version) === null) {
+          clearPendingRootSwap(rootDir);
+          log(`[single-copy] pending swap ${marker.version} already applied \u2014 cleared marker`);
           return {
-            kind: "data-root",
-            version: pending.version,
-            probation: true,
-            stateToWrite: {
-              ...next,
-              pendingBoot: {
-                ...pending,
-                bootAttempts: pending.bootAttempts + 1
-              }
-            }
+            applied: true,
+            version: marker.version,
+            reason: "already applied"
           };
         }
+        log(`[single-copy] staged swap ${marker.version} invalid \u2014 discarding (${invalid})`);
+        rmrf(staging);
+        clearPendingRootSwap(rootDir);
+        return {
+          applied: false,
+          version: null,
+          reason: invalid
+        };
       }
-      if (next.currentVersion !== null) {
-        if (isValidVersion(next.currentVersion)) {
-          if (!changed && seedVersion !== null && compareSemver(seedVersion, next.currentVersion) > 0) {
-            return {
-              kind: "baked",
-              reason: `baked seed ${seedVersion} is newer than active data-root ${next.currentVersion} \u2014 adopting the image seed`,
-              stateToWrite: {
-                ...next,
-                currentVersion: null,
-                previousVersion: null,
-                pendingBoot: null,
-                rolledBack: null
-              }
-            };
+      const missing = findMissingNativePrebuilds(staging);
+      if (missing.length > 0) {
+        log(`[single-copy] staged swap ${marker.version} missing native prebuilds: ${missing.join(", ")} \u2014 discarding`);
+        rmrf(staging);
+        clearPendingRootSwap(rootDir);
+        return {
+          applied: false,
+          version: null,
+          reason: `missing native prebuilds: ${missing.join(", ")}`
+        };
+      }
+      let trash = null;
+      try {
+        if (fs3.existsSync(dest)) {
+          trash = path3.join(rootDir, `.trash-${now()}-${process.pid}`);
+          fs3.renameSync(dest, trash);
+        }
+        try {
+          fs3.renameSync(staging, dest);
+        } catch (err) {
+          if (trash !== null && !fs3.existsSync(dest)) {
+            try {
+              fs3.renameSync(trash, dest);
+            } catch {
+            }
           }
-          return {
-            kind: "data-root",
-            version: next.currentVersion,
-            probation: false,
-            stateToWrite: changed ? next : null
-          };
+          throw err;
+        }
+      } catch (err) {
+        log(`[single-copy] swap of ${marker.version} FAILED \u2014 current preserved (${errMsg(err)})`);
+        return {
+          applied: false,
+          version: null,
+          reason: errMsg(err)
+        };
+      }
+      if (trash !== null) rmrf(trash);
+      clearPendingRootSwap(rootDir);
+      log(`[single-copy] applied staged root swap \u2192 ${marker.version}`);
+      return {
+        applied: true,
+        version: marker.version,
+        reason: "applied"
+      };
+    }
+    __name(applyPendingRootSwap, "applyPendingRootSwap");
+    function readClosureVersion(closureDir, spec) {
+      try {
+        const raw = JSON.parse(fs3.readFileSync(path3.join(rootPackageDir2(closureDir, spec), "package.json"), "utf-8"));
+        if (typeof raw === "object" && raw !== null) {
+          const version = raw["version"];
+          if (typeof version === "string") return version;
         }
-        const broken = next.currentVersion;
-        if (next.previousVersion !== null && isValidVersion(next.previousVersion)) {
-          const fallback = next.previousVersion;
+      } catch {
+      }
+      return null;
+    }
+    __name(readClosureVersion, "readClosureVersion");
+    function isAdoptablePendingClosure(rootDir, version, nodeMajor, spec) {
+      const dir = versionDir(rootDir, version);
+      return validateClosureDir(dir, nodeMajor, spec, version) === null && findMissingNativePrebuilds(dir).length === 0;
+    }
+    __name(isAdoptablePendingClosure, "isAdoptablePendingClosure");
+    function migrateToSingleCopy(rootDir, spec, nodeMajor, now, log) {
+      const dest = currentDir(rootDir);
+      const legacyState = readServerRootState(rootDir);
+      const pendingVersion = legacyState?.pendingBoot?.version ?? null;
+      const pendingAdoptable = pendingVersion !== null && isAdoptablePendingClosure(rootDir, pendingVersion, nodeMajor, spec);
+      const currentValid = fs3.existsSync(dest) && validateClosureDir(dest, nodeMajor, spec) === null;
+      if (currentValid) {
+        const currentVersion = readClosureVersion(dest, spec);
+        const pendingSupersedes = pendingAdoptable && pendingVersion !== null && (currentVersion === null || compareSemver(pendingVersion, currentVersion) > 0);
+        if (!pendingSupersedes) {
           return {
-            kind: "data-root",
-            version: fallback,
-            probation: false,
-            stateToWrite: {
-              ...next,
-              currentVersion: fallback,
-              previousVersion: null,
-              rolledBack: {
-                fromVersion: broken,
-                toVersion: fallback,
-                atMs: now(),
-                reason: "active version failed validation"
-              }
-            }
+            migrated: false,
+            version: null,
+            reason: "current already present"
           };
         }
+        log(`[single-copy] in-flight pending ${pendingVersion} supersedes older current ${currentVersion ?? "?"}`);
+      }
+      const candidates = [];
+      if (pendingAdoptable && pendingVersion !== null) candidates.push(pendingVersion);
+      if (legacyState !== null) {
+        for (const v of [
+          legacyState.currentVersion,
+          legacyState.pendingBoot?.version ?? null,
+          legacyState.previousVersion
+        ]) {
+          if (typeof v === "string" && !candidates.includes(v)) candidates.push(v);
+        }
+      }
+      try {
+        for (const entry of fs3.readdirSync(versionsDir(rootDir))) {
+          if (!entry.startsWith(".") && !candidates.includes(entry)) candidates.push(entry);
+        }
+      } catch {
+      }
+      const source = candidates.find((v) => validateClosureDir(versionDir(rootDir, v), nodeMajor, spec, v) === null);
+      if (source === void 0) {
+        return {
+          migrated: false,
+          version: null,
+          reason: "no valid legacy versions/<X> to adopt"
+        };
+      }
+      if (fs3.existsSync(dest)) {
+        const aside = path3.join(rootDir, `.trash-${now()}-${process.pid}-stale-current`);
+        try {
+          fs3.renameSync(dest, aside);
+        } catch {
+          rmrf(dest);
+        }
+      }
+      try {
+        fs3.renameSync(versionDir(rootDir, source), dest);
+      } catch (err) {
+        log(`[single-copy] migration rename of versions/${source} failed (${errMsg(err)})`);
         return {
-          kind: "baked",
-          reason: `active version ${broken} failed validation and no valid previous version exists`,
-          stateToWrite: {
-            ...next,
-            currentVersion: null,
-            rolledBack: {
-              fromVersion: broken,
-              toVersion: null,
-              atMs: now(),
-              reason: "active version failed validation"
-            }
-          }
+          migrated: false,
+          version: null,
+          reason: errMsg(err)
+        };
+      }
+      rmrf(versionsDir(rootDir));
+      rmrf(stateFilePath(rootDir));
+      const dataDir = path3.dirname(rootDir);
+      for (const marker of LEGACY_FRAMEWORK_MARKERS) rmrf(path3.join(dataDir, marker));
+      log(`[single-copy] migrated legacy versions/${source} \u2192 current`);
+      return {
+        migrated: true,
+        version: source,
+        reason: "adopted legacy version"
+      };
+    }
+    __name(migrateToSingleCopy, "migrateToSingleCopy");
+    function sweepTransientRootDirs(rootDir, now, staleMs) {
+      let entries;
+      try {
+        entries = fs3.readdirSync(rootDir);
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (!entry.startsWith(".staging-") && !entry.startsWith(".trash-")) continue;
+        const full = path3.join(rootDir, entry);
+        try {
+          if (now - fs3.statSync(full).mtimeMs < staleMs) continue;
+        } catch {
+          continue;
+        }
+        rmrf(full);
+      }
+    }
+    __name(sweepTransientRootDirs, "sweepTransientRootDirs");
+    function planBoot(currentValid) {
+      if (currentValid) {
+        return {
+          kind: "current",
+          reason: "single-copy closure present and valid"
         };
       }
       return {
         kind: "baked",
-        reason: "no active data-root version",
-        stateToWrite: changed ? next : null
+        reason: "no valid single-copy closure \u2014 booting the baked seed"
       };
     }
     __name(planBoot, "planBoot");
-    var fs3 = __toESM2(require("fs"));
-    var path3 = __toESM2(require("path"));
+    var fs4 = __toESM2(require("fs"));
+    var path4 = __toESM2(require("path"));
     function detectWorkspaceRoot(fromDir) {
-      let dir = path3.resolve(fromDir);
+      let dir = path4.resolve(fromDir);
       for (; ; ) {
-        const pkgPath = path3.join(dir, "package.json");
+        const pkgPath = path4.join(dir, "package.json");
         try {
-          const raw = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+          const raw = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
           if (typeof raw === "object" && raw !== null && raw["workspaces"] !== void 0) {
             return dir;
           }
         } catch {
         }
-        const parent = path3.dirname(dir);
+        const parent = path4.dirname(dir);
         if (parent === dir) return null;
         dir = parent;
       }
     }
     __name(detectWorkspaceRoot, "detectWorkspaceRoot");
-    var fs4 = __toESM2(require("fs"));
-    var path4 = __toESM2(require("path"));
+    var fs5 = __toESM2(require("fs"));
+    var path5 = __toESM2(require("path"));
     var import_node_url = require("url");
     var HOST_EXTERNAL_SPECIFIERS = [
       "@camstack/system",
@@ -543,7 +764,7 @@ var require_dist = __commonJS({
         console.warn("[starter] module.registerHooks unavailable (Node < 22.15) \u2014 host-external redirect skipped");
         return;
       }
-      const anchorURL = (0, import_node_url.pathToFileURL)(path4.join(activeRootDir, "node_modules", "__camstack_starter_anchor__.js")).href;
+      const anchorURL = (0, import_node_url.pathToFileURL)(path5.join(activeRootDir, "node_modules", "__camstack_starter_anchor__.js")).href;
       const hooks = {
         resolve: /* @__PURE__ */ __name((specifier, context, nextResolve) => {
           if (isHostExternal(specifier)) {
@@ -561,24 +782,23 @@ var require_dist = __commonJS({
       registerHooks(hooks);
     }
     __name(registerActiveRootResolver, "registerActiveRootResolver");
-    function readSeedVersion(seedEntry) {
+    function readClosureVersion2(closureDir, spec) {
       try {
-        const pkgJsonPath = path4.join(path4.dirname(seedEntry), "..", "package.json");
-        const raw = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf-8"));
+        const raw = JSON.parse(fs5.readFileSync(path5.join(rootPackageDir2(closureDir, spec), "package.json"), "utf-8"));
         if (typeof raw === "object" && raw !== null) {
           const version = raw["version"];
           if (typeof version === "string") return version;
         }
-        return null;
       } catch {
-        return null;
       }
+      return null;
     }
-    __name(readSeedVersion, "readSeedVersion");
+    __name(readClosureVersion2, "readClosureVersion2");
     function runNodeStarter(options) {
       const env = options.env ?? process.env;
       const now = options.now ?? Date.now;
       const registerResolver = options.registerResolver ?? registerActiveRootResolver;
+      const nodeMajor = options.nodeMajor ?? Number.parseInt(process.versions.node.split(".")[0] ?? "0", 10);
       const disabled = env[options.envNames.killSwitch] === "off";
       const workspaceRoot = detectWorkspaceRoot(options.starterDir);
       if (workspaceRoot !== null) {
@@ -594,36 +814,24 @@ var require_dist = __commonJS({
         return;
       }
       const rootDir = serverRootDir(options.dataDir);
-      const state = readServerRootState(rootDir);
-      const nodeMajor = options.nodeMajor ?? Number.parseInt(process.versions.node.split(".")[0] ?? "0", 10);
-      const isValidVersion = /* @__PURE__ */ __name((version) => {
-        const reason = validateVersionDir(rootDir, version, nodeMajor, options.spec);
-        if (reason !== null) console.warn(`[starter] version ${version} invalid: ${reason}`);
-        return reason === null;
-      }, "isValidVersion");
-      const seedVersion = readSeedVersion(options.seedEntry);
-      const plan = planBoot(state, isValidVersion, now, seedVersion);
-      if (plan.stateToWrite !== null) {
-        try {
-          writeServerRootState(rootDir, plan.stateToWrite);
-        } catch (err) {
-          console.error("[starter] FAILED to persist server-root state \u2014 booting baked seed:", err);
-          env[options.envNames.bootMode] = "baked";
-          options.loadEntry(options.seedEntry);
-          return;
-        }
-        if (plan.stateToWrite.rolledBack !== null && (state?.rolledBack ?? null) !== plan.stateToWrite.rolledBack) {
-          const rb = plan.stateToWrite.rolledBack;
-          console.warn(`[starter] ROLLED BACK ${rb.fromVersion} -> ${rb.toVersion ?? "baked seed"}: ${rb.reason}`);
-        }
+      const swap = applyPendingRootSwap(rootDir, options.spec, nodeMajor, now, (m) => console.log(m));
+      if (swap.applied) console.log(`[starter] applied staged update \u2192 ${swap.version ?? "?"}`);
+      else if (swap.reason !== "no pending swap") console.warn(`[starter] staged update NOT applied: ${swap.reason}`);
+      const migration = migrateToSingleCopy(rootDir, options.spec, nodeMajor, now, (m) => console.log(m));
+      if (migration.migrated) console.log(`[starter] migrated legacy layout \u2192 single copy (${migration.version ?? "?"})`);
+      const activeRootDir = currentDir(rootDir);
+      const invalid = validateClosureDir(activeRootDir, nodeMajor, options.spec);
+      if (invalid !== null && fs5.existsSync(activeRootDir)) {
+        console.warn(`[starter] single copy invalid: ${invalid}`);
       }
-      if (plan.kind === "data-root") {
-        const activeRootDir = versionDir(rootDir, plan.version);
-        const entry = rootEntryPath2(activeRootDir, options.spec);
-        console.log(`[starter] booting ${options.spec.packageName}@${plan.version} from ${activeRootDir}` + (plan.probation ? " (probation boot \u2014 health-check armed)" : ""));
+      const plan = planBoot(invalid === null);
+      if (plan.kind === "current") {
+        const version = readClosureVersion2(activeRootDir, options.spec);
+        const entry = currentEntryPath(rootDir, options.spec);
+        console.log(`[starter] booting ${options.spec.packageName}@${version ?? "?"} from ${activeRootDir}`);
         env[options.envNames.bootMode] = "data-root";
         env[options.envNames.activeRoot] = activeRootDir;
-        env[options.envNames.activeVersion] = plan.version;
+        if (version !== null) env[options.envNames.activeVersion] = version;
         registerResolver(activeRootDir);
         options.loadEntry(entry);
         return;
@@ -634,8 +842,8 @@ var require_dist = __commonJS({
     }
     __name(runNodeStarter, "runNodeStarter");
     var import_node_child_process = require("child_process");
-    var fs5 = __toESM2(require("fs"));
-    var path5 = __toESM2(require("path"));
+    var fs6 = __toESM2(require("fs"));
+    var path6 = __toESM2(require("path"));
     var import_node_util = require("util");
     var execFileAsync = (0, import_node_util.promisify)(import_node_child_process.execFile);
     function buildNpmRegistryArgs(registry) {
@@ -650,9 +858,10 @@ var require_dist = __commonJS({
     var NPM_VIEW_TIMEOUT_MS = 2e4;
     var NPM_INSTALL_TIMEOUT_MS = 15 * 6e4;
     var RESTART_REASON_PREFIX = "server-update";
+    var STALE_TRANSIENT_MS = 24 * 60 * 60 * 1e3;
     function readPackageVersion(pkgJsonPath) {
       try {
-        const raw = JSON.parse(fs5.readFileSync(pkgJsonPath, "utf-8"));
+        const raw = JSON.parse(fs6.readFileSync(pkgJsonPath, "utf-8"));
         if (typeof raw === "object" && raw !== null) {
           const version = raw["version"];
           if (typeof version === "string") return version;
@@ -662,9 +871,9 @@ var require_dist = __commonJS({
       return null;
     }
     __name(readPackageVersion, "readPackageVersion");
-    var RootUpdateService = class _RootUpdateService {
+    var RootUpdateService = class {
       static {
-        __name(this, "_RootUpdateService");
+        __name(this, "RootUpdateService");
       }
       spec;
       envNames;
@@ -683,7 +892,7 @@ var require_dist = __commonJS({
         this.envNames = options.envNames;
         this.logger = options.logger;
         this.restartServerFn = options.restartServer;
-        this.dataDir = path5.resolve(options.dataDir);
+        this.dataDir = path6.resolve(options.dataDir);
         this.execNpm = options.execNpm ?? (async (args, opts) => {
           const { stdout } = await execFileAsync("npm", [
             ...args
@@ -719,63 +928,37 @@ var require_dist = __commonJS({
       seedVersion() {
         const seedDir = this.env[this.envNames.seedDir];
         if (seedDir === void 0 || seedDir.length === 0) return null;
-        return readPackageVersion(path5.join(seedDir, "package.json"));
+        return readPackageVersion(path6.join(seedDir, "package.json"));
       }
       rootDir() {
         return serverRootDir(this.dataDir);
       }
-      readState() {
-        return readServerRootState(this.rootDir()) ?? emptyServerRootState();
-      }
-      /**
-      * Like `readState`, but distinguishes "state.json missing" (normal on a
-      * fresh node) from "state.json present but corrupt" — in the corrupt case
-      * the starter booted the baked seed while installed data-dir versions are
-      * silently ignored, which the status surface must make visible.
-      */
-      readStateInfo() {
-        const rootDir = this.rootDir();
-        const raw = readServerRootState(rootDir);
-        if (raw !== null) return {
-          state: raw,
-          corrupt: false
-        };
-        return {
-          state: emptyServerRootState(),
-          corrupt: fs5.existsSync(stateFilePath(rootDir))
-        };
-      }
-      updateState(state) {
+      updateState() {
         if (this.inFlight === "checking") return "checking";
         if (this.inFlight === "staging") return "staging";
-        if (state.pendingBoot !== null) {
-          const activeVersion = this.env[this.envNames.activeVersion] ?? null;
-          if (activeVersion !== null && activeVersion === state.pendingBoot.version) {
-            return "awaiting-confirmation";
-          }
-          return "pending-restart";
-        }
+        if (readPendingRootSwap(this.rootDir()) !== null) return "pending-restart";
         return "idle";
       }
       async getServerPackageStatus() {
-        const { state, corrupt } = this.readStateInfo();
         const runningVersion = this.runningVersion();
         const latestVersion = this.checkCache?.latestVersion ?? null;
+        const pending = readPendingRootSwap(this.rootDir());
         const updateAvailable = latestVersion !== null && runningVersion !== null && compareSemver(latestVersion, runningVersion) > 0;
         return {
           packageName: this.spec.packageName,
           runningVersion,
           nodeRuntimeVersion: process.versions.node,
-          activeVersion: this.env[this.envNames.activeVersion] ?? state.currentVersion,
-          previousVersion: state.previousVersion,
+          activeVersion: this.env[this.envNames.activeVersion] ?? runningVersion,
+          // Single-copy model: no N-1 retention, no rollback record.
+          previousVersion: null,
           seedVersion: this.seedVersion(),
           latestVersion,
           updateAvailable,
           bootMode: this.resolveBootMode(),
-          updateState: this.updateState(state),
-          pendingVersion: state.pendingBoot?.version ?? null,
-          rolledBack: state.rolledBack,
-          stateFileCorrupt: corrupt,
+          updateState: this.updateState(),
+          pendingVersion: pending?.version ?? null,
+          rolledBack: null,
+          stateFileCorrupt: false,
           lastCheckedAtMs: this.checkCache?.checkedAtMs ?? null
         };
       }
@@ -862,13 +1045,13 @@ var require_dist = __commonJS({
             message: `Refused: another operation is in flight (${this.inFlight}).`
           };
         }
-        const stateBefore = this.readState();
-        if (stateBefore.pendingBoot !== null) {
+        const pendingBefore = readPendingRootSwap(this.rootDir());
+        if (pendingBefore !== null) {
           return {
             accepted: false,
             targetVersion: input.version ?? null,
             restarting: false,
-            message: `Refused: version ${stateBefore.pendingBoot.version} is already staged and awaiting restart.`
+            message: `Refused: version ${pendingBefore.version} is already staged and awaiting restart.`
           };
         }
         let target = input.version ?? null;
@@ -895,7 +1078,7 @@ var require_dist = __commonJS({
         }
         if (isDevChannelVersion(target)) {
           const uploadsDir = devUploadVersionDir(this.rootDir(), target);
-          if (!fs5.existsSync(uploadsDir)) {
+          if (!fs6.existsSync(uploadsDir)) {
             return {
               accepted: false,
               targetVersion: target,
@@ -905,8 +1088,9 @@ var require_dist = __commonJS({
           }
         }
         this.inFlight = "staging";
+        let stagingPath;
         try {
-          await this.stageAndActivate(target);
+          stagingPath = await this.stageClosure(target);
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
           this.logger.error("root package update staging failed", {
@@ -924,21 +1108,16 @@ var require_dist = __commonJS({
         } finally {
           this.inFlight = "idle";
         }
-        const state = this.readState();
-        writeServerRootState(this.rootDir(), {
-          ...state,
-          pendingBoot: {
-            version: target,
-            fromVersion: state.currentVersion,
-            requestedAtMs: this.now(),
-            bootAttempts: 0
-          },
-          rolledBack: null
+        writePendingRootSwap(this.rootDir(), {
+          schemaVersion: 1,
+          version: target,
+          stagingPath,
+          requestedAtMs: this.now()
         });
         this.logger.info("root package update staged \u2014 restarting to apply", {
           meta: {
             targetVersion: target,
-            fromVersion: state.currentVersion
+            fromVersion: runningVersion
           }
         });
         this.restartServerFn(`${RESTART_REASON_PREFIX}: ${this.spec.packageName}@${target}`);
@@ -946,21 +1125,23 @@ var require_dist = __commonJS({
           accepted: true,
           targetVersion: target,
           restarting: true,
-          message: `Staged ${this.spec.packageName}@${target} \u2014 restarting to apply (probation boot with auto-rollback).`
+          message: `Staged ${this.spec.packageName}@${target} \u2014 restarting to apply (single automatic reboot).`
         };
       }
       /**
-      * npm-install the target closure into a SAME-FS staging dir inside
-      * `versions/`, validate it, then atomically rename it into place.
+      * npm-install the target closure into a SAME-FS `.staging-*` dir, then
+      * validate it (entry + version + native prebuilds). Returns the staging dir
+      * path for the pending-root-swap marker; the STARTER swaps it into `current`
+      * on the next boot. Throws (cleaning up the staging dir) on any failure so
+      * `applyServerUpdate` reports a staging error and never arms a bad swap.
       */
-      async stageAndActivate(target) {
+      async stageClosure(target) {
         const rootDir = this.rootDir();
-        const vDir = versionsDir(rootDir);
-        fs5.mkdirSync(vDir, {
+        fs6.mkdirSync(rootDir, {
           recursive: true
         });
-        const stagingDir = path5.join(vDir, `.staging-${target}-${process.pid}-${this.now()}`);
-        fs5.mkdirSync(stagingDir, {
+        const stagingDir = stagingDirPath(rootDir, target, process.pid, this.now());
+        fs6.mkdirSync(stagingDir, {
           recursive: true
         });
         try {
@@ -973,8 +1154,8 @@ var require_dist = __commonJS({
             "--no-fund",
             "--loglevel=error"
           ];
-          if (fs5.existsSync(devDir)) {
-            fs5.writeFileSync(path5.join(stagingDir, "package.json"), JSON.stringify(this.buildDevUploadsPackageJson(devDir, target), null, 2), "utf-8");
+          if (fs6.existsSync(devDir)) {
+            fs6.writeFileSync(path6.join(stagingDir, "package.json"), JSON.stringify(this.buildDevUploadsPackageJson(devDir, target), null, 2), "utf-8");
             await this.execNpm([
               ...installArgs,
               ...buildNpmRegistryArgs(registry)
@@ -983,7 +1164,7 @@ var require_dist = __commonJS({
               timeoutMs: NPM_INSTALL_TIMEOUT_MS
             });
           } else {
-            fs5.writeFileSync(path5.join(stagingDir, "package.json"), JSON.stringify({
+            fs6.writeFileSync(path6.join(stagingDir, "package.json"), JSON.stringify({
               name: "camstack-node-root",
               private: true
             }, null, 2), "utf-8");
@@ -997,25 +1178,21 @@ var require_dist = __commonJS({
             });
           }
           const entry = rootEntryPath2(stagingDir, this.spec);
-          if (!fs5.existsSync(entry)) {
+          if (!fs6.existsSync(entry)) {
             throw new Error(`staged closure is missing the root entry (${entry})`);
           }
-          const stagedVersion = readPackageVersion(path5.join(rootPackageDir2(stagingDir, this.spec), "package.json"));
-          if (stagedVersion !== target) {
-            throw new Error(`staged closure version mismatch: expected ${target}, got ${stagedVersion ?? "unknown"}`);
+          const nodeMajor = Number.parseInt(process.versions.node.split(".")[0] ?? "0", 10);
+          const invalid = validateClosureDir(stagingDir, nodeMajor, this.spec, target);
+          if (invalid !== null) {
+            throw new Error(`staged closure invalid: ${invalid}`);
           }
-          const dest = versionDir(rootDir, target);
-          if (fs5.existsSync(dest)) {
-            const aside = `${dest}.evicted-${this.now()}`;
-            await fs5.promises.rename(dest, aside);
-            await fs5.promises.rm(aside, {
-              recursive: true,
-              force: true
-            }).catch(() => void 0);
+          const missingNatives = findMissingNativePrebuilds(stagingDir);
+          if (missingNatives.length > 0) {
+            throw new Error(`staged closure missing native prebuilds: ${missingNatives.join(", ")} \u2014 refusing to arm a swap that would break the forked runners`);
           }
-          await fs5.promises.rename(stagingDir, dest);
+          return stagingDir;
         } catch (err) {
-          await fs5.promises.rm(stagingDir, {
+          await fs6.promises.rm(stagingDir, {
             recursive: true,
             force: true
           }).catch(() => void 0);
@@ -1025,11 +1202,9 @@ var require_dist = __commonJS({
       /**
       * Synthetic staging package.json for the dev server-deploy channel:
       * `dependencies` carries the root package as a `file:` ref to its uploaded
-      * tgz; `overrides` maps EVERY OTHER uploaded `@camstack/<name>` to its tgz
-      * so any transitive occurrence resolves to the uploaded copy, never npm.
+      * tgz; `overrides` maps EVERY OTHER uploaded `@camstack/<name>` to its tgz.
       * Fail-closed: a missing/invalid manifest, a manifest for a different
-      * version, a missing root package, or a listed-but-absent tgz all throw
-      * (surfaced by `applyServerUpdate` as a staging failure).
+      * version, a missing root package, or a listed-but-absent tgz all throw.
       */
       buildDevUploadsPackageJson(devDir, target) {
         const manifest = readDevUploadManifest(devDir);
@@ -1044,8 +1219,8 @@ var require_dist = __commonJS({
           throw new Error(`dev-uploads for ${target} do not include the root package ${this.spec.packageName}`);
         }
         const fileRef = /* @__PURE__ */ __name((filename) => {
-          const abs = path5.join(devDir, filename);
-          if (!fs5.existsSync(abs)) {
+          const abs = path6.join(devDir, filename);
+          if (!fs6.existsSync(abs)) {
             throw new Error(`dev-uploads tarball listed in the manifest is missing: ${abs}`);
           }
           return `file:${abs}`;
@@ -1066,73 +1241,28 @@ var require_dist = __commonJS({
           } : {}
         };
       }
-      // ── Rollback ──────────────────────────────────────────────────────────
+      // ── Rollback (removed — single-copy has no N-1) ────────────────────────
+      /**
+      * Rollback is NOT supported in the single-copy model — there is no retained
+      * N-1 copy to revert to (operator's accepted tradeoff). Recovery is manual:
+      * re-apply a known-good version via {@link applyServerUpdate}, or reinstall
+      * the image seed. Kept on the surface so the cap contract is unchanged.
+      */
       async rollbackServerUpdate() {
-        if (this.inFlight !== "idle") {
-          return {
-            accepted: false,
-            targetVersion: null,
-            restarting: false,
-            message: `Refused: another operation is in flight (${this.inFlight}).`
-          };
-        }
-        const state = this.readState();
-        if (state.pendingBoot !== null) {
-          return {
-            accepted: false,
-            targetVersion: null,
-            restarting: false,
-            message: `Refused: version ${state.pendingBoot.version} is already staged and awaiting restart.`
-          };
-        }
-        if (state.currentVersion === null || state.previousVersion === null) {
-          return {
-            accepted: false,
-            targetVersion: state.previousVersion,
-            restarting: false,
-            message: "Refused: no previous version available to roll back to."
-          };
-        }
-        const nodeMajor = Number.parseInt(process.versions.node.split(".")[0] ?? "0", 10);
-        const invalidReason = validateVersionDir(this.rootDir(), state.previousVersion, nodeMajor, this.spec);
-        if (invalidReason !== null) {
-          return {
-            accepted: false,
-            targetVersion: state.previousVersion,
-            restarting: false,
-            message: `Refused: previous version ${state.previousVersion} is not loadable (${invalidReason}).`
-          };
-        }
-        writeServerRootState(this.rootDir(), {
-          ...state,
-          pendingBoot: {
-            version: state.previousVersion,
-            fromVersion: state.currentVersion,
-            requestedAtMs: this.now(),
-            bootAttempts: 0
-          }
-        });
-        this.logger.info("root package rollback requested \u2014 restarting", {
-          meta: {
-            fromVersion: state.currentVersion,
-            toVersion: state.previousVersion
-          }
-        });
-        this.restartServerFn(`${RESTART_REASON_PREFIX}: rollback to ${this.spec.packageName}@${state.previousVersion}`);
         return {
-          accepted: true,
-          targetVersion: state.previousVersion,
-          restarting: true,
-          message: `Rolling back to ${this.spec.packageName}@${state.previousVersion} \u2014 restarting.`
+          accepted: false,
+          targetVersion: null,
+          restarting: false,
+          message: "Rollback is not supported in the single-copy model (no retained previous version). Recover by re-applying a known-good version via applyServerUpdate, or reinstall the image seed."
         };
       }
       // ── Plain restart ─────────────────────────────────────────────────────
       /**
-      * Plain process restart — no version change. Backs the `restartServer` cap
-      * method. Guards mirror apply/rollback: refuse while a stage is in flight
-      * (a concurrent npm install must not be interrupted) or while a version is
-      * already staged awaiting restart (a naive bounce would boot the OLD version
-      * and orphan the pending one — the operator should apply/rollback instead).
+      * Plain process restart — no version change. Refuse while a stage is in
+      * flight (a concurrent npm install must not be interrupted) or while a
+      * version is already staged awaiting restart (a naive bounce would boot the
+      * OLD version and orphan the pending swap — the operator should apply
+      * instead).
       */
       restartNode() {
         const runningVersion = this.runningVersion();
@@ -1144,13 +1274,12 @@ var require_dist = __commonJS({
             message: `Refused: another operation is in flight (${this.inFlight}).`
           };
         }
-        const state = this.readState();
-        if (state.pendingBoot !== null) {
+        if (readPendingRootSwap(this.rootDir()) !== null) {
           return {
             accepted: false,
             targetVersion: runningVersion,
             restarting: false,
-            message: `Refused: version ${state.pendingBoot.version} is staged and awaiting restart \u2014 apply or roll it back instead of a plain restart.`
+            message: "Refused: a version is staged and awaiting restart \u2014 apply it instead of a plain restart."
           };
         }
         this.logger.info("plain node restart requested", {
@@ -1168,118 +1297,37 @@ var require_dist = __commonJS({
       }
       // ── Boot health confirmation ──────────────────────────────────────────
       /**
-      * Called by the post-boot path once the node is READY (hub: post-boot
-      * pipeline; agent: first acked `$hub.registerNode`). When THIS process is
-      * the probation boot of a pending version, promote it: `currentVersion` ←
-      * pending, `previousVersion` ← the version it replaced (N-1 retained for
-      * rollback), clear `pendingBoot` + `rolledBack`, and prune every version
-      * dir beyond {current, previous}. No-op otherwise.
+      * Called by the post-boot path once the node is READY. In the single-copy
+      * model there is no pending version to promote (the swap already happened in
+      * the starter). This becomes a best-effort GC of orphaned transient dirs
+      * (`.staging-*` / `.trash-*` left by a crash mid-swap) + the dev-uploads
+      * sweep. Kept returning the legacy `{ promoted }` shape for the callers.
       */
       confirmBootHealthy() {
-        const state = readServerRootState(this.rootDir());
-        if (state === null || state.pendingBoot === null) return {
-          promoted: null
-        };
-        const activeVersion = this.env[this.envNames.activeVersion] ?? null;
-        if (activeVersion !== state.pendingBoot.version) {
-          return {
-            promoted: null
-          };
-        }
-        const promoted = {
-          ...state,
-          currentVersion: state.pendingBoot.version,
-          previousVersion: state.pendingBoot.fromVersion,
-          pendingBoot: null,
-          rolledBack: null
-        };
-        writeServerRootState(this.rootDir(), promoted);
-        this.pruneVersions([
-          promoted.currentVersion,
-          promoted.previousVersion
-        ].filter((v) => typeof v === "string"));
+        sweepTransientRootDirs(this.rootDir(), this.now(), STALE_TRANSIENT_MS);
         this.sweepDevUploads(DEV_UPLOADS_KEEP_COUNT);
-        this.logger.info("root package update confirmed healthy", {
-          meta: {
-            version: promoted.currentVersion,
-            previousVersion: promoted.previousVersion
-          }
-        });
         return {
-          promoted: promoted.currentVersion
+          promoted: null
         };
       }
       /**
-      * Remove version dirs under `versions/` not in `keep`.
-      *
-      * Transient dot-entries (`.staging-*` / `.evicted-*`) are NOT pruned unless
-      * older than {@link RootUpdateService.STALE_TRANSIENT_MS}: the API starts
-      * serving BEFORE the post-boot `confirmBootHealthy()` runs, so a concurrent
-      * `applyServerUpdate` can be mid-npm-install into a fresh `.staging-*` dir
-      * when this prune fires — deleting it would corrupt that install. Fresh
-      * transient dirs are owned by their in-flight operation (which cleans up on
-      * failure); the staleness sweep only collects dirs orphaned by a crash.
-      */
-      pruneVersions(keep) {
-        const vDir = versionsDir(this.rootDir());
-        let entries;
-        try {
-          entries = fs5.readdirSync(vDir);
-        } catch {
-          return;
-        }
-        for (const entry of entries) {
-          if (keep.includes(entry)) continue;
-          const full = path5.join(vDir, entry);
-          if (entry.startsWith(".")) {
-            try {
-              const ageMs = this.now() - fs5.statSync(full).mtimeMs;
-              if (ageMs < _RootUpdateService.STALE_TRANSIENT_MS) continue;
-            } catch {
-              continue;
-            }
-          }
-          try {
-            fs5.rmSync(full, {
-              recursive: true,
-              force: true
-            });
-            this.logger.debug("pruned server-root version dir", {
-              meta: {
-                entry
-              }
-            });
-          } catch (err) {
-            this.logger.warn("failed to prune server-root version dir", {
-              meta: {
-                entry,
-                error: err instanceof Error ? err.message : String(err)
-              }
-            });
-          }
-        }
-      }
-      /**
       * Promote-time sweep of `server-root/dev-uploads/`: keep only the
       * `keepCount` most recent entries (ordered by the self-describing
       * `-dev.<epochSeconds>` suffix; non-dev-shaped residue counts as oldest).
-      * Uses the same rename-aside graveyard pattern as the addon installer —
-      * a rename is a metadata op that succeeds even when a tarball is held
-      * open, and residue in the graveyard is re-swept on the next promote.
       */
       sweepDevUploads(keepCount) {
         const dir = devUploadsDir(this.rootDir());
         let entries;
         try {
-          entries = fs5.readdirSync(dir);
+          entries = fs6.readdirSync(dir);
         } catch {
           return;
         }
-        const graveyard = path5.join(dir, ".sweeping");
+        const graveyard = path6.join(dir, ".sweeping");
         try {
-          for (const residue of fs5.readdirSync(graveyard)) {
+          for (const residue of fs6.readdirSync(graveyard)) {
             try {
-              fs5.rmSync(path5.join(graveyard, residue), {
+              fs6.rmSync(path6.join(graveyard, residue), {
                 recursive: true,
                 force: true
               });
@@ -1294,13 +1342,13 @@ var require_dist = __commonJS({
         ].sort((a, b) => (devChannelEpoch(b) ?? -1) - (devChannelEpoch(a) ?? -1));
         const doomed = byNewestFirst.slice(keepCount);
         if (doomed.length === 0) return;
-        fs5.mkdirSync(graveyard, {
+        fs6.mkdirSync(graveyard, {
           recursive: true
         });
         for (const entry of doomed) {
-          const aside = path5.join(graveyard, `${entry}-${this.now()}`);
+          const aside = path6.join(graveyard, `${entry}-${this.now()}`);
           try {
-            fs5.renameSync(path5.join(dir, entry), aside);
+            fs6.renameSync(path6.join(dir, entry), aside);
           } catch (err) {
             this.logger.warn("failed to move dev-uploads entry aside for sweep", {
               meta: {
@@ -1311,7 +1359,7 @@ var require_dist = __commonJS({
             continue;
           }
           try {
-            fs5.rmSync(aside, {
+            fs6.rmSync(aside, {
               recursive: true,
               force: true
             });
@@ -1324,8 +1372,6 @@ var require_dist = __commonJS({
           }
         }
       }
-      /** Transient (.staging- / .evicted-) dirs younger than this are never pruned. */
-      static STALE_TRANSIENT_MS = 24 * 60 * 60 * 1e3;
     };
   }
 });