windows-development-sandbox 1.23.2 → 1.25.1

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

@@ -0,0 +1,189 @@
+import { z } from 'zod';
+import type { VsRequest } from './vs-request.js';
+/** The marker file in the saved copy's folder, written last. */
+export declare const MARKER_FILE = ".complete.json";
+/** The Setup Configuration COM class (vswhere and UnrealBuildTool find Visual Studio through it). */
+export declare const SETUP_CLSID = "{177F0C4A-1CD3-4DE7-A32C-71DBBB9FA36D}";
+/** The Windows folders an install uses (from the environment; the tests pass their own). */
+export interface WinPlaces {
+    readonly programFiles: string;
+    readonly programFilesX86: string;
+    readonly programData: string;
+}
+export declare function winPlaces(env: NodeJS.ProcessEnv): WinPlaces;
+export declare const FOLDER_NAMES: readonly ["Community", "BuildTools", "WindowsKits10", "NETFXSDK", "MicrosoftSDKs-v10.0A", "ReferenceAssemblies", "Installer", "Shared", "Setup", "instance"];
+export type FolderName = (typeof FOLDER_NAMES)[number];
+/**
+ * What a boot does with a saved folder: 'stay' on the data disk (registered there), 'copy' back to where it came from
+ * (programs look for it at a fixed path), or 'copy-missing': only the versions not there yet (the reference assemblies,
+ * where the .NET step may have put some).
+ */
+export type RestoreMode = 'stay' | 'copy' | 'copy-missing';
+export interface PersistFolder {
+    readonly name: FolderName;
+    /** Where the install put it. */
+    readonly source: string;
+    readonly restore: RestoreMode;
+    /** Not every install has it (the Build Tools without .NET parts): skipped when missing. */
+    readonly optional: boolean;
+}
+export declare function productFolder(product: VsRequest['product']): 'Community' | 'BuildTools';
+/** The instances folder of the Visual Studio installer (one subfolder per instance ID). */
+export declare function instancesDir(places: WinPlaces): string;
+/** Every folder a Visual Studio install spreads over, and what a boot does with each. */
+export declare function persistFolders(vs: {
+    readonly product: VsRequest['product'];
+    readonly installationPath: string;
+    readonly instanceId: string;
+}, places: WinPlaces): PersistFolder[];
+export declare const RegEntrySchema: z.ZodObject<{
+    view: z.ZodEnum<{
+        32: "32";
+        64: "64";
+    }>;
+    key: z.ZodString;
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        string: "string";
+        expand: "expand";
+        dword: "dword";
+    }>;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+}, z.core.$strict>;
+export type RegEntry = z.infer<typeof RegEntrySchema>;
+export interface RegRead {
+    readonly view: '64' | '32';
+    readonly key: string;
+    /** Only these values (null: every string and DWORD value). */
+    readonly names: readonly string[] | null;
+    readonly recurse: boolean;
+}
+/** The registry values that point at the saved folders, read in both views at capture time. */
+export declare const REGISTRY_READS: readonly Omit<RegRead, 'view'>[];
+export declare const VsPersistMarkerSchema: z.ZodObject<{
+    product: z.ZodEnum<{
+        buildtools: "buildtools";
+        community: "community";
+    }>;
+    version: z.ZodString;
+    components: z.ZodArray<z.ZodString>;
+    instanceId: z.ZodString;
+    installationPath: z.ZodString;
+    sdkVersion: z.ZodString;
+    folders: z.ZodArray<z.ZodEnum<{
+        Community: "Community";
+        BuildTools: "BuildTools";
+        WindowsKits10: "WindowsKits10";
+        NETFXSDK: "NETFXSDK";
+        "MicrosoftSDKs-v10.0A": "MicrosoftSDKs-v10.0A";
+        ReferenceAssemblies: "ReferenceAssemblies";
+        Installer: "Installer";
+        Shared: "Shared";
+        Setup: "Setup";
+        instance: "instance";
+    }>>;
+    registry: z.ZodArray<z.ZodObject<{
+        view: z.ZodEnum<{
+            32: "32";
+            64: "64";
+        }>;
+        key: z.ZodString;
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            string: "string";
+            expand: "expand";
+            dword: "dword";
+        }>;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    }, z.core.$strict>>;
+    capturedAt: z.ZodString;
+}, z.core.$strict>;
+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<{
+        Community: "Community";
+        BuildTools: "BuildTools";
+        WindowsKits10: "WindowsKits10";
+        NETFXSDK: "NETFXSDK";
+        "MicrosoftSDKs-v10.0A": "MicrosoftSDKs-v10.0A";
+        ReferenceAssemblies: "ReferenceAssemblies";
+        Installer: "Installer";
+        Shared: "Shared";
+        Setup: "Setup";
+        instance: "instance";
+    }>>;
+    registry: z.ZodArray<z.ZodObject<{
+        view: z.ZodEnum<{
+            32: "32";
+            64: "64";
+        }>;
+        key: z.ZodString;
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            string: "string";
+            expand: "expand";
+            dword: "dword";
+        }>;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SaveResult = z.infer<typeof SaveResultSchema>;
+/**
+ * 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 declare function persistCovers(marker: VsPersistMarker, req: Pick<VsRequest, 'product' | 'components'>): boolean;
+/**
+ * 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 declare function rewriteInstanceState(text: string, from: string, to: string): string;
+/** `value` with a saved folder's old place swapped for its place on the data disk (case-insensitive prefix). */
+export declare function rebase(value: string, moves: readonly {
+    from: string;
+    to: string;
+}[]): string;
+/** What the boot writes under HKLM: the saved values (paths moved to the data disk) in both views, the COM class. */
+export declare function registryPlan(marker: VsPersistMarker, root: string, places: WinPlaces): RegEntry[];
+/**
+ * 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 declare function newestInstance<T extends {
+    readonly installationVersion?: string;
+}>(instances: readonly T[]): T | null;
+export interface SaveCopy {
+    readonly name: FolderName;
+    readonly from: string;
+    readonly to: string;
+    readonly optional: boolean;
+}
+/** The input of save-visual-studio.ps1: the folders to mirror onto the data disk and the registry values to read. */
+export declare function saveInput(vs: {
+    readonly product: VsRequest['product'];
+    readonly installationPath: string;
+    readonly instanceId: string;
+}, root: string, places: WinPlaces, resultFile: string): {
+    copies: SaveCopy[];
+    registry: RegRead[];
+    resultFile: string;
+};
+/** The marker for a finished capture (written after the instance's state is rewritten). */
+export declare function markerFrom(req: Pick<VsRequest, 'product' | 'components'>, vs: {
+    readonly installationPath: string;
+    readonly instanceId: string;
+    readonly version: string;
+}, result: SaveResult, capturedAt: string): VsPersistMarker;
+export interface RestoreCopy {
+    readonly name: FolderName;
+    readonly from: string;
+    readonly to: string;
+    /** 'all': what differs is copied; 'missing': each subfolder only when the target has none. */
+    readonly mode: 'all' | 'missing';
+}
+/** The input of restore-visual-studio.ps1: the folders copied back to their fixed places, then the registry values. */
+export declare function restoreInput(marker: VsPersistMarker, root: string, places: WinPlaces): {
+    copies: RestoreCopy[];
+    registry: RegEntry[];
+};

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,30 +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. The layout of the Unreal
- * components is about the size of their download (5-8 GB); the sandbox's ~40 GB disk has about 14 GB free at boot
- * (a fixed paging file takes 16 GB), so the estimate must stay under that. A layout that outgrows it fails cleanly.
- */
-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,38 +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. The layout of the Unreal
- * components is about the size of their download (5-8 GB); the sandbox's ~40 GB disk has about 14 GB free at boot
- * (a fixed paging file takes 16 GB), so the estimate must stay under that. A layout that outgrows it fails cleanly.
- */
-export const LAYOUT_STAGING_BYTES = 8 * 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 = 1.5 * 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),
-        })),
-    ];
-}