windows-development-sandbox 1.16.0 → 1.17.3

package/dist/bin/sbx-show.js

@@ -2,8 +2,8 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   run
-} from "./chunk-7EXDUNE7.js";
-import "./chunk-HIC4CUMY.js";
+} from "./chunk-QLGGAG3D.js";
+import "./chunk-REE3EMHD.js";
 
 // src/bin/sbx-show.ts
 run(process.argv.slice(2), { command: "show" });

package/dist/cli/commands/web.js

@@ -95,7 +95,7 @@ function remoteAudit(ctx) {
  * served (it refuses everyone while web.remote.windowsSignIn is off).
  */
 function remoteGate(ctx) {
-    const secrets = SecretStore.standard();
+    const secrets = SecretStore.standard(ctx.storageRoot);
     let ownerSid = '';
     try {
         ownerSid = currentUserSid();

package/dist/core/config/defaults.js

@@ -62,6 +62,7 @@ export const DEFAULTS = {
             linkSlots: 'auto',
         },
         msvc: { enabled: 'auto', acceptLicense: false, msvcVersion: 'latest', sdkVersion: 'latest' },
+        unreal: { enabled: 'auto', acceptLicense: false, components: [], keepInstallFiles: true },
         cpp: { enabled: 'auto', flexBison: true },
         dotnet: {
             enabled: 'auto',

package/dist/core/detect/toolchains.d.ts

@@ -4,6 +4,7 @@ export declare const MARKERS: {
     readonly python: readonly ["pyproject.toml", "requirements.txt", "setup.py", "setup.cfg", "Pipfile", "uv.lock", "poetry.lock", ".python-version", "*.py", "*.ipynb"];
     readonly rust: readonly ["Cargo.toml", "rust-toolchain", "rust-toolchain.toml"];
     readonly msvc: readonly ["*.vcxproj", "CMakePresets.json", "CMakeUserPresets.json"];
+    readonly unreal: readonly ["*.uproject", "*.uplugin"];
     readonly cpp: readonly ["CMakeLists.txt", "Makefile", "meson.build", "premake5.lua", "Cargo.toml", "*.vcxproj", "*.c", "*.cpp", "*.cc", "*.h", "*.hpp"];
     readonly dotnet: readonly ["*.sln", "*.slnx", "*.csproj", "*.fsproj", "*.vbproj", "global.json", "*.cs"];
     readonly go: readonly ["go.mod", "go.work", "*.go"];

package/dist/core/detect/toolchains.js

@@ -15,6 +15,7 @@ export const MARKERS = {
     ],
     rust: ['Cargo.toml', 'rust-toolchain', 'rust-toolchain.toml'],
     msvc: ['*.vcxproj', 'CMakePresets.json', 'CMakeUserPresets.json'],
+    unreal: ['*.uproject', '*.uplugin'],
     cpp: [
         'CMakeLists.txt',
         'Makefile',
@@ -86,6 +87,12 @@ export function decideToolchains(settings, entries, pcHas, hints = {}) {
             on: false,
             reason: 'would be used (' + result.msvc.reason + '); set toolchains.msvc.acceptLicense to install it',
         };
+    // Unreal is a ~10 GB licensed install every boot: "auto" only installs it once its licence is accepted.
+    if (settings.unreal.enabled === 'auto' && result.unreal.on && !settings.unreal.acceptLicense)
+        result.unreal = {
+            on: false,
+            reason: 'would be used (' + result.unreal.reason + '); set toolchains.unreal.acceptLicense to install it',
+        };
     if (result.rust.on && !result.msvc.on && !result.cpp.on && settings.cpp.enabled !== false)
         result.cpp = { on: true, reason: 'the linker for Rust' };
     // uv installs the Python tools (`uv tool install`), so Python tools turn an "auto" uv on.

package/dist/core/schema/config.d.ts

@@ -153,6 +153,12 @@ export declare const ConfigSchema: z.ZodObject<{
             msvcVersion: z.ZodString;
             sdkVersion: z.ZodString;
         }, z.core.$strict>;
+        unreal: z.ZodObject<{
+            enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+            acceptLicense: z.ZodBoolean;
+            components: z.ZodArray<z.ZodString>;
+            keepInstallFiles: z.ZodBoolean;
+        }, z.core.$strict>;
         cpp: z.ZodObject<{
             enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
             flexBison: z.ZodBoolean;
@@ -506,6 +512,21 @@ export declare const LocalOverridesSchema: z.ZodObject<{
             zstd: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
             openssl: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
         }, z.core.$strict>>;
+        unreal: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict> | z.ZodObject<{
+            version: z.ZodOptional<z.ZodString>;
+            extraVersions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            corepack: z.ZodOptional<z.ZodBoolean>;
+            volta: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
+            globalPackages: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict> | z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
+        }, z.core.$strict> | z.ZodObject<{
+            gh: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
+            zstd: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
+            openssl: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
+        }, z.core.$strict>>;
         cpp: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict> | z.ZodObject<{

package/dist/core/schema/sandbox.js

@@ -51,7 +51,7 @@ export const SandboxSchema = z.strictObject({
         .describe('When the sandbox (or this PC) runs low on memory, slow builds down in steps, like a PC that gets slower instead of failing: build programs get lower CPU and memory priority, then less CPU, then compilers take turns (the waiting ones briefly suspended and trimmed to the paging file). Nothing is stopped or killed, and the agents themselves are never touched. Yours only: a project file cannot change it.'),
     vGpu: z
         .boolean()
-        .describe("Virtual GPU. Off by default: Microsoft notes it widens the sandbox attack surface. The sandbox then uses this PC's graphics card, and with some graphics drivers heavy use can freeze the whole PC: turn it on only when a program in the sandbox needs the GPU (the mesa toolchain gives software OpenGL without it)."),
+        .describe("Virtual GPU. Off by default: Microsoft notes it widens the sandbox attack surface. The sandbox then uses this PC's graphics card, and with some graphics drivers heavy use can freeze the whole PC: turn it on only when a program in the sandbox needs the GPU (the mesa toolchain gives software OpenGL without it). Browsers in the sandbox never use it (they draw in software)."),
     networking: z.boolean().describe('Internet access. false is the only hard network isolation Windows Sandbox offers.'),
     clipboard: z
         .boolean()

package/dist/core/schema/toolchains.d.ts

@@ -34,6 +34,12 @@ export declare const ToolchainsSchema: z.ZodObject<{
         msvcVersion: z.ZodString;
         sdkVersion: z.ZodString;
     }, z.core.$strict>;
+    unreal: z.ZodObject<{
+        enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
+        acceptLicense: z.ZodBoolean;
+        components: z.ZodArray<z.ZodString>;
+        keepInstallFiles: z.ZodBoolean;
+    }, z.core.$strict>;
     cpp: z.ZodObject<{
         enabled: z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>;
         flexBison: z.ZodBoolean;

package/dist/core/schema/toolchains.js

@@ -53,6 +53,16 @@ export const ToolchainsSchema = z.strictObject({
         msvcVersion: z.string().min(1).describe('"latest" or an MSVC tools version prefix, e.g. "14.44".'),
         sdkVersion: z.string().min(1).describe('"latest" or a Windows SDK build, e.g. "26100" or "10.0.22621".'),
     }),
+    unreal: z.strictObject({
+        enabled: enabled('Unreal Engine development: Visual Studio Community 2022 with the C++ game workload (MSVC, a Windows 11 SDK, .NET Framework targeting packs, Unreal integration and the Epic Games Launcher) and the DirectX End-User Runtime. A real installer: it runs every boot (~10 GB on the sandbox disk). The engine itself comes from the Epic Games Launcher or its source.', 'a .uproject or .uplugin'),
+        acceptLicense: z
+            .boolean()
+            .describe('Required to install: you accept the Visual Studio Community licence terms (https://visualstudio.microsoft.com/license-terms/) and the DirectX End-User Runtime licence.'),
+        components: StringsSchema.describe('More Visual Studio workload or component IDs to add, e.g. ["Microsoft.VisualStudio.Component.VC.Llvm.Clang"].'),
+        keepInstallFiles: z
+            .boolean()
+            .describe('Keep an offline copy of the Visual Studio install files in tools\\visualstudio (~10 GB, made once), so later boots install without downloading them again. Skipped while that disk has too little room.'),
+    }),
     cpp: z.strictObject({
         enabled: enabled("MinGW-w64 GCC with CMake, Ninja, premake5 and mingw32-make (also Rust's linker).", 'CMakeLists.txt, Makefile, meson.build, premake5.lua or Cargo.toml'),
         flexBison: z

package/dist/guest/agents/agent-files.d.ts

@@ -48,6 +48,12 @@ export declare function bootResetPaths(agents: Readonly<Record<string, Harness>>
     agent: string;
     path: string;
 }[];
+/**
+ * Codex's config.toml with its own command sandbox off, or null when it already says which one to use. Inside Windows
+ * Sandbox that inner sandbox only costs: its setup re-grants ACLs over the whole profile at every boot (minutes), and
+ * every command hangs until it is done. A `sandbox_mode` the user set (before the first [table]) is kept.
+ */
+export declare function codexConfigWithoutSandbox(toml: string): string | null;
 /** A SQLite database file or one of its -wal / -shm siblings. */
 export declare const isDatabaseFile: (name: string) => boolean;
 /** Files that make a consistent copy: the databases and their -wal (the -shm is rebuilt by SQLite). */

package/dist/guest/agents/agent-files.js

@@ -61,6 +61,20 @@ export function localStateEntries(agents, stateDir, localRoot) {
 export function bootResetPaths(agents, stateDir) {
     return Object.entries(agents).flatMap(([agent, harness]) => (harness.bootReset ?? []).map((rel) => ({ agent, path: path.join(stateDir, agent, rel) })));
 }
+/**
+ * Codex's config.toml with its own command sandbox off, or null when it already says which one to use. Inside Windows
+ * Sandbox that inner sandbox only costs: its setup re-grants ACLs over the whole profile at every boot (minutes), and
+ * every command hangs until it is done. A `sandbox_mode` the user set (before the first [table]) is kept.
+ */
+export function codexConfigWithoutSandbox(toml) {
+    const firstTable = toml.search(/^\s*\[/m);
+    const topLevel = firstTable < 0 ? toml : toml.slice(0, firstTable);
+    if (/^\s*sandbox_mode\s*=/m.test(topLevel))
+        return null;
+    return ('# Set by the sandbox: Windows Sandbox already contains Codex, its own command sandbox would only slow it down.\n' +
+        'sandbox_mode = "danger-full-access"\n' +
+        (toml ? '\n' + toml : ''));
+}
 /** A SQLite database file or one of its -wal / -shm siblings. */
 export const isDatabaseFile = (name) => /\.(sqlite3?|db)(-wal|-shm)?$/i.test(name);
 /** Files that make a consistent copy: the databases and their -wal (the -shm is rebuilt by SQLite). */

package/dist/guest/agents/local-state.d.ts

@@ -5,6 +5,8 @@ export declare function agentLocalStates(): LocalState[];
 export declare function localStateVars(): Record<string, string>;
 /** Boot: what an agent sealed to the last sandbox (bootReset) is deleted, so it sets it up again. Links are left. */
 export declare function resetMachineBound(): void;
+/** Boot: Codex runs its commands without its own sandbox (codexConfigWithoutSandbox), unless the user picked one. */
+export declare function codexWithoutInnerSandbox(): void;
 /** Boot: the saved databases of every configured agent are copied to the sandbox's disk, where the agent runs them. */
 export declare function restoreLocalState(): void;
 /**

package/dist/guest/agents/local-state.js

@@ -10,7 +10,7 @@ import { execOutput } from '../runtime/process.js';
 import { log, warn } from '../runtime/log.js';
 import { session, stateDir } from '../runtime/session.js';
 import { errMsg } from '../../core/util/errors.js';
-import { bootResetPaths, isCopyableDatabaseFile, isDatabaseFile, localStateEntries, } from './agent-files.js';
+import { bootResetPaths, codexConfigWithoutSandbox, isCopyableDatabaseFile, isDatabaseFile, localStateEntries, } from './agent-files.js';
 const SQLITE_HEADER = 'SQLite format 3\0';
 /** The sandbox-disk folder that holds the working copies. */
 const localRoot = () => path.join(localDir, 'agent-state');
@@ -102,6 +102,18 @@ export function resetMachineBound() {
         }
     }
 }
+/** Boot: Codex runs its commands without its own sandbox (codexConfigWithoutSandbox), unless the user picked one. */
+export function codexWithoutInnerSandbox() {
+    if (dryRun || !session.agents?.codex)
+        return;
+    const file = path.join(stateDir, 'codex', 'config.toml');
+    const updated = codexConfigWithoutSandbox(exists(file) ? fs.readFileSync(file, 'utf8') : '');
+    if (updated === null)
+        return;
+    mkdirp(path.dirname(file));
+    fs.writeFileSync(file, updated, 'utf8');
+    log('codex: its own command sandbox is off (sandbox_mode = "danger-full-access" in config.toml).');
+}
 /** Boot: the saved databases of every configured agent are copied to the sandbox's disk, where the agent runs them. */
 export function restoreLocalState() {
     if (dryRun)

package/dist/guest/boot/boot.js

@@ -6,7 +6,7 @@ import { writeGuides } from './guide.js';
 import { setupToolchains } from '../toolchains/index.js';
 import { agents } from '../agents/agent-installer.js';
 import { agentShims, sbxAgentText, shimText } from '../agents/agent-files.js';
-import { resetMachineBound, restoreLocalState } from '../agents/local-state.js';
+import { codexWithoutInnerSandbox, resetMachineBound, restoreLocalState } from '../agents/local-state.js';
 import { installShellPath } from '../setup/shell-path.js';
 import { linkProfileDirs } from '../agents/profile-links.js';
 import { restoreClaudeMem } from '../setup/claude-mem.js';
@@ -19,6 +19,7 @@ import { writeManagedSettings } from '../setup/managed-policy.js';
 import { writeAddonMcpServers } from '../setup/addon-mcp.js';
 import { startHeadroom } from '../setup/headroom.js';
 import { applyPersonalization } from '../setup/desktop.js';
+import { keepBrowsersOffGpu } from '../setup/browser-gpu.js';
 import { setupGitConfig } from '../setup/git-identity.js';
 import { loginGithub, prepareGithubFolder } from '../setup/github-token.js';
 import { ensurePtyHost } from '../sessions/pty-host.js';
@@ -172,6 +173,7 @@ export class Boot {
         step(2, 'Pre-provision hooks and desktop');
         runHooks('pre-provision', process.env);
         await soft('Personalisation', applyPersonalization);
+        await soft('Browsers without the GPU', keepBrowsersOffGpu);
     }
     /** Toolchains, databases, apps, the network proxy and VS Code; then the agent environment, saved machine-wide. */
     async developerTools() {
@@ -247,6 +249,7 @@ export class Boot {
         await soft('Agent databases restore', restoreLocalState);
         // Agent add-ons: MCP servers in the sandbox's Claude Code, and the Headroom proxy before the managed settings point
         // Claude Code at it (the guide reads them back, so it comes last).
+        await soft('Codex without its own sandbox', codexWithoutInnerSandbox);
         let headroom = null;
         await soft('MCP servers from Apps', writeAddonMcpServers);
         await soft('Headroom proxy', async () => {

package/dist/guest/setup/browser-gpu.d.ts

@@ -0,0 +1 @@
+export declare function keepBrowsersOffGpu(): void;

package/dist/guest/setup/browser-gpu.js

@@ -0,0 +1,18 @@
+// Browsers in the sandbox draw without the GPU (Edge and Chrome machine policy, written every boot). With sandbox.vGpu
+// the sandbox shares this PC's graphics card through one virtual GPU: a browser's GPU process starting next to a game
+// or other Direct3D program there has taken the whole sandbox down. Pages still render, WebGL included, in software;
+// programs that need the GPU keep it. Without vGPU nothing changes (there is no GPU to use).
+import { SYSTEM } from '../../shared/system.js';
+import { dryRun, isWin } from '../runtime/paths.js';
+import { exec } from '../runtime/process.js';
+import { log } from '../runtime/log.js';
+const POLICY_KEYS = ['HKLM\\SOFTWARE\\Policies\\Microsoft\\Edge', 'HKLM\\SOFTWARE\\Policies\\Google\\Chrome'];
+export function keepBrowsersOffGpu() {
+    if (dryRun || !isWin)
+        return;
+    for (const key of POLICY_KEYS)
+        exec(SYSTEM.reg(), ['add', key, '/v', 'HardwareAccelerationModeEnabled', '/t', 'REG_DWORD', '/d', '0', '/f'], {
+            stdio: 'ignore',
+        });
+    log('Browsers draw without the GPU (Edge and Chrome policy).');
+}

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

@@ -98,5 +98,7 @@ export function rustHost(config) {
     if (config.rust.host !== 'auto')
         return config.rust.host;
     const cpu = arch === 'arm64' ? 'aarch64' : 'x86_64';
-    return cpu + (wanted(config.msvc.enabled, 'msvc') ? '-pc-windows-msvc' : '-pc-windows-gnu');
+    // Unreal's Visual Studio is a full MSVC too (rustc finds it through the Setup API).
+    const msvc = wanted(config.msvc.enabled, 'msvc') || wanted(config.unreal.enabled, 'unreal');
+    return cpu + (msvc ? '-pc-windows-msvc' : '-pc-windows-gnu');
 }

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

@@ -0,0 +1,9 @@
+import type { Toolchains } from '../../../core/types.js';
+import { type ToolEnv } from '../tool-env.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,
+ * 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"];
+export declare function setupUnreal(env: ToolEnv, config: Toolchains['unreal']): Promise<void>;

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

@@ -0,0 +1,198 @@
+// Unreal Engine development (toolchains.unreal): Visual Studio Community 2022 with the C++ game workload and the parts
+// Unreal's build tool looks for (it finds Visual Studio through the Setup API, so the portable MSVC does not do), and
+// the DirectX End-User Runtime. Real installers: they run every boot. The installers are kept in tools\ and run only
+// when Microsoft's signature on them checks out; with keepInstallFiles an offline copy of the install files
+// (tools\visualstudio\layout) spares later boots the download. The engine itself comes from the Epic Games Launcher.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { z } from 'zod';
+import { spawnAsync } from '../../../shared/download/index.js';
+import { writeJsonAtomic } from '../../../shared/io/json.js';
+import { safeRemove } from '../../../shared/io/safe-remove.js';
+import { dryRun } from '../../runtime/paths.js';
+import { execOutput } from '../../runtime/process.js';
+import { exists, mkdirp } from '../../runtime/fs.js';
+import { log, warn } from '../../runtime/log.js';
+import { errMsg } from '../../../core/util/errors.js';
+import { downloadFile } from '../install.js';
+import { tool } from '../tool-env.js';
+import { MICROSOFT_SIGNER, signerOf } from './vcruntime.js';
+const BOOTSTRAPPER_URL = 'https://aka.ms/vs/17/release/vs_community.exe';
+const DIRECTX_URL = 'https://download.microsoft.com/download/8/4/A/84A35BF1-DAFE-4AE8-82AF-AD2AE20B6B14/directx_Jun2010_redist.exe';
+/**
+ * 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,
+ * Visual Studio's Unreal support and the Unreal Engine installer (the Epic Games Launcher).
+ */
+export const UNREAL_COMPONENTS = [
+    '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',
+];
+/** Visual Studio installer exit codes that mean installed: 0, and 3010 (a restart would finish it, not needed here). */
+const OK_EXIT_CODES = [0, 3010];
+/** Free room the offline copy needs before it is made (it grows to about 10 GB). */
+const LAYOUT_ROOM_BYTES = 15 * 1024 ** 3;
+/**
+ * Free room on the sandbox's own disk before Visual Studio goes on it: it takes about 7 GB, and the disk (about 40 GB)
+ * also holds the paging file and every build, so it is installed only when about 13 GB stay free after it.
+ */
+const INSTALL_ROOM_BYTES = 20 * 1024 ** 3;
+const ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,199}$/;
+const VS_DIR = tool('visualstudio');
+const BOOTSTRAPPER = path.join(VS_DIR, 'vs_community.exe');
+const LAYOUT = path.join(VS_DIR, 'layout');
+const LAYOUT_MARKER = path.join(LAYOUT, '.complete.json');
+const LayoutSchema = z.object({ components: z.array(z.string()) });
+const VSWHERE = path.join(process.env['ProgramFiles(x86)'] ?? 'C:\\Program Files (x86)', 'Microsoft Visual Studio', 'Installer', 'vswhere.exe');
+/** The newest Visual Studio with the C++ compiler: its folder and version, or null. */
+function installedVs() {
+    if (!exists(VSWHERE))
+        return null;
+    const ask = (property) => execOutput(VSWHERE, [
+        '-latest',
+        '-products',
+        '*',
+        '-requires',
+        'Microsoft.VisualStudio.Component.VC.Tools.x86.x64',
+        '-property',
+        property,
+    ]);
+    const at = ask('installationPath');
+    return at ? { path: at, version: ask('installationVersion') || 'installed' } : null;
+}
+/** A Microsoft-signed installer kept in tools\ (downloaded once); a file with a bad signature is deleted. */
+async function signedInstaller(url, file, what) {
+    if (!exists(file)) {
+        log('Downloading ' + what + ' ...');
+        mkdirp(path.dirname(file));
+        await downloadFile(url, file);
+    }
+    if (signerOf(file) !== MICROSOFT_SIGNER) {
+        fs.rmSync(file, { force: true });
+        throw new Error(path.basename(file) + ' is not signed by Microsoft; deleted it (it is downloaded again next boot)');
+    }
+    return file;
+}
+function freeBytes(dir) {
+    try {
+        const s = fs.statfsSync(dir);
+        return s.bavail * s.bsize;
+    }
+    catch {
+        return 0;
+    }
+}
+/** The offline copy's installer when it holds every component; made or completed when there is room. */
+async function layoutInstaller(bootstrapper, ids) {
+    const installer = path.join(LAYOUT, 'vs_community.exe');
+    const has = () => {
+        if (!exists(LAYOUT_MARKER) || !exists(installer))
+            return false;
+        try {
+            const done = LayoutSchema.parse(JSON.parse(fs.readFileSync(LAYOUT_MARKER, 'utf8')));
+            return ids.every((id) => done.components.includes(id));
+        }
+        catch {
+            return false;
+        }
+    };
+    if (has())
+        return installer;
+    if (freeBytes(mkdirp(VS_DIR)) < LAYOUT_ROOM_BYTES) {
+        warn('unreal: not keeping the install files (less than 15 GB free in ' + VS_DIR + '); downloading this boot');
+        return null;
+    }
+    log('Saving the Visual Studio install files for later boots (~10 GB, once) ...');
+    fs.rmSync(LAYOUT_MARKER, { force: true });
+    const code = await spawnAsync(bootstrapper, [
+        '--layout',
+        LAYOUT,
+        '--lang',
+        'en-US',
+        '--quiet',
+        '--wait',
+        ...ids.flatMap((id) => ['--add', id]),
+    ]);
+    if (!OK_EXIT_CODES.includes(code) || !exists(installer)) {
+        warn('unreal: saving the install files failed (exit ' + code + '); downloading this boot');
+        return null;
+    }
+    writeJsonAtomic(LAYOUT_MARKER, { components: [...ids] });
+    return installer;
+}
+async function installVisualStudio(config, ids) {
+    const bootstrapper = await signedInstaller(BOOTSTRAPPER_URL, BOOTSTRAPPER, 'the Visual Studio installer');
+    let installer = null;
+    if (config.keepInstallFiles) {
+        try {
+            installer = await layoutInstaller(bootstrapper, ids);
+        }
+        catch (e) {
+            warn('unreal: the offline copy failed (' + errMsg(e) + '); downloading this boot');
+        }
+    }
+    log('Installing Visual Studio Community 2022 with the C++ game workload' +
+        (installer ? ' from the saved install files' : ' (downloads ~5-8 GB)') +
+        ' ...');
+    const code = await spawnAsync(installer ?? bootstrapper, [
+        '--quiet',
+        '--wait',
+        '--norestart',
+        '--nocache',
+        ...(installer ? ['--noWeb'] : []),
+        ...ids.flatMap((id) => ['--add', id]),
+    ]);
+    if (!OK_EXIT_CODES.includes(code) || !installedVs())
+        throw new Error('the Visual Studio installer failed (exit ' + code + '); its logs are the dd_*.log files in ' + os.tmpdir());
+}
+/** The June 2010 DirectX End-User Runtime (D3DX, XAudio 2.7, XInput 1.3), which Epic lists for the engine. */
+async function installDirectX() {
+    const system32 = path.join(process.env.WINDIR ?? 'C:\\Windows', 'System32');
+    if (exists(path.join(system32, 'd3dx9_43.dll')) && exists(path.join(system32, 'XAudio2_7.dll')))
+        return;
+    const redist = await signedInstaller(DIRECTX_URL, path.join(VS_DIR, 'directx_Jun2010_redist.exe'), 'the DirectX End-User Runtime (~95 MB once)');
+    const unpacked = path.join(os.tmpdir(), 'directx-redist');
+    safeRemove(unpacked, os.tmpdir());
+    mkdirp(unpacked);
+    if ((await spawnAsync(redist, ['/Q', '/T:' + unpacked])) !== 0 || !exists(path.join(unpacked, 'DXSETUP.exe')))
+        throw new Error('could not unpack the DirectX End-User Runtime');
+    const code = await spawnAsync(path.join(unpacked, 'DXSETUP.exe'), ['/silent']);
+    safeRemove(unpacked, os.tmpdir());
+    if (code !== 0)
+        throw new Error('the DirectX End-User Runtime installer failed (exit ' + code + ')');
+}
+export async function setupUnreal(env, config) {
+    if (!config.acceptLicense)
+        throw new Error('Unreal tools are installed only with toolchains.unreal.acceptLicense = true: Visual Studio Community and the DirectX End-User Runtime come under Microsoft licence terms (https://visualstudio.microsoft.com/license-terms/)');
+    const bad = config.components.find((id) => !ID.test(id));
+    if (bad)
+        throw new Error('toolchains.unreal.components: "' + bad + '" is not a Visual Studio component ID');
+    const ids = [...new Set([...UNREAL_COMPONENTS, ...config.components])];
+    if (dryRun) {
+        log('(dry run) would install Visual Studio Community 2022 with ' + ids.join(', ') + ' and DirectX');
+        return;
+    }
+    if (!installedVs()) {
+        const programFiles = process.env.ProgramFiles ?? 'C:\\Program Files';
+        const free = freeBytes(programFiles);
+        if (free < INSTALL_ROOM_BYTES)
+            throw new Error('not installing Visual Studio: the sandbox disk has ' +
+                (free / 1024 ** 3).toFixed(1) +
+                ' GB free and it needs 20 GB (7 GB for Visual Studio, the rest for builds and the paging file)');
+        await installVisualStudio(config, ids);
+    }
+    await installDirectX();
+    const vs = installedVs();
+    env.summary.push('unreal: Visual Studio Community ' +
+        vs.version +
+        ' (C++ game workload, Windows 11 SDK, Unreal support) at ' +
+        vs.path +
+        '; DirectX End-User Runtime; get the engine from the Epic Games Launcher (Start menu)');
+}

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

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

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

@@ -9,11 +9,11 @@ import { log } from '../../runtime/log.js';
 import { downloadFile } from '../install.js';
 import { tool } from '../tool-env.js';
 const VC_REDIST = 'https://aka.ms/vs/17/release/vc_redist.x64.exe';
-const MICROSOFT_SIGNER = 'CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US';
+export const MICROSOFT_SIGNER = 'CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US';
 /** 1638: a newer version is already installed; 3010: installed, a restart would finish it (not needed for the DLLs). */
 const OK_EXIT_CODES = [0, 1638, 3010];
 /** The subject of a valid Authenticode signature, or '' when the file is unsigned or tampered with. */
-const signerOf = (file) => scriptOutput('get-signer.ps1', ['-Path', file]).trim();
+export const signerOf = (file) => scriptOutput('get-signer.ps1', ['-Path', file]).trim();
 /**
  * A real installer (it writes to System32), so it runs on every boot; the installer itself is kept in persistent
  * storage and only run when Microsoft's signature on it checks out. Resolves true when this call ran the installer.

package/dist/guest/toolchains/plan.js

@@ -11,6 +11,7 @@ import { setupCpp } from './native/cpp.js';
 import { setupDotnet } from './native/dotnet.js';
 import { setupMesa } from './native/mesa.js';
 import { setupMsvc } from './native/msvc/index.js';
+import { setupUnreal } from './native/unreal.js';
 import { setupRust } from './native/rust.js';
 import { setupNode } from './languages/node.js';
 import { setupPwsh } from './tools/pwsh.js';
@@ -26,6 +27,7 @@ export function plan(config, versions, o) {
     const apps = Boolean(o.apps && (o.apps.install.length || Object.keys(o.apps.custom).length));
     const java = wanted(config.java.enabled, 'java');
     const python = wanted(config.python.enabled, 'python');
+    const unreal = wanted(config.unreal.enabled, 'unreal');
     return [
         {
             name: 'Git',
@@ -43,12 +45,18 @@ export function plan(config, versions, o) {
             enabled: wanted(config.cpp.enabled, 'cpp') || wanted(config.rust.enabled, 'rust'),
             install: (env) => setupCpp(env, config.cpp),
         },
-        { name: 'MSVC', enabled: wanted(config.msvc.enabled, 'msvc'), install: (env) => setupMsvc(env, config.msvc) },
+        // Unreal's Visual Studio brings MSVC and the real vswhere: the portable MSVC (and its stand-in vswhere) stays out.
+        { name: 'Unreal', enabled: unreal, shared: true, install: (env) => setupUnreal(env, config.unreal) },
+        {
+            name: 'MSVC',
+            enabled: wanted(config.msvc.enabled, 'msvc') && !unreal,
+            install: (env) => setupMsvc(env, config.msvc),
+        },
         // Rust links with MSVC (msvc host) or MinGW's gcc (GNU host): whichever it uses goes first.
         {
             name: 'Rust',
             enabled: wanted(config.rust.enabled, 'rust'),
-            after: ['C/C++', 'MSVC'],
+            after: ['C/C++', 'MSVC', 'Unreal'],
             install: async (env) => {
                 await setupRust(env, { ...config.rust, host: rustHost(config) }, o.refresh);
                 Object.assign(env.vars, rustCaches(config.rust));

package/dist/host/engines/hcs/live-folders.js

@@ -331,7 +331,7 @@ export function realLiveFolders(storageRoot, dataPath) {
     return new LiveFolders({
         storageRoot,
         dataPath,
-        secrets: SecretStore.standard(),
+        secrets: SecretStore.standard(storageRoot),
         elevated: new ScriptLivePort(),
         userSid: currentUserSid,
         isAlive: isSandboxRunning,

package/dist/host/github/token.js

@@ -23,7 +23,7 @@ export function checkGithubToken(token) {
 export class GithubToken {
     storageRoot;
     secrets;
-    constructor(storageRoot, secrets = SecretStore.standard()) {
+    constructor(storageRoot, secrets = SecretStore.standard(storageRoot)) {
         this.storageRoot = storageRoot;
         this.secrets = secrets;
     }

package/dist/host/profile/accounts.js

@@ -69,7 +69,7 @@ export class AccountStore {
     /** What the last activate() did with the shared plugins (a problem there never stops the switch). */
     pluginNote = null;
     /** @param sharePlugins claudeProfile.sharePluginsAcrossAccounts: carry Claude plugins to the account switched to */
-    constructor(storageRoot, sharePlugins = false, secrets = SecretStore.standard()) {
+    constructor(storageRoot, sharePlugins = false, secrets = SecretStore.standard(storageRoot)) {
         this.storageRoot = storageRoot;
         this.sharePlugins = sharePlugins;
         this.secrets = secrets;

package/dist/host/profile/agent-accounts.js

@@ -34,7 +34,7 @@ export class AgentAccountStore {
     /**
      * @param loginFiles files of the login, relative to the folder they are read from and written to
      */
-    constructor(storageRoot, agent, loginFiles, secrets = SecretStore.standard()) {
+    constructor(storageRoot, agent, loginFiles, secrets = SecretStore.standard(storageRoot)) {
         this.storageRoot = storageRoot;
         this.agent = agent;
         this.loginFiles = loginFiles;

package/dist/host/profile/plugin-share.d.ts

@@ -21,6 +21,11 @@ export declare class PluginShare {
     save(dataPath: string, claudeDir: string): void;
     /** The shared set goes into a data set's Claude folder; its own settings win, its other settings are untouched. */
     restore(dataPath: string, claudeDir: string): void;
+    /**
+     * Whether the shared set already holds this Claude folder's plugins: the same plugin records and plugin settings.
+     * Copying a big plugins folder takes seconds, so a switch between accounts with the same plugins skips it.
+     */
+    matches(claudeDir: string): boolean;
     /** One step when an account is switched to. */
     sync(dataPath: string, claudeDir: string): PluginShareResult;
 }