windows-development-sandbox 1.23.2 → 1.25.1

package/dist/guest/toolchains/plan.js

@@ -12,6 +12,7 @@ import { setupDotnet } from './native/dotnet.js';
 import { setupMesa } from './native/mesa.js';
 import { setupMsvc } from './native/msvc/index.js';
 import { fetchDirectX, setupUnreal } from './native/unreal.js';
+import { setupUnrealEngines } from './engines/unreal-engines.js';
 import { fetchRustupInit, setupRust } from './native/rust.js';
 import { setupNode } from './languages/node.js';
 import { setupPwsh } from './tools/pwsh.js';
@@ -21,7 +22,7 @@ import { fetchPhp, setupPhp } from './languages/php.js';
 import { setupRuby } from './languages/ruby.js';
 import { fetchVcRuntime, setupVcRuntime } from './native/vcruntime.js';
 import { setupVscode } from './tools/vscode.js';
-import { ensureVisualStudio, prefetchVisualStudio, unrealUsesAutosdk, visualStudioWanted, } from './native/visual-studio.js';
+import { ensureVisualStudio, prefetchVisualStudio, visualStudioSaved, visualStudioWanted, } from './native/visual-studio.js';
 import { duringSession } from '../runtime/project-context.js';
 import { setupSteam } from './steam/steam.js';
 import { setupGodot } from './engines/godot.js';
@@ -32,7 +33,7 @@ import { setupFlutter } from './mobile/flutter.js';
 import { setupDart } from './mobile/dart.js';
 import { setupReactNative } from './mobile/react-native.js';
 import { setupKotlin } from './languages/kotlin.js';
-import { rustHost, rustCaches, cargoDefaults, cargoShim, linkGate, resolveTargetDir, targetSummary, } from './native/rust-extras.js';
+import { rustHost, rustCaches, cargoDefaults, cargoShim, linkGate, lldLink, resolveTargetDir, targetSummary, } from './native/rust-extras.js';
 import { setupPythonTools } from './languages/python-tools.js';
 export function plan(config, versions, o) {
     const apps = Boolean(o.apps && (o.apps.install.length || Object.keys(o.apps.custom).length));
@@ -42,8 +43,6 @@ export function plan(config, versions, o) {
     const android = wanted(config.android.enabled, 'android');
     // One Visual Studio for every toolchain that needs the real one (Unreal, Flutter desktop, Unity IL2CPP).
     const vs = visualStudioWanted(config, (setting, name) => wanted(setting, name));
-    // Unreal on the portable MSVC (AutoSDK) needs that MSVC even when nothing else asked for it.
-    const autosdk = unrealUsesAutosdk(config, (setting, name) => wanted(setting, name));
     const ctx = {
         refresh: o.refresh,
         pcInstalls: o.pcInstalls ?? { items: [] },
@@ -69,32 +68,38 @@ export function plan(config, versions, o) {
             enabled: wanted(config.cpp.enabled, 'cpp') || wanted(config.rust.enabled, 'rust'),
             install: (env) => setupCpp(env, config.cpp),
         },
-        // Visual Studio brings MSVC and the real vswhere: the portable MSVC (and its stand-in vswhere) stays out.
+        // Visual Studio brings MSVC and the real vswhere: the portable MSVC (and its stand-in vswhere) stays out. Only the
+        // first install goes to the background: a saved copy is back in seconds, before the agent starts.
         {
             name: 'Visual Studio',
             enabled: vs !== null,
             shared: true,
-            background: deferred,
+            background: deferred && !visualStudioSaved(vs),
             ...ahead(() => prefetchVisualStudio(vs)),
             install: async (env) => {
-                await ensureVisualStudio(env, vs, { keepInstallFiles: config.unreal.keepInstallFiles, lowPriority: deferred });
+                await ensureVisualStudio(env, vs, { lowPriority: deferred });
             },
         },
         {
             name: 'Unreal',
             enabled: unreal,
             shared: true,
-            after: ['Visual Studio', 'MSVC'],
+            after: ['Visual Studio'],
             ...ahead(() => fetchDirectX(config.unreal)),
             install: (env) => setupUnreal(env, config.unreal, ctx),
         },
+        // Each project's engine (its .uproject's EngineAssociation) on its PATH: not shared, a project that joins later
+        // gets its own. It registers every engine too, so this PC's engines work without the licence step above.
+        {
+            name: 'Unreal engines',
+            enabled: unreal,
+            after: ['Unreal'],
+            install: (env) => setupUnrealEngines(env, config.unreal, ctx),
+        },
         {
             name: 'MSVC',
-            enabled: (wanted(config.msvc.enabled, 'msvc') || (autosdk && config.msvc.enabled !== false)) && vs === null,
-            // The same Visual Studio licence terms, which Unreal's acceptLicense already names.
-            install: (env) => setupMsvc(env, autosdk
-                ? { ...config.msvc, acceptLicense: config.msvc.acceptLicense || config.unreal.acceptLicense }
-                : config.msvc),
+            enabled: wanted(config.msvc.enabled, 'msvc') && vs === null,
+            install: (env) => setupMsvc(env, config.msvc),
         },
         // Rust links with MSVC (msvc host) or MinGW's gcc (GNU host): whichever it uses goes first.
         {
@@ -112,6 +117,8 @@ export function plan(config, versions, o) {
                     cargoDefaults(rustHost(config));
                     cargoShim(env, rust);
                     linkGate(env, rust, rustHost(config));
+                    lldLink(env, rust, rustHost(config));
+                    lldLink(env, rust, rustHost(config));
                 }
             },
         },
@@ -167,10 +174,11 @@ export function plan(config, versions, o) {
         },
         { name: 'Ruby', enabled: wanted(config.ruby.enabled, 'ruby'), install: (env) => setupRuby(env, config.ruby) },
         // PHP installs the Visual C++ runtime itself: one installer at a time.
-        // Many apps (bat, delta, Neovim, most GUIs, your own programs) are built against it too.
+        // Many apps (bat, delta, Neovim, most GUIs, your own programs) are built against it too, and so is what Visual
+        // Studio builds: a Visual Studio put back from the data disk does not bring it, as its installer did.
         {
             name: 'Visual C++ runtime',
-            enabled: config.vcRuntime.enabled || apps,
+            enabled: config.vcRuntime.enabled || apps || vs !== null,
             shared: true,
             ...ahead(fetchVcRuntime),
             install: async (env) => {

package/dist/guest/toolchains/tools/vscode-profile.js

@@ -54,6 +54,8 @@ const BY_TOOLCHAIN = {
     rust: ['rust-lang.rust-analyzer', 'vadimcn.vscode-lldb'],
     cpp: ['ms-vscode.cpptools', 'ms-vscode.cmake-tools'],
     msvc: ['ms-vscode.cpptools', 'ms-vscode.cmake-tools'],
+    // Unreal C++ (IntelliSense from the generated .code-workspace) and the C# of the *.Build.cs / *.Target.cs rules.
+    unreal: ['ms-vscode.cpptools', 'ms-dotnettools.csharp'],
     dotnet: ['ms-dotnettools.csharp'],
     ruby: ['shopify.ruby-lsp'],
     php: ['bmewburn.vscode-intelephense-client', 'xdebug.php-debug'],

package/dist/host/accounts/kinds/epic.js

@@ -1,15 +1,21 @@
-// Epic Games: this PC's launcher sign-in ("Remember me" in its GameUserSettings.ini, often UTF-16). Taking it signs
-// the launcher on this PC out the first time a sandbox uses it (a sign-in works in one place at a time).
+// Epic Games: this PC's launcher sign-in ("Remember me" in its GameUserSettings.ini, often UTF-16; launcher 17+ keeps
+// it in Config\WindowsEditor, older ones in Config\Windows). Taking it signs the launcher on this PC out the first time
+// a sandbox uses it (a sign-in works in one place at a time).
 import path from 'node:path';
-import { epicSettingsFile, MAX_EPIC_INI_BYTES, readEpicLogin, } from '../../../shared/accounts/index.js';
+import { epicSettingsFiles, MAX_EPIC_INI_BYTES, readEpicLogin, } from '../../../shared/accounts/index.js';
 import { decodeText, readBoundedFile } from '../../../shared/io/index.js';
 export const epicSource = {
     fromPc(pc, from) {
         const localAppData = from ? path.resolve(from) : pc.localAppData;
         if (!localAppData)
             return null;
-        const bytes = readBoundedFile(epicSettingsFile(localAppData), MAX_EPIC_INI_BYTES);
-        return bytes ? readEpicLogin(decodeText(bytes).text) : null;
+        for (const file of epicSettingsFiles(localAppData)) {
+            const bytes = readBoundedFile(file, MAX_EPIC_INI_BYTES);
+            const login = bytes ? readEpicLogin(decodeText(bytes).text) : null;
+            if (login)
+                return login;
+        }
+        return null;
     },
     summary: () => null,
 };

package/dist/host/accounts/source.d.ts

@@ -4,6 +4,8 @@ export interface PcEnv {
     readonly localAppData: string;
     readonly appData: string;
     readonly programData: string;
+    /** C:\Program Files (where the Epic Games Launcher installs engines by default). */
+    readonly programFiles?: string;
     /** The environment the command runs with (a variable set in this terminal). */
     readonly env?: Readonly<Record<string, string | undefined>>;
     /** A variable of this Windows user's saved environment (HKCU\Environment), or null when it is not set. */

package/dist/host/accounts/source.js

@@ -32,6 +32,7 @@ export function pcEnv() {
         localAppData: env.LOCALAPPDATA ?? '',
         appData: env.APPDATA ?? '',
         programData: env.ProgramData ?? env.PROGRAMDATA ?? 'C:\\ProgramData',
+        programFiles: env.ProgramFiles ?? 'C:\\Program Files',
         env,
         userVariable: savedUserVariable,
     };

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

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

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

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

package/dist/host/migrate/registry.js

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

package/dist/host/pc-installs/discover.d.ts

@@ -10,6 +10,8 @@ export interface DiscoverOptions {
     readonly packageRoot: string;
     readonly storageRoot: string;
     readonly sources?: readonly PcInstallSource[];
+    /** This launch sets the sandbox up for Unreal ("auto" maps this PC's engines and vault cache then). */
+    readonly unrealOn?: boolean;
 }
 export interface DiscoveredInstalls {
     readonly mappings: ResolvedMapping[];

package/dist/host/pc-installs/discover.js

@@ -5,21 +5,29 @@ import { pcEnv } from '../accounts/index.js';
 import { epicInstalls } from './epic.js';
 import { steamInstalls } from './steam.js';
 import { unityInstalls } from './unity.js';
-import { unrealInstalls } from './unreal.js';
+import { unrealFolders, unrealInstalls } from './unreal.js';
+import { unrealVault } from './unreal-vault.js';
 /** At most this many installs are mapped (each one is a mapping in the .wsb). */
 export const MAX_PC_INSTALLS = 40;
 export const PC_INSTALL_SOURCES = [
     steamInstalls,
     epicInstalls,
+    unrealFolders,
     unrealInstalls,
+    unrealVault,
     unityInstalls,
 ];
+/** What a setting asks for: false (nothing), true (everything) or a list; "auto" follows the Unreal toolchain. */
+function wantedOf(s, setting, unrealOn) {
+    const value = s[setting];
+    return value === 'auto' ? unrealOn : value;
+}
 export function discoverPcInstalls(s, o, pc = pcEnv()) {
     const mappings = [];
     const items = [];
     const notes = [];
     for (const source of o.sources ?? PC_INSTALL_SOURCES) {
-        const wanted = s[source.setting];
+        const wanted = wantedOf(s, source.setting, o.unrealOn === true);
         if (wanted === false || (Array.isArray(wanted) && !wanted.length))
             continue;
         let found = [];
@@ -37,14 +45,22 @@ export function discoverPcInstalls(s, o, pc = pcEnv()) {
             }
             try {
                 const guest = pcInstallGuest(install.kind, install.id);
-                if (mappings.some((m) => m.guest.toLowerCase() === guest.toLowerCase()))
+                // Once each: a folder you registered (writable, listed first) is not mapped again read-only.
+                const same = (m) => m.guest.toLowerCase() === guest.toLowerCase() || m.host.toLowerCase() === install.host.toLowerCase();
+                if (mappings.some(same))
                     continue;
                 if (!dirExists(install.host)) {
                     notes.push('pcInstalls: ' + install.name + ' is not there any more (' + install.host + ').');
                     continue;
                 }
                 assertSafeMapping(install.host, o.packageRoot, o.storageRoot);
-                mappings.push({ host: install.host, guest, readOnly: true, label: 'this PC, read-only' });
+                const writable = install.writable === true;
+                mappings.push({
+                    host: install.host,
+                    guest,
+                    readOnly: !writable,
+                    label: writable ? 'this PC, writable' : 'this PC, read-only',
+                });
                 const { host: _host, ...shown } = install;
                 items.push({ ...shown, guest });
             }
@@ -53,7 +69,11 @@ export function discoverPcInstalls(s, o, pc = pcEnv()) {
             }
         }
         if (Array.isArray(wanted) && found.length < wanted.length)
-            notes.push('pcInstalls.' + source.setting + ': some of the listed ones are not installed on this PC.');
+            notes.push('pcInstalls.' +
+                source.setting +
+                (source.setting === 'unrealEngineFolders'
+                    ? ': some of the listed folders are missing or hold no engine (Engine\\Build\\Build.version).'
+                    : ': some of the listed ones are not installed on this PC.'));
     }
     return { mappings, manifest: { items }, notes };
 }

package/dist/host/pc-installs/epic.d.ts

@@ -1,2 +1,5 @@
+import type { PcInstall } from '../../shared/paths/index.js';
 import type { PcInstallSource } from './source.js';
+/** The games a LauncherInstalled.dat lists that `wanted` maps (by app name), each once. */
+export declare function findEpicGames(text: string | null, wanted: true | readonly (string | number)[]): PcInstall[];
 export declare const epicInstalls: PcInstallSource;

package/dist/host/pc-installs/epic.js

@@ -1,7 +1,38 @@
+// Epic Games Launcher games of this PC (pcInstalls.epicGames): the InstallationList of its LauncherInstalled.dat
+// (%ProgramData%\Epic\UnrealEngineLauncher), engines (UE_x.y) left to unreal.ts. C:\PcInstalls\epic\<AppName>.
+import path from 'node:path';
+import { readBoundedFile } from '../../shared/io/index.js';
+import { launcherInstallations, launcherInstalledFile, MAX_LAUNCHER_FILE_BYTES } from '../../shared/unreal/index.js';
+const APP = /^[A-Za-z0-9._-]{1,100}$/;
+/** The games a LauncherInstalled.dat lists that `wanted` maps (by app name), each once. */
+export function findEpicGames(text, wanted) {
+    const names = wanted === true ? null : new Set(wanted.map((w) => String(w).toLowerCase()));
+    const found = [];
+    for (const i of text ? launcherInstallations(text) : []) {
+        if (!APP.test(i.appName) || /^\.+$/.test(i.appName) || /^UE_\d/.test(i.appName))
+            continue;
+        if (names && !names.has(i.appName.toLowerCase()))
+            continue;
+        if (found.some((f) => f.id.toLowerCase() === i.appName.toLowerCase()))
+            continue;
+        found.push({
+            kind: 'epic-game',
+            id: i.appName,
+            name: path.win32.basename(i.installLocation).slice(0, 100) || i.appName,
+            ...(i.ids ? { version: i.ids.appVersion.slice(0, 60), launcher: i.ids } : {}),
+            host: path.win32.normalize(i.installLocation),
+            guest: '',
+        });
+    }
+    return found;
+}
 export const epicInstalls = {
     kind: 'epic-game',
     setting: 'epicGames',
-    find(_wanted, _pc) {
-        return [];
+    find(wanted, pc) {
+        const bytes = readBoundedFile(launcherInstalledFile(pc.programData), MAX_LAUNCHER_FILE_BYTES);
+        if (!bytes)
+            throw new Error('the Epic Games Launcher has no LauncherInstalled.dat here');
+        return findEpicGames(bytes.toString('utf8'), wanted);
     },
 };

package/dist/host/pc-installs/source.d.ts

@@ -3,7 +3,7 @@ import type { PcEnv } from '../accounts/index.js';
 export interface PcInstallSource {
     readonly kind: PcInstall['kind'];
     /** The settings key that turns it on (pcInstalls.<setting>). */
-    readonly setting: 'steamGames' | 'epicGames' | 'unrealEngines' | 'unityEditors';
+    readonly setting: 'steamGames' | 'epicGames' | 'unrealEngines' | 'unrealEngineFolders' | 'unrealAssets' | 'unityEditors';
     /** What is installed: everything (true) or the ones listed. Bounded reads only (registry, manifests). */
     find(wanted: true | readonly (string | number)[], pc: PcEnv): PcInstall[];
 }

package/dist/host/pc-installs/unreal-vault.d.ts

@@ -0,0 +1,11 @@
+import type { PcInstall } from '../../shared/paths/index.js';
+import { type VaultFs } from '../../shared/unreal/index.js';
+import type { PcEnv } from '../accounts/index.js';
+import type { PcInstallSource } from './source.js';
+/** The vault cache folders of this PC: the ones its launcher settings name, else the default. */
+export declare function vaultDirs(pc: Pick<PcEnv, 'localAppData' | 'programData'>, isDir: (dir: string) => boolean): string[];
+/** The vault folders as installs to map (read-only). */
+export declare function vaultInstalls(dirs: readonly string[]): PcInstall[];
+/** This PC's disk for vaultPacks (bounded lists). */
+export declare const PC_VAULT_FS: VaultFs;
+export declare const unrealVault: PcInstallSource;

package/dist/host/pc-installs/unreal-vault.js

@@ -0,0 +1,78 @@
+// The Epic Games Launcher's vault cache of this PC (pcInstalls.unrealAssets): the Fab and Marketplace packs you
+// downloaded, mapped read-only at C:\PcInstalls\unreal\Vault (Vault2 ... for more folders), so what you download on the
+// PC is in the sandbox at once. Its folders come from the launcher's settings (shared/unreal/vault.ts), else the
+// default one; only folders that exist are mapped.
+import fs from 'node:fs';
+import path from 'node:path';
+import { epicSettingsFiles, MAX_EPIC_INI_BYTES } from '../../shared/accounts/index.js';
+import { decodeText, readBoundedFile } from '../../shared/io/index.js';
+import { defaultVaultDir, vaultDirsFromIni } from '../../shared/unreal/index.js';
+const MAX_VAULTS = 4;
+/** The vault cache folders of this PC: the ones its launcher settings name, else the default. */
+export function vaultDirs(pc, isDir) {
+    const named = pc.localAppData
+        ? epicSettingsFiles(pc.localAppData).flatMap((file) => {
+            const bytes = readBoundedFile(file, MAX_EPIC_INI_BYTES);
+            return bytes ? vaultDirsFromIni(decodeText(bytes).text) : [];
+        })
+        : [];
+    const all = [...named, defaultVaultDir(pc.programData)];
+    return all
+        .filter((d, i) => all.findIndex((o) => o.toLowerCase() === d.toLowerCase()) === i)
+        .filter(isDir)
+        .slice(0, MAX_VAULTS);
+}
+/** The vault folders as installs to map (read-only). */
+export function vaultInstalls(dirs) {
+    return dirs.map((dir, i) => ({
+        kind: 'unreal-vault',
+        id: i ? 'Vault' + (i + 1) : 'Vault',
+        name: 'Epic Games Launcher vault cache' + (i ? ' ' + (i + 1) : ''),
+        host: dir,
+        guest: '',
+    }));
+}
+const isDir = (dir) => {
+    try {
+        return fs.statSync(dir).isDirectory();
+    }
+    catch {
+        return false;
+    }
+};
+/** This PC's disk for vaultPacks (bounded lists). */
+export const PC_VAULT_FS = {
+    exists: (file) => fs.existsSync(file),
+    list: (dir) => {
+        try {
+            return fs.readdirSync(dir).slice(0, 5000);
+        }
+        catch {
+            return []; // Not a folder: nothing in it.
+        }
+    },
+    size: (file) => {
+        try {
+            const s = fs.lstatSync(file);
+            return s.isFile() ? s.size : null;
+        }
+        catch {
+            return null;
+        }
+    },
+    isDir: (dir) => {
+        try {
+            return fs.lstatSync(dir).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    },
+};
+export const unrealVault = {
+    kind: 'unreal-vault',
+    setting: 'unrealAssets',
+    find(_wanted, pc) {
+        return vaultInstalls(vaultDirs(pc, isDir)).map((v) => ({ ...v, host: path.win32.normalize(v.host) }));
+    },
+};

package/dist/host/pc-installs/unreal.d.ts

@@ -1,2 +1,38 @@
+import type { PcInstall } from '../../shared/paths/index.js';
+import type { PcEnv } from '../accounts/index.js';
 import type { PcInstallSource } from './source.js';
+/** At most this many engines of this PC are mapped. */
+export declare const MAX_PC_ENGINES = 8;
+/** What discovery reads on this PC (the self-test passes fixtures). */
+export interface UnrealPcFiles {
+    /** LauncherInstalled.dat's text, or null. */
+    readonly launcherInstalled: string | null;
+    /** `reg query HKCU\Software\Epic Games\Unreal Engine\Builds` output ('' when the key is missing). */
+    readonly builds: string;
+    /** The launcher's default engines folder (<Program Files>\Epic Games). */
+    readonly defaultRoot: string;
+    readonly list: (dir: string) => string[];
+    readonly read: (file: string, max: number) => Buffer | null;
+}
+/** The values of `reg query <key>` output: the name and string of each REG_SZ / REG_EXPAND_SZ line. */
+export declare function regValues(text: string): {
+    name: string;
+    value: string;
+}[];
+/** The engines of this PC that `wanted` maps, each folder once, at most MAX_PC_ENGINES. */
+export declare function findUnrealInstalls(files: UnrealPcFiles, wanted: true | readonly (string | number)[]): PcInstall[];
+/** A source build of this PC's Builds key. */
+export interface PcSourceBuild {
+    readonly buildId: string;
+    readonly version: string;
+    readonly host: string;
+}
+/** Source builds this PC registered (the Builds key). They are not mapped by themselves: UBT writes inside them. */
+export declare function pcSourceBuilds(files: Pick<UnrealPcFiles, 'read' | 'builds'>): PcSourceBuild[];
+/** The engine folders you registered (pcInstalls.unrealEngineFolders), mapped writable. A folder that is a source
+ * build of this PC keeps the PC's build id. */
+export declare function findEngineFolders(files: Pick<UnrealPcFiles, 'read' | 'builds'>, folders: readonly (string | number)[]): PcInstall[];
+/** This PC's files (reg.exe through system32, bounded reads). */
+export declare function unrealPcFiles(pc: PcEnv): UnrealPcFiles;
 export declare const unrealInstalls: PcInstallSource;
+export declare const unrealFolders: PcInstallSource;

package/dist/host/pc-installs/unreal.js

@@ -1,7 +1,150 @@
+// Unreal Engine versions of this PC (pcInstalls.unrealEngines): the launcher's LauncherInstalled.dat (engines it
+// installed, with its own ids) and the launcher's default folders (<Program Files>\Epic Games\UE_*, for an install
+// whose LauncherInstalled.dat is gone). Each must hold Engine\Build\Build.version; it is mapped read-only at
+// C:\PcInstalls\unreal\UE_5.4. Source builds (HKCU\Software\Epic Games\Unreal Engine\Builds) are NOT mapped by
+// themselves, as UBT writes inside an engine. pcInstalls.unrealEngineFolders: folders you registered, mapped writable
+// (dir-<name>; a source build of this PC keeps its build id). Every file is read bounded.
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { readBoundedFile } from '../../shared/io/index.js';
+import { SYSTEM } from '../../shared/system.js';
+import { BUILDS_KEY, launcherInstallations, launcherInstalledFile, MAX_LAUNCHER_FILE_BYTES, parseBuildVersion, versionText, } from '../../shared/unreal/index.js';
+const win = path.win32;
+/** At most this many engines of this PC are mapped. */
+export const MAX_PC_ENGINES = 8;
+const APP_NAME = /^UE_(\d{1,2}\.\d{1,2})$/;
+/** The values of `reg query <key>` output: the name and string of each REG_SZ / REG_EXPAND_SZ line. */
+export function regValues(text) {
+    return text
+        .split(/\r?\n/)
+        .slice(0, 500)
+        .flatMap((line) => {
+        const m = /^\s{2,}(\S(?:.{0,200}?\S)?)\s{2,}REG_(?:EXPAND_)?SZ\s{2,}(.{1,1000})$/.exec(line);
+        return m ? [{ name: m[1], value: m[2].trim() }] : [];
+    });
+}
+const versionOf = (dir, files) => {
+    const bytes = files.read(win.join(dir, 'Engine', 'Build', 'Build.version'), 64 * 1024);
+    return bytes ? parseBuildVersion(bytes.toString('utf8')) : null;
+};
+const isWanted = (wanted, v) => wanted === true || wanted.map((w) => String(w).replace(/^UE_/i, '')).includes(v.major + '.' + v.minor);
+/** The engines of this PC that `wanted` maps, each folder once, at most MAX_PC_ENGINES. */
+export function findUnrealInstalls(files, wanted) {
+    const found = [];
+    const add = (install) => {
+        const key = win.resolve(install.host).toLowerCase();
+        if (found.length >= MAX_PC_ENGINES)
+            return;
+        if (found.some((f) => f.id === install.id || win.resolve(f.host).toLowerCase() === key))
+            return;
+        found.push(install);
+    };
+    const installed = (dir, ids) => {
+        const v = versionOf(dir, files);
+        if (!v || !isWanted(wanted, v))
+            return;
+        add({
+            kind: 'unreal',
+            id: 'UE_' + v.major + '.' + v.minor,
+            name: 'Unreal Engine ' + versionText(v),
+            version: versionText(v),
+            host: win.normalize(dir),
+            guest: '',
+            ...(ids ? { launcher: ids } : {}),
+        });
+    };
+    for (const i of files.launcherInstalled ? launcherInstallations(files.launcherInstalled) : [])
+        if (APP_NAME.test(i.appName))
+            installed(i.installLocation, i.ids ?? undefined);
+    for (const name of files
+        .list(files.defaultRoot)
+        .filter((n) => APP_NAME.test(n))
+        .sort())
+        installed(win.join(files.defaultRoot, name));
+    return found;
+}
+/** Source builds this PC registered (the Builds key). They are not mapped by themselves: UBT writes inside them. */
+export function pcSourceBuilds(files) {
+    const found = [];
+    for (const { name, value } of regValues(files.builds)) {
+        const dir = value.replace(/\//g, '\\');
+        if (!win.isAbsolute(dir) || found.length >= MAX_PC_ENGINES)
+            continue;
+        const v = versionOf(dir, files);
+        if (v)
+            found.push({ buildId: name.slice(0, 64), version: versionText(v), host: win.normalize(dir) });
+    }
+    return found;
+}
+/** The engine folders you registered (pcInstalls.unrealEngineFolders), mapped writable. A folder that is a source
+ * build of this PC keeps the PC's build id. */
+export function findEngineFolders(files, folders) {
+    const found = [];
+    const sources = pcSourceBuilds(files);
+    for (const raw of folders.map(String)) {
+        const dir = win.normalize(raw);
+        if (!win.isAbsolute(dir) || found.some((f) => f.host.toLowerCase() === dir.toLowerCase()))
+            continue;
+        const v = versionOf(dir, files);
+        if (!v)
+            continue;
+        const base = win
+            .basename(dir)
+            .replace(/[^A-Za-z0-9._-]/g, '')
+            .replace(/^\.+/, '')
+            .slice(0, 40) || 'engine';
+        const id = 'dir-' + base;
+        const source = sources.find((b) => b.host.toLowerCase() === dir.toLowerCase());
+        found.push({
+            kind: 'unreal',
+            id: found.some((f) => f.id === id) ? id + '-' + (found.length + 1) : id,
+            name: 'Unreal Engine ' + versionText(v) + ' (' + win.basename(dir).slice(0, 60) + ')',
+            version: versionText(v),
+            host: dir,
+            guest: '',
+            writable: true,
+            ...(source ? { buildId: source.buildId } : {}),
+        });
+    }
+    return found;
+}
+function listDir(dir) {
+    try {
+        return fs.readdirSync(dir).slice(0, 500);
+    }
+    catch {
+        return []; // Not there: nothing in it.
+    }
+}
+/** This PC's files (reg.exe through system32, bounded reads). */
+export function unrealPcFiles(pc) {
+    const query = spawnSync(SYSTEM.reg(), ['query', 'HKCU\\' + BUILDS_KEY], {
+        encoding: 'utf8',
+        windowsHide: true,
+        timeout: 15_000,
+        maxBuffer: 256 * 1024,
+    });
+    const dat = readBoundedFile(launcherInstalledFile(pc.programData), MAX_LAUNCHER_FILE_BYTES);
+    return {
+        launcherInstalled: dat ? dat.toString('utf8') : null,
+        builds: query.status === 0 ? String(query.stdout ?? '') : '',
+        defaultRoot: win.join(pc.programFiles ?? 'C:\\Program Files', 'Epic Games'),
+        list: listDir,
+        read: readBoundedFile,
+    };
+}
 export const unrealInstalls = {
     kind: 'unreal',
     setting: 'unrealEngines',
-    find(_wanted, _pc) {
-        return [];
+    find(wanted, pc) {
+        return findUnrealInstalls(unrealPcFiles(pc), wanted);
+    },
+};
+export const unrealFolders = {
+    kind: 'unreal',
+    setting: 'unrealEngineFolders',
+    find(wanted, pc) {
+        return wanted === true ? [] : findEngineFolders(unrealPcFiles(pc), wanted);
     },
 };