windows-development-sandbox 1.18.2 → 1.18.3

package/dist/host/channel/channel.js

@@ -192,8 +192,16 @@ export class SandboxChannel {
         return this.waitForResponse(requestId, 30000);
     }
     /** The PC is low on memory or CPU: the sandbox slows its builds down for `seconds`. Never waits for an answer. */
-    pressure(reason, seconds, level = 'slow') {
-        this.send({ kind: 'pressure', id: newId(), reason, seconds, level, createdAt: now() });
+    pressure(reason, seconds, level = 'slow', diskQueue) {
+        this.send({
+            kind: 'pressure',
+            id: newId(),
+            reason,
+            seconds,
+            level,
+            ...(diskQueue === undefined ? {} : { diskQueue }),
+            createdAt: now(),
+        });
     }
     async ping() {
         const requestId = newId();

package/dist/host/launch/wsb-file.d.ts

@@ -18,7 +18,12 @@ export interface MemoryDecision {
     readonly commitAvailableMb: number | null;
 }
 /**
- * The most memory this PC can keep in RAM for the sandbox (pure): its RAM minus max(reserveHostMb, 25 %), and 2 GB
+ * GPU-PV (vGPU) needs room of its own on this PC: the GPU's shared memory for the sandbox comes out of this PC's RAM,
+ * and a GPU game plus heavy builds with vGPU on has killed the VM when the PC had no RAM left for it.
+ */
+export declare const VGPU_RESERVE_MB = 4096;
+/**
+ * The most memory this PC can keep in RAM for the sandbox (pure): its RAM minus max(reserveHostMb, 25 %), and 4 GB
  * more with vGPU. Windows Sandbox's memory is this PC's memory taken as needed; beyond what the PC can keep resident it
  * is paged to this PC's disk while the sandbox pages to its own, and that is what can freeze the whole PC.
  */

package/dist/host/launch/wsb-file.js

@@ -11,10 +11,13 @@ export const GUEST = {
 const MB = 1048576;
 const MIN_AUTO_MEMORY_MB = 4096;
 const roundDown = (mb) => Math.floor(mb / 1024) * 1024;
-/** GPU-PV (vGPU) needs room of its own on this PC: memory the graphics driver pins for the sandbox. */
-const VGPU_RESERVE_MB = 2048;
 /**
- * The most memory this PC can keep in RAM for the sandbox (pure): its RAM minus max(reserveHostMb, 25 %), and 2 GB
+ * GPU-PV (vGPU) needs room of its own on this PC: the GPU's shared memory for the sandbox comes out of this PC's RAM,
+ * and a GPU game plus heavy builds with vGPU on has killed the VM when the PC had no RAM left for it.
+ */
+export const VGPU_RESERVE_MB = 4096;
+/**
+ * The most memory this PC can keep in RAM for the sandbox (pure): its RAM minus max(reserveHostMb, 25 %), and 4 GB
  * more with vGPU. Windows Sandbox's memory is this PC's memory taken as needed; beyond what the PC can keep resident it
  * is paged to this PC's disk while the sandbox pages to its own, and that is what can freeze the whole PC.
  */
@@ -46,8 +49,9 @@ export function residentNote(asked, given) {
  */
 export function decideMemory(sandbox, freeMb, totalMb, commitAvailableMb) {
     const shareMb = Math.floor((totalMb * sandbox.maxMemoryPercent) / 100);
-    const byFree = freeMb - sandbox.reserveHostMb;
-    const byCommit = commitAvailableMb === null ? Infinity : commitAvailableMb - sandbox.reserveHostMb;
+    const reserveMb = sandbox.reserveHostMb + (sandbox.vGpu ? VGPU_RESERVE_MB : 0);
+    const byFree = freeMb - reserveMb;
+    const byCommit = commitAvailableMb === null ? Infinity : commitAvailableMb - reserveMb;
     const candidates = [
         ['max', sandbox.maxMemoryMb],
         ['share', shareMb],

package/dist/host/life/crash-report.d.ts

@@ -11,6 +11,8 @@ export interface CrashExtra {
     readonly hostMemoryNow?: string;
     /** The frozen sandbox's launch had vGPU on (read from its .wsb). */
     readonly vgpu?: boolean;
+    /** The sandbox's last heartbeat as a line (see heartbeatLine): what it was doing inside. */
+    readonly lastInside?: string;
 }
 /** "This PC stopped responding at X and was restarted at Y (n minutes later)", or null when there was no long gap. */
 export declare function freezeLine(cause: StopCause, lastSeen: string): string | null;

package/dist/host/life/crash-report.js

@@ -6,6 +6,7 @@ import { assertNoLinks, safeText } from '../../core/util/index.js';
 import { vgpuWarning } from '../launch/risk-notes.js';
 import { hostMemoryLine, readHostMemory } from './host-memory.js';
 import { hostDataFolder, hostDataRoot } from '../storage/index.js';
+import { heartbeatLine, readHeartbeat } from './last-end.js';
 import { bugcheckCode, explainStop, readStopEvents } from './stop-events.js';
 const KEEP_REPORTS = 20;
 const MEMORY_TAIL_BYTES = 16 * 1024;
@@ -170,6 +171,7 @@ export function crashReportText(cause, events, memoryLog, lastSeen, extra = {})
         ...(hostLines.length ? hostLines : ['  (none: the background sync was not running)']),
         ...(extra.hostMemoryNow ? ['  after the restart: ' + extra.hostMemoryNow] : []),
         '',
+        ...(extra.lastInside ? [safeText(extra.lastInside), ''] : []),
         "The sandbox's memory log, last lines (C:\\AgentData\\logs\\memory-*.log inside it):",
         ...memoryLines,
         '',
@@ -239,9 +241,11 @@ export function saveCrashReport(storageRoot, dataPath, lastSeen) {
     const since = new Date(Date.parse(lastSeen) - 10 * 60 * 1000);
     const windir = process.env.SystemRoot ?? 'C:\\Windows';
     const memoryNow = readHostMemory(storageRoot);
+    const heartbeat = readHeartbeat(dataPath);
     fs.writeFileSync(file, crashReportText(cause, events, memoryLogTail(dataPath), lastSeen, {
         hostMemoryLog: hostMemoryTail(storageRoot, dataPath),
         vgpu: launchHadVgpu(storageRoot, lastSeen),
+        ...(heartbeat ? { lastInside: heartbeatLine(heartbeat) } : {}),
         dumps: findDumps([path.join(windir, 'Minidump'), windir], since),
         ...(memoryNow ? { hostMemoryNow: hostMemoryLine(memoryNow) } : {}),
     }));

package/dist/host/life/index.d.ts

@@ -4,6 +4,7 @@ export * from './stop-warning.js';
 export * from './keep-awake.js';
 export * from './windows-update.js';
 export * from './crash-report.js';
+export * from './last-end.js';
 export * from './session-ledger.js';
 export * from './host-memory.js';
 export * from './watchdog.js';

package/dist/host/life/index.js

@@ -4,6 +4,7 @@ export * from './stop-warning.js';
 export * from './keep-awake.js';
 export * from './windows-update.js';
 export * from './crash-report.js';
+export * from './last-end.js';
 export * from './session-ledger.js';
 export * from './host-memory.js';
 export * from './watchdog.js';

package/dist/host/life/last-end.d.ts

@@ -0,0 +1,21 @@
+import { type Heartbeat } from '../../shared/channel/index.js';
+import type { Life } from './life-record.js';
+/** How the last sandbox ended, when nobody closed it. */
+export interface LastEnd {
+    /** "ended unexpectedly 21:31: this PC's disks were overloaded (queue 40)". */
+    readonly text: string;
+    readonly at: string;
+}
+/** The sandbox's last heartbeat, or null (none written, damaged, or reached through a link). */
+export declare function readHeartbeat(dataPath: string): Heartbeat | null;
+/** One line of what the sandbox was doing at its last heartbeat (pure; guest text goes through safeText). */
+export declare function heartbeatLine(hb: Heartbeat): string;
+/** The likeliest reason, from the last heartbeat (pure). */
+export declare function guessReason(hb: Heartbeat | null): string;
+/**
+ * How the last sandbox ended (pure): null when it was closed normally, or is still running. `heartbeat` only counts
+ * when it was written during that run.
+ */
+export declare function lastEndOf(life: Life | null, heartbeat: Heartbeat | null, running: boolean): LastEnd | null;
+/** The status page's "Last sandbox" fact for this data folder. */
+export declare function readLastEnd(lifeRead: () => Life | null, dataPath: string, running: boolean): LastEnd | null;

package/dist/host/life/last-end.js

@@ -0,0 +1,70 @@
+// What the sandbox did in its last seconds and how it ended, for the status page and the crash report. The sandbox's
+// daemon writes run\heartbeat.json every 10 seconds; when the sandbox vanishes, the last one is the best evidence.
+// The guest wrote it, so it is read through the schema, never through a link, and printed through safeText.
+import { assertNoLinks, safeText } from '../../core/util/index.js';
+import { RunDir, HeartbeatSchema } from '../../shared/channel/index.js';
+import { readValid } from '../../shared/io/index.js';
+import { hostDataRoot } from '../storage/index.js';
+/** The sandbox's last heartbeat, or null (none written, damaged, or reached through a link). */
+export function readHeartbeat(dataPath) {
+    try {
+        const root = hostDataRoot(dataPath);
+        const file = new RunDir(root).heartbeatFile;
+        assertNoLinks(root, file);
+        return readValid(HeartbeatSchema, file);
+    }
+    catch {
+        // A link or an unreadable folder: no evidence, never an error.
+        return null;
+    }
+}
+const clock = (iso) => {
+    const at = new Date(iso);
+    return Number.isNaN(at.getTime())
+        ? iso
+        : at.toLocaleTimeString(undefined, { hour: '2-digit', minute: '2-digit', hour12: false });
+};
+/** One line of what the sandbox was doing at its last heartbeat (pure; guest text goes through safeText). */
+export function heartbeatLine(hb) {
+    const top = hb.topProcesses.map((p) => safeText(p.name) + ' ' + p.privateMb + ' MB').join(', ');
+    return ('last seen inside at ' +
+        clock(hb.at) +
+        ': up ' +
+        Math.round(hb.uptimeS / 60) +
+        ' min, ' +
+        hb.ramFreePct +
+        '% RAM free, ' +
+        hb.commitPct +
+        '% commit used, builds at step ' +
+        hb.step +
+        (hb.hostStep > 0 ? ' (this PC asked for step ' + hb.hostStep + ')' : '') +
+        (hb.diskQueueReported !== undefined ? ', this PC disk queue ' + hb.diskQueueReported : '') +
+        (top ? '; biggest: ' + top : ''));
+}
+/** The likeliest reason, from the last heartbeat (pure). */
+export function guessReason(hb) {
+    if (hb && hb.diskQueueReported !== undefined && hb.hostStep > 0)
+        return "this PC's disks were overloaded (queue " + hb.diskQueueReported + ')';
+    if (hb && (hb.ramFreePct < 8 || hb.commitPct > 92))
+        return 'the sandbox was running out of memory';
+    return 'Windows stopped it (no reason was logged)';
+}
+/**
+ * How the last sandbox ended (pure): null when it was closed normally, or is still running. `heartbeat` only counts
+ * when it was written during that run.
+ */
+export function lastEndOf(life, heartbeat, running) {
+    if (!life || running)
+        return null;
+    if (life.ended && !life.ended.cause)
+        return null;
+    const hb = heartbeat && Date.parse(heartbeat.at) >= Date.parse(life.started) - 60000 ? heartbeat : null;
+    const at = life.ended?.at ?? life.lastSeen;
+    const why = life.ended?.cause ? safeText(life.ended.cause.text) : guessReason(hb);
+    return { at, text: 'ended unexpectedly ' + clock(at) + ': ' + why };
+}
+/** The status page's "Last sandbox" fact for this data folder. */
+export function readLastEnd(lifeRead, dataPath, running) {
+    const life = lifeRead();
+    return lastEndOf(life, life && !running ? readHeartbeat(dataPath) : null, running);
+}

package/dist/host/life/watchdog.d.ts

@@ -10,6 +10,8 @@ export interface WatchdogState {
     readonly cpuHighSeconds: number;
     /** Seconds the disk queue has been above the limit. */
     readonly diskHighSeconds: number;
+    /** Seconds the disk queue has been at or above twice the limit (for the severe step). */
+    readonly diskSevereSeconds: number;
     /** Time (ms) the last request went out. */
     readonly lastSentAt: number;
 }

package/dist/host/life/watchdog.js

@@ -9,6 +9,7 @@ export const WATCHDOG_START = {
     calm: 0,
     cpuHighSeconds: 0,
     diskHighSeconds: 0,
+    diskSevereSeconds: 0,
     lastSentAt: 0,
 };
 /** The request is repeated this often while the PC stays low, and each one lasts a bit longer than that. */
@@ -50,8 +51,12 @@ export function watchdogStep(prev, input) {
         reason = "this PC's CPU has been above " + t.cpuPercent + '% for ' + cpuHigh + ' seconds';
     const diskQueue = input.memory?.diskQueue;
     const diskHigh = diskQueue !== undefined && diskQueue >= t.diskQueue ? prev.diskHighSeconds + input.intervalSeconds : 0;
+    const diskDouble = diskQueue !== undefined && diskQueue >= 2 * t.diskQueue ? prev.diskSevereSeconds + input.intervalSeconds : 0;
+    const diskSevere = diskDouble >= t.diskSeconds || diskHigh >= 3 * t.diskSeconds;
     if (!reason && diskHigh >= t.diskSeconds)
-        reason = "this PC's disks have had a queue of " + diskQueue + ' for ' + diskHigh + ' seconds';
+        reason = diskSevere
+            ? "this PC's disks are overloaded (queue " + diskQueue + ' for ' + diskHigh + ' seconds)'
+            : "this PC's disks have had a queue of " + diskQueue + ' for ' + diskHigh + ' seconds';
     const calmNow = input.memory ? lowReason(input.memory, input.reserveHostMb, t, 1.25) === '' : true;
     let low = prev.low;
     let calm = prev.calm;
@@ -66,7 +71,7 @@ export function watchdogStep(prev, input) {
             calm = 0;
         }
     }
-    const severe = low && input.memory !== null && severeHost(input.memory);
+    const severe = low && ((input.memory !== null && severeHost(input.memory)) || diskSevere);
     // Getting severe is sent at once; otherwise the request is repeated every RESEND_MS while the PC stays low.
     const send = low && (input.nowMs - prev.lastSentAt >= RESEND_MS || (severe && !prev.severe));
     return {
@@ -76,6 +81,7 @@ export function watchdogStep(prev, input) {
             calm,
             cpuHighSeconds: cpuHigh,
             diskHighSeconds: diskHigh,
+            diskSevereSeconds: diskDouble,
             lastSentAt: send ? input.nowMs : prev.lastSentAt,
         },
         send,

package/dist/runtime/agent.js

@@ -25466,7 +25466,7 @@ var SandboxSchema = external_exports.strictObject({
     '(alpha) What runs the sandbox. "windows-sandbox" = Windows Sandbox (the default: desktop, Windows Terminal, GPU, clipboard, audio, printers). "hcs" = a headless Hyper-V isolated Server Core container for agents (no desktop, GPU or clipboard); it needs Windows features and an image on this PC (sandbox engine check hcs lists what is missing), and starting it is not enabled yet in this alpha. sandbox engine shows what each engine can do. Yours only: a project file (.sandbox-config.json) cannot set it.'
   ),
   memoryMb: external_exports.union([external_exports.literal("auto"), external_exports.number().int().min(2048)]).describe(
-    'Sandbox RAM in MB (>= 2048), or "auto": free RAM minus reserveHostMb, capped at maxMemoryMb. Never more than this PC can keep in RAM for it (its RAM minus the larger of reserveHostMb and 25 %, 2 GB more with vGPU): a bigger value is lowered.'
+    'Sandbox RAM in MB (>= 2048), or "auto": free RAM minus reserveHostMb, capped at maxMemoryMb. Never more than this PC can keep in RAM for it (its RAM minus the larger of reserveHostMb and 25 %, 4 GB more with vGPU): a bigger value is lowered.'
   ),
   maxMemoryMb: external_exports.number().int().positive().describe('Upper limit for memoryMb "auto".'),
   maxMemoryPercent: external_exports.number().int().min(10).max(100).describe(`memoryMb "auto" never takes more than this share of this PC's total RAM (percent).`),
@@ -25628,13 +25628,13 @@ var ToolchainsSchema = external_exports.strictObject({
       '["sccache", "cargo-nextest", "cargo-deny"]'
     ),
     targetDir: external_exports.string().min(1).describe(
-      `"shared": cargo's default target\\ (shared with builds on this PC, so builds on either side invalidate the other), "separate": <workspace>\\target\\sandbox (kept, no cross-talk), "local": on the sandbox's own disk (fastest, lost every boot), or a guest path.`
+      `"auto" (default): on the sandbox's own disk when C: has 25 GB free at boot, else "separate" (builds then write through the mapped workspace, which can overload this PC's disk). "shared": cargo's default target\\ (shared with builds on this PC, so builds on either side invalidate the other), "separate": <workspace>\\target\\sandbox (kept, no cross-talk), "local": on the sandbox's own disk (fastest, lost every boot), or a guest path.`
     ),
     linker: external_exports.enum(["lld", "gnu"]).describe(
       `GNU host: "lld" links with Rust's own lld through MinGW's gcc (much less memory than GNU ld), "gnu" with GNU ld.`
     ),
     linkSlots: external_exports.union([external_exports.literal("auto"), external_exports.number().int().min(1).max(32)]).describe(
-      'GNU host: how many programs may link at the same time in the whole sandbox (other links wait). "auto" = one per 3 GB of sandbox memory after 6 GB, 2 to 8 (the memory governor slows links down too when memory runs short).'
+      'GNU host: how many programs may link at the same time in the whole sandbox (other links wait). "auto" = one per 6 GB of sandbox memory, 1 to 4 (the memory governor slows links down too when memory runs short).'
     )
   }),
   msvc: external_exports.strictObject({
@@ -27282,6 +27282,8 @@ var GuestRequestSchema = external_exports.discriminatedUnion("kind", [
     seconds: external_exports.number().int().min(10).max(300),
     /** "severe": the PC is nearly out of memory; builds go to the governor's last step at once. */
     level: external_exports.enum(["slow", "severe"]).optional(),
+    /** The disk queue the PC reported (shown in the heartbeat). */
+    diskQueue: external_exports.number().min(0).max(1e5).optional(),
     createdAt: TimeSchema
   })
 ]);
@@ -27304,6 +27306,21 @@ var PressureStatusSchema = external_exports.object({
   lastAction: Text(300),
   updatedAt: TimeSchema
 });
+var HeartbeatSchema = external_exports.object({
+  at: TimeSchema,
+  /** Seconds since the sandbox booted. */
+  uptimeS: external_exports.number().int().min(0).max(1e9),
+  ramFreePct: external_exports.number().min(0).max(100),
+  commitPct: external_exports.number().min(0).max(100),
+  /** The governor's dial now, and the step this PC asked for. */
+  step: external_exports.number().int().min(0).max(4),
+  hostStep: external_exports.number().int().min(0).max(4),
+  /** The biggest programs in the agents' job. */
+  topProcesses: external_exports.array(external_exports.object({ name: Text(64), privateMb: external_exports.number().int().min(0).max(1e7) })).max(5),
+  /** The disk queue this PC last reported while asking the sandbox to slow down. */
+  diskQueueReported: external_exports.number().min(0).max(1e5).optional(),
+  phase: external_exports.enum(["ready", "working"])
+});
 var GuestResponseSchema = external_exports.object({
   id: IdSchema,
   ok: external_exports.boolean(),
@@ -27489,6 +27506,8 @@ var RunDir = class {
   vpnFile;
   /** What the memory governor in the sandbox is doing (pressure.json). */
   pressureFile;
+  /** The daemon's heartbeat every 10 seconds (heartbeat.json): what the sandbox did last. */
+  heartbeatFile;
   /** What the sandbox's programs may really use (budget.json): processors, memory, build jobs, link slots. */
   budgetFile;
   requestsDir;
@@ -27512,6 +27531,7 @@ var RunDir = class {
     this.sandboxFile = path5.join(this.root, "sandbox.json");
     this.vpnFile = path5.join(this.root, "vpn.json");
     this.pressureFile = path5.join(this.root, "pressure.json");
+    this.heartbeatFile = path5.join(this.root, "heartbeat.json");
     this.budgetFile = path5.join(this.root, "budget.json");
     this.requestsDir = path5.join(this.root, "requests");
     this.responsesDir = path5.join(this.root, "responses");
@@ -27556,6 +27576,9 @@ var RunDir = class {
   readPressure() {
     return readValid(PressureStatusSchema, this.pressureFile);
   }
+  readHeartbeat() {
+    return readValid(HeartbeatSchema, this.heartbeatFile);
+  }
   readSession(id) {
     return readValid(SessionStatusSchema, this.sessionFile(id));
   }