windows-development-sandbox 1.23.1 → 1.25.0

package/dist/guest/toolchains/native/vs-persist.js

@@ -0,0 +1,256 @@
+// Visual Studio kept on the data disk (visual-studio.ts runs it): what is saved once after the real install, the marker
+// that says the saved copy is complete, and what a later boot puts back (a few copies and registry values) so the Setup
+// API, vswhere and vcvars find it again in seconds. The big folders (Visual Studio, the Windows SDK) stay on the data
+// disk and are registered where they are; the small ones that programs look for at fixed paths are copied back. Pure:
+// no runtime, so the self-test loads it.
+import path from 'node:path';
+import { z } from 'zod';
+const win = path.win32;
+/** The marker file in the saved copy's folder, written last. */
+export const MARKER_FILE = '.complete.json';
+/** The Setup Configuration COM class (vswhere and UnrealBuildTool find Visual Studio through it). */
+export const SETUP_CLSID = '{177F0C4A-1CD3-4DE7-A32C-71DBBB9FA36D}';
+const SETUP_DLL = 'Microsoft.VisualStudio.Setup.Configuration.Native.dll';
+/** A Visual Studio instance ID (8 hex digits in practice); never a path. */
+const INSTANCE_ID = /^[A-Za-z0-9]{1,64}$/;
+export function winPlaces(env) {
+    return {
+        programFiles: env.ProgramFiles ?? 'C:\\Program Files',
+        programFilesX86: env['ProgramFiles(x86)'] ?? 'C:\\Program Files (x86)',
+        programData: env.ProgramData ?? 'C:\\ProgramData',
+    };
+}
+export const FOLDER_NAMES = [
+    'Community',
+    'BuildTools',
+    'WindowsKits10',
+    'NETFXSDK',
+    'MicrosoftSDKs-v10.0A',
+    'ReferenceAssemblies',
+    'Installer',
+    'Shared',
+    'Setup',
+    'instance',
+];
+export function productFolder(product) {
+    return product === 'community' ? 'Community' : 'BuildTools';
+}
+/** The instances folder of the Visual Studio installer (one subfolder per instance ID). */
+export function instancesDir(places) {
+    return win.join(places.programData, 'Microsoft', 'VisualStudio', 'Packages', '_Instances');
+}
+/** Every folder a Visual Studio install spreads over, and what a boot does with each. */
+export function persistFolders(vs, places) {
+    if (!INSTANCE_ID.test(vs.instanceId))
+        throw new Error('"' + vs.instanceId + '" is not a Visual Studio instance ID');
+    const x86 = places.programFilesX86;
+    const one = (name, source, restore, optional = false) => ({
+        name,
+        source,
+        restore,
+        optional,
+    });
+    return [
+        one(productFolder(vs.product), vs.installationPath, 'stay'),
+        one('WindowsKits10', win.join(x86, 'Windows Kits', '10'), 'stay'),
+        one('NETFXSDK', win.join(x86, 'Windows Kits', 'NETFXSDK'), 'stay', true),
+        one('MicrosoftSDKs-v10.0A', win.join(x86, 'Microsoft SDKs', 'Windows', 'v10.0A'), 'stay', true),
+        // MSBuild looks for the .NET Framework reference assemblies at this fixed path.
+        one('ReferenceAssemblies', win.join(x86, 'Reference Assemblies', 'Microsoft', 'Framework', '.NETFramework'), 'copy-missing', true),
+        // Scripts and build tools look for vswhere here; the instance's state names setup.exe here too (144 MB).
+        one('Installer', win.join(x86, 'Microsoft Visual Studio', 'Installer'), 'copy'),
+        one('Shared', win.join(x86, 'Microsoft Visual Studio', 'Shared'), 'copy', true),
+        one('Setup', win.join(places.programData, 'Microsoft', 'VisualStudio', 'Setup'), 'copy'),
+        one('instance', win.join(instancesDir(places), vs.instanceId), 'copy'),
+    ];
+}
+export const RegEntrySchema = z.strictObject({
+    view: z.enum(['64', '32']),
+    /** Under HKLM, e.g. SOFTWARE\Microsoft\Microsoft SDKs\Windows\v10.0 (the view picks WOW6432Node). */
+    key: z.string().min(1).max(400),
+    /** '' is the default value. */
+    name: z.string().max(200),
+    kind: z.enum(['string', 'expand', 'dword']),
+    value: z.union([z.string().max(2000), z.number().int()]),
+});
+/** The registry values that point at the saved folders, read in both views at capture time. */
+export const REGISTRY_READS = [
+    { key: 'SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots', names: ['KitsRoot10'], recurse: false },
+    { key: 'SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v10.0', names: null, recurse: false },
+    { key: 'SOFTWARE\\Microsoft\\Microsoft SDKs\\NETFXSDK', names: null, recurse: true },
+    { key: 'SOFTWARE\\Microsoft\\VisualStudio\\Setup', names: null, recurse: false },
+];
+const VIEWS = ['64', '32'];
+export const VsPersistMarkerSchema = z.strictObject({
+    product: z.enum(['community', 'buildtools']),
+    /** The installed version (17.14.37827.9). */
+    version: z.string().min(1).max(100),
+    /** The component IDs it was installed with. */
+    components: z.array(z.string().max(200)).max(500),
+    instanceId: z.string().regex(INSTANCE_ID),
+    /** Where the installer put it (the paths in its state and the registry are rewritten from this). */
+    installationPath: z.string().min(3).max(400),
+    /** The Windows SDK's ProductVersion (10.0.22621), '' when there is none. */
+    sdkVersion: z.string().max(50),
+    folders: z.array(z.enum(FOLDER_NAMES)).max(FOLDER_NAMES.length),
+    /** The registry values as the installer wrote them (paths on C:). */
+    registry: z.array(RegEntrySchema).max(500),
+    capturedAt: z.string().max(50),
+});
+/** What save-visual-studio.ps1 writes to its result file. */
+export const SaveResultSchema = z.strictObject({
+    copied: z.array(z.enum(FOLDER_NAMES)).max(FOLDER_NAMES.length),
+    registry: z.array(RegEntrySchema).max(500),
+});
+/** Without these a saved copy is not usable (the product, its instance, the Setup API, vswhere, the SDK). */
+const needed = (product) => [
+    productFolder(product),
+    'instance',
+    'Setup',
+    'Installer',
+    'WindowsKits10',
+];
+/**
+ * Whether the saved copy serves this request: the same product with every component, or Community for a Build Tools
+ * request (it holds the same C++ parts; only the workload IDs differ).
+ */
+export function persistCovers(marker, req) {
+    const same = marker.product === req.product;
+    if (!same && !(marker.product === 'community' && req.product === 'buildtools'))
+        return false;
+    if (!needed(marker.product).every((f) => marker.folders.includes(f)))
+        return false;
+    const have = new Set(marker.components.map((c) => c.toLowerCase()));
+    return req.components.filter((id) => same || !/\.workload\./i.test(id)).every((id) => have.has(id.toLowerCase()));
+}
+/** A string as it appears inside a JSON string (backslashes doubled). */
+const jsonEscaped = (s) => JSON.stringify(s).slice(1, -1);
+/**
+ * The instance's state.json with every mention of the install folder (JSON-escaped, any case) moved to `to`. A longer
+ * folder name that only starts the same (Community2) is left alone.
+ */
+export function rewriteInstanceState(text, from, to) {
+    const needle = jsonEscaped(win.normalize(from).replace(/\\+$/, ''));
+    const replacement = jsonEscaped(win.normalize(to).replace(/\\+$/, ''));
+    const lower = text.toLowerCase();
+    const find = needle.toLowerCase();
+    let out = '';
+    let at = 0;
+    for (let i = lower.indexOf(find); i !== -1; i = lower.indexOf(find, i + find.length)) {
+        const next = text.slice(i + find.length, i + find.length + 2);
+        if (next !== '\\\\' && !next.startsWith('"'))
+            continue;
+        out += text.slice(at, i) + replacement;
+        at = i + find.length;
+    }
+    return out + text.slice(at);
+}
+/** `value` with a saved folder's old place swapped for its place on the data disk (case-insensitive prefix). */
+export function rebase(value, moves) {
+    for (const move of moves) {
+        const from = move.from.replace(/\\+$/, '');
+        const lower = value.toLowerCase();
+        if (lower === from.toLowerCase() || lower.startsWith(from.toLowerCase() + '\\'))
+            return move.to.replace(/\\+$/, '') + value.slice(from.length);
+    }
+    return value;
+}
+/** Whether a registry value from the marker is one the capture reads (a tampered marker writes nothing else). */
+const allowed = (entry) => REGISTRY_READS.some((read) => {
+    const key = entry.key.toLowerCase();
+    const root = read.key.toLowerCase();
+    const under = key === root || (read.recurse && key.startsWith(root + '\\'));
+    return under && (read.names === null || read.names.some((n) => n.toLowerCase() === entry.name.toLowerCase()));
+});
+/** What the boot writes under HKLM: the saved values (paths moved to the data disk) in both views, the COM class. */
+export function registryPlan(marker, root, places) {
+    const folders = persistFolders(marker, places).filter((f) => marker.folders.includes(f.name));
+    const moves = folders
+        .filter((f) => f.restore === 'stay')
+        .map((f) => ({ from: f.source, to: win.join(root, f.name) }));
+    const values = new Map();
+    const put = (e) => {
+        values.set(e.key.toLowerCase() + '|' + e.name.toLowerCase(), e);
+    };
+    for (const e of marker.registry.filter(allowed))
+        put({
+            key: e.key,
+            name: e.name,
+            kind: e.kind,
+            value: typeof e.value === 'string' ? rebase(e.value, moves) : e.value,
+        });
+    if (marker.folders.includes('WindowsKits10')) {
+        const kits = win.join(root, 'WindowsKits10') + '\\';
+        const sdk = 'SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v10.0';
+        put({ key: 'SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots', name: 'KitsRoot10', kind: 'string', value: kits });
+        put({ key: sdk, name: 'InstallationFolder', kind: 'string', value: kits });
+        if (marker.sdkVersion)
+            put({ key: sdk, name: 'ProductVersion', kind: 'string', value: marker.sdkVersion });
+    }
+    const both = [...values.values()].flatMap((e) => VIEWS.map((view) => ({ view, ...e })));
+    const setup = win.join(places.programData, 'Microsoft', 'VisualStudio', 'Setup');
+    const com = (view, arch) => {
+        const key = 'SOFTWARE\\Classes\\CLSID\\' + SETUP_CLSID + '\\InprocServer32';
+        return [
+            { view, key, name: '', kind: 'string', value: win.join(setup, arch, SETUP_DLL) },
+            { view, key, name: 'ThreadingModel', kind: 'string', value: 'Both' },
+        ];
+    };
+    return [...both, ...com('64', 'x64'), ...com('32', 'x86')];
+}
+/** Compares dotted versions (17.14.37827.9) part by part, as numbers. */
+function compareVersions(a, b) {
+    const x = a.split('.').map((p) => parseInt(p, 10) || 0);
+    const y = b.split('.').map((p) => parseInt(p, 10) || 0);
+    for (let i = 0; i < Math.max(x.length, y.length); i++)
+        if ((x[i] ?? 0) !== (y[i] ?? 0))
+            return (x[i] ?? 0) - (y[i] ?? 0);
+    return 0;
+}
+/**
+ * The newest of the instances vswhere lists. Chosen here, not with vswhere's -latest, which fails outright (0x8000FFFF)
+ * when two instances have the same install date, as a copy of an instance does.
+ */
+export function newestInstance(instances) {
+    return ([...instances].sort((a, b) => compareVersions(b.installationVersion ?? '', a.installationVersion ?? ''))[0] ?? null);
+}
+/** The input of save-visual-studio.ps1: the folders to mirror onto the data disk and the registry values to read. */
+export function saveInput(vs, root, places, resultFile) {
+    return {
+        copies: persistFolders(vs, places).map((f) => ({
+            name: f.name,
+            from: f.source,
+            to: win.join(root, f.name),
+            optional: f.optional,
+        })),
+        registry: VIEWS.flatMap((view) => REGISTRY_READS.map((r) => ({ view, ...r }))),
+        resultFile,
+    };
+}
+/** The marker for a finished capture (written after the instance's state is rewritten). */
+export function markerFrom(req, vs, result, capturedAt) {
+    const sdk = result.registry.find((e) => /\\Microsoft SDKs\\Windows\\v10\.0$/i.test(e.key) && e.name.toLowerCase() === 'productversion');
+    return {
+        product: req.product,
+        version: vs.version,
+        components: [...req.components],
+        instanceId: vs.instanceId,
+        installationPath: vs.installationPath,
+        sdkVersion: typeof sdk?.value === 'string' ? sdk.value : '',
+        folders: [...result.copied],
+        registry: [...result.registry],
+        capturedAt,
+    };
+}
+/** The input of restore-visual-studio.ps1: the folders copied back to their fixed places, then the registry values. */
+export function restoreInput(marker, root, places) {
+    const copies = persistFolders(marker, places)
+        .filter((f) => f.restore !== 'stay' && marker.folders.includes(f.name))
+        .map((f) => ({
+        name: f.name,
+        from: win.join(root, f.name),
+        to: f.source,
+        mode: f.restore === 'copy-missing' ? 'missing' : 'all',
+    }));
+    return { copies, registry: registryPlan(marker, root, places) };
+}

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

@@ -1,12 +1,17 @@
 import type { Toolchains } from '../../../core/types.js';
 /**
  * What Epic lists for Unreal Engine 5 with Visual Studio 2022: the game workload, MSVC v143, a Windows SDK of
- * 10.0.18362 or newer, the C++ profiling tools, the .NET Framework targeting packs some engine tools build against,
+ * 10.0.22621 or newer, the C++ profiling tools, the .NET Framework targeting packs some engine tools build against,
  * Visual Studio's Unreal support and the Unreal Engine installer (the Epic Games Launcher).
  */
 export declare const UNREAL_COMPONENTS: readonly ["Microsoft.VisualStudio.Workload.NativeGame", "Microsoft.VisualStudio.Component.VC.Tools.x86.x64", "Microsoft.VisualStudio.Component.Windows11SDK.22621", "Microsoft.VisualStudio.Component.VC.DiagnosticTools", "Microsoft.Net.Component.4.6.2.TargetingPack", "Microsoft.Net.Component.4.8.SDK", "Component.Unreal.Ide", "Component.Unreal"];
 /** The Build Tools' C++ desktop parts: MSVC v143 and a Windows 11 SDK (Flutter desktop, Unity IL2CPP). */
 export declare const BUILD_TOOLS_COMPONENTS: readonly ["Microsoft.VisualStudio.Workload.VCTools", "Microsoft.VisualStudio.Component.VC.Tools.x86.x64", "Microsoft.VisualStudio.Component.Windows11SDK.22621"];
+/**
+ * Unreal on the Build Tools: what UnrealBuildTool needs (it finds them through the Setup API like Visual Studio):
+ * MSVC v143, the Windows SDK and the .NET Framework parts its tools build against. No IDE and no debugger.
+ */
+export declare const UNREAL_BUILD_TOOLS_COMPONENTS: readonly ["Microsoft.VisualStudio.Workload.VCTools", "Microsoft.VisualStudio.Component.VC.Tools.x86.x64", "Microsoft.VisualStudio.Component.Windows11SDK.22621", "Microsoft.Net.Component.4.6.2.TargetingPack", "Microsoft.Net.Component.4.8.SDK"];
 export interface VsRequest {
     readonly product: 'community' | 'buildtools';
     readonly components: readonly string[];
@@ -17,26 +22,5 @@ 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[];

package/dist/guest/toolchains/native/vs-request.js

@@ -1,11 +1,6 @@
-// Which Visual Studio this sandbox installs (a real installer: it runs every boot), from every toolchain that needs
-// one: Unreal (Community with the C++ game workload), Flutter's Windows desktop builds and Unity's Windows IL2CPP
-// builds (the Build Tools' C++ parts). Pure: no runtime, so the self-test loads it. Community holds everything the
-// Build Tools would add, so one install serves all of them.
-import path from 'node:path';
 /**
  * What Epic lists for Unreal Engine 5 with Visual Studio 2022: the game workload, MSVC v143, a Windows SDK of
- * 10.0.18362 or newer, the C++ profiling tools, the .NET Framework targeting packs some engine tools build against,
+ * 10.0.22621 or newer, the C++ profiling tools, the .NET Framework targeting packs some engine tools build against,
  * Visual Studio's Unreal support and the Unreal Engine installer (the Epic Games Launcher).
  */
 export const UNREAL_COMPONENTS = [
@@ -24,24 +19,34 @@ export const BUILD_TOOLS_COMPONENTS = [
     'Microsoft.VisualStudio.Component.VC.Tools.x86.x64',
     'Microsoft.VisualStudio.Component.Windows11SDK.22621',
 ];
+/**
+ * Unreal on the Build Tools: what UnrealBuildTool needs (it finds them through the Setup API like Visual Studio):
+ * MSVC v143, the Windows SDK and the .NET Framework parts its tools build against. No IDE and no debugger.
+ */
+export const UNREAL_BUILD_TOOLS_COMPONENTS = [
+    ...BUILD_TOOLS_COMPONENTS,
+    'Microsoft.Net.Component.4.6.2.TargetingPack',
+    'Microsoft.Net.Component.4.8.SDK',
+];
 /** Whether a toolchain is on (the host resolved "auto"; a session file that still says "auto" counts as off). */
 const isOn = (setting) => setting === true;
 export function visualStudioWanted(t, on = isOn) {
-    // Unreal with visualStudio "autosdk" needs no Visual Studio: it builds from the portable MSVC (autosdk.ts).
-    const unreal = on(t.unreal.enabled, 'unreal') && t.unreal.visualStudio === 'full';
+    const unreal = on(t.unreal.enabled, 'unreal');
     const flutter = on(t.flutter.enabled, 'flutter') && t.flutter.windowsDesktop;
     const unity = on(t.unity.enabled, 'unity') && t.unity.modules.includes('windows-il2cpp');
     const users = [...(unreal ? ['unreal'] : []), ...(flutter ? ['flutter'] : []), ...(unity ? ['unity'] : [])];
     if (!users.length)
         return null;
-    if (unreal)
+    if (unreal) {
+        const full = t.unreal.visualStudio === 'full';
         return {
-            product: 'community',
-            components: [...new Set([...UNREAL_COMPONENTS, ...t.unreal.components])],
+            product: full ? 'community' : 'buildtools',
+            components: [...new Set([...(full ? UNREAL_COMPONENTS : UNREAL_BUILD_TOOLS_COMPONENTS), ...t.unreal.components])],
             for: users,
             licence: 'toolchains.unreal.acceptLicense',
             accepted: t.unreal.acceptLicense,
         };
+    }
     return {
         product: 'buildtools',
         components: [...BUILD_TOOLS_COMPONENTS],
@@ -50,10 +55,6 @@ export function visualStudioWanted(t, on = isOn) {
         accepted: t.msvc.acceptLicense,
     };
 }
-/** Whether Unreal is on and builds from the portable MSVC through AutoSDK instead of Visual Studio. */
-export function unrealUsesAutosdk(t, on = isOn) {
-    return on(t.unreal.enabled, 'unreal') && t.unreal.visualStudio === 'autosdk';
-}
 /** The Visual Studio installer's exit code in plain words (it is a uint32: -1 and 4294967295 are the same). */
 export function vsExitText(code) {
     const c = code >>> 0;
@@ -74,34 +75,3 @@ export function vsExitText(code) {
             return 'the installer failed with exit ' + c + ' (0x' + c.toString(16).toUpperCase() + ')';
     }
 }
-/** Room the staging copy of the layout needs on the sandbox's own disk, on top of the reserve. */
-export const LAYOUT_STAGING_BYTES = 12 * 1024 ** 3;
-/** Spare room on the sandbox's disk while the layout is built there (before Visual Studio is installed). */
-export const STAGING_RESERVE_BYTES = 3 * 1024 ** 3;
-/**
- * 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 function layoutNextStep(exit, localFreeBytes, reserveBytes) {
-    if (exit !== null && (exit === 0 || exit === 3010))
-        return 'done';
-    return localFreeBytes >= LAYOUT_STAGING_BYTES + reserveBytes ? 'stage' : 'skip';
-}
-/**
- * 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 function autosdkLayout(msvcRoot, msvc, sdk, autosdkRoot) {
-    const win64 = path.win32.join(autosdkRoot, 'HostWin64', 'Win64');
-    return [
-        {
-            from: path.win32.join(msvcRoot, 'VC', 'Tools', 'MSVC', msvc),
-            to: path.win32.join(win64, 'VS2022', msvc),
-        },
-        ...['Include', 'Lib', 'bin'].map((part) => ({
-            from: path.win32.join(msvcRoot, 'Windows Kits', '10', part, sdk),
-            to: path.win32.join(win64, 'Windows Kits', '10', part, sdk),
-        })),
-    ];
-}

package/dist/guest/toolchains/plan.js

@@ -21,7 +21,7 @@ import { fetchPhp, setupPhp } from './languages/php.js';
 import { setupRuby } from './languages/ruby.js';
 import { fetchVcRuntime, setupVcRuntime } from './native/vcruntime.js';
 import { setupVscode } from './tools/vscode.js';
-import { ensureVisualStudio, prefetchVisualStudio, unrealUsesAutosdk, visualStudioWanted, } from './native/visual-studio.js';
+import { ensureVisualStudio, prefetchVisualStudio, visualStudioSaved, visualStudioWanted, } from './native/visual-studio.js';
 import { duringSession } from '../runtime/project-context.js';
 import { setupSteam } from './steam/steam.js';
 import { setupGodot } from './engines/godot.js';
@@ -42,8 +42,6 @@ export function plan(config, versions, o) {
     const android = wanted(config.android.enabled, 'android');
     // One Visual Studio for every toolchain that needs the real one (Unreal, Flutter desktop, Unity IL2CPP).
     const vs = visualStudioWanted(config, (setting, name) => wanted(setting, name));
-    // Unreal on the portable MSVC (AutoSDK) needs that MSVC even when nothing else asked for it.
-    const autosdk = unrealUsesAutosdk(config, (setting, name) => wanted(setting, name));
     const ctx = {
         refresh: o.refresh,
         pcInstalls: o.pcInstalls ?? { items: [] },
@@ -69,32 +67,30 @@ export function plan(config, versions, o) {
             enabled: wanted(config.cpp.enabled, 'cpp') || wanted(config.rust.enabled, 'rust'),
             install: (env) => setupCpp(env, config.cpp),
         },
-        // Visual Studio brings MSVC and the real vswhere: the portable MSVC (and its stand-in vswhere) stays out.
+        // Visual Studio brings MSVC and the real vswhere: the portable MSVC (and its stand-in vswhere) stays out. Only the
+        // first install goes to the background: a saved copy is back in seconds, before the agent starts.
         {
             name: 'Visual Studio',
             enabled: vs !== null,
             shared: true,
-            background: deferred,
+            background: deferred && !visualStudioSaved(vs),
             ...ahead(() => prefetchVisualStudio(vs)),
             install: async (env) => {
-                await ensureVisualStudio(env, vs, { keepInstallFiles: config.unreal.keepInstallFiles, lowPriority: deferred });
+                await ensureVisualStudio(env, vs, { lowPriority: deferred });
             },
         },
         {
             name: 'Unreal',
             enabled: unreal,
             shared: true,
-            after: ['Visual Studio', 'MSVC'],
+            after: ['Visual Studio'],
             ...ahead(() => fetchDirectX(config.unreal)),
             install: (env) => setupUnreal(env, config.unreal, ctx),
         },
         {
             name: 'MSVC',
-            enabled: (wanted(config.msvc.enabled, 'msvc') || (autosdk && config.msvc.enabled !== false)) && vs === null,
-            // The same Visual Studio licence terms, which Unreal's acceptLicense already names.
-            install: (env) => setupMsvc(env, autosdk
-                ? { ...config.msvc, acceptLicense: config.msvc.acceptLicense || config.unreal.acceptLicense }
-                : config.msvc),
+            enabled: wanted(config.msvc.enabled, 'msvc') && vs === null,
+            install: (env) => setupMsvc(env, config.msvc),
         },
         // Rust links with MSVC (msvc host) or MinGW's gcc (GNU host): whichever it uses goes first.
         {
@@ -167,10 +163,11 @@ export function plan(config, versions, o) {
         },
         { name: 'Ruby', enabled: wanted(config.ruby.enabled, 'ruby'), install: (env) => setupRuby(env, config.ruby) },
         // PHP installs the Visual C++ runtime itself: one installer at a time.
-        // Many apps (bat, delta, Neovim, most GUIs, your own programs) are built against it too.
+        // Many apps (bat, delta, Neovim, most GUIs, your own programs) are built against it too, and so is what Visual
+        // Studio builds: a Visual Studio put back from the data disk does not bring it, as its installer did.
         {
             name: 'Visual C++ runtime',
-            enabled: config.vcRuntime.enabled || apps,
+            enabled: config.vcRuntime.enabled || apps || vs !== null,
             shared: true,
             ...ahead(fetchVcRuntime),
             install: async (env) => {

package/dist/host/migrate/migrations/drop-vs-install-files.d.ts

@@ -0,0 +1,5 @@
+import type { Migration } from '../migration.js';
+import { type Json } from './config-file.js';
+/** The retired values in a config file. */
+export declare function retiredVsSettings(file: Json): string[][];
+export declare const dropVsInstallFiles: Migration;

package/dist/host/migrate/migrations/drop-vs-install-files.js

@@ -0,0 +1,34 @@
+// 1.24 keeps Visual Studio itself on the data disk, so two Unreal settings are gone: toolchains.unreal.keepInstallFiles
+// (the offline install files, which the installer never managed to make in a sandbox) and visualStudio "autosdk" (the
+// portable MSVC instead of Visual Studio, which nothing needs now that Visual Studio is put back in seconds). A config
+// file that still has them would no longer load: they are removed (the rest and the comments stay).
+import _ from 'lodash';
+import { readFileObject, removeValues } from './config-file.js';
+const KEEP_INSTALL_FILES = ['toolchains', 'unreal', 'keepInstallFiles'];
+const VISUAL_STUDIO = ['toolchains', 'unreal', 'visualStudio'];
+/** The retired values in a config file. */
+export function retiredVsSettings(file) {
+    return [
+        ...(_.has(file, KEEP_INSTALL_FILES) ? [KEEP_INSTALL_FILES] : []),
+        ...(_.get(file, VISUAL_STUDIO) === 'autosdk' ? [VISUAL_STUDIO] : []),
+    ];
+}
+export const dropVsInstallFiles = {
+    id: '2026-11-drop-vs-install-files',
+    introducedIn: '1.24.0',
+    scope: 'user',
+    needsIdleSandbox: false,
+    summary: 'Removes toolchains.unreal.keepInstallFiles and visualStudio "autosdk": Visual Studio is now kept on the data disk.',
+    applies(ctx) {
+        const file = readFileObject(ctx.configPath);
+        return file !== null && retiredVsSettings(file).length > 0;
+    },
+    touches(ctx) {
+        return ctx.configPath ? [ctx.configPath] : [];
+    },
+    async run(ctx, note) {
+        const parsed = readFileObject(ctx.configPath);
+        if (ctx.configPath && parsed)
+            removeValues(ctx.configPath, retiredVsSettings(parsed), 'No longer needed (Visual Studio is kept)', note);
+    },
+};

package/dist/host/migrate/registry.js

@@ -1,4 +1,10 @@
+import { dropVsInstallFiles } from './migrations/drop-vs-install-files.js';
 import { followMachineStorage } from './migrations/follow-machine-storage.js';
 import { pinStorageRoot } from './migrations/pin-storage-root.js';
 import { unpinConfigDefaults } from './migrations/unpin-config-defaults.js';
-export const MIGRATIONS = [unpinConfigDefaults, followMachineStorage, pinStorageRoot];
+export const MIGRATIONS = [
+    unpinConfigDefaults,
+    followMachineStorage,
+    pinStorageRoot,
+    dropVsInstallFiles,
+];