windows-development-sandbox 1.18.4 → 1.23.0

package/dist/guest/toolchains/languages/php.js

@@ -69,6 +69,17 @@ const setupComposer = async (env, php) => {
     shim(env, 'composer', '"' + php + '" "' + phar + '"');
     env.summary.push('composer: ' + (/\d+\.\d+\.\d+/.exec(execOutput(php, [phar, '--version', '--no-ansi']))?.[0] ?? 'installed'));
 };
+const PHP_RELEASES = 'https://windows.php.net/downloads/releases/';
+const phpCache = (zip) => tool('downloads', 'php-' + path.basename(zip));
+/** Downloads PHP's zip ahead of the install (which unpacks it); nothing when PHP is there already. */
+export async function fetchPhp(config) {
+    const spec = versionFromFiles(['.php-version']) ?? { spec: config.version, source: 'config' };
+    const version = await resolveCached('php:' + spec.spec, async () => (await phpBuild(spec.spec)).version);
+    if (exists(path.join(tool('php', version), 'php.exe')))
+        return;
+    const build = await phpBuild(version);
+    await downloader.file(PHP_RELEASES + build.path, phpCache(build.path), build.sha256);
+}
 export async function setupPhp(env, config) {
     const wantedSpec = versionFromFiles(['.php-version']) ?? { spec: config.version, source: 'config' };
     if (dryRun) {
@@ -82,10 +93,11 @@ export async function setupPhp(env, config) {
     if (!exists(path.join(home, 'php.exe'))) {
         const build = await phpBuild(version);
         log('Downloading PHP ' + version + ' (~30 MB once) ...');
-        await downloader.archive('https://windows.php.net/downloads/releases/' + build.path, home, {
+        await downloader.archive(PHP_RELEASES + build.path, home, {
             sha256: build.sha256,
             locate: 'php.exe',
             fileName: build.path,
+            cached: phpCache(build.path),
         });
     }
     writePhpIni(home);

package/dist/guest/toolchains/languages/python-tools.js

@@ -1,4 +1,4 @@
-import { execAsync } from '../../runtime/process.js';
+import { execHeavy as execAsync } from '../../runtime/pools.js';
 import { exists } from '../../runtime/fs.js';
 import { tool } from '../tool-env.js';
 import { installOnce } from '../package-ledger.js';

package/dist/guest/toolchains/languages/ruby.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { downloader, fetchJson } from '../../../shared/download/index.js';
 import { SYSTEM } from '../../../shared/system.js';
 import { dryRun } from '../../runtime/paths.js';
-import { execAsync } from '../../runtime/process.js';
+import { execHeavy as execAsync } from '../../runtime/pools.js';
 import { exists } from '../../runtime/fs.js';
 import { log } from '../../runtime/log.js';
 import { installOnce } from '../package-ledger.js';

package/dist/guest/toolchains/native/autosdk.d.ts

@@ -0,0 +1,3 @@
+import { type ToolEnv } from '../tool-env.js';
+/** Makes the AutoSDK tree from the portable MSVC if it is missing for this MSVC and SDK, and points Unreal at it. */
+export declare function setupAutosdk(env: ToolEnv): Promise<void>;

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

@@ -0,0 +1,50 @@
+// Unreal without Visual Studio (toolchains.unreal.visualStudio = "autosdk", experimental): an AutoSDK tree made from
+// the portable MSVC (tools\msvc), at tools\unreal\autosdk, which UnrealBuildTool finds through UE_SDKS_ROOT. Made of
+// copies (mapped folders refuse links), once; kept between sandboxes. The editor's Visual Studio integration is not
+// available.
+import fs from 'node:fs';
+import path from 'node:path';
+import { z } from 'zod';
+import { writeJsonAtomic } from '../../../shared/io/json.js';
+import { robocopyFailed } from '../../../shared/io/robocopy-result.js';
+import { spawnAsync } from '../../../shared/download/index.js';
+import { SYSTEM } from '../../../shared/system.js';
+import { exists, mkdirp } from '../../runtime/fs.js';
+import { log } from '../../runtime/log.js';
+import { tool } from '../tool-env.js';
+import { hasCompiler, readInstalled, ROOT as MSVC_ROOT } from './msvc/tree.js';
+import { autosdkLayout } from './vs-request.js';
+const AUTOSDK_DIR = tool('unreal', 'autosdk');
+const MARKER = path.join(AUTOSDK_DIR, '.complete.json');
+const MarkerSchema = z.object({ msvc: z.string(), sdk: z.string() });
+function builtFor(msvc, sdk) {
+    try {
+        const done = MarkerSchema.parse(JSON.parse(fs.readFileSync(MARKER, 'utf8')));
+        return done.msvc === msvc && done.sdk === sdk;
+    }
+    catch {
+        return false; // No marker, or a half-written one: build again.
+    }
+}
+/** Makes the AutoSDK tree from the portable MSVC if it is missing for this MSVC and SDK, and points Unreal at it. */
+export async function setupAutosdk(env) {
+    const msvc = readInstalled();
+    if (!msvc || !hasCompiler(msvc.msvc))
+        throw new Error('toolchains.unreal.visualStudio = "autosdk" builds from the portable MSVC, which is not installed ' +
+            '(is toolchains.msvc off?)');
+    if (!builtFor(msvc.msvc, msvc.sdk)) {
+        log('Making the Unreal AutoSDK from MSVC ' + msvc.msvc + ' (~2 GB, once) ...');
+        fs.rmSync(MARKER, { force: true });
+        for (const pair of autosdkLayout(MSVC_ROOT, msvc.msvc, msvc.sdk, AUTOSDK_DIR)) {
+            mkdirp(pair.to);
+            const code = await spawnAsync(SYSTEM.robocopy(), [pair.from, pair.to, '/E', '/COPY:DAT', '/R:1', '/W:1', '/NP']);
+            if (robocopyFailed(code))
+                throw new Error('could not copy ' + pair.from + ' into the AutoSDK (robocopy ' + code + ')');
+        }
+        writeJsonAtomic(MARKER, { msvc: msvc.msvc, sdk: msvc.sdk });
+    }
+    if (!exists(MARKER))
+        throw new Error('the Unreal AutoSDK was not completed');
+    env.vars['UE_SDKS_ROOT'] = AUTOSDK_DIR;
+    env.summary.push('unreal autosdk: MSVC ' + msvc.msvc + ', Windows SDK ' + msvc.sdk + ' (UE_SDKS_ROOT=' + AUTOSDK_DIR + ')');
+}

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

@@ -2,7 +2,7 @@
 // published Windows build in seconds; only crates without one are compiled with `cargo install --locked`.
 import fs from 'node:fs';
 import path from 'node:path';
-import { execAsync } from '../../runtime/process.js';
+import { execHeavy as execAsync } from '../../runtime/pools.js';
 import { exists } from '../../runtime/fs.js';
 import { log, warn } from '../../runtime/log.js';
 import { errMsg } from '../../../core/util/errors.js';

package/dist/guest/toolchains/native/msvc/packages.js

@@ -6,7 +6,7 @@ import path from 'node:path';
 import { downloader, extractArchive, fetchJson } from '../../../../shared/download/index.js';
 import { safeRemove } from '../../../../shared/io/safe-remove.js';
 import { system32 } from '../../../../shared/system.js';
-import { execAsync } from '../../../runtime/process.js';
+import { runInstallerChecked } from '../../../runtime/pools.js';
 import { exists, mkdirp } from '../../../runtime/fs.js';
 import { log } from '../../../runtime/log.js';
 import { msiCabs, pickMsvcVersion, pickWindowsSdk } from '../../../../core/detect/versions.js';
@@ -93,9 +93,15 @@ const unpackVsix = async (vsix, work) => {
 const unpackMsi = async (msi) => {
     const logFile = msi + '.log';
     try {
-        await execAsync(system32('msiexec.exe'), ['/a', msi, '/quiet', '/qn', 'TARGETDIR=' + ROOT, '/l*v', logFile], {
-            stdio: 'ignore',
-        });
+        await runInstallerChecked(system32('msiexec.exe'), [
+            '/a',
+            msi,
+            '/quiet',
+            '/qn',
+            'TARGETDIR=' + ROOT,
+            '/l*v',
+            logFile,
+        ]);
     }
     catch (e) {
         const lines = exists(logFile)

package/dist/guest/toolchains/native/rust.d.ts

@@ -1,3 +1,5 @@
 import type { Toolchains } from '../../../core/types.js';
 import { type ToolEnv } from '../tool-env.js';
+/** rustup-init.exe (the small installer; the toolchain itself downloads when it runs), kept with Rust's tools. */
+export declare function fetchRustupInit(): Promise<void>;
 export declare function setupRust(env: ToolEnv, config: Toolchains['rust'], refresh: boolean): Promise<void>;

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

@@ -1,7 +1,7 @@
 // Rust: rustup + cargo, with crates installed prebuilt where possible (binstall.ts).
 import path from 'node:path';
 import { dryRun } from '../../runtime/paths.js';
-import { execAsync } from '../../runtime/process.js';
+import { execHeavy as execAsync } from '../../runtime/pools.js';
 import { exists } from '../../runtime/fs.js';
 import { log } from '../../runtime/log.js';
 import { arch, tool, versionOf } from '../tool-env.js';
@@ -9,6 +9,15 @@ import { downloadFile } from '../install.js';
 import { installOnce } from '../package-ledger.js';
 import { crateInstaller } from './binstall.js';
 import { installedMsvcEnv } from './msvc/index.js';
+/** rustup-init.exe (the small installer; the toolchain itself downloads when it runs), kept with Rust's tools. */
+export async function fetchRustupInit() {
+    const init = tool('rust', 'rustup-init.exe');
+    if (exists(init) || exists(path.join(tool('rust', 'cargo'), 'bin', 'rustup.exe')))
+        return;
+    await downloadFile('https://static.rust-lang.org/rustup/dist/' +
+        (arch === 'arm64' ? 'aarch64' : 'x86_64') +
+        '-pc-windows-msvc/rustup-init.exe', init);
+}
 export async function setupRust(env, config, refresh) {
     const RUSTUP_HOME = tool('rust', 'rustup');
     const CARGO_HOME = tool('rust', 'cargo');
@@ -21,9 +30,7 @@ export async function setupRust(env, config, refresh) {
     if (!exists(rustup)) {
         const init = tool('rust', 'rustup-init.exe');
         log('Installing Rust with rustup (~300 MB once; the toolchain downloads after rustup itself) ...');
-        await downloadFile('https://static.rust-lang.org/rustup/dist/' +
-            (arch === 'arm64' ? 'aarch64' : 'x86_64') +
-            '-pc-windows-msvc/rustup-init.exe', init);
+        await fetchRustupInit();
         await execAsync(init, [
             '-y',
             '--no-modify-path',

package/dist/guest/toolchains/native/unreal.d.ts

@@ -2,4 +2,6 @@ import type { Toolchains } from '../../../core/types.js';
 import type { ToolCtx } from '../step.js';
 import { type ToolEnv } from '../tool-env.js';
 export { UNREAL_COMPONENTS } from './vs-request.js';
+/** Downloads the DirectX redistributable ahead of the install (only once the licence is accepted). */
+export declare function fetchDirectX(config: Toolchains['unreal']): Promise<void>;
 export declare function setupUnreal(env: ToolEnv, config: Toolchains['unreal'], ctx: ToolCtx): Promise<void>;

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

@@ -4,7 +4,7 @@
 // (visual-studio.ts), which the plan runs first. The engine itself comes from the Epic Games Launcher or its source.
 import os from 'node:os';
 import path from 'node:path';
-import { spawnAsync } from '../../../shared/download/index.js';
+import { runInstaller } from '../../runtime/pools.js';
 import { safeRemove } from '../../../shared/io/safe-remove.js';
 import { dryRun } from '../../runtime/paths.js';
 import { exists, mkdirp } from '../../runtime/fs.js';
@@ -12,21 +12,32 @@ import { log } from '../../runtime/log.js';
 import { setupUnrealEngines } from '../engines/unreal-engines.js';
 import { SIGNERS, signedInstaller } from '../installers.js';
 import { tool } from '../tool-env.js';
+import { setupAutosdk } from './autosdk.js';
 import { installedVs } from './visual-studio.js';
 export { UNREAL_COMPONENTS } from './vs-request.js';
 const DIRECTX_URL = 'https://download.microsoft.com/download/8/4/A/84A35BF1-DAFE-4AE8-82AF-AD2AE20B6B14/directx_Jun2010_redist.exe';
 /** The June 2010 DirectX End-User Runtime (D3DX, XAudio 2.7, XInput 1.3), which Epic lists for the engine. */
-async function installDirectX() {
+const directXInstalled = () => {
     const system32 = path.join(process.env.WINDIR ?? 'C:\\Windows', 'System32');
-    if (exists(path.join(system32, 'd3dx9_43.dll')) && exists(path.join(system32, 'XAudio2_7.dll')))
+    return exists(path.join(system32, 'd3dx9_43.dll')) && exists(path.join(system32, 'XAudio2_7.dll'));
+};
+/** The redistributable (downloaded once, signature checked). */
+const directXRedist = () => signedInstaller(DIRECTX_URL, path.join(tool('visualstudio'), 'directx_Jun2010_redist.exe'), 'the DirectX End-User Runtime (~95 MB once)', SIGNERS.microsoft);
+/** Downloads the DirectX redistributable ahead of the install (only once the licence is accepted). */
+export async function fetchDirectX(config) {
+    if (config.acceptLicense && !directXInstalled())
+        await directXRedist();
+}
+async function installDirectX() {
+    if (directXInstalled())
         return;
-    const redist = await signedInstaller(DIRECTX_URL, path.join(tool('visualstudio'), 'directx_Jun2010_redist.exe'), 'the DirectX End-User Runtime (~95 MB once)', SIGNERS.microsoft);
+    const redist = await directXRedist();
     const unpacked = path.join(os.tmpdir(), 'directx-redist');
     safeRemove(unpacked, os.tmpdir());
     mkdirp(unpacked);
-    if ((await spawnAsync(redist, ['/Q', '/T:' + unpacked])) !== 0 || !exists(path.join(unpacked, 'DXSETUP.exe')))
+    if ((await runInstaller(redist, ['/Q', '/T:' + unpacked])) !== 0 || !exists(path.join(unpacked, 'DXSETUP.exe')))
         throw new Error('could not unpack the DirectX End-User Runtime');
-    const code = await spawnAsync(path.join(unpacked, 'DXSETUP.exe'), ['/silent']);
+    const code = await runInstaller(path.join(unpacked, 'DXSETUP.exe'), ['/silent']);
     safeRemove(unpacked, os.tmpdir());
     if (code !== 0)
         throw new Error('the DirectX End-User Runtime installer failed (exit ' + code + ')');
@@ -39,6 +50,8 @@ export async function setupUnreal(env, config, ctx) {
         return;
     }
     await installDirectX();
+    if (config.visualStudio === 'autosdk')
+        await setupAutosdk(env);
     await setupUnrealEngines(env, config, ctx);
     const vs = installedVs();
     env.summary.push('unreal: ' +

package/dist/guest/toolchains/native/vcruntime.d.ts

@@ -1,7 +1,6 @@
 import { type ToolEnv } from '../tool-env.js';
-export declare const MICROSOFT_SIGNER = "CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US";
-/** The subject of a valid Authenticode signature, or '' when the file is unsigned or tampered with. */
-export declare const signerOf: (file: string) => string;
+/** Downloads the installer ahead of `setupVcRuntime` (nothing when the runtime or the installer is there). */
+export declare function fetchVcRuntime(): Promise<void>;
 /**
  * A real installer (it writes to System32), so it runs on every boot; the installer itself is kept in persistent
  * storage and only run when Microsoft's signature on it checks out. Resolves true when this call ran the installer.

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

@@ -1,19 +1,24 @@
 // The Visual C++ runtime (vcruntime140.dll & co.) that PHP and other native tools need.
 import fs from 'node:fs';
 import path from 'node:path';
-import { spawnAsync } from '../../../shared/download/index.js';
+import { runInstaller } from '../../runtime/pools.js';
 import { dryRun } from '../../runtime/paths.js';
-import { scriptOutput } from '../../runtime/process.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 { tool } from '../tool-env.js';
 const VC_REDIST = 'https://aka.ms/vs/17/release/vc_redist.x64.exe';
-export const MICROSOFT_SIGNER = 'CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US';
 /** 1638: a newer version is already installed; 3010: installed, a restart would finish it (not needed for the DLLs). */
 const OK_EXIT_CODES = [0, 1638, 3010];
-/** The subject of a valid Authenticode signature, or '' when the file is unsigned or tampered with. */
-export const signerOf = (file) => scriptOutput('get-signer.ps1', ['-Path', file]).trim();
+/** Downloads the installer ahead of `setupVcRuntime` (nothing when the runtime or the installer is there). */
+export async function fetchVcRuntime() {
+    const system32 = path.join(process.env.WINDIR ?? 'C:\\Windows', 'System32');
+    const installer = tool('vcredist', 'vc_redist.x64.exe');
+    if (exists(installer) || exists(path.join(system32, 'vcruntime140.dll')))
+        return;
+    await downloadFile(VC_REDIST, installer);
+}
 /**
  * A real installer (it writes to System32), so it runs on every boot; the installer itself is kept in persistent
  * storage and only run when Microsoft's signature on it checks out. Resolves true when this call ran the installer.
@@ -32,12 +37,12 @@ export async function setupVcRuntime(env, summary = true) {
             log('Downloading the Visual C++ runtime (~25 MB once) ...');
             await downloadFile(VC_REDIST, installer);
         }
-        if (signerOf(installer) !== MICROSOFT_SIGNER) {
+        if (!signedBy(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)');
         }
         log('Installing the Visual C++ runtime ...');
-        const code = await spawnAsync(installer, ['/install', '/quiet', '/norestart']);
+        const code = await runInstaller(installer, ['/install', '/quiet', '/norestart']);
         if (!OK_EXIT_CODES.includes(code ?? -1) || !exists(path.join(system32, 'vcruntime140.dll')))
             throw new Error('the Visual C++ runtime installer failed (exit ' + code + ')');
     }

package/dist/guest/toolchains/native/visual-studio.d.ts

@@ -1,14 +1,17 @@
 import { type ToolEnv } from '../tool-env.js';
-import type { VsRequest } from './vs-request.js';
-export { BUILD_TOOLS_COMPONENTS, UNREAL_COMPONENTS, visualStudioWanted, type VsRequest } from './vs-request.js';
+import { type VsRequest } from './vs-request.js';
+export { BUILD_TOOLS_COMPONENTS, UNREAL_COMPONENTS, unrealUsesAutosdk, visualStudioWanted, type VsRequest, } from './vs-request.js';
 /** The newest Visual Studio (or Build Tools) with the C++ compiler: its folder and version, or null. */
 export declare function installedVs(): {
     path: string;
     version: string;
 } | null;
+/** Downloads the bootstrapper now, so the install later starts without waiting for it. */
+export declare function prefetchVisualStudio(req: VsRequest): Promise<void>;
 /** Visual Studio as asked for: installed at boot when it is not there yet; its folder and version. */
 export declare function ensureVisualStudio(env: ToolEnv, req: VsRequest, o: {
     keepInstallFiles: boolean;
+    lowPriority?: boolean;
 }): Promise<{
     path: string;
     version: string;

package/dist/guest/toolchains/native/visual-studio.js

@@ -9,16 +9,23 @@ import os from 'node:os';
 import path from 'node:path';
 import { z } from 'zod';
 import { spawnAsync } from '../../../shared/download/index.js';
+import { heavy, runInstaller } from '../../runtime/pools.js';
 import { writeJsonAtomic } from '../../../shared/io/json.js';
+import { robocopyFailed } from '../../../shared/io/robocopy-result.js';
+import { safeRemove } from '../../../shared/io/safe-remove.js';
+import { SYSTEM } from '../../../shared/system.js';
 import { execOutput } from '../../runtime/process.js';
 import { exists, mkdirp } from '../../runtime/fs.js';
 import { log, warn } from '../../runtime/log.js';
+import { logsDir } from '../../runtime/paths.js';
 import { duringSession } from '../../runtime/project-context.js';
+import { backgroundRunning } from '../../runtime/status.js';
 import { errMsg } from '../../../core/util/errors.js';
 import { SIGNERS, signedInstaller } from '../installers.js';
 import { assertLocalRoom, freeBytes } from '../persisted.js';
 import { tool } from '../tool-env.js';
-export { BUILD_TOOLS_COMPONENTS, UNREAL_COMPONENTS, visualStudioWanted } from './vs-request.js';
+import { LAYOUT_STAGING_BYTES, layoutNextStep, STAGING_RESERVE_BYTES, vsExitText, } from './vs-request.js';
+export { BUILD_TOOLS_COMPONENTS, UNREAL_COMPONENTS, unrealUsesAutosdk, visualStudioWanted, } from './vs-request.js';
 const BOOTSTRAPPERS = {
     community: {
         url: 'https://aka.ms/vs/17/release/vs_community.exe',
@@ -63,8 +70,63 @@ export function installedVs() {
 function layoutDir(product) {
     return path.join(VS_DIR, product === 'community' ? 'layout' : 'layout-buildtools');
 }
+/** The layout arguments of the bootstrapper (the same for the data disk and the staging folder). */
+const layoutArgs = (req, folder) => [
+    '--layout',
+    folder,
+    '--lang',
+    'en-US',
+    '--quiet',
+    '--wait',
+    ...req.components.flatMap((id) => ['--add', id]),
+];
+/** The bootstrapper's newest log (dd_bootstrapper_*.log) in these folders, or null. */
+function newestBootstrapperLog(folders) {
+    const logs = folders.flatMap((dir) => {
+        try {
+            return fs
+                .readdirSync(dir)
+                .filter((n) => /^dd_bootstrapper_.*\.log$/i.test(n))
+                .map((n) => path.join(dir, n));
+        }
+        catch {
+            return []; // The folder is not there: no log in it.
+        }
+    });
+    const stamp = (f) => {
+        try {
+            return fs.statSync(f).mtimeMs;
+        }
+        catch {
+            return 0; // Gone since the listing.
+        }
+    };
+    return logs.sort((x, y) => stamp(y) - stamp(x))[0] ?? null;
+}
+/** Says why the layout failed and keeps the installer's log where the sandbox's logs are. */
+function reportLayoutFailure(code, temps) {
+    warn('Visual Studio: saving the install files failed (exit ' + code + '): ' + vsExitText(code));
+    const found = newestBootstrapperLog(temps);
+    if (!found)
+        return;
+    const kept = path.join(logsDir, 'vs-layout-' + new Date().toISOString().slice(0, 10) + '.log');
+    try {
+        fs.mkdirSync(logsDir, { recursive: true });
+        fs.copyFileSync(found, kept);
+        warn('Visual Studio: the installer log is ' + found + ' (a copy is in ' + kept + ')');
+    }
+    catch (e) {
+        warn('Visual Studio: the installer log is ' + found + ' (could not copy it: ' + errMsg(e) + ')');
+    }
+}
+/** Copies a finished layout onto the data disk (never /MOV: mapped folders refuse rename-over). */
+async function copyLayout(from, to) {
+    mkdirp(to);
+    const code = await heavy.run(() => spawnAsync(SYSTEM.robocopy(), [from, to, '/E', '/COPY:DAT', '/R:1', '/W:1', '/MT:8', '/NP']));
+    return !robocopyFailed(code);
+}
 /** The offline copy's installer when it holds every component; made or completed when there is room. */
-async function layoutInstaller(req, bootstrapper) {
+async function layoutInstaller(req, bootstrapper, lowPriority) {
     const layout = layoutDir(req.product);
     const marker = path.join(layout, '.complete.json');
     const installer = path.join(layout, BOOTSTRAPPERS[req.product].file);
@@ -79,6 +141,10 @@ async function layoutInstaller(req, bootstrapper) {
             return false;
         }
     };
+    const finish = () => {
+        writeJsonAtomic(marker, { components: [...req.components] });
+        return installer;
+    };
     if (has())
         return installer;
     if (freeBytes(mkdirp(VS_DIR)) < LAYOUT_ROOM_BYTES) {
@@ -87,45 +153,79 @@ async function layoutInstaller(req, bootstrapper) {
     }
     log('Saving the Visual Studio install files for later boots (~10 GB, once) ...');
     fs.rmSync(marker, { force: true });
-    const code = await spawnAsync(bootstrapper, [
-        '--layout',
-        layout,
-        '--lang',
-        'en-US',
-        '--quiet',
-        '--wait',
-        ...req.components.flatMap((id) => ['--add', id]),
-    ]);
-    if (!OK_EXIT_CODES.includes(code) || !exists(installer)) {
-        warn('Visual Studio: saving the install files failed (exit ' + code + '); downloading this boot');
+    // The installer crashes (0xE0434352) when it builds the layout in a mapped folder, so it is built on the sandbox's
+    // own disk and copied over. That runs before Visual Studio is installed and the copy on C: is deleted first, so it
+    // needs room for the layout only (STAGING_RESERVE_BYTES spare), not for the layout and the install together.
+    const drive = (process.env.SystemDrive ?? 'C:') + '\\';
+    if (layoutNextStep(null, freeBytes(drive), STAGING_RESERVE_BYTES) !== 'stage') {
+        warn('Visual Studio: less than ' +
+            Math.round((LAYOUT_STAGING_BYTES + STAGING_RESERVE_BYTES) / 1024 ** 3) +
+            ' GB free on ' +
+            drive +
+            ' to build the install files; downloading this boot');
         return null;
     }
-    writeJsonAtomic(marker, { components: [...req.components] });
-    return installer;
+    const staging = path.join(drive, 'vs-layout-staging');
+    log('Building the install files on ' + drive + ' and copying them to ' + layout + ' ...');
+    const stagedCode = await runInstaller(bootstrapper, layoutArgs(req, staging), { lowPriority });
+    const staged = path.join(staging, BOOTSTRAPPERS[req.product].file);
+    let kept = false;
+    if (OK_EXIT_CODES.includes(stagedCode) && exists(staged)) {
+        kept = await copyLayout(staging, layout);
+        if (!kept)
+            warn('Visual Studio: copying the install files to ' + layout + ' failed');
+    }
+    else {
+        reportLayoutFailure(stagedCode, [os.tmpdir()]);
+    }
+    safeRemove(staging, drive);
+    return kept && exists(installer) ? finish() : null;
 }
-async function install(req, keepInstallFiles) {
+/** The bootstrapper, downloaded (net pool) and checked; kept in tools\ for later boots. */
+function bootstrapperFor(req) {
     const boot = BOOTSTRAPPERS[req.product];
-    const bootstrapper = await signedInstaller(boot.url, path.join(VS_DIR, boot.file), 'the ' + boot.name + ' installer', SIGNERS.microsoft);
+    return signedInstaller(boot.url, path.join(VS_DIR, boot.file), 'the ' + boot.name + ' installer', SIGNERS.microsoft);
+}
+/** Downloads the bootstrapper now, so the install later starts without waiting for it. */
+export async function prefetchVisualStudio(req) {
+    if (!req.accepted || installedVs())
+        return;
+    await bootstrapperFor(req);
+}
+async function install(req, keepInstallFiles, lowPriority) {
+    const boot = BOOTSTRAPPERS[req.product];
+    const bootstrapper = await bootstrapperFor(req);
     let installer = null;
     if (keepInstallFiles) {
         try {
-            installer = await layoutInstaller(req, bootstrapper);
+            installer = await layoutInstaller(req, bootstrapper, lowPriority);
         }
         catch (e) {
             warn('Visual Studio: the offline copy failed (' + errMsg(e) + '); downloading this boot');
         }
     }
-    log('Installing ' + boot.name + (installer ? ' from the saved install files' : ' (downloads ~5-8 GB)') + ' ...');
-    const code = await spawnAsync(installer ?? bootstrapper, [
+    const run = (from, offline) => runInstaller(from, [
         '--quiet',
         '--wait',
         '--norestart',
         '--nocache',
-        ...(installer ? ['--noWeb'] : []),
+        ...(offline ? ['--noWeb'] : []),
         ...req.components.flatMap((id) => ['--add', id]),
-    ]);
+    ], { lowPriority });
+    log('Installing ' + boot.name + (installer ? ' from the saved install files' : ' (downloads ~5-8 GB)') + ' ...');
+    let code = await run(installer ?? bootstrapper, installer !== null);
+    if (installer && (!OK_EXIT_CODES.includes(code) || !installedVs())) {
+        // The saved copy is on the shared data disk: if installing from it fails, this boot downloads instead.
+        warn('Visual Studio: installing from the saved install files failed (' + vsExitText(code) + '); downloading');
+        code = await run(bootstrapper, false);
+    }
     if (!OK_EXIT_CODES.includes(code) || !installedVs())
-        throw new Error('the Visual Studio installer failed (exit ' + code + '); its logs are the dd_*.log files in ' + os.tmpdir());
+        throw new Error('the Visual Studio installer failed (exit ' +
+            code +
+            ': ' +
+            vsExitText(code) +
+            '); its logs are the dd_*.log files in ' +
+            os.tmpdir());
 }
 /** Visual Studio as asked for: installed at boot when it is not there yet; its folder and version. */
 export async function ensureVisualStudio(env, req, o) {
@@ -142,9 +242,11 @@ export async function ensureVisualStudio(env, req, o) {
     if (have)
         return have;
     if (duringSession())
-        throw new Error('Visual Studio is installed when the sandbox starts: restart it (sandbox restart) to get it');
+        throw new Error(backgroundRunning('Visual Studio')
+            ? 'Visual Studio is still installing in the background; it is ready in a few minutes'
+            : 'Visual Studio is installed when the sandbox starts: restart it (sandbox restart) to get it');
     assertLocalRoom(INSTALL_BYTES[req.product], BOOTSTRAPPERS[req.product].name);
-    await install(req, o.keepInstallFiles);
+    await install(req, o.keepInstallFiles, o.lowPriority === true);
     const vs = installedVs();
     env.summary.push('visual studio: ' +
         BOOTSTRAPPERS[req.product].name +

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

@@ -17,3 +17,26 @@ export interface VsRequest {
     readonly accepted: boolean;
 }
 export declare function visualStudioWanted(t: Toolchains, on?: (setting: boolean | 'auto', name: string) => boolean): VsRequest | null;
+/** Whether Unreal is on and builds from the portable MSVC through AutoSDK instead of Visual Studio. */
+export declare function unrealUsesAutosdk(t: Toolchains, on?: (setting: boolean | 'auto', name: string) => boolean): boolean;
+/** The Visual Studio installer's exit code in plain words (it is a uint32: -1 and 4294967295 are the same). */
+export declare function vsExitText(code: number): string;
+/** Room the staging copy of the layout needs on the sandbox's own disk, on top of the reserve. */
+export declare const LAYOUT_STAGING_BYTES: number;
+/** Spare room on the sandbox's disk while the layout is built there (before Visual Studio is installed). */
+export declare const STAGING_RESERVE_BYTES: number;
+/**
+ * What to do after the layout attempt in the data disk: 'done' when it worked, 'stage' (build it on the sandbox's
+ * own disk and copy it over) when it failed and that disk has room, 'skip' (download this boot) otherwise.
+ */
+export declare function layoutNextStep(exit: number | null, localFreeBytes: number, reserveBytes: number): 'done' | 'stage' | 'skip';
+export interface CopyPair {
+    readonly from: string;
+    readonly to: string;
+}
+/**
+ * The copies that make an Unreal AutoSDK tree from the portable MSVC (copies, not links: mapped folders refuse
+ * junctions): MSVC's tools into HostWin64\Win64\VS2022\<msvc> and the Windows SDK's Include, Lib and bin folders into
+ * HostWin64\Win64\Windows Kits\10. Pure.
+ */
+export declare function autosdkLayout(msvcRoot: string, msvc: string, sdk: string, autosdkRoot: string): CopyPair[];