windows-development-sandbox 1.25.0 → 1.27.0

package/dist/shared/unreal/launcher-files.js

@@ -0,0 +1,292 @@
+// What the Epic Games Launcher keeps about installed apps, pure apart from the files it is pointed at:
+// LauncherInstalled.dat (%ProgramData%\Epic\UnrealEngineLauncher: the InstallationList the editor and
+// UnrealVersionSelector read), the .item manifests (%ProgramData%\Epic\EpicGamesLauncher\Data\Manifests: what the
+// launcher itself lists as installed) and GameUserSettings.ini (its DefaultAppInstallLocation). Entries and manifests
+// that are not ours (other games, engines elsewhere) are never dropped or changed. Every file is read bounded.
+import fs from 'node:fs';
+import path from 'node:path';
+import { z } from 'zod';
+import { readBoundedFile } from '../io/bounded.js';
+import { decodeText, encodeText } from '../io/text.js';
+import { launcherAppName, preferredInstalled } from './engines.js';
+const win = path.win32;
+/** "5.4.4-33043543+++UE5+Release-5.4": the launcher's AppVersion of an engine version. */
+export function appVersionText(v) {
+    return v.major + '.' + v.minor + '.' + v.patch + '-' + v.changelist + '+' + v.branch.replace(/^\+*/, '++');
+}
+export const MAX_LAUNCHER_FILE_BYTES = 4 * 1024 * 1024;
+const MAX_ITEM_BYTES = 1024 * 1024;
+const MAX_ENTRIES = 2000;
+const stripBom = (text) => text.replace(/^\uFEFF/, '');
+/** %ProgramData%\Epic\UnrealEngineLauncher\LauncherInstalled.dat */
+export function launcherInstalledFile(programData) {
+    return win.join(programData, 'Epic', 'UnrealEngineLauncher', 'LauncherInstalled.dat');
+}
+/** %ProgramData%\Epic\EpicGamesLauncher\Data\Manifests */
+export function launcherManifestsDir(programData) {
+    return win.join(programData, 'Epic', 'EpicGamesLauncher', 'Data', 'Manifests');
+}
+/**
+ * The launcher's settings files under %LOCALAPPDATA%\EpicGamesLauncher\Saved\Config: WindowsEditor\ (what launcher 17+
+ * writes; 20.3 checked) and Windows\ (older launchers).
+ */
+export function launcherSettingsFiles(localAppData) {
+    const config = win.join(localAppData, 'EpicGamesLauncher', 'Saved', 'Config');
+    return [
+        win.join(config, 'WindowsEditor', 'GameUserSettings.ini'),
+        win.join(config, 'Windows', 'GameUserSettings.ini'),
+    ];
+}
+const EntrySchema = z.looseObject({
+    InstallLocation: z.string().max(1024),
+    AppName: z.string().max(200),
+    NamespaceId: z.string().max(200).optional(),
+    ItemId: z.string().max(200).optional(),
+    ArtifactId: z.string().max(200).optional(),
+    AppVersion: z.string().max(200).optional(),
+});
+const InstalledFileSchema = z.looseObject({ InstallationList: z.array(z.unknown()).max(MAX_ENTRIES) });
+/** The InstallationList of a LauncherInstalled.dat text ([] when it is empty or not one). */
+export function launcherInstallations(text) {
+    let list;
+    try {
+        list = InstalledFileSchema.parse(JSON.parse(stripBom(text))).InstallationList;
+    }
+    catch {
+        return [];
+    }
+    return list.flatMap((raw) => {
+        const e = EntrySchema.safeParse(raw);
+        if (!e.success || !win.isAbsolute(e.data.InstallLocation) || /["\r\n]/.test(e.data.InstallLocation))
+            return [];
+        const { NamespaceId, ItemId, ArtifactId, AppVersion } = e.data;
+        return [
+            {
+                appName: e.data.AppName,
+                installLocation: e.data.InstallLocation,
+                ids: NamespaceId && ItemId && ArtifactId && AppVersion
+                    ? { namespaceId: NamespaceId, itemId: ItemId, artifactId: ArtifactId, appVersion: AppVersion }
+                    : null,
+            },
+        ];
+    });
+}
+/** The entry that lists an engine folder as an installed engine (with the launcher's own ids when they are known). */
+export function launcherEntry(engine, ids = null) {
+    const name = launcherAppName(engine.version);
+    return {
+        InstallLocation: engine.dir,
+        NamespaceId: ids?.namespaceId ?? 'ue',
+        ItemId: ids?.itemId ?? name,
+        ArtifactId: ids?.artifactId ?? name,
+        AppVersion: ids?.appVersion ?? appVersionText(engine.version),
+        AppName: name,
+    };
+}
+/**
+ * The LauncherInstalled.dat entries for the installed builds: only the one preferred for each version (Unreal keeps
+ * the LAST entry per app name, so a second UE_5.4 would shadow the first), with the launcher's own saved entry when
+ * there is one, else the ids copied from this PC, else made up.
+ */
+export function launcherEntriesFor(engines, saved, pcItems) {
+    return preferredInstalled(engines).map((e) => {
+        const own = saved.find((s) => s.InstallLocation.toLowerCase() === e.dir.toLowerCase());
+        if (own)
+            return own;
+        const pc = pcItems.find((i) => i.kind === 'unreal' && i.guest.toLowerCase() === e.dir.toLowerCase());
+        return launcherEntry(e, pc?.launcher ?? null);
+    });
+}
+/**
+ * LauncherInstalled.dat with these entries in it. Every entry that is not one of them (another game, an engine at
+ * another place) stays as it was; an entry for the same folder is replaced. A file that is not a LauncherInstalled.dat
+ * throws (it is never overwritten); a missing or empty one starts a new list.
+ */
+export function mergeLauncherInstalled(existing, entries) {
+    let list = [];
+    let rest = {};
+    if (existing && existing.trim()) {
+        const { InstallationList, ...others } = InstalledFileSchema.parse(JSON.parse(stripBom(existing)));
+        list = InstallationList;
+        rest = others;
+    }
+    const same = (raw, mine) => {
+        const e = EntrySchema.safeParse(raw);
+        return (e.success &&
+            win.normalize(e.data.InstallLocation).toLowerCase() === win.normalize(mine.InstallLocation).toLowerCase());
+    };
+    const kept = list.filter((raw) => !entries.some((mine) => same(raw, mine)));
+    return JSON.stringify({ ...rest, InstallationList: [...kept, ...entries] }, null, '\t') + '\n';
+}
+/** Whether `child` is `parent` or inside it (case-insensitive, Windows paths). */
+export function isWithin(parent, child) {
+    const rel = win.relative(win.resolve(parent).toLowerCase(), win.resolve(child).toLowerCase());
+    return rel === '' || (!rel.startsWith('..') && !win.isAbsolute(rel));
+}
+/** The entries of a LauncherInstalled.dat text whose folder is under `root` (the engines kept on the data disk). */
+export function entriesUnder(text, root) {
+    return launcherInstallations(text)
+        .filter((i) => i.ids && isWithin(root, i.installLocation) && win.resolve(i.installLocation) !== win.resolve(root))
+        .map((i) => ({
+        InstallLocation: i.installLocation,
+        NamespaceId: i.ids.namespaceId,
+        ItemId: i.ids.itemId,
+        ArtifactId: i.ids.artifactId,
+        AppVersion: i.ids.appVersion,
+        AppName: i.appName,
+    }));
+}
+// ---- .item manifests ------------------------------------------------------------------------------------------
+const ItemSchema = z.looseObject({
+    InstallLocation: z.string().max(1024).optional(),
+    AppName: z.string().max(200).optional(),
+    InstallSize: z.number().int().min(0).optional(),
+    bIsIncompleteInstall: z.boolean().optional(),
+});
+/** The folder a launcher manifest says its app is installed in, or null. */
+export function itemInstallLocation(text) {
+    return itemInfo(text)?.installLocation ?? null;
+}
+/** A launcher manifest's folder and size, or null when it is not one we can read. */
+export function itemInfo(text) {
+    try {
+        const item = ItemSchema.parse(JSON.parse(stripBom(text)));
+        const at = item.InstallLocation;
+        return at && win.isAbsolute(at) ? { installLocation: at, sizeBytes: item.InstallSize ?? null } : null;
+    }
+    catch {
+        return null; // Not a manifest we can read: left alone.
+    }
+}
+/**
+ * The folders (lower-case, normalized) the manifests in these folders mark as a launcher install still in progress
+ * (bIsIncompleteInstall): not engines yet.
+ */
+export function incompleteDirs(...manifestDirs) {
+    const dirs = new Set();
+    for (const dir of manifestDirs)
+        for (const name of itemFiles(dir)) {
+            const bytes = readBoundedFile(win.join(dir, name), MAX_ITEM_BYTES);
+            if (!bytes)
+                continue;
+            try {
+                const item = ItemSchema.parse(JSON.parse(stripBom(bytes.toString('utf8'))));
+                if (item.bIsIncompleteInstall === true && item.InstallLocation && win.isAbsolute(item.InstallLocation))
+                    dirs.add(win.normalize(item.InstallLocation).toLowerCase());
+            }
+            catch {
+                // Not a manifest we can read: it marks nothing.
+            }
+        }
+    return dirs;
+}
+/** The sizes the saved manifests give their engine folders (lower-case folder -> bytes). */
+export function itemSizes(saved) {
+    const sizes = new Map();
+    for (const name of itemFiles(saved)) {
+        const bytes = readBoundedFile(win.join(saved, name), MAX_ITEM_BYTES);
+        const info = bytes ? itemInfo(bytes.toString('utf8')) : null;
+        if (info?.sizeBytes !== null && info?.sizeBytes !== undefined)
+            sizes.set(win.normalize(info.installLocation).toLowerCase(), info.sizeBytes);
+    }
+    return sizes;
+}
+/** Whether the text is a launcher manifest of an app installed under `root`. */
+export function isItemUnder(text, root) {
+    const at = itemInstallLocation(text);
+    return at !== null && isWithin(root, at) && win.resolve(at) !== win.resolve(root);
+}
+function itemFiles(dir) {
+    try {
+        return fs.readdirSync(dir).filter((f) => /^[A-Za-z0-9_-]{1,80}\.item$/.test(f));
+    }
+    catch {
+        return [];
+    }
+}
+/** Copies the launcher's manifests of apps under `root` into `saved` (changed ones only). Returns the file names. */
+export function saveItems(manifests, saved, root) {
+    const done = [];
+    for (const name of itemFiles(manifests)) {
+        const bytes = readBoundedFile(win.join(manifests, name), MAX_ITEM_BYTES);
+        if (!bytes || !isItemUnder(bytes.toString('utf8'), root))
+            continue;
+        const old = readBoundedFile(win.join(saved, name), MAX_ITEM_BYTES);
+        if (old && old.equals(bytes))
+            continue;
+        fs.mkdirSync(saved, { recursive: true });
+        fs.writeFileSync(win.join(saved, name), bytes);
+        done.push(name);
+    }
+    return done;
+}
+/**
+ * Puts saved manifests back where the launcher reads them, for the apps whose folder is still there. A manifest the
+ * launcher already has is never replaced. Returns the folders they name.
+ */
+export function restoreItems(saved, manifests, root, exists) {
+    const dirs = [];
+    for (const name of itemFiles(saved)) {
+        const bytes = readBoundedFile(win.join(saved, name), MAX_ITEM_BYTES);
+        const at = bytes ? itemInstallLocation(bytes.toString('utf8')) : null;
+        if (!bytes || !at || !isItemUnder(bytes.toString('utf8'), root) || !exists(at))
+            continue;
+        dirs.push(win.normalize(at));
+        if (fs.existsSync(win.join(manifests, name)))
+            continue;
+        fs.mkdirSync(manifests, { recursive: true });
+        fs.writeFileSync(win.join(manifests, name), bytes);
+    }
+    return dirs;
+}
+// ---- GameUserSettings.ini -------------------------------------------------------------------------------------
+/** The ini text with [Launcher] DefaultAppInstallLocation set (other lines, comments and line ends untouched). */
+export function withInstallLocation(ini, dir) {
+    if (/[\r\n]/.test(dir))
+        throw new Error('not a folder: ' + dir);
+    const eol = ini.includes('\r\n') || !ini.includes('\n') ? '\r\n' : '\n';
+    const lines = ini.length ? ini.split(/\r?\n/) : [];
+    if (lines.length && lines[lines.length - 1] === '')
+        lines.pop();
+    const entry = 'DefaultAppInstallLocation=' + dir;
+    const start = lines.findIndex((l) => /^\s*\[Launcher\]\s*$/i.test(l));
+    if (start < 0)
+        return [...lines, ...(lines.length ? [''] : []), '[Launcher]', entry].join(eol) + eol;
+    let end = lines.findIndex((l, i) => i > start && /^\s*\[/.test(l));
+    if (end < 0)
+        end = lines.length;
+    const at = lines.findIndex((l, i) => i > start && i < end && /^\s*DefaultAppInstallLocation\s*=/i.test(l));
+    if (at >= 0)
+        lines[at] = entry;
+    else
+        lines.splice(start + 1, 0, entry);
+    return lines.join(eol) + eol;
+}
+/** The [Launcher] DefaultAppInstallLocation of an ini text, or null. */
+export function installLocationOf(ini) {
+    let inLauncher = false;
+    for (const raw of ini.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (line.startsWith('[')) {
+            inLauncher = /^\[Launcher\]$/i.test(line);
+            continue;
+        }
+        const m = inLauncher ? /^DefaultAppInstallLocation\s*=\s*(.*)$/i.exec(line) : null;
+        if (m)
+            return m[1].trim() || null;
+    }
+    return null;
+}
+/** Sets the launcher's default install folder in a settings file, keeping its encoding. Returns whether it changed. */
+export function setLauncherInstallLocation(file, dir) {
+    const bytes = readBoundedFile(file, MAX_LAUNCHER_FILE_BYTES);
+    if (!bytes && fs.existsSync(file))
+        throw new Error('could not read ' + file + ' (too big or not a file)');
+    const decoded = bytes ? decodeText(bytes) : { text: '', encoding: 'utf8' };
+    const next = withInstallLocation(decoded.text, dir);
+    if (bytes && next === decoded.text)
+        return false;
+    fs.mkdirSync(win.dirname(file), { recursive: true });
+    fs.writeFileSync(file, encodeText(next, decoded.encoding));
+    return true;
+}

package/dist/shared/unreal/mixamo.d.ts

@@ -0,0 +1,5 @@
+/** The Mixamo lines: where downloads land, the export settings, the import, and the licence. */
+export declare function mixamoGuideLines(o: {
+    readonly downloads: string;
+    readonly script: string | null;
+}): string[];

package/dist/shared/unreal/mixamo.js

@@ -0,0 +1,16 @@
+// The guide's Mixamo lines (free rigged characters and animations, downloaded in the sandbox's browser) and how
+// to bring them into Unreal. Pure: the guide adds them when an Unreal engine is set up (guide.ts).
+/** The Mixamo lines: where downloads land, the export settings, the import, and the licence. */
+export function mixamoGuideLines(o) {
+    const lines = [
+        "- Mixamo (rigged characters and animations, free with an Adobe sign-in): the user downloads them in this sandbox's browser from https://www.mixamo.com; downloads land in `" +
+            o.downloads +
+            '` (kept between sandboxes). Ask for the character as FBX Binary (.fbx), T-pose, With Skin; each animation as FBX Binary, Without Skin, 30 fps, In Place for walk and run loops.',
+        "- Mixamo into Unreal: import the character first (Skeletal Mesh, Import Uniform Scale 1.0; `mixamorig:Hips` is the root, so there is no root motion), then each animation with Skeleton = that character's skeleton. To use the UE5 mannequin's animations, retarget with an IK Rig per skeleton and an IK Retargeter. Licence: use them in the game; never ship or share the raw FBX files.",
+    ];
+    if (o.script)
+        lines.push('- Mixamo import script: `UnrealEditor-Cmd.exe "<Project>.uproject" -run=pythonscript -script="' +
+            o.script +
+            ' --fbx <file.fbx> --dest /Game/Characters/<Name> [--skeleton /Game/Characters/<Name>/<Name>_Skeleton]" -unattended -nullrhi -nosplash` (needs the Python Editor Script Plugin on in the .uproject).');
+    return lines;
+}

package/dist/shared/unreal/room.d.ts

@@ -0,0 +1,17 @@
+import { type StatFs } from '../io/disk.js';
+/** What one engine takes while the launcher installs it (download and unpacked, 40-60 GB). */
+export declare const ENGINE_NEED_BYTES: number;
+export interface LauncherPlace {
+    /** The launcher's install folder was set to the data disk. */
+    readonly set: boolean;
+    /** Why it could not be (the file could not be written), or that persistEngines is off. */
+    readonly error?: string;
+}
+/**
+ * The loud line for the boot summary and the Unreal page when an engine would not go to the data disk, or would not
+ * fit there; null when all is well.
+ */
+export declare function enginePlaceProblem(place: LauncherPlace, enginesDir: string, statfs?: StatFs): {
+    problem: string | null;
+    freeBytes: number | null;
+};

package/dist/shared/unreal/room.js

@@ -0,0 +1,34 @@
+// Where the Epic Games Launcher puts an engine, and whether there is room: engines go to the data disk only (never the
+// sandbox's own disk, which holds 8-14 GB free and the paging file), and one needs 60 GB free there. Pure apart from
+// the disk check it is given.
+import { freeBytesAt } from '../io/disk.js';
+const GB = 1024 ** 3;
+/** What one engine takes while the launcher installs it (download and unpacked, 40-60 GB). */
+export const ENGINE_NEED_BYTES = 60 * GB;
+const gb = (bytes) => (bytes / GB).toFixed(0) + ' GB';
+/**
+ * The loud line for the boot summary and the Unreal page when an engine would not go to the data disk, or would not
+ * fit there; null when all is well.
+ */
+export function enginePlaceProblem(place, enginesDir, statfs) {
+    if (!place.set)
+        return {
+            problem: 'ENGINES WOULD GO ON THE SANDBOX DISK: ' +
+                (place.error ?? "the Epic Games Launcher's install folder could not be set") +
+                '. Do not install an engine with the launcher in this sandbox (it would fill C: and be lost); install it on your PC instead (the next sandbox maps it read-only).',
+            freeBytes: null,
+        };
+    const free = freeBytesAt(enginesDir, statfs);
+    if (free !== null && free < ENGINE_NEED_BYTES)
+        return {
+            problem: 'Only ' +
+                gb(free) +
+                ' free on the data disk (' +
+                enginesDir +
+                '); an engine from the Epic Games Launcher needs ' +
+                gb(ENGINE_NEED_BYTES) +
+                '. Free room on that disk first, or install the engine on your PC (the next sandbox maps it read-only).',
+            freeBytes: free,
+        };
+    return { problem: null, freeBytes: free };
+}

package/dist/shared/unreal/status.d.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+/** The file in tools\unreal. */
+export declare const UNREAL_STATUS_FILE = "status.json";
+export declare const UnrealStatusSchema: z.ZodObject<{
+    updatedAt: z.ZodString;
+    engines: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        dir: z.ZodString;
+        version: z.ZodString;
+        build: z.ZodEnum<{
+            installed: "installed";
+            source: "source";
+        }>;
+        origin: z.ZodEnum<{
+            pc: "pc";
+            project: "project";
+            launcher: "launcher";
+            "pc-folder": "pc-folder";
+            data: "data";
+        }>;
+        writable: z.ZodBoolean;
+        sizeBytes: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    projects: z.ZodArray<z.ZodObject<{
+        workspace: z.ZodString;
+        engine: z.ZodNullable<z.ZodString>;
+        reason: z.ZodString;
+    }, z.core.$strip>>;
+    launcher: z.ZodObject<{
+        installed: z.ZodBoolean;
+        installLocation: z.ZodNullable<z.ZodString>;
+        problem: z.ZodNullable<z.ZodString>;
+        freeBytes: z.ZodNullable<z.ZodNumber>;
+        needBytes: z.ZodNumber;
+    }, z.core.$strip>;
+    visualStudio: z.ZodObject<{
+        version: z.ZodString;
+        path: z.ZodString;
+        how: z.ZodString;
+        check: z.ZodString;
+        ok: z.ZodBoolean;
+    }, z.core.$strip>;
+    debugger: z.ZodNullable<z.ZodString>;
+    ddc: z.ZodObject<{
+        mode: z.ZodEnum<{
+            persisted: "persisted";
+            local: "local";
+        }>;
+        dir: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    vaults: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    mcpUrl: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export type UnrealStatus = z.output<typeof UnrealStatusSchema>;

package/dist/shared/unreal/status.js

@@ -0,0 +1,57 @@
+// What the sandbox last found for Unreal (tools\unreal\status.json): its engines, which engine each project builds
+// with, the Epic Games Launcher's install folder, Visual Studio, the debuggers and the derived data cache. The sandbox
+// writes it every boot and when a project joins; the Unreal page on this PC reads it. It is written by the guest, so
+// the host reads it with this schema (bounded strings and lists) and prints its text through safeText.
+import { z } from 'zod';
+/** The file in tools\unreal. */
+export const UNREAL_STATUS_FILE = 'status.json';
+const Text = (max = 400) => z.string().max(max);
+export const UnrealStatusSchema = z.object({
+    updatedAt: Text(40),
+    engines: z
+        .array(z.object({
+        id: Text(100),
+        dir: Text(),
+        version: Text(40),
+        build: z.enum(['installed', 'source']),
+        origin: z.enum(['pc', 'pc-folder', 'launcher', 'data', 'project']),
+        writable: z.boolean(),
+        /** Its size on disk, when it was counted (the launcher's manifest says it). */
+        sizeBytes: z.number().int().min(0).nullable(),
+    }))
+        .max(32),
+    projects: z
+        .array(z.object({
+        workspace: Text(),
+        /** The engine's folder, null when there is none for it. */
+        engine: Text().nullable(),
+        reason: Text(),
+    }))
+        .max(64),
+    launcher: z.object({
+        installed: z.boolean(),
+        /** Where the launcher installs engines; null when it could not be set. */
+        installLocation: Text().nullable(),
+        /** Why engines would not go to the data disk (shown loudly), null when they do. */
+        problem: Text(600).nullable(),
+        freeBytes: z.number().min(0).nullable(),
+        needBytes: z.number().min(0),
+    }),
+    visualStudio: z.object({
+        version: Text(60),
+        path: Text(),
+        /** "kept on the data disk", "installed" ... ('' when there is none). */
+        how: Text(100),
+        /** What UnrealBuildTool's way of looking finds (the Setup API, MSVC, the Windows SDK), in plain words. */
+        check: Text(600),
+        /** Whether that check found everything a build needs. */
+        ok: z.boolean(),
+    }),
+    /** cdb.exe of the Windows SDK's debuggers, null when they are missing. */
+    debugger: Text().nullable(),
+    ddc: z.object({ mode: z.enum(['persisted', 'local']), dir: Text().nullable() }),
+    /** This PC's vault cache folders (Fab and Marketplace packs), read-only in the sandbox. */
+    vaults: z.array(Text()).max(4).default([]),
+    /** The editor's MCP server address when the project's engine has the plugin. */
+    mcpUrl: Text(200).nullable(),
+});

package/dist/shared/unreal/vault.d.ts

@@ -0,0 +1,21 @@
+/** The default vault cache under a ProgramData folder. */
+export declare function defaultVaultDir(programData: string): string;
+/** The vault cache folders a launcher settings text names (VaultCacheDirectories / VaultCacheLocation lines). */
+export declare function vaultDirsFromIni(ini: string): string[];
+export interface VaultFs {
+    exists(file: string): boolean;
+    list(dir: string): string[];
+    /** A file's size, or null when it is a folder or missing. */
+    size(file: string): number | null;
+    isDir(dir: string): boolean;
+}
+export interface VaultPack {
+    readonly name: string;
+    /** Bytes counted (at least this much when `partial`). */
+    readonly sizeBytes: number;
+    readonly partial: boolean;
+    /** "content" (data\Content: copy it into a project's Content) or "plugin" (a code plugin: into Plugins). */
+    readonly kind: 'content' | 'plugin' | 'other';
+}
+/** The packs in a vault cache folder, by name, with their size (bounded: very big packs read "at least"). */
+export declare function vaultPacks(vault: string, fs: VaultFs): VaultPack[];

package/dist/shared/unreal/vault.js

@@ -0,0 +1,67 @@
+// The Epic Games Launcher's vault cache: the Fab and Marketplace packs it downloaded but has not added to a project
+// yet, one folder per pack (<VaultCache>\<Pack>\data\Content\..., or data\<Plugin>.uplugin for a code plugin). Where
+// it is comes from the launcher's GameUserSettings.ini (VaultCacheDirectories in launcher 20.3; older files may say
+// VaultCacheLocation), else its default %ProgramData%\Epic\EpicGamesLauncher\VaultCache. Pure apart from the
+// EngineFs-style reads it is given; every walk is bounded.
+import path from 'node:path';
+const win = path.win32;
+const MAX_PACKS = 500;
+const MAX_FILES_PER_PACK = 5_000;
+const MAX_FILES = 50_000;
+/** The default vault cache under a ProgramData folder. */
+export function defaultVaultDir(programData) {
+    return win.join(programData, 'Epic', 'EpicGamesLauncher', 'VaultCache');
+}
+/** The vault cache folders a launcher settings text names (VaultCacheDirectories / VaultCacheLocation lines). */
+export function vaultDirsFromIni(ini) {
+    const found = [];
+    for (const raw of ini.split(/\r?\n/).slice(0, 5000)) {
+        const m = /^\s*[+.-]?\s*(VaultCacheDirectories|VaultCacheLocation)\s*=\s*(.{0,2000})$/i.exec(raw);
+        if (!m)
+            continue;
+        for (const hit of m[2].matchAll(/[A-Za-z]:[\\/][^"\r\n,()]{0,400}/g)) {
+            const dir = win.normalize(hit[0].trim().replace(/\//g, '\\')).replace(/\\+$/, '');
+            if (dir.length > 3 && !found.some((f) => f.toLowerCase() === dir.toLowerCase()))
+                found.push(dir);
+        }
+    }
+    return found;
+}
+function walk(dir, fs, budget) {
+    let bytes = 0;
+    let files = 0;
+    const stack = [dir];
+    while (stack.length) {
+        const at = stack.pop();
+        for (const name of fs.list(at)) {
+            if (++files > MAX_FILES_PER_PACK || --budget.left < 0)
+                return { bytes, partial: true };
+            const full = win.join(at, name);
+            const size = fs.size(full);
+            if (size === null) {
+                if (fs.isDir(full))
+                    stack.push(full);
+            }
+            else
+                bytes += size;
+        }
+    }
+    return { bytes, partial: false };
+}
+/** The packs in a vault cache folder, by name, with their size (bounded: very big packs read "at least"). */
+export function vaultPacks(vault, fs) {
+    const budget = { left: MAX_FILES };
+    return fs
+        .list(vault)
+        .filter((n) => !n.startsWith('.') && fs.isDir(win.join(vault, n)))
+        .sort((a, b) => a.localeCompare(b))
+        .slice(0, MAX_PACKS)
+        .map((name) => {
+        const dir = win.join(vault, name);
+        const data = win.join(dir, 'data');
+        const plugin = fs.list(data).some((n) => /\.uplugin$/i.test(n));
+        const kind = plugin ? 'plugin' : fs.isDir(win.join(data, 'Content')) ? 'content' : 'other';
+        const { bytes, partial } = walk(dir, fs, budget);
+        return { name, sizeBytes: bytes, partial, kind };
+    });
+}

package/dist/shared/unreal/vs-check.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+export declare const VsSetupReportSchema: z.ZodObject<{
+    setupError: z.ZodString;
+    instances: z.ZodArray<z.ZodObject<{
+        instanceId: z.ZodString;
+        installationPath: z.ZodString;
+        installationVersion: z.ZodString;
+        productId: z.ZodString;
+        state: z.ZodNumber;
+        isComplete: z.ZodBoolean;
+        isLaunchable: z.ZodBoolean;
+        packages: z.ZodArray<z.ZodString>;
+        toolchains: z.ZodArray<z.ZodObject<{
+            version: z.ZodString;
+            cl: z.ZodBoolean;
+            link: z.ZodBoolean;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    kitsRoots: z.ZodArray<z.ZodObject<{
+        where: z.ZodString;
+        path: z.ZodString;
+    }, z.core.$strip>>;
+    sdks: z.ZodArray<z.ZodObject<{
+        version: z.ZodString;
+        root: z.ZodString;
+        windowsH: z.ZodBoolean;
+        kernel32: z.ZodBoolean;
+        ucrt: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type VsSetupReport = z.output<typeof VsSetupReportSchema>;
+/** The oldest MSVC Unreal 5.4+ builds with. */
+export declare const MIN_MSVC: readonly [14, 38];
+export interface VsVerdict {
+    readonly ok: boolean;
+    readonly text: string;
+}
+/** What UnrealBuildTool would find, in plain words. */
+export declare function vsVerdict(r: VsSetupReport): VsVerdict;