windows-development-sandbox 1.23.2 → 1.25.0

package/dist/selftest/guest-boot.test.js

@@ -34,7 +34,13 @@ export const guestBootSuite = {
         ];
         const headers = [1, 2, 3, 4, 5, 6, 7, 8, 9].map((n) => boot.out.indexOf('[' + n + '/9] '));
         t.check(headers.every((at, i) => at >= 0 && (i === 0 || at > headers[i - 1])), 'the boot prints its nine stages, [1/9] to [9/9], in order', headers.join(', '));
-        t.check(boot.out.includes('Boot ready in ') && boot.out.includes('] Developer tools: done in '), 'the boot says how long it took and how long each task took');
+        t.check(/^Ready in \d+\.\ds/m.test(boot.out) && /^\[3\/9\] Developer tools +\d+\.\ds$/m.test(boot.out), 'the boot says how long it took and how long each stage took', boot.out);
+        const tools = boot.out.indexOf('\nTools\n');
+        t.check(!boot.out.includes(': started') &&
+            !/^\s*[A-Z][\w -]+ \| /m.test(boot.out) &&
+            !boot.out.includes('\x1b[') &&
+            tools > headers[8] &&
+            /\n {2}gh {2,}off \(not listed in toolchains\.cli\)\n/.test(boot.out.slice(tools)), 'the dry run prints plain lines: no per-task lines, no prefixes, no colours; the tool list once, after the stages', boot.out);
         t.equal(steps.filter((s) => !boot.out.includes(s)), [], 'the guest provisions every enabled toolchain');
         t.check(boot.out.includes('AgentSandbox-Block-Private') &&
             boot.out.includes('remoteport=1-52,54-65535') &&

package/dist/selftest/index.js

@@ -80,6 +80,7 @@ import { uiTextSuite } from './ui-text.test.js';
 import { menuCoverageSuite } from './menu-coverage.test.js';
 import { auditSuite } from './audit.test.js';
 import { bootRunnerSuite } from './boot-runner.test.js';
+import { bootConsoleSuite } from './boot-console.test.js';
 import { layoutSuite } from './layout.test.js';
 import { menuSuite } from './menu.test.js';
 import { menuPerfSuite } from './menu-perf.test.js';
@@ -133,6 +134,7 @@ export const SUITES = [
     // pure helpers and the command line
     layoutSuite,
     bootRunnerSuite,
+    bootConsoleSuite,
     toolchainsSuite,
     persistedInstallsSuite,
     steamSuite,

package/dist/selftest/layout.test.js

@@ -19,6 +19,8 @@ const PURE_GUEST = [
     'guest/boot/project-env.js',
     'guest/boot/runner.js',
     'guest/boot/graph.js',
+    'guest/boot/progress-view.js',
+    'guest/runtime/log-line.js',
     'guest/toolchains/split.js',
     'guest/toolchains/step-scheduler.js',
     'guest/audit/parse.js',
@@ -30,6 +32,8 @@ const PURE_GUEST = [
     'guest/governor/decide.js',
     'guest/governor/core.js',
     'guest/daemon/live-folders.js',
+    'guest/toolchains/native/vs-request.js',
+    'guest/toolchains/native/vs-persist.js',
 ];
 const SIDE_EFFECTS = ['guest/runtime/session.js', 'guest/runtime/log.js'];
 const readModules = (dist) => {

package/dist/selftest/migrate.test.js

@@ -159,6 +159,27 @@ export const migrateSuite = {
         finally {
             fs.rmSync(machineFile);
         }
+        t.section('drop-vs-install-files');
+        const dropVs = MIGRATIONS.find((m) => m.id === '2026-11-drop-vs-install-files');
+        if (!dropVs)
+            return t.check(false, 'the drop-vs-install-files migration exists');
+        const oldVs = t.write(t.at('vs', 'old.json'), '// mine\n' +
+            JSON.stringify({
+                toolchains: { unreal: { enabled: true, keepInstallFiles: true, visualStudio: 'autosdk', components: ['X'] } },
+            }));
+        const fullVs = t.write(t.at('vs', 'full.json'), JSON.stringify({ toolchains: { unreal: { visualStudio: 'full' } } }));
+        const vsNotes = [];
+        const vsWanted = dropVs.applies(ctx(t.at('vs'), oldVs)) && !dropVs.applies(ctx(t.at('vs'), fullVs));
+        await dropVs.run(ctx(t.at('vs'), oldVs), (line) => vsNotes.push(line));
+        const vsAfter = parse(readText(oldVs));
+        t.check(vsWanted &&
+            vsAfter.toolchains.unreal.keepInstallFiles === undefined &&
+            vsAfter.toolchains.unreal.visualStudio === undefined &&
+            vsAfter.toolchains.unreal.enabled === true &&
+            readText(oldVs).includes('// mine') &&
+            vsNotes.join().includes('toolchains.unreal.keepInstallFiles') &&
+            loadConfig(oldVs).config.toolchains.unreal.visualStudio === 'full' &&
+            !dropVs.applies(ctx(t.at('vs'), oldVs)), 'the retired Visual Studio settings are removed (a chosen "full" stays), the file loads again, and it is idempotent');
         t.section('sandbox migrate');
         const cmdUser = t.dir('cmd-user');
         const cmdConfig = t.write(t.at('cmd-user', 'config.json'), JSON.stringify({ ...JSON.parse(JSON.stringify(old.defaults)), sandbox: { memoryMb: 4096 } }, null, 2));

package/dist/selftest/persisted-installs.test.js

@@ -1,12 +1,13 @@
 // Large installs kept between sandboxes (guest/toolchains/persisted.ts): the staging folder and its TEMP, the marker,
 // the refusal when the disk is short (an injected statfs), keeping only keepVersions, the records `sandbox data`
-// reads, and which Visual Studio the toolchains ask for (vs-request.ts). Temp folders only.
+// reads, which Visual Studio the toolchains ask for (vs-request.ts), and how it is saved on the data disk and put
+// back (vs-persist.ts: folders, marker, instance state, registry). Temp folders only.
 import fs from 'node:fs';
 import path from 'node:path';
 import { DEFAULTS } from '../core/config/index.js';
 import { assertLocalRoom, ensurePersisted, installRecords, InstallRecordsSchema, LOCAL_RESERVE_BYTES, recordUse, } from '../guest/toolchains/persisted.js';
-import { BUILD_TOOLS_COMPONENTS, UNREAL_COMPONENTS, visualStudioWanted, } from '../guest/toolchains/native/vs-request.js';
-import { autosdkLayout, layoutNextStep, STAGING_RESERVE_BYTES, unrealUsesAutosdk, vsExitText, } from '../guest/toolchains/native/vs-request.js';
+import { BUILD_TOOLS_COMPONENTS, UNREAL_BUILD_TOOLS_COMPONENTS, UNREAL_COMPONENTS, visualStudioWanted, vsExitText, } from '../guest/toolchains/native/vs-request.js';
+import { markerFrom, newestInstance, persistCovers, rebase, registryPlan, restoreInput, rewriteInstanceState, SaveResultSchema, saveInput, SETUP_CLSID, VsPersistMarkerSchema, } from '../guest/toolchains/native/vs-persist.js';
 import { freeBytesAt } from '../shared/io/disk.js';
 import { SIGNERS, signerMatches } from '../shared/signer.js';
 import { decideToolchains } from '../core/detect/toolchains.js';
@@ -17,7 +18,7 @@ import { collectDataEntries } from '../cli/services/data-collect.js';
 const GB = 1024 ** 3;
 export const persistedInstallsSuite = {
     name: 'persisted-installs',
-    title: 'large persisted installs: staging, marker, room checks, pruning, records; the Visual Studio request',
+    title: 'large persisted installs: staging, marker, room checks, pruning, records; Visual Studio: request, save, restore',
     run: async (t) => {
         t.section('installing a version');
         const tools = t.dir('persisted-tools');
@@ -110,28 +111,172 @@ export const persistedInstallsSuite = {
             all.for.join() === 'unreal,flutter,unity' &&
             UNREAL_COMPONENTS.every((c) => all.components.includes(c)) &&
             all.components.includes('Microsoft.VisualStudio.Component.VC.Llvm.Clang'), 'with Unreal: one Community install serves all of them');
-        t.section('Unreal on the portable MSVC (autosdk)');
-        tc.unreal.visualStudio = 'autosdk';
-        const noUnreal = visualStudioWanted(tc);
-        t.check(noUnreal?.product === 'buildtools' && noUnreal.for.join() === 'flutter,unity', 'autosdk: Unreal asks for no Visual Studio (the others still get the Build Tools)');
-        tc.flutter.enabled = false;
-        tc.unity.enabled = false;
-        t.equal(visualStudioWanted(tc), null, 'autosdk alone: no Visual Studio at all');
-        t.check(unrealUsesAutosdk(tc, (s) => s === true) && !unrealUsesAutosdk(DEFAULTS.toolchains), 'autosdk is only when asked');
-        const pairs = autosdkLayout('T:\\msvc', '14.44.35207', '10.0.26100.0', 'T:\\autosdk');
-        t.check(pairs.length === 4 &&
-            pairs[0].to === 'T:\\autosdk\\HostWin64\\Win64\\VS2022\\14.44.35207' &&
-            pairs[0].from === 'T:\\msvc\\VC\\Tools\\MSVC\\14.44.35207' &&
-            pairs[1].from === 'T:\\msvc\\Windows Kits\\10\\Include\\10.0.26100.0' &&
-            pairs[1].to === 'T:\\autosdk\\HostWin64\\Win64\\Windows Kits\\10\\Include\\10.0.26100.0', 'the AutoSDK tree is MSVC under VS2022\\<version> and the SDK under Windows Kits\\10 (copies)');
+        t.section('Unreal on the Build Tools');
+        tc.unreal.visualStudio = 'buildtools';
+        const bt = visualStudioWanted(tc);
+        t.check(bt?.product === 'buildtools' &&
+            bt.for.join() === 'unreal,flutter,unity' &&
+            bt.licence === 'toolchains.unreal.acceptLicense' &&
+            UNREAL_BUILD_TOOLS_COMPONENTS.every((c) => bt.components.includes(c)) &&
+            BUILD_TOOLS_COMPONENTS.every((c) => bt.components.includes(c)) &&
+            bt.components.includes('Microsoft.VisualStudio.Component.VC.Llvm.Clang'), '"buildtools": the Build Tools with what UnrealBuildTool needs, shared with Flutter and Unity');
+        t.equal(DEFAULTS.toolchains.unreal.visualStudio, 'full', 'Community is the default (the IDE, its debugger and Unreal integration)');
         const on = DEFAULTS.toolchains;
-        const auto = {
-            ...structuredClone(on),
-            unreal: { ...on.unreal, visualStudio: 'autosdk', acceptLicense: true },
+        const decided = decideToolchains({ ...structuredClone(on), unreal: { ...on.unreal, acceptLicense: true } }, ['Game.uproject'], []);
+        t.check(decided.unreal.on && !decided.msvc.on, 'an Unreal project does not turn the portable MSVC on (Visual Studio brings MSVC)');
+        t.section('Visual Studio kept on the data disk');
+        const places = {
+            programFiles: 'C:\\Program Files',
+            programFilesX86: 'C:\\Program Files (x86)',
+            programData: 'C:\\ProgramData',
         };
-        const decided = decideToolchains(auto, ['Game.uproject'], []);
-        t.check(decided.unreal.on && decided.msvc.on, 'an Unreal project with autosdk turns the portable MSVC on, under its licence');
-        t.section('the Visual Studio layout');
+        const root = 'C:\\AgentData\\tools\\visualstudio\\persist';
+        const community = 'C:\\Program Files\\Microsoft Visual Studio\\2022\\Community';
+        const instances = 'C:\\ProgramData\\Microsoft\\VisualStudio\\Packages\\_Instances';
+        const vsAt = { product: 'community', installationPath: community, instanceId: 'a190d188' };
+        const save = saveInput(vsAt, root, places, 'T:\\result.json');
+        const saved = (name) => save.copies.find((c) => c.name === name);
+        t.check(saved('Community')?.from === community &&
+            saved('Community')?.to === root + '\\Community' &&
+            saved('WindowsKits10')?.from === 'C:\\Program Files (x86)\\Windows Kits\\10' &&
+            saved('instance')?.from === instances + '\\a190d188' &&
+            saved('instance')?.to === root + '\\instance' &&
+            saved('Setup')?.from === 'C:\\ProgramData\\Microsoft\\VisualStudio\\Setup' &&
+            saved('Installer')?.optional === false &&
+            saved('ReferenceAssemblies')?.optional === true &&
+            save.resultFile === 'T:\\result.json', 'the capture mirrors the install, the Windows SDK, the installer, the Setup API and the instance onto the data disk');
+        t.check(save.registry.length === 8 &&
+            save.registry.filter((r) => r.view === '32').length === 4 &&
+            save.registry.some((r) => r.key.endsWith('NETFXSDK') && r.recurse) &&
+            save.registry.some((r) => r.key.endsWith('Installed Roots') && r.names?.join() === 'KitsRoot10'), 'it reads the SDK registry values in both views (NETFXSDK with its subkeys, only KitsRoot10 of the kits roots)');
+        await t.throws(() => Promise.resolve(saveInput({ ...vsAt, instanceId: '..\\x' }, root, places, 'r')), 'not a Visual Studio instance ID', 'an instance ID is never a path');
+        const captured = [
+            {
+                view: '64',
+                key: 'SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots',
+                name: 'KitsRoot10',
+                kind: 'string',
+                value: 'C:\\Program Files (x86)\\Windows Kits\\10\\',
+            },
+            {
+                view: '32',
+                key: 'SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v10.0',
+                name: 'ProductVersion',
+                kind: 'string',
+                value: '10.0.22621',
+            },
+            {
+                view: '32',
+                key: 'SOFTWARE\\Microsoft\\Microsoft SDKs\\NETFXSDK\\4.8',
+                name: 'KitsInstallationFolder',
+                kind: 'string',
+                value: 'C:\\Program Files (x86)\\Windows Kits\\NETFXSDK\\4.8\\',
+            },
+            {
+                view: '32',
+                key: 'SOFTWARE\\Microsoft\\Microsoft SDKs\\NETFXSDK\\4.8\\WinSDK-NetFx40Tools-x64',
+                name: 'InstallationFolder',
+                kind: 'string',
+                value: 'c:\\program files (x86)\\Microsoft SDKs\\Windows\\v10.0A\\bin\\NETFX 4.8 Tools\\x64\\',
+            },
+            {
+                view: '64',
+                key: 'SOFTWARE\\Microsoft\\VisualStudio\\Setup',
+                name: 'KeepDownloadedPayloads',
+                kind: 'dword',
+                value: 0,
+            },
+            {
+                view: '64',
+                key: 'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run',
+                name: 'planted',
+                kind: 'string',
+                value: 'C:\\planted.exe',
+            },
+        ];
+        const result = SaveResultSchema.parse({
+            copied: [
+                'Community',
+                'WindowsKits10',
+                'NETFXSDK',
+                'MicrosoftSDKs-v10.0A',
+                'ReferenceAssemblies',
+                'Installer',
+            ].concat(['Setup', 'instance']),
+            registry: captured,
+        });
+        const marker = VsPersistMarkerSchema.parse(markerFrom({ product: 'community', components: [...UNREAL_COMPONENTS] }, { installationPath: community, instanceId: 'a190d188', version: '17.14.37827.9' }, result, '2026-11-04T00:00:00.000Z'));
+        t.check(marker.sdkVersion === '10.0.22621' && marker.instanceId === 'a190d188' && marker.folders.length === 8, 'the marker keeps the instance ID, what was saved and the Windows SDK version from the registry');
+        t.check(!VsPersistMarkerSchema.safeParse({ ...marker, instanceId: '..\\..\\Windows' }).success &&
+            !VsPersistMarkerSchema.safeParse({ ...marker, folders: ['..'] }).success, 'a marker with a path for its instance ID, or a folder it does not know, is refused');
+        const plan = registryPlan(marker, root, places);
+        const value = (view, key, name) => plan.find((e) => e.view === view && e.key.toLowerCase() === key.toLowerCase() && e.name === name)?.value;
+        const kits = root + '\\WindowsKits10\\';
+        const sdk = 'SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows\\v10.0';
+        const netfx = 'SOFTWARE\\Microsoft\\Microsoft SDKs\\NETFXSDK\\4.8';
+        t.check(['64', '32'].every((v) => value(v, 'SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots', 'KitsRoot10') === kits &&
+            value(v, sdk, 'InstallationFolder') === kits &&
+            value(v, sdk, 'ProductVersion') === '10.0.22621' &&
+            value(v, netfx, 'KitsInstallationFolder') === root + '\\NETFXSDK\\4.8\\' &&
+            value(v, netfx + '\\WinSDK-NetFx40Tools-x64', 'InstallationFolder') ===
+                root + '\\MicrosoftSDKs-v10.0A\\bin\\NETFX 4.8 Tools\\x64\\' &&
+            value(v, 'SOFTWARE\\Microsoft\\VisualStudio\\Setup', 'KeepDownloadedPayloads') === 0), 'both registry views point the Windows SDK and the .NET Framework SDK at the data disk (any case); the rest stays');
+        const clsid = 'SOFTWARE\\Classes\\CLSID\\' + SETUP_CLSID + '\\InprocServer32';
+        const setupDll = 'Microsoft.VisualStudio.Setup.Configuration.Native.dll';
+        t.check(value('64', clsid, '') === 'C:\\ProgramData\\Microsoft\\VisualStudio\\Setup\\x64\\' + setupDll &&
+            value('32', clsid, '') === 'C:\\ProgramData\\Microsoft\\VisualStudio\\Setup\\x86\\' + setupDll &&
+            value('64', clsid, 'ThreadingModel') === 'Both' &&
+            value('32', clsid, 'ThreadingModel') === 'Both', 'the Setup Configuration COM class is registered (x64 and x86), so vswhere and UnrealBuildTool find the instance');
+        t.check(!plan.some((e) => /CurrentVersion\\Run/i.test(e.key)), 'a value the capture never reads is never written back (a tampered marker)');
+        const back = restoreInput(marker, root, places);
+        const copied = (name) => back.copies.find((c) => c.name === name);
+        t.check(!copied('Community') &&
+            !copied('WindowsKits10') &&
+            !copied('NETFXSDK') &&
+            !copied('Shared') &&
+            copied('Installer')?.to === 'C:\\Program Files (x86)\\Microsoft Visual Studio\\Installer' &&
+            copied('Installer')?.mode === 'all' &&
+            copied('ReferenceAssemblies')?.mode === 'missing' &&
+            copied('instance')?.from === root + '\\instance' &&
+            copied('instance')?.to === instances + '\\a190d188' &&
+            back.registry.length === plan.length, 'a boot copies back only the small fixed-path folders that were saved (the instance under its ID); the big ones stay');
+        t.check(persistCovers(marker, { product: 'community', components: [...UNREAL_COMPONENTS] }) &&
+            persistCovers(marker, { product: 'community', components: ['component.unreal'] }) &&
+            !persistCovers(marker, {
+                product: 'community',
+                components: [...UNREAL_COMPONENTS, 'Microsoft.VisualStudio.Component.VC.Llvm.Clang'],
+            }) &&
+            persistCovers(marker, { product: 'buildtools', components: [...BUILD_TOOLS_COMPONENTS] }) &&
+            !persistCovers({ ...marker, product: 'buildtools' }, { product: 'community', components: [] }) &&
+            !persistCovers({ ...marker, folders: marker.folders.filter((f) => f !== 'Setup') }, {
+                product: 'community',
+                components: [],
+            }), 'a saved copy serves requests with no more components (Community serves the Build Tools too); one without the Setup API none');
+        const state = JSON.stringify({
+            installationPath: community,
+            resolvedInstallationPath: community.toLowerCase(),
+            nested: community + '\\Common7\\IDE',
+            longer: community + '2',
+            launchParams: { fileName: 'Common7\\IDE\\devenv.exe' },
+            enginePath: 'C:\\Program Files (x86)\\Microsoft Visual Studio\\Installer\\resources\\app',
+        });
+        const moved = JSON.parse(rewriteInstanceState(state, community, root + '\\Community'));
+        t.check(moved.installationPath === root + '\\Community' &&
+            moved.resolvedInstallationPath === root + '\\Community' &&
+            moved.nested === root + '\\Community\\Common7\\IDE' &&
+            moved.longer === community + '2' &&
+            moved.enginePath === 'C:\\Program Files (x86)\\Microsoft Visual Studio\\Installer\\resources\\app', "the instance's state names the saved folder (JSON-escaped, any case); a longer name that only starts the same stays");
+        const buildTools = 'C:\\Program Files (x86)\\Microsoft Visual Studio\\2022\\BuildTools';
+        const movedBt = JSON.parse(rewriteInstanceState(JSON.stringify({ installationPath: buildTools }), buildTools + '\\', root + '\\BuildTools'));
+        t.check(movedBt.installationPath === root + '\\BuildTools' &&
+            rebase('D:\\Other\\x', [{ from: 'C:\\Program Files', to: 'D:\\y' }]) === 'D:\\Other\\x', 'the Build Tools too (a trailing backslash does not matter); a value outside the saved folders is kept');
+        t.equal(newestInstance([
+            { installationVersion: '17.9.1', id: 'a' },
+            { installationVersion: '17.14.37827.9', id: 'b' },
+            { installationVersion: '17.14.3', id: 'c' },
+        ])?.id, 'b', 'the newest instance is chosen by version (vswhere -latest fails on two instances installed at the same time)');
+        t.equal(newestInstance([]), null, 'no instance: none');
+        t.section('the Visual Studio installer');
         t.check(vsExitText(3762504530).includes('crashed') &&
             vsExitText(-1).includes('exit 4294967295') &&
             vsExitText(0) === 'installed' &&
@@ -139,15 +284,6 @@ export const persistedInstallsSuite = {
             vsExitText(8006).includes('running') &&
             vsExitText(3010).includes('restart') &&
             vsExitText(5007).includes('refused'), 'installer exit codes are told in words (0xE0434352 is a crash)');
-        const reserve = LOCAL_RESERVE_BYTES;
-        const room = (free) => freeBytesAt(t.dir('layout-room'), () => ({ bavail: free, bsize: 1 })) ?? 0;
-        t.check(layoutNextStep(0, 0, reserve) === 'done' &&
-            layoutNextStep(3762504530, room(40 * GB), reserve) === 'stage' &&
-            layoutNextStep(3762504530, room(20 * GB), reserve) === 'skip' &&
-            layoutNextStep(null, room(40 * GB), reserve) === 'stage', 'a failed layout is built on the sandbox disk only with room for it (8 GB plus the reserve)');
-        t.check(layoutNextStep(null, room(14 * GB), STAGING_RESERVE_BYTES) === 'stage' &&
-            layoutNextStep(null, room(9.5 * GB), STAGING_RESERVE_BYTES) === 'stage' &&
-            layoutNextStep(null, room(9 * GB), STAGING_RESERVE_BYTES) === 'skip', 'before Visual Studio is installed, the ~14 GB free at boot is enough to build the install files (9.5 GB needed)');
         t.equal(freeBytesAt(path.join(t.dir('layout-room'), 'not', 'there'), () => ({ bavail: 3, bsize: 2 })), 6, 'free room of a folder that does not exist asks its parent');
         t.equal(freeBytesAt(t.dir('layout-room'), () => {
             throw new Error('no');

package/dist/selftest/support/engine-golden.js

@@ -80,6 +80,8 @@ export const LAUNCH_FILES_GOLDEN = [
     'sandbox/scripts/link-profile-dirs.ps1',
     'sandbox/scripts/new-shortcuts.ps1',
     'sandbox/scripts/repair-wmi-services.ps1',
+    'sandbox/scripts/restore-visual-studio.ps1',
+    'sandbox/scripts/save-visual-studio.ps1',
     'sandbox/scripts/set-desktop.ps1',
     'sandbox/scripts/set-dns-servers.ps1',
     'sandbox/scripts/set-machine-environment.ps1',

package/dist/selftest/support/fixtures.d.ts

@@ -199,8 +199,7 @@ export declare function createFixtures(t: Harness): {
                 enabled: boolean | "auto";
                 acceptLicense: boolean;
                 components: string[];
-                keepInstallFiles: boolean;
-                visualStudio: "full" | "autosdk";
+                visualStudio: "full" | "buildtools";
                 persistEngines: boolean;
                 derivedDataCache: "persisted" | "local";
             };

package/dist/shared/channel/schema.d.ts

@@ -109,10 +109,9 @@ export declare const ProjectSpecSchema: z.ZodObject<{
             enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
             acceptLicense: z.ZodBoolean;
             components: z.ZodArray<z.ZodString>;
-            keepInstallFiles: z.ZodBoolean;
             visualStudio: z.ZodEnum<{
                 full: "full";
-                autosdk: "autosdk";
+                buildtools: "buildtools";
             }>;
             persistEngines: z.ZodBoolean;
             derivedDataCache: z.ZodEnum<{
@@ -346,10 +345,9 @@ export declare const GuestRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
                 acceptLicense: z.ZodBoolean;
                 components: z.ZodArray<z.ZodString>;
-                keepInstallFiles: z.ZodBoolean;
                 visualStudio: z.ZodEnum<{
                     full: "full";
-                    autosdk: "autosdk";
+                    buildtools: "buildtools";
                 }>;
                 persistEngines: z.ZodBoolean;
                 derivedDataCache: z.ZodEnum<{
@@ -603,10 +601,9 @@ export declare const GuestRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
                 acceptLicense: z.ZodBoolean;
                 components: z.ZodArray<z.ZodString>;
-                keepInstallFiles: z.ZodBoolean;
                 visualStudio: z.ZodEnum<{
                     full: "full";
-                    autosdk: "autosdk";
+                    buildtools: "buildtools";
                 }>;
                 persistEngines: z.ZodBoolean;
                 derivedDataCache: z.ZodEnum<{

package/dist/shared/pty/terminal.js

@@ -185,7 +185,8 @@ options = {}) {
         socket.on('close', () => finish({ reason: 'closed' }));
         socket.on('error', () => finish({ reason: 'closed' }));
         const [c, r] = size();
-        stdout.write('\x1b[2J\x1b[3J\x1b[H');
+        // A clean screen, but the scrollback stays: the boot's summary (warnings, tools, Ready) is just above the session.
+        stdout.write('\x1b[2J\x1b[H');
         socket.write(helloFrame(token, c, r));
         if (stdin.isTTY)
             stdin.setRawMode(true);

package/dist/sync/watcher.js

@@ -68,7 +68,11 @@ export function watcherRunning(dataPath) {
     }
 }
 /** The ways the sandbox itself ends badly (the PC going down takes the watcher with it, so it never gets here). */
-const RESTARTABLE = ['sandboxCrash', 'memory', 'gpu', 'hyperv', 'vanished'];
+/**
+ * Ends that start the sandbox again: only those Windows logged. A "vanished" end (busy, no word of leaving, nothing
+ * in the log) is also what closing the Windows Sandbox window looks like, so it gets a report but no restart.
+ */
+const RESTARTABLE = ['sandboxCrash', 'memory', 'gpu', 'hyperv'];
 /**
  * The background watcher of one data folder: while the sandbox runs it syncs history back every minute, guards the
  * projects' git folders, keeps filtered workspaces in step, forwards ports, marks downloaded files, records the audit

package/native/csharp/HcsHost/AssemblyInfo.cs

@@ -8,9 +8,9 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyCompany("windows-development-sandbox (open source)")]
 [assembly: AssemblyProduct("Windows Development Sandbox")]
 [assembly: AssemblyCopyright("MIT License, windows-development-sandbox contributors")]
-[assembly: AssemblyVersion("1.23.2.0")]
-[assembly: AssemblyFileVersion("1.23.2.0")]
-[assembly: AssemblyInformationalVersion("1.23.2")]
+[assembly: AssemblyVersion("1.25.0.0")]
+[assembly: AssemblyFileVersion("1.25.0.0")]
+[assembly: AssemblyInformationalVersion("1.25.0")]
 [assembly: ComVisible(false)]
 // computecore.dll and computestorage.dll are not KnownDLLs: load them from System32 only, never from the exe's folder.
 [assembly: DefaultDllImportSearchPaths(DllImportSearchPath.System32)]

package/native/csharp/HostTools/AssemblyInfo.cs

@@ -8,7 +8,7 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyCompany("windows-development-sandbox (open source)")]
 [assembly: AssemblyProduct("Windows Development Sandbox")]
 [assembly: AssemblyCopyright("MIT License, windows-development-sandbox contributors")]
-[assembly: AssemblyVersion("1.23.2.0")]
-[assembly: AssemblyFileVersion("1.23.2.0")]
-[assembly: AssemblyInformationalVersion("1.23.2")]
+[assembly: AssemblyVersion("1.25.0.0")]
+[assembly: AssemblyFileVersion("1.25.0.0")]
+[assembly: AssemblyInformationalVersion("1.25.0")]
 [assembly: ComVisible(false)]

package/native/csharp/StorageHelper/AssemblyInfo.cs

@@ -9,7 +9,7 @@ using System.Runtime.InteropServices;
 [assembly: AssemblyCompany("windows-development-sandbox (open source)")]
 [assembly: AssemblyProduct("Windows Development Sandbox")]
 [assembly: AssemblyCopyright("MIT License, windows-development-sandbox contributors")]
-[assembly: AssemblyVersion("1.23.2.0")]
-[assembly: AssemblyFileVersion("1.23.2.0")]
-[assembly: AssemblyInformationalVersion("1.23.2")]
+[assembly: AssemblyVersion("1.25.0.0")]
+[assembly: AssemblyFileVersion("1.25.0.0")]
+[assembly: AssemblyInformationalVersion("1.25.0")]
 [assembly: ComVisible(false)]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windows-development-sandbox",
-  "version": "1.23.2",
+  "version": "1.25.0",
   "description": "A disposable Windows Sandbox for development, with or without an AI agent (Claude Code, Codex, Gemini, opencode, ...): the folder you run it from is the workspace, toolchains and databases for your project install themselves, and nothing else on your PC is reachable.",
   "type": "module",
   "license": "MIT",

package/sandbox/scripts/restore-visual-studio.ps1

@@ -0,0 +1,78 @@
+#Requires -Version 5.1
+# Puts a saved Visual Studio back at boot, in seconds (guest/toolchains/native/visual-studio.ts; what goes where is
+# decided in vs-persist.ts): the small folders programs look for at fixed paths are copied back, then the registry
+# values that point at the big folders on the data disk and the Setup Configuration COM class are written. -PlanFile is
+# JSON written by the runtime:
+#   copies:   [{ name, from, to, mode: 'all' | 'missing' }]   'all': robocopy /E (only what differs is copied);
+#                                                            'missing': each subfolder only when the target has none
+#   registry: [{ view: '64'|'32', key, name, kind: 'string'|'expand'|'dword', value }]   under HKLM ('' = default)
+# Safe to run again. Exit 0 when everything is in place, 1 when a copy failed, 2 when a registry value could not be set.
+param([Parameter(Mandatory = $true)][string]$PlanFile)
+$ErrorActionPreference = 'Stop'
+
+$plan = Get-Content -LiteralPath $PlanFile -Raw -Encoding UTF8 | ConvertFrom-Json
+$robocopy = Join-Path $env:SystemRoot 'System32\Robocopy.exe'
+
+function Copy-Folder([string]$From, [string]$To) {
+    New-Item -ItemType Directory -Force -Path $To | Out-Null
+    & $robocopy $From $To /E /COPY:DAT /XJ /R:1 /W:1 /MT:16 /NP /NFL /NDL /NJH /NJS | Where-Object { $_ -and $_.Trim() } | Out-Host
+    return $LASTEXITCODE
+}
+
+$copied = 0
+$failed = New-Object System.Collections.ArrayList
+foreach ($copy in @($plan.copies)) {
+    if (-not (Test-Path -LiteralPath $copy.from -PathType Container)) {
+        [void]$failed.Add($copy.name + ' (' + $copy.from + ' is missing)')
+        continue
+    }
+    if ($copy.mode -eq 'missing') {
+        foreach ($child in Get-ChildItem -LiteralPath $copy.from -Directory) {
+            $target = Join-Path $copy.to $child.Name
+            if (Test-Path -LiteralPath $target) { continue }
+            $code = Copy-Folder -From $child.FullName -To $target
+            if ($code -ge 8) { [void]$failed.Add($copy.name + '\' + $child.Name + ' (robocopy ' + $code + ')') }
+        }
+        $copied++
+        continue
+    }
+    $code = Copy-Folder -From $copy.from -To $copy.to
+    if ($code -ge 8) { [void]$failed.Add($copy.name + ' (robocopy ' + $code + ')') } else { $copied++ }
+}
+if ($failed.Count) {
+    Write-Error ('restore-visual-studio: could not copy ' + ($failed -join ', '))
+    exit 1
+}
+
+$set = 0
+$bad = New-Object System.Collections.ArrayList
+foreach ($entry in @($plan.registry)) {
+    $view = [Microsoft.Win32.RegistryView]::Registry64
+    if ($entry.view -eq '32') { $view = [Microsoft.Win32.RegistryView]::Registry32 }
+    $base = [Microsoft.Win32.RegistryKey]::OpenBaseKey([Microsoft.Win32.RegistryHive]::LocalMachine, $view)
+    try {
+        $key = $base.CreateSubKey([string]$entry.key)
+        try {
+            if ($entry.kind -eq 'dword') {
+                $key.SetValue([string]$entry.name, [int]$entry.value, [Microsoft.Win32.RegistryValueKind]::DWord)
+            } elseif ($entry.kind -eq 'expand') {
+                $key.SetValue([string]$entry.name, [string]$entry.value, [Microsoft.Win32.RegistryValueKind]::ExpandString)
+            } else {
+                $key.SetValue([string]$entry.name, [string]$entry.value, [Microsoft.Win32.RegistryValueKind]::String)
+            }
+            $set++
+        } finally {
+            $key.Close()
+        }
+    } catch {
+        [void]$bad.Add($entry.view + ':' + $entry.key + '\' + $entry.name + ' (' + $_.Exception.Message + ')')
+    } finally {
+        $base.Close()
+    }
+}
+if ($bad.Count) {
+    Write-Error ('restore-visual-studio: could not set ' + ($bad -join '; '))
+    exit 2
+}
+Write-Output ('Restored Visual Studio: ' + $copied + ' folders in place, ' + $set + ' registry values set')
+exit 0