@akanjs/cli 3.0.0-beta.9 → 3.0.1

package/{index-hwkygn9s.js → index-senscydg.js}

@@ -1,11 +1,294 @@
 // @bun
+// pkgs/@akanjs/devkit/applicationBuildReporter.ts
+import { realpathSync } from "fs";
+import path from "path";
+import { Logger } from "akanjs/common";
+
+class ApplicationBuildReporter {
+  static create() {
+    return {
+      phaseDone: (phase) => Logger.rawLog(ApplicationBuildReporter.formatPhaseLine(phase))
+    };
+  }
+  static printSummary(result) {
+    Logger.rawLog("");
+    Logger.rawLog(`Route artifacts: ${result.artifactDir}`);
+    Logger.rawLog(`Server output: ${result.outputDir}`);
+    Logger.rawLog(`Done in ${ApplicationBuildReporter.formatDuration(result.durationMs)}`);
+  }
+  static formatError(error, workspaceRoot = process.cwd()) {
+    if (error instanceof AggregateError) {
+      const nestedMessages = error.errors.map((nestedError, index) => ApplicationBuildReporter.formatError(nestedError, workspaceRoot).trim() || `Unknown error ${index + 1}`).map((message) => message.replace(/^/gm, "  ")).join(`
+`);
+      return nestedMessages ? `${error.message}
+${nestedMessages}` : error.message;
+    }
+    if (error instanceof Error) {
+      const causeMessage = error.cause ? `
+Caused by: ${ApplicationBuildReporter.formatError(error.cause, workspaceRoot)}` : "";
+      return `${ApplicationBuildReporter.#withLocation(error.message, error, workspaceRoot)}${causeMessage}`;
+    }
+    if (typeof error === "object" && error !== null && "message" in error)
+      return ApplicationBuildReporter.#withLocation(String(error.message), error, workspaceRoot);
+    return String(error);
+  }
+  static #withLocation(message, error, workspaceRoot) {
+    const { position } = error;
+    if (!position?.file)
+      return message;
+    const file = ApplicationBuildReporter.#relativeToWorkspace(position.file, workspaceRoot);
+    const location = position.line > 0 ? `${file}:${position.line}:${position.column}` : file;
+    return message.includes(location) ? message : message.replace(/^.*/, (headline) => `${headline} (${location})`);
+  }
+  static #relativeToWorkspace(file, workspaceRoot) {
+    if (!path.isAbsolute(file))
+      return file;
+    for (const root of [workspaceRoot, ApplicationBuildReporter.#realpathOf(workspaceRoot)]) {
+      const relative = path.relative(root, file);
+      if (!relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative))
+        return relative.replaceAll(path.sep, "/");
+    }
+    return file;
+  }
+  static #realpathOf(dir) {
+    try {
+      return realpathSync(dir);
+    } catch {
+      return dir;
+    }
+  }
+  static formatDuration(ms) {
+    if (ms < 1000)
+      return `${ms}ms`;
+    if (ms < 60000)
+      return `${Math.round(ms / 100) / 10}s`;
+    const seconds = Math.floor(ms / 1000);
+    return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+  }
+  static formatPhaseLine(phase) {
+    const summary = phase.summary ? `: ${phase.summary}` : "";
+    return `\u2713 ${phase.label}${summary} (${ApplicationBuildReporter.formatDuration(phase.durationMs)})`;
+  }
+}
+
 // pkgs/@akanjs/devkit/frontendBuild/hmrWatcher.ts
 import fs from "fs";
-import path3 from "path";
+import path5 from "path";
 
 // pkgs/@akanjs/devkit/frontendBuild/hmrChangeClassifier.ts
-import path from "path";
+import path3 from "path";
+
+// pkgs/@akanjs/devkit/akanApp/devHostPolicy.ts
+import path2 from "path";
+var BACKEND_RECOVERY_MAX_ATTEMPTS = 5;
+var HELD_BUILDER_REQUEST_LIMIT = 64;
+var BUILDER_MIN_RSS_RECYCLE_INTERVAL_MS = 30000;
+var BUILDER_TIGHT_RSS_REPORT_LIMIT = 2;
+var BUILDER_RSS_HARD_MULTIPLE = 1.5;
+var DEV_IDLE_SUSPEND_MS = 300000;
+var DEV_IDLE_MIN_UPTIME_MS = 30000;
 var SOURCE_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+var SERVER_SUFFIXES = [".service.ts", ".document.ts"];
+var SHARED_SUFFIXES = [".constant.ts", ".dictionary.ts", ".signal.ts"];
+var RUNTIME_METADATA_BASENAMES = new Set(["dict.ts", "sig.ts", "useClient.ts", "useServer.ts"]);
+var shouldRestartBackendByDevPlan = (message) => {
+  if (!message.devPlan)
+    return null;
+  if (message.devPlan.actions.includes("report-error"))
+    return false;
+  if (message.devPlan.actions.includes("restart-builder"))
+    return false;
+  return message.devPlan.actions.includes("restart-backend");
+};
+var shouldRestartBuilderByDevPlan = (message) => message.devPlan?.actions.includes("restart-builder") ?? false;
+var shouldAbandonBackendRecovery = (attempts, maxAttempts = BACKEND_RECOVERY_MAX_ATTEMPTS) => attempts >= maxAttempts;
+var normalizeBackendReportedGeneration = (generation) => generation >= 0 ? generation : undefined;
+var shouldRestartDevHostByDevPlan = (message) => message.devPlan?.actions.includes("restart-dev-host") ?? message.kinds.includes("config");
+var devHostStateByBackendState = {
+  starting: "starting",
+  ready: "ready",
+  "restart-pending": "restarting",
+  recovering: "recovering",
+  stopping: "stopped",
+  stopped: "stopped"
+};
+var devHostStateOf = (state, gaveUp) => state === "stopped" && gaveUp ? "failed" : devHostStateByBackendState[state];
+var RESTART_ROLE_ORDER = ["server", "shared", "barrel", "config"];
+var generationValue = (generation) => generation ?? -1;
+var isLegacyBackendFallbackFile = (file, workspaceRoot) => {
+  const abs = path2.resolve(file);
+  const ext = path2.extname(abs).toLowerCase();
+  if (!SOURCE_EXTS.has(ext))
+    return false;
+  const rel = path2.relative(path2.resolve(workspaceRoot), abs);
+  if (!rel || rel.startsWith("..") || path2.isAbsolute(rel))
+    return false;
+  const parts = rel.split(path2.sep).filter(Boolean);
+  const [scope] = parts;
+  if (scope !== "apps" && scope !== "libs" && scope !== "pkgs")
+    return false;
+  const base = path2.basename(abs);
+  return parts.includes("srvkit") || parts.includes("common") || SERVER_SUFFIXES.some((suffix) => base.endsWith(suffix)) || SHARED_SUFFIXES.some((suffix) => base.endsWith(suffix)) || RUNTIME_METADATA_BASENAMES.has(base) || base === "main.ts" || base === "server.ts";
+};
+var shouldMarkBuildPhaseRecovered = (previousByPhase, status) => {
+  const previous = previousByPhase.get(status.phase);
+  if (!previous || previous.ok || !status.ok)
+    return false;
+  const generation = generationValue(status.generation);
+  if (status.phase === "route" && status.scope !== undefined && previous.scope !== undefined)
+    return status.scope === previous.scope && generation >= previous.generation;
+  if (generation !== previous.generation)
+    return generation > previous.generation;
+  return status.phase === "backend";
+};
+var shouldKeepBuildFailure = (previousByPhase, status) => status.ok && previousByPhase.get(status.phase)?.ok === false && !shouldMarkBuildPhaseRecovered(previousByPhase, status);
+var createBackendBuildStatus = ({
+  generation,
+  ok,
+  files = [],
+  message
+}) => ({
+  generation,
+  phase: "backend",
+  ok,
+  files,
+  message
+});
+var backendRestartReasonFromMessage = (message) => {
+  const roleSet = new Set;
+  for (const role of message.devPlan?.roles ?? []) {
+    if (role === "server" || role === "shared" || role === "barrel" || role === "config")
+      roleSet.add(role);
+  }
+  return {
+    generation: message.devPlan?.generation ?? message.generation,
+    files: [...new Set(message.files)].sort(),
+    roles: RESTART_ROLE_ORDER.filter((role) => roleSet.has(role))
+  };
+};
+var mergeBackendRestartReasons = (current, next) => ({
+  generation: generationValue(next.generation) >= generationValue(current?.generation) ? next.generation : current?.generation,
+  files: [...new Set([...current?.files ?? [], ...next.files])].sort(),
+  roles: RESTART_ROLE_ORDER.filter((role) => current?.roles.includes(role) || next.roles.includes(role))
+});
+var shouldReplaceLastGoodMessage = (current, next) => !current || generationValue(next.data.generation) >= generationValue(current.data.generation);
+var shouldQueueBuildStatusReplay = (backendReady, pendingReplayCount) => !backendReady || pendingReplayCount > 0;
+var hasBuildFailureForGeneration = (statusByPhase, generation) => {
+  if (typeof generation !== "number")
+    return false;
+  for (const status of statusByPhase.values()) {
+    if (!status.ok && status.phase !== "route" && status.generation === generation)
+      return true;
+  }
+  return false;
+};
+var decideBuilderRssRecycle = ({
+  rssBytes,
+  ceilingBytes,
+  buildFailed,
+  msSinceLastRecycle,
+  minIntervalMs = BUILDER_MIN_RSS_RECYCLE_INTERVAL_MS
+}) => {
+  if (!ceilingBytes)
+    return "unbounded";
+  if (rssBytes < ceilingBytes)
+    return "below-ceiling";
+  if (buildFailed)
+    return "build-failed";
+  if (msSinceLastRecycle !== null && msSinceLastRecycle < minIntervalMs)
+    return "too-soon";
+  return "recycle";
+};
+var decideBuilderRssSettle = ({
+  rssBytes,
+  ceilingBytes,
+  hardMultiple = BUILDER_RSS_HARD_MULTIPLE
+}) => rssBytes >= ceilingBytes * hardMultiple ? "recycle-now" : "wait-and-recheck";
+var decideIdleSuspend = ({
+  enabled,
+  suspended,
+  builderReady,
+  backendReady,
+  buildFailed,
+  restartPending,
+  msSinceWake,
+  minUptimeMs = DEV_IDLE_MIN_UPTIME_MS
+}) => {
+  if (!enabled)
+    return "disabled";
+  if (suspended)
+    return "already-suspended";
+  if (!builderReady)
+    return "builder-not-ready";
+  if (!backendReady)
+    return "backend-not-ready";
+  if (buildFailed)
+    return "build-failed";
+  if (restartPending)
+    return "restart-pending";
+  if (msSinceWake !== null && msSinceWake < minUptimeMs)
+    return "too-soon";
+  return "suspend";
+};
+var resolveIdleSuspendMs = (raw) => {
+  if (raw === undefined || raw === "")
+    return DEV_IDLE_SUSPEND_MS;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed <= 0)
+    return null;
+  return Math.round(parsed);
+};
+var hasAnyBuildFailure = (statusByPhase) => [...statusByPhase.values()].some((status) => !status.ok && status.phase !== "route");
+var shouldRefreshConfigOnIdleWake = (batch) => !!batch && batch.kinds.has("config");
+var RETURNING_BUILDER_STATUSES = new Set(["starting", "recycling", "restarting"]);
+var shouldHoldForReturningBuilder = ({
+  status,
+  heldCount,
+  limit = HELD_BUILDER_REQUEST_LIMIT
+}) => RETURNING_BUILDER_STATUSES.has(status) && heldCount < limit;
+var shouldWarnBuilderRssCeilingTight = (reportsSinceRecycle, limit = BUILDER_TIGHT_RSS_REPORT_LIMIT) => reportsSinceRecycle >= limit;
+var isRssCeilingUnreachable = (freshRssBytes, ceilingBytes) => freshRssBytes !== null && ceilingBytes !== null && freshRssBytes >= ceilingBytes;
+var shouldRelayRecycledFrontendState = (current, next) => {
+  if (!current || current.type !== next.type)
+    return true;
+  if (current.type === "pages-updated" && next.type === "pages-updated")
+    return current.data.bundlePath !== next.data.bundlePath;
+  if (current.type === "css-updated" && next.type === "css-updated")
+    return JSON.stringify(current.data.cssAssets) !== JSON.stringify(next.data.cssAssets);
+  return true;
+};
+var mergeDevPlans = (current, next) => {
+  if (!current)
+    return next;
+  if (!next)
+    return current;
+  const reasonByFile = { ...current.reasonByFile };
+  for (const [file, reasons] of Object.entries(next.reasonByFile)) {
+    reasonByFile[file] = [...new Set([...reasonByFile[file] ?? [], ...reasons])].sort();
+  }
+  return {
+    generation: Math.max(current.generation, next.generation),
+    files: [...new Set([...current.files, ...next.files])].sort(),
+    generatedFiles: [...new Set([...current.generatedFiles, ...next.generatedFiles])].sort(),
+    roles: [...new Set([...current.roles, ...next.roles])].sort(),
+    actions: [...new Set([...current.actions, ...next.actions])].sort(),
+    reasonByFile
+  };
+};
+var mergeInvalidateMessages = (current, next) => {
+  const generation = Math.max(generationValue(current.generation), generationValue(next.generation));
+  return {
+    type: "invalidate",
+    kinds: [...new Set([...current.kinds, ...next.kinds])].sort(),
+    files: [...new Set([...current.files, ...next.files])].sort(),
+    generation: generation >= 0 ? generation : undefined,
+    devPlan: mergeDevPlans(current.devPlan, next.devPlan)
+  };
+};
+var buildStatusReplaySequence = (pendingReplay, latestByPhase) => [...pendingReplay, ...latestByPhase.values()];
+var filesChangedSince = (before, after) => [...before].filter(([file, stamp]) => after.get(file) !== stamp).map(([file]) => file);
+
+// pkgs/@akanjs/devkit/frontendBuild/hmrChangeClassifier.ts
 var CSS_EXTS = new Set([".css"]);
 var CONFIG_BASENAMES = new Set(["akan.config.ts", "bunfig.toml", "tsconfig.json", "package.json"]);
 
@@ -13,10 +296,10 @@ class HmrChangeClassifier {
   classify(abs) {
     if (this.#isUninteresting(abs))
       return "ignore";
-    const base = path.basename(abs);
+    const base = path3.basename(abs);
     if (CONFIG_BASENAMES.has(base))
       return "config";
-    const ext = path.extname(abs).toLowerCase();
+    const ext = path3.extname(abs).toLowerCase();
     if (CSS_EXTS.has(ext))
       return "css";
     if (SOURCE_EXTS.has(ext))
@@ -24,16 +307,16 @@ class HmrChangeClassifier {
     return "ignore";
   }
   #isUninteresting(abs) {
-    const base = path.basename(abs);
+    const base = path3.basename(abs);
     if (!base)
       return true;
     if (base.startsWith("."))
       return true;
     if (base.endsWith("~") || base.endsWith(".swp") || base.endsWith(".swx") || base.endsWith(".tmp"))
       return true;
-    if (abs.includes(`${path.sep}node_modules${path.sep}`))
+    if (abs.includes(`${path3.sep}node_modules${path3.sep}`))
       return true;
-    if (abs.includes(`${path.sep}.akan${path.sep}`))
+    if (abs.includes(`${path3.sep}.akan${path3.sep}`))
       return true;
     return false;
   }
@@ -41,7 +324,7 @@ class HmrChangeClassifier {
 
 // pkgs/@akanjs/devkit/frontendBuild/sourceMtimeIndex.ts
 import { readdir, stat } from "fs/promises";
-import path2 from "path";
+import path4 from "path";
 var UNREADABLE = Number.NaN;
 
 class SourceMtimeIndex {
@@ -104,7 +387,7 @@ class SourceMtimeIndex {
       if (!this.#primed)
         return;
       await Promise.all(paths.map(async (file) => {
-        const abs = path2.resolve(file);
+        const abs = path4.resolve(file);
         const stats = await stat(abs).catch(() => null);
         if (!stats?.isFile()) {
           this.#files.delete(abs);
@@ -190,7 +473,7 @@ class SourceMtimeIndex {
     for (const entry of entries) {
       if (SourceMtimeIndex.#skipDirent(entry.name))
         continue;
-      const abs = path2.join(dir, entry.name);
+      const abs = path4.join(dir, entry.name);
       if (entry.isDirectory()) {
         descend.push(abs);
         continue;
@@ -217,7 +500,7 @@ class SourceMtimeIndex {
     }
     if (known) {
       for (const abs of [...this.#files.keys()]) {
-        if (present.has(abs) || path2.dirname(abs) !== dir)
+        if (present.has(abs) || path4.dirname(abs) !== dir)
           continue;
         this.#files.delete(abs);
         changed?.add(abs);
@@ -235,7 +518,7 @@ class SourceMtimeIndex {
     this.#unsettled.delete(dir);
   }
   #forget(dir) {
-    const prefix = `${dir}${path2.sep}`;
+    const prefix = `${dir}${path4.sep}`;
     this.#dirs.delete(dir);
     this.#unreadable.delete(dir);
     this.#unsettled.delete(dir);
@@ -273,8 +556,8 @@ class SourceMtimeIndex {
     return !name || name.startsWith(".") || name === "node_modules";
   }
   static #pruneNestedRoots(roots) {
-    const resolved = [...new Set(roots.map((root) => path2.resolve(root)))].sort();
-    return resolved.filter((root) => !resolved.some((other) => other !== root && root.startsWith(`${other}${path2.sep}`)));
+    const resolved = [...new Set(roots.map((root) => path4.resolve(root)))].sort();
+    return resolved.filter((root) => !resolved.some((other) => other !== root && root.startsWith(`${other}${path4.sep}`)));
   }
 }
 
@@ -292,14 +575,15 @@ class HmrWatcher {
   #index;
   #timer = null;
   #verifyTimer = null;
+  #windowStartedAt = null;
   #stopped = false;
   #flushing = false;
   #unreportedChanges = 0;
   #reportedCompensating = false;
   #reportedGaps = "";
   constructor(opts) {
-    this.#roots = [...new Set(opts.roots.map((r) => path3.resolve(r)))];
-    this.#debounceMs = opts.debounceMs ?? 80;
+    this.#roots = [...new Set(opts.roots.map((r) => path5.resolve(r)))];
+    this.#debounceMs = opts.debounceMs ?? HmrWatcher.#envDebounceMs() ?? 30;
     this.#verifyDelayMs = opts.verifyDelayMs ?? 250;
     this.#onBatch = opts.onBatch;
     this.#logger = opts.logger;
@@ -314,9 +598,15 @@ class HmrWatcher {
         const w = fs.watch(root, { recursive: true, persistent: false }, (_event, filename) => {
           if (!filename)
             return;
-          const abs = path3.resolve(root, filename.toString());
+          const abs = path5.resolve(root, filename.toString());
           this.#queue(abs);
         });
+        w.on("error", (err) => {
+          if (err.code === "EACCES" || err.code === "EPERM")
+            this.#logger.verbose(`[hmr] ${err.message}`);
+          else
+            this.#logger.warn(`[hmr] watcher error under ${root}: ${err.message}`);
+        });
         this.#watchers.push(w);
         this.#logger.verbose(`[hmr] watching ${root}`);
       } catch (err) {
@@ -365,6 +655,7 @@ class HmrWatcher {
     this.#scheduleFlush();
   }
   #scheduleFlush() {
+    this.#windowStartedAt ??= Date.now();
     if (this.#flushing)
       return;
     if (this.#timer)
@@ -382,14 +673,19 @@ class HmrWatcher {
     try {
       while (!this.#stopped) {
         await this.#mergeDetectedChanges();
-        if (this.#pending.size === 0)
+        if (this.#pending.size === 0) {
+          this.#windowStartedAt = null;
           break;
+        }
         const files = Array.from(this.#pending.keys());
         const kinds = new Set(this.#pending.values());
+        const flushAt = Date.now();
+        const trace = { eventAt: this.#windowStartedAt ?? flushAt, flushAt };
+        this.#windowStartedAt = null;
         this.#pending.clear();
         this.#hinted.clear();
         try {
-          await this.#onBatch({ files, kinds });
+          await this.#onBatch({ files, kinds, trace });
         } catch (e) {
           this.#logger.error(`[hmr] onBatch error: ${e.message}`);
         }
@@ -440,6 +736,11 @@ class HmrWatcher {
     const rest = gaps.length > 3 ? ` and ${gaps.length - 3} more` : "";
     this.#logger.warn(`[hmr] cannot read ${gaps.length} path(s), so edits underneath them will not rebuild: ${shown}${rest}`);
   }
+  static #envDebounceMs() {
+    const raw = process.env.AKAN_DEV_WATCH_DEBOUNCE_MS;
+    const ms = raw ? Number(raw) : Number.NaN;
+    return Number.isInteger(ms) && ms >= 0 ? ms : null;
+  }
   #scheduleVerify() {
     if (this.#stopped || this.#verifyDelayMs <= 0)
       return;
@@ -464,7 +765,7 @@ class HmrWatcher {
 // pkgs/@akanjs/devkit/frontendBuild/watchRootResolver.ts
 import fs2 from "fs";
 import { readFile } from "fs/promises";
-import path4 from "path";
+import path6 from "path";
 
 class WatchRootResolver {
   #app;
@@ -473,20 +774,20 @@ class WatchRootResolver {
   }
   async resolve() {
     const tsconfig = await this.#app.getTsConfig();
-    const appDir = path4.resolve(this.#app.cwdPath);
-    const appsContainer = path4.dirname(appDir);
-    const libsContainer = path4.resolve(this.#app.workspace.workspaceRoot, "libs");
-    const libRoots = await this.#resolveLibRoots(libsContainer);
+    const appDir = path6.resolve(this.#app.cwdPath);
+    const appsContainer = path6.dirname(appDir);
+    const libsContainer = path6.resolve(this.#app.workspace.workspaceRoot, "libs");
+    const libRoots = (await this.#resolveLibDeps(libsContainer))?.map((name) => path6.join(libsContainer, name)).filter((dir) => fs2.existsSync(dir));
     const set = new Set;
-    set.add(path4.resolve(`${this.#app.cwdPath}/page`));
+    set.add(path6.resolve(`${this.#app.cwdPath}/page`));
     for (const targets of Object.values(tsconfig.compilerOptions.paths ?? {})) {
       for (const target of targets) {
         if (!target)
           continue;
-        if (path4.isAbsolute(target))
+        if (path6.isAbsolute(target))
           continue;
         const cleaned = target.replace(/\/?\*+.*$/, "").replace(/\/[^/]+\.[^/]+$/, "");
-        const resolved = path4.resolve(this.#app.workspace.workspaceRoot, cleaned);
+        const resolved = path6.resolve(this.#app.workspace.workspaceRoot, cleaned);
         if (resolved === libsContainer && libRoots) {
           for (const root of libRoots)
             set.add(root);
@@ -499,17 +800,11 @@ class WatchRootResolver {
     }
     return [...set];
   }
-  async#resolveLibRoots(libsContainer) {
-    const libDeps = await this.#resolveLibDeps(libsContainer);
-    if (!libDeps)
-      return null;
-    return libDeps.map((name) => path4.join(libsContainer, name)).filter((dir) => fs2.existsSync(dir));
-  }
   async#resolveLibDeps(libsContainer) {
     const scanInfo = this.#app.getScanInfo({ allowEmpty: true });
     if (scanInfo?.type === "app")
       return scanInfo.libDeps;
-    const direct = await WatchRootResolver.#readManifestLibDeps(path4.join(this.#app.cwdPath, "akan.app.json"));
+    const direct = await WatchRootResolver.#readManifestLibDeps(path6.join(this.#app.cwdPath, "akan.app.json"));
     if (!direct)
       return null;
     const closure = new Set;
@@ -519,7 +814,7 @@ class WatchRootResolver {
       if (!name || closure.has(name))
         continue;
       closure.add(name);
-      const nested = await WatchRootResolver.#readManifestLibDeps(path4.join(libsContainer, name, "akan.lib.json"));
+      const nested = await WatchRootResolver.#readManifestLibDeps(path6.join(libsContainer, name, "akan.lib.json"));
       if (!nested)
         return null;
       queue.push(...nested);
@@ -538,4 +833,4 @@ class WatchRootResolver {
   }
 }
 
-export { HmrWatcher, WatchRootResolver };
+export { ApplicationBuildReporter, BUILDER_MIN_RSS_RECYCLE_INTERVAL_MS, SOURCE_EXTS, shouldRestartBackendByDevPlan, shouldRestartBuilderByDevPlan, shouldAbandonBackendRecovery, normalizeBackendReportedGeneration, shouldRestartDevHostByDevPlan, devHostStateOf, isLegacyBackendFallbackFile, shouldMarkBuildPhaseRecovered, shouldKeepBuildFailure, createBackendBuildStatus, backendRestartReasonFromMessage, mergeBackendRestartReasons, shouldReplaceLastGoodMessage, shouldQueueBuildStatusReplay, hasBuildFailureForGeneration, decideBuilderRssRecycle, decideBuilderRssSettle, decideIdleSuspend, resolveIdleSuspendMs, hasAnyBuildFailure, shouldRefreshConfigOnIdleWake, shouldHoldForReturningBuilder, shouldWarnBuilderRssCeilingTight, isRssCeilingUnreachable, shouldRelayRecycledFrontendState, mergeInvalidateMessages, buildStatusReplaySequence, filesChangedSince, HmrWatcher, WatchRootResolver };