windows-development-sandbox 1.27.1 → 1.28.0

package/dist/guest/governor/core.js

@@ -1,6 +1,94 @@
 import { now } from '../../shared/channel/run-dir.js';
+import { z } from 'zod';
+import { BURST_GATE } from '../../shared/memory/index.js';
 import { errMsg } from '../../core/util/errors.js';
-import { decide, HOLD_MS, INITIAL_STATE } from './decide.js';
+import { decide, GATE_NAMES, HOLD_MS, INITIAL_STATE, } from './decide.js';
+/** memgov.exe's arguments: samples every 2 s and the memory gate for this profile. */
+export function memgovArgs(profile) {
+    const g = BURST_GATE[profile];
+    return [
+        'serve',
+        '--interval',
+        '2',
+        '--gate',
+        [g.growthMb, g.windowMs, g.releaseMs, g.maxHoldMs].join(':'),
+        '--gate-names',
+        GATE_NAMES.join(','),
+    ];
+}
+const GateBase = { event: z.literal('gate'), at: z.number() };
+const GateName = z.string().max(128);
+const GateCount = z.number().int().min(0);
+/** What the memory gate in memgov reports on its stdout (one JSON line each). */
+export const GateEventSchema = z.discriminatedUnion('kind', [
+    z.strictObject({
+        ...GateBase,
+        kind: z.literal('ready'),
+        mode: z.enum(['notify', 'poll']),
+        growthMb: GateCount,
+        windowMs: GateCount,
+    }),
+    z.strictObject({ ...GateBase, kind: z.literal('off'), reason: z.string().max(200) }),
+    z.strictObject({
+        ...GateBase,
+        kind: z.literal('trip'),
+        grewMb: GateCount,
+        ms: GateCount,
+        jobMb: GateCount,
+        held: z.array(z.strictObject({ pid: z.number().int(), name: GateName })).max(64),
+    }),
+    z.strictObject({ ...GateBase, kind: z.literal('hold'), pid: z.number().int(), name: GateName }),
+    z.strictObject({
+        ...GateBase,
+        kind: z.literal('release'),
+        pid: z.number().int(),
+        name: GateName,
+        heldMs: GateCount,
+        forced: z.boolean(),
+    }),
+]);
+/** One memory-log line for a gate event (names cut to 64 characters). */
+export function gateLine(e) {
+    const cut = (s) => s.slice(0, 64);
+    switch (e.kind) {
+        case 'ready':
+            return ('gate: on (' +
+                e.mode +
+                "): new compilers wait when the agents' programs grow by more than " +
+                e.growthMb +
+                ' MB within ' +
+                e.windowMs / 1000 +
+                ' s');
+        case 'off':
+            return 'gate: off (' + e.reason + '): builds are only slowed down by the dial';
+        case 'trip':
+            return ("gate: the agents' programs grew " +
+                e.grewMb +
+                ' MB in ' +
+                (e.ms / 1000).toFixed(1) +
+                ' s (now ' +
+                e.jobMb +
+                ' MB); holding ' +
+                e.held.length +
+                ': ' +
+                e.held
+                    .slice(0, 8)
+                    .map((p) => cut(p.name) + ' (' + p.pid + ')')
+                    .join(', ') +
+                (e.held.length > 8 ? ' …' : ''));
+        case 'hold':
+            return 'gate: ' + cut(e.name) + ' (' + e.pid + ') waits at start while a build burst goes through in turn';
+        case 'release':
+            return ('gate: ' +
+                cut(e.name) +
+                ' (' +
+                e.pid +
+                ') goes on after ' +
+                (e.heldMs / 1000).toFixed(1) +
+                ' s' +
+                (e.forced ? ' (the longest it may wait)' : ''));
+    }
+}
 const STEP_TEXT = [
     'builds back to normal',
     'build programs at lower priority',
@@ -55,6 +143,7 @@ export class GovernorCore {
             commitPercent: d.commitPercent,
             step: d.state.step,
             hostStep: nowMs < d.state.hostUntil ? d.state.hostStep : 0,
+            held: sample.gateHeld ?? 0,
             diskQueue: null,
             top: [...sample.procs]
                 .sort((a, b) => b.mb - a.mb)
@@ -89,6 +178,7 @@ export class GovernorCore {
             paused: [...this.held]
                 .slice(0, 8)
                 .map(([pid, name]) => ({ name: name.slice(0, 64), pid, seconds: HOLD_MS / 1000 })),
+            held: sample.gateHeld ?? 0,
             cpuPercent: d.state.cpuRate,
             pcLow: nowMs < d.state.hostUntil,
             lastAction: this.lastAction.slice(0, 300),
@@ -102,6 +192,10 @@ export class GovernorCore {
             this.deps.saveStatus(status);
         }
     }
+    /** An event from the memory gate in memgov: goes to the memory log. */
+    onGate(event) {
+        this.note(gateLine(event));
+    }
     apply(action) {
         const port = this.deps.port;
         try {

package/dist/guest/governor/decide.d.ts

@@ -16,6 +16,8 @@ export interface MemSample {
     readonly commitAvailMb: number;
     /** Only the processes in the agents' job. */
     readonly procs: readonly ProcSample[];
+    /** Build programs the memory gate holds now (memgov). */
+    readonly gateHeld?: number;
 }
 export declare const isNeverTouched: (name: string) => boolean;
 export declare const canLower: (name: string) => boolean;
@@ -24,6 +26,8 @@ export declare const isLinker: (name: string) => boolean;
 export declare function linkerSlots(totalMb: number, cpus: number): number;
 export declare const isHeavyCompiler: (name: string) => boolean;
 export declare const canPause: (name: string) => boolean;
+/** What the memory gate in memgov may freeze (compilers, linkers, Unreal's shader workers); passed as --gate-names. */
+export declare const GATE_NAMES: readonly string[];
 export type Level = 'ok' | 'throttled' | 'suspending';
 export interface GovernorState {
     /** The dial: 0 nothing wrong, 1 lower priority, 2 less CPU and fewer compilers, 3 and 4 harder. */

package/dist/guest/governor/decide.js

@@ -109,6 +109,8 @@ export function linkerSlots(totalMb, cpus) {
 }
 export const isHeavyCompiler = (name) => !isNeverTouched(name) && HEAVY.has(key(name));
 export const canPause = (name) => !isNeverTouched(name) && COMPILERS.has(key(name));
+/** What the memory gate in memgov may freeze (compilers, linkers, Unreal's shader workers); passed as --gate-names. */
+export const GATE_NAMES = [...COMPILERS, 'shadercompileworker'].filter((n) => !NEVER.has(n)).sort();
 export const INITIAL_STATE = {
     step: 0,
     calm: 0,

package/dist/guest/governor/governor.js

@@ -1,6 +1,7 @@
 // The memory governor: samples the sandbox's memory every 2 seconds (memgov.exe, sandbox/csharp/MemGov.cs) and turns
 // a dial as it fills: the build programs the agents started get lower priority, lower memory priority, less CPU, and
-// take turns (decide.ts). Builds slow down; nothing fails. What it does goes to the memory log and run\pressure.json.
+// take turns (decide.ts). A memory gate in memgov also holds new compilers when memory grows faster than a few GB in
+// seconds. Builds slow down; nothing fails. What it does goes to the memory log and run\pressure.json.
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -8,14 +9,14 @@ import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
 import { z } from 'zod';
 import { writeJsonAtomic } from '../../shared/io/json.js';
-import { DIAL_STEPS, maxCompilers } from '../../shared/memory/index.js';
+import { BURST_GATE, DIAL_STEPS, maxCompilers } from '../../shared/memory/index.js';
 import { ensureCompiled } from '../runtime/csc.js';
 import { dataDir } from '../runtime/paths.js';
 import { warn } from '../runtime/log.js';
 import { run } from '../runtime/paths.js';
 import { session } from '../runtime/session.js';
 import { errMsg } from '../../core/util/errors.js';
-import { GovernorCore } from './core.js';
+import { GateEventSchema, GovernorCore, memgovArgs, } from './core.js';
 const SampleSchema = z.object({
     ramTotalMb: z.number(),
     ramAvailMb: z.number(),
@@ -29,27 +30,36 @@ const SampleSchema = z.object({
         prio: z.enum(['idle', 'below', 'normal']).catch('normal'),
     }))
         .max(1024),
+    gateHeld: z.number().int().min(0).max(1024).optional().catch(undefined),
 });
 /** memgov.exe as a child process: samples come out of its stdout, commands go into its stdin. */
 class MemGovProcess {
+    args;
     onSample;
+    onGate;
     child = null;
-    constructor(onSample) {
+    constructor(args, onSample, onGate) {
+        this.args = args;
         this.onSample = onSample;
+        this.onGate = onGate;
     }
     start() {
         try {
-            const child = spawn(ensureCompiled('memgov'), ['serve', '--interval', '2'], {
+            const child = spawn(ensureCompiled('memgov'), [...this.args], {
                 stdio: ['pipe', 'pipe', 'ignore'],
                 windowsHide: true,
             });
             this.child = child;
             createInterface({ input: child.stdout }).on('line', (line) => {
                 try {
-                    this.onSample(SampleSchema.parse(JSON.parse(line)));
+                    const raw = JSON.parse(line);
+                    if (typeof raw === 'object' && raw !== null && raw.event === 'gate')
+                        this.onGate(GateEventSchema.parse(raw));
+                    else
+                        this.onSample(SampleSchema.parse(raw));
                 }
                 catch (e) {
-                    warn('governor: bad sample: ' + errMsg(e));
+                    warn('governor: bad line from memgov: ' + errMsg(e));
                 }
             });
             child.stdin.on('error', () => undefined);
@@ -120,13 +130,17 @@ export class Governor {
                 first.availablePercent +
                 '% free RAM or ' +
                 first.commitPercent +
-                '% commit, in steps';
+                '% commit, in steps; holds new compilers when memory grows faster than ' +
+                BURST_GATE[profile].growthMb +
+                ' MB in ' +
+                BURST_GATE[profile].windowMs / 1000 +
+                ' s';
     }
     start() {
         if (session.pressureResponse === false)
             return;
         const profile = session.loadProfile === 'gentle' ? 'gentle' : 'normal';
-        const proc = new MemGovProcess((s) => this.core?.onSample(s));
+        const proc = new MemGovProcess(memgovArgs(profile), (s) => this.core?.onSample(s), (e) => this.core?.onGate(e));
         this.core = new GovernorCore({
             port: proc,
             profile,

package/dist/guest/runtime/pools.d.ts

@@ -1,10 +1,10 @@
-import { type SpawnOptions } from 'node:child_process';
 import { heavy, installer, net } from '../../shared/concurrency/index.js';
+import { lowerPriority, type SpawnAsyncOptions } from '../../shared/download/index.js';
 export { net, heavy, installer };
 /** Called at the start of the boot and of the daemon: the downloader and the extractor use the pools from then on. */
 export declare function installPools(): void;
 /** Lowers a process (and the children it starts from now on) to below-normal priority; best effort. */
-export declare function belowNormal(pid: number | undefined): void;
+export declare const belowNormal: typeof lowerPriority;
 export interface InstallerOptions {
     /** Below-normal priority for the installer and what it starts (the background Visual Studio). */
     readonly lowPriority?: boolean;
@@ -20,5 +20,5 @@ export interface InstallerOptions {
 export declare function runInstaller(file: string, args: string[], o?: InstallerOptions): Promise<number>;
 /** runInstaller that throws like execAsync when the installer fails. */
 export declare function runInstallerChecked(file: string, args: string[], o?: InstallerOptions): Promise<void>;
-/** execAsync for heavy local work (npm, uv, rustup ...): one of the two heavy slots. */
-export declare function execHeavy(file: string, args: string[], options?: SpawnOptions): Promise<void>;
+/** execAsync for heavy local work (npm, uv, rustup ...): one of the two heavy slots, at below-normal priority. */
+export declare function execHeavy(file: string, args: string[], options?: SpawnAsyncOptions): Promise<void>;

package/dist/guest/runtime/pools.js

@@ -1,10 +1,9 @@
 // The guest's work pools: network bodies, heavy local work and installers. A task takes one slot at the leaf (the
 // call that downloads, unpacks or installs), never while it holds another: the limiter refuses nested pools.
-import os from 'node:os';
 import { spawn } from 'node:child_process';
 import path from 'node:path';
 import { heavy, installer, net, INSTALLER_WAIT_MS, installerRetry } from '../../shared/concurrency/index.js';
-import { downloader, limitExtraction } from '../../shared/download/index.js';
+import { downloader, limitExtraction, lowerPriority } from '../../shared/download/index.js';
 import { log } from './log.js';
 import { execAsync } from './process.js';
 export { net, heavy, installer };
@@ -13,18 +12,8 @@ export function installPools() {
     downloader.limit = net;
     limitExtraction(heavy);
 }
-const BELOW_NORMAL = os.constants.priority.PRIORITY_BELOW_NORMAL;
 /** Lowers a process (and the children it starts from now on) to below-normal priority; best effort. */
-export function belowNormal(pid) {
-    if (pid === undefined)
-        return;
-    try {
-        os.setPriority(pid, BELOW_NORMAL);
-    }
-    catch {
-        /* the process may have ended already; a normal priority only makes it a little slower to share the machine */
-    }
-}
+export const belowNormal = lowerPriority;
 /**
  * Runs an installer in the one installer slot and starts it again while another process holds the Windows Installer
  * lock (exit 1618). Resolves with the exit code of the last try.
@@ -54,7 +43,7 @@ export async function runInstallerChecked(file, args, o = {}) {
     if (code !== 0)
         throw new Error(path.basename(file) + ' ' + args.slice(0, 3).join(' ') + ' failed with exit code ' + code);
 }
-/** execAsync for heavy local work (npm, uv, rustup ...): one of the two heavy slots. */
+/** execAsync for heavy local work (npm, uv, rustup ...): one of the two heavy slots, at below-normal priority. */
 export function execHeavy(file, args, options = {}) {
-    return heavy.run(() => execAsync(file, args, options));
+    return heavy.run(() => execAsync(file, args, { ...options, lowPriority: true }));
 }

package/dist/guest/runtime/process.d.ts

@@ -1,4 +1,5 @@
-import { type SpawnOptions, type SpawnSyncOptions } from 'node:child_process';
+import { type SpawnSyncOptions } from 'node:child_process';
+import { type SpawnAsyncOptions } from '../../shared/download/index.js';
 /** Takes the output of the programs started while the boot draws its progress (boot/boot-console.ts). */
 export interface OutputSink {
     /** Whether programs started now hand their output over instead of writing to the console. */
@@ -11,7 +12,7 @@ export declare function routeOutput(sink: OutputSink | null): void;
 /** Runs a program, streaming output, and throws with a readable message when it fails. */
 export declare function exec(file: string, args: string[], options?: SpawnSyncOptions): void;
 /** exec without blocking: other toolchains keep downloading while this one runs an installer. */
-export declare function execAsync(file: string, args: string[], options?: SpawnOptions): Promise<void>;
+export declare function execAsync(file: string, args: string[], options?: SpawnAsyncOptions): Promise<void>;
 export declare function execOutput(file: string, args: string[], options?: SpawnSyncOptions): string;
 /** Runs sandbox\scripts\<name> (a .ps1 in the launch folder) with `args`; throws when it fails. */
 export declare function runScript(name: string, args?: readonly string[]): void;
@@ -19,6 +20,8 @@ export declare function runScript(name: string, args?: readonly string[]): void;
 export declare function runScriptAsync(name: string, args?: readonly string[]): Promise<void>;
 /** runScript for what it prints ('' when it fails). */
 export declare function scriptOutput(name: string, args?: readonly string[], options?: SpawnSyncOptions): string;
+/** scriptOutput without blocking the event loop ('' when the script fails). */
+export declare function scriptOutputAsync(name: string, args?: readonly string[]): Promise<string>;
 /** Runs sandbox\scripts\<name> with a JSON file (-<param> path) holding `data`, removed afterwards. */
 export declare function runScriptWithJson(name: string, param: string, data: unknown, args?: readonly string[]): void;
 /** runScriptWithJson without blocking the event loop. */

package/dist/guest/runtime/process.js

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { spawn, spawnSync } from 'node:child_process';
-import { moveIntoPlace, spawnAsync, stagingFolder } from '../../shared/download/index.js';
+import { lowerPriority, moveIntoPlace, spawnAsync, stagingFolder, } from '../../shared/download/index.js';
 import { safeRemove } from '../../shared/io/safe-remove.js';
 import { robocopyErrors, robocopyFailed, robocopyMeaning } from '../../shared/io/robocopy-result.js';
 import { SYSTEM } from '../../shared/system.js';
@@ -57,15 +57,18 @@ export function exec(file, args, options = {}) {
 }
 /** exec without blocking: other toolchains keep downloading while this one runs an installer. */
 export async function execAsync(file, args, options = {}) {
+    const { lowPriority, ...spawnOptions } = options;
     const code = captureOutput()
         ? await new Promise((resolve, reject) => {
-            const child = spawn(file, args, { stdio: ['inherit', 'pipe', 'pipe'], windowsHide: true, ...options });
+            const child = spawn(file, args, { stdio: ['inherit', 'pipe', 'pipe'], windowsHide: true, ...spawnOptions });
+            if (lowPriority)
+                lowerPriority(child.pid);
             logLines(child.stdout);
             logLines(child.stderr);
             child.once('error', reject);
             child.once('close', (c) => resolve(c ?? -1));
         })
-        : await spawnAsync(file, args, { stdio: 'inherit', ...options });
+        : await spawnAsync(file, args, { stdio: 'inherit', ...spawnOptions, ...(lowPriority ? { lowPriority } : {}) });
     if (code !== 0)
         throw new Error(path.basename(file) + ' ' + args.slice(0, 3).join(' ') + ' failed with exit code ' + code);
 }
@@ -131,6 +134,23 @@ export function runScriptAsync(name, args = []) {
 export function scriptOutput(name, args = [], options = {}) {
     return execOutput(SYSTEM.powershell(), scriptArgs(name, args), options);
 }
+/** scriptOutput without blocking the event loop ('' when the script fails). */
+export function scriptOutputAsync(name, args = []) {
+    return new Promise((resolve) => {
+        const child = spawn(SYSTEM.powershell(), scriptArgs(name, args), {
+            stdio: ['ignore', 'pipe', 'ignore'],
+            windowsHide: true,
+        });
+        let out = '';
+        child.stdout?.setEncoding('utf8');
+        child.stdout?.on('data', (chunk) => {
+            if (out.length < CAPTURE_BYTES)
+                out += chunk;
+        });
+        child.once('error', () => resolve(''));
+        child.once('close', (code) => resolve(code === 0 ? out.trim() : ''));
+    });
+}
 /** Runs sandbox\scripts\<name> with a JSON file (-<param> path) holding `data`, removed afterwards. */
 export function runScriptWithJson(name, param, data, args = []) {
     const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sbx-'));

package/dist/guest/toolchains/engines/epic-launcher.d.ts

@@ -1,3 +1,4 @@
+import type { PcInstall } from '../../../shared/paths/pc-installs.js';
 import { type LauncherEntry } from '../../../shared/unreal/index.js';
 /** The launcher's program: newer MSIs install into Program Files, older ones into Program Files (x86). */
 export declare function launcherExe(): string | null;
@@ -17,6 +18,11 @@ export declare function placeEngines(persist: boolean): LauncherPlaceResult;
 export declare function savedEntries(): LauncherEntry[];
 /** Puts the saved manifests back where the launcher reads them; the engine folders they name. */
 export declare function restoreLauncherItems(): string[];
+/**
+ * The manifests of this PC's engines (session.json) where the launcher reads them: without one it drops the engine
+ * from LauncherInstalled.dat when it starts. Only a manifest of the engine's own folder; one of ours is replaced.
+ */
+export declare function writePcLauncherItems(items: readonly Pick<PcInstall, 'kind' | 'guest' | 'launcherItem'>[]): number;
 /** Merges these entries into the launcher's LauncherInstalled.dat (foreign entries kept). */
 export declare function writeLauncherEntries(entries: readonly LauncherEntry[]): void;
 /**

package/dist/guest/toolchains/engines/epic-launcher.js

@@ -9,7 +9,7 @@ import { z } from 'zod';
 import { readBoundedFile } from '../../../shared/io/bounded.js';
 import { readValid, writeJsonAtomic } from '../../../shared/io/json.js';
 import { SYSTEM } from '../../../shared/system.js';
-import { enginePlaceProblem, ENGINE_NEED_BYTES, entriesUnder, launcherInstalledFile, launcherManifestsDir, launcherSettingsFiles, MAX_LAUNCHER_FILE_BYTES, mergeLauncherInstalled, restoreItems, saveItems, setLauncherInstallLocation, } from '../../../shared/unreal/index.js';
+import { enginePlaceProblem, ENGINE_NEED_BYTES, entriesUnder, itemInstallLocation, ITEM_NAME, launcherInstalledFile, launcherManifestsDir, launcherSettingsFiles, MAX_LAUNCHER_FILE_BYTES, mergeLauncherInstalled, restoreItems, saveItems, setLauncherInstallLocation, } from '../../../shared/unreal/index.js';
 import { errMsg } from '../../../core/util/errors.js';
 import { runInstaller } from '../../runtime/pools.js';
 import { exists, mkdirp } from '../../runtime/fs.js';
@@ -93,6 +93,24 @@ export function savedEntries() {
 export function restoreLauncherItems() {
     return restoreItems(SAVED_MANIFESTS, launcherManifestsDir(programData()), ENGINES_DIR, exists);
 }
+/**
+ * The manifests of this PC's engines (session.json) where the launcher reads them: without one it drops the engine
+ * from LauncherInstalled.dat when it starts. Only a manifest of the engine's own folder; one of ours is replaced.
+ */
+export function writePcLauncherItems(items) {
+    const dir = launcherManifestsDir(programData());
+    let written = 0;
+    for (const i of items) {
+        if (i.kind !== 'unreal' || !i.launcherItem || !ITEM_NAME.test(i.launcherItem.name))
+            continue;
+        const at = itemInstallLocation(i.launcherItem.text);
+        if (!at || path.win32.resolve(at).toLowerCase() !== path.win32.resolve(i.guest).toLowerCase())
+            continue;
+        fs.writeFileSync(path.join(mkdirp(dir), i.launcherItem.name), i.launcherItem.text, 'utf8');
+        written++;
+    }
+    return written;
+}
 /** Merges these entries into the launcher's LauncherInstalled.dat (foreign entries kept). */
 export function writeLauncherEntries(entries) {
     if (!entries.length)

package/dist/guest/toolchains/engines/unreal-engines.js

@@ -16,7 +16,7 @@ import { runScriptWithJsonAsync } from '../../runtime/process.js';
 import { projectWorkspace } from '../../runtime/project-context.js';
 import { session } from '../../runtime/session.js';
 import { setUnrealMcp, writeAddonMcpServers } from '../../setup/addon-mcp.js';
-import { saveLauncherState, savedEntries, writeLauncherEntries } from './epic-launcher.js';
+import { saveLauncherState, savedEntries, writeLauncherEntries, writePcLauncherItems } from './epic-launcher.js';
 import { DDC_DIR, ENGINES_DIR, SAVED_DIR, updateUnrealStatus } from './unreal-status.js';
 const SAVED_MANIFESTS = path.join(SAVED_DIR, 'Manifests');
 /** The real disk, read bounded. */
@@ -76,6 +76,7 @@ export async function registerEngines(engines, selectorFrom, ctx, aliases = [])
     if (values.length)
         await runScriptWithJsonAsync('set-registry-values.ps1', 'PlanFile', { values });
     try {
+        writePcLauncherItems(ctx.pcInstalls.items);
         writeLauncherEntries(launcherEntries(engines, ctx));
     }
     catch (e) {

package/dist/guest/toolchains/installers.d.ts

@@ -1,8 +1,8 @@
 import { SIGNERS, type AppSigner } from '../../shared/signer.js';
-import { signedBy } from './signature.js';
+import { signedBy, signedByAsync } from './signature.js';
 export { SIGNERS };
-export { signedBy };
+export { signedBy, signedByAsync };
 /** A downloader `verify` hook: refuses a file not signed by `signer` (it counts as integrity for requireChecksum). */
-export declare function signatureCheck(signer: AppSigner, what: string): (file: string) => void;
+export declare function signatureCheck(signer: AppSigner, what: string): (file: string) => Promise<void>;
 /** The installer at `file` (downloaded once from `url`), checked against its signer and, when given, its SHA-256. */
 export declare function signedInstaller(url: string, file: string, what: string, signer: AppSigner, sha256?: string | null): Promise<string>;

package/dist/guest/toolchains/installers.js

@@ -6,13 +6,13 @@ import { downloader } from '../../shared/download/index.js';
 import { exists, mkdirp } from '../runtime/fs.js';
 import { log } from '../runtime/log.js';
 import { SIGNERS } from '../../shared/signer.js';
-import { signedBy } from './signature.js';
+import { signedBy, signedByAsync } from './signature.js';
 export { SIGNERS };
-export { signedBy };
+export { signedBy, signedByAsync };
 /** A downloader `verify` hook: refuses a file not signed by `signer` (it counts as integrity for requireChecksum). */
 export function signatureCheck(signer, what) {
-    return (file) => {
-        if (!signedBy(file, signer))
+    return async (file) => {
+        if (!(await signedByAsync(file, signer)))
             throw new Error(what + ' is not signed by its vendor');
     };
 }
@@ -23,7 +23,7 @@ export async function signedInstaller(url, file, what, signer, sha256 = null) {
         mkdirp(path.dirname(file));
         await downloader.file(url, file, { sha256, verify: signatureCheck(signer, path.basename(file)) });
     }
-    if (!signedBy(file, signer)) {
+    if (!(await signedByAsync(file, signer))) {
         fs.rmSync(file, { force: true });
         throw new Error(path.basename(file) + ' is not signed by its vendor; deleted it (it is downloaded again next boot)');
     }

package/dist/guest/toolchains/native/unreal.js

@@ -1,20 +1,23 @@
 // Unreal Engine development, machine-wide (toolchains.unreal, once per boot): the DirectX End-User Runtime the engine
 // lists and the Epic Games Launcher (real installers: they run every boot), the launcher pointed at the data disk for
-// engines and given back the engines it installed there, the Windows SDK debuggers for crash dumps, and a check that
-// UnrealBuildTool finds Visual Studio the way it looks (the Setup Configuration API). Visual Studio itself is its own
-// step (visual-studio.ts), which the plan runs first; each project's engine is set up by engines/unreal-engines.ts.
+// engines and given back the engines it installed there, the Windows SDK debuggers for crash dumps, a check that
+// UnrealBuildTool finds Visual Studio the way it looks (the Setup Configuration API), and its parallel compiles capped.
+// Visual Studio itself is its own step (visual-studio.ts), which the plan runs first; each project's engine is set up
+// by engines/unreal-engines.ts.
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { errMsg } from '../../../core/util/errors.js';
 import { readValid } from '../../../shared/io/json.js';
 import { safeRemove } from '../../../shared/io/safe-remove.js';
+import { buildJobs, ubtBuildConfiguration, usableCpus } from '../../../shared/memory/index.js';
 import { VsSetupReportSchema, vsVerdict } from '../../../shared/unreal/index.js';
 import { runInstaller } from '../../runtime/pools.js';
 import { dryRun } from '../../runtime/paths.js';
 import { exists, mkdirp } from '../../runtime/fs.js';
 import { log, warn } from '../../runtime/log.js';
 import { runScriptAsync } from '../../runtime/process.js';
+import { session } from '../../runtime/session.js';
 import { ensureLauncher, fetchLauncher, placeEngines, restoreLauncherItems } from '../engines/epic-launcher.js';
 import { resetUnrealStatus, updateUnrealStatus } from '../engines/unreal-status.js';
 import { SIGNERS, signedInstaller } from '../installers.js';
@@ -68,6 +71,18 @@ async function checkVisualStudio() {
         fs.rmSync(dir, { recursive: true, force: true });
     }
 }
+/**
+ * UnrealBuildTool's per-user BuildConfiguration.xml (%APPDATA%, wiped with the sandbox): compiles at once from the
+ * sandbox's build budget, so a build start cannot outrun the memory Windows backs the sandbox with. Returns the cap.
+ */
+function capUnrealBuilds() {
+    const cpus = usableCpus(os.cpus().length, session.cpuLimitPercent ?? null);
+    const jobs = buildJobs(cpus, os.totalmem() / 1024 ** 3);
+    const appData = process.env.APPDATA ?? 'C:\\Users\\WDAGUtilityAccount\\AppData\\Roaming';
+    const dir = mkdirp(path.join(appData, 'Unreal Engine', 'UnrealBuildTool'));
+    fs.writeFileSync(path.join(dir, 'BuildConfiguration.xml'), ubtBuildConfiguration(jobs), 'utf8');
+    return jobs;
+}
 /** Runs one part, warning (not failing the step) when it does not work. */
 async function part(what, work, fallback) {
     try {
@@ -86,6 +101,9 @@ export async function setupUnreal(env, config, _ctx) {
         return;
     }
     resetUnrealStatus();
+    const jobs = await part('capping parallel compiles', async () => capUnrealBuilds(), 0);
+    if (jobs)
+        log('Unreal: UnrealBuildTool runs at most ' + jobs + ' compiles at once (the build budget)');
     await part('the DirectX End-User Runtime', installDirectX, undefined);
     const launcher = await part('the Epic Games Launcher', ensureLauncher, null);
     // Before anyone opens the launcher: engines go to the data disk, and it knows the ones it installed there before.
@@ -131,6 +149,7 @@ export async function setupUnreal(env, config, _ctx) {
                 vs.version +
                 (check.ok ? ' (UnrealBuildTool finds it)' : ' (UnrealBuildTool would NOT find it)')
             : 'no Visual Studio') +
+        (jobs ? ', at most ' + jobs + ' compiles at once' : '') +
         ', DirectX End-User Runtime' +
         (launcher ? ', Epic Games Launcher' : '') +
         (debuggers ? ', cdb/windbg' : ''));

package/dist/guest/toolchains/native/vcruntime.js

@@ -6,7 +6,7 @@ import { dryRun } from '../../runtime/paths.js';
 import { exists } from '../../runtime/fs.js';
 import { log } from '../../runtime/log.js';
 import { downloadFile } from '../install.js';
-import { SIGNERS, signedBy } from '../installers.js';
+import { SIGNERS, signedByAsync } from '../installers.js';
 import { tool } from '../tool-env.js';
 const VC_REDIST = 'https://aka.ms/vs/17/release/vc_redist.x64.exe';
 /** 1638: a newer version is already installed; 3010: installed, a restart would finish it (not needed for the DLLs). */
@@ -37,7 +37,7 @@ export async function setupVcRuntime(env, summary = true) {
             log('Downloading the Visual C++ runtime (~25 MB once) ...');
             await downloadFile(VC_REDIST, installer);
         }
-        if (!signedBy(installer, SIGNERS.microsoft)) {
+        if (!(await signedByAsync(installer, SIGNERS.microsoft))) {
             fs.rmSync(installer, { force: true });
             throw new Error('vc_redist.x64.exe is not signed by Microsoft; deleted it (it is downloaded again next boot)');
         }

package/dist/guest/toolchains/native/vs-persist.d.ts

@@ -71,6 +71,7 @@ export declare const VsPersistMarkerSchema: z.ZodObject<{
     installationPath: z.ZodString;
     sdkVersion: z.ZodString;
     folders: z.ZodArray<z.ZodEnum<{
+        Shared: "Shared";
         Community: "Community";
         BuildTools: "BuildTools";
         WindowsKits10: "WindowsKits10";
@@ -78,7 +79,6 @@ export declare const VsPersistMarkerSchema: z.ZodObject<{
         "MicrosoftSDKs-v10.0A": "MicrosoftSDKs-v10.0A";
         ReferenceAssemblies: "ReferenceAssemblies";
         Installer: "Installer";
-        Shared: "Shared";
         Setup: "Setup";
         instance: "instance";
     }>>;
@@ -102,6 +102,7 @@ export type VsPersistMarker = z.infer<typeof VsPersistMarkerSchema>;
 /** What save-visual-studio.ps1 writes to its result file. */
 export declare const SaveResultSchema: z.ZodObject<{
     copied: z.ZodArray<z.ZodEnum<{
+        Shared: "Shared";
         Community: "Community";
         BuildTools: "BuildTools";
         WindowsKits10: "WindowsKits10";
@@ -109,7 +110,6 @@ export declare const SaveResultSchema: z.ZodObject<{
         "MicrosoftSDKs-v10.0A": "MicrosoftSDKs-v10.0A";
         ReferenceAssemblies: "ReferenceAssemblies";
         Installer: "Installer";
-        Shared: "Shared";
         Setup: "Setup";
         instance: "instance";
     }>>;

package/dist/guest/toolchains/runtimes.js

@@ -28,12 +28,13 @@ export async function setupSingleExe(env, name, repo, pattern, exeName, dir, opt
 }
 export async function setupBun(env) {
     await setupSingleExe(env, 'bun', 'oven-sh/bun', arch === 'arm64' ? /^bun-windows-aarch64\.zip$/ : /^bun-windows-x64\.zip$/, 'bun.exe', tool('bun', 'bin'), { size: '35 MB' });
-    // Bun cannot keep its cache or temp files on a mapped folder (EINVAL); they go to the sandbox's own disk.
-    Object.assign(env.vars, {
-        BUN_INSTALL: tool('bun'),
-        BUN_INSTALL_CACHE_DIR: path.join(localDir, 'bun-cache'),
-        BUN_TMPDIR: path.join(localDir, 'bun-tmp'),
-    });
+    // Bun cannot keep its cache or temp files on a mapped folder (EINVAL); they go to the sandbox's own disk. The temp
+    // folder must exist: programs compiled with Bun (opencode) unpack their DLLs there and fail when it is missing.
+    const cache = path.join(localDir, 'bun-cache');
+    const temp = path.join(localDir, 'bun-tmp');
+    if (!dryRun)
+        [cache, temp].forEach((dir) => mkdirp(dir));
+    Object.assign(env.vars, { BUN_INSTALL: tool('bun'), BUN_INSTALL_CACHE_DIR: cache, BUN_TMPDIR: temp });
 }
 export async function setupDeno(env) {
     await setupSingleExe(env, 'deno', 'denoland/deno', arch === 'arm64' ? /^deno-aarch64-pc-windows-msvc[.]zip$/ : /^deno-x86_64-pc-windows-msvc[.]zip$/, 'deno.exe', tool('deno', 'bin'), { size: '40 MB' });

package/dist/guest/toolchains/signature.d.ts

@@ -3,3 +3,5 @@ import { type AppSigner, type Signature } from '../../shared/signer.js';
 export declare function signatureOf(file: string): Signature | null;
 /** Whether a file's valid signature is the expected signer's. */
 export declare function signedBy(file: string, signer: AppSigner): boolean;
+/** signedBy without blocking the event loop: a boot check of a big download must not stall the other tasks. */
+export declare function signedByAsync(file: string, signer: AppSigner): Promise<boolean>;