windows-development-sandbox 1.17.3 → 1.18.2

package/dist/guest/devtools/steam.js

@@ -0,0 +1,228 @@
+// sbx-steam: log in to SteamCMD, download apps and workshop items, upload builds and workshop items, list games, start
+// the Steam client. SteamCMD runs from C:\SteamCMD (set up at boot); it asks for the password and the Steam Guard code
+// itself, and keeps only its login token (never the password or a Steam Guard secret).
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { readSteamAccountFile, steamAccounts, steamConfigFile, STEAM_ACCOUNT_FILE, } from '../../shared/accounts/kinds/steam.js';
+import { spawnAsync } from '../../shared/download/index.js';
+import { readBoundedFile } from '../../shared/io/bounded.js';
+import { session } from '../runtime/session.js';
+import { errMsg } from '../../core/util/errors.js';
+import { appBuildArgs, appUpdateArgs, checkAppId, loginArgs, readScript, scriptKind, steamAppDir, STEAMCMD_DIR, steamClientDir, workshopCache, workshopGetArgs, workshopItemDir, workshopPushArgs, withBuildSettings, } from '../toolchains/steam/commands.js';
+import { assertAppRoom, DEFAULT_APP_NEED_BYTES, folderSize, installedApps, recordApp, } from '../toolchains/steam/apps.js';
+const GB = 1024 ** 3;
+const USAGE = [
+    'Usage: sbx-steam <command>',
+    '  login <account>                      sign in to SteamCMD (it asks for the password and Steam Guard code)',
+    '  app <appid> [--beta <branch>] [--dir <folder>] [--validate] [--anonymous] [--need-gb <n>]',
+    '                                       download or update a game or dedicated server (tools\\steam-apps\\<appid>)',
+    '  workshop get <appid> <item>... [--validate] [--anonymous]',
+    '                                       download workshop items (cache\\steam-workshop on the data disk)',
+    '  workshop push <workshop_item.vdf>    upload a workshop item',
+    '  build <app_build.vdf> [--preview] [--desc <text>]',
+    '                                       upload a build with ContentBuilder (--preview: check it, upload nothing)',
+    "  games                                what is downloaded here and this PC's games mapped read-only",
+    '  client                               start the Steam client (toolchains.steam.client)',
+    'Options: --user <account> uses another signed-in account.',
+].join('\n');
+const VALUE_FLAGS = new Set(['--beta', '--dir', '--user', '--need-gb', '--desc']);
+const BOOLEAN_FLAGS = new Set(['--validate', '--anonymous', '--preview']);
+function parse(args) {
+    const words = [];
+    const values = new Map();
+    const flags = new Set();
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (VALUE_FLAGS.has(a)) {
+            const v = args[++i];
+            if (v === undefined)
+                throw new Error(a + ' needs a value');
+            values.set(a, v);
+        }
+        else if (BOOLEAN_FLAGS.has(a))
+            flags.add(a);
+        else if (a.startsWith('--'))
+            throw new Error('unknown option ' + a);
+        else
+            words.push(a);
+    }
+    return { words, values, flags };
+}
+const steamcmd = () => path.join(STEAMCMD_DIR, 'steamcmd.exe');
+function requireSteamCmd() {
+    if (!fs.existsSync(steamcmd()))
+        throw new Error('SteamCMD is not set up in this sandbox (toolchains.steam: see the boot log for why)');
+    return steamcmd();
+}
+/** The account SteamCMD has a login for here, or null. */
+function knownAccount() {
+    const fromFile = readSteamAccountFile(STEAMCMD_DIR);
+    if (fromFile)
+        return fromFile;
+    const bytes = readBoundedFile(steamConfigFile(STEAMCMD_DIR), 256 * 1024);
+    return bytes ? (steamAccounts(bytes.toString('utf8'))[0] ?? null) : null;
+}
+function account(p, anonymousOk) {
+    if (p.flags.has('--anonymous'))
+        return 'anonymous';
+    const name = p.values.get('--user') ?? knownAccount();
+    if (name)
+        return name;
+    if (anonymousOk) {
+        console.log('Not signed in: using anonymous (enough for dedicated servers and free tools).');
+        return 'anonymous';
+    }
+    throw new Error('not signed in: run sbx-steam login <account> first');
+}
+/** Runs SteamCMD in the terminal (it asks there when it needs to); its exit code. */
+async function steamCmd(args) {
+    return spawnAsync(requireSteamCmd(), args, { cwd: STEAMCMD_DIR, stdio: 'inherit', windowsHide: false });
+}
+const gb = (bytes) => (bytes === null ? 'size unknown' : (bytes / GB).toFixed(2) + ' GB');
+async function login(p) {
+    const name = p.words[1] ?? p.values.get('--user');
+    if (!name)
+        throw new Error('Usage: sbx-steam login <account name>');
+    const code = await steamCmd(loginArgs(name));
+    if (code !== 0)
+        return code;
+    fs.mkdirSync(path.join(STEAMCMD_DIR, 'config'), { recursive: true });
+    fs.writeFileSync(path.join(STEAMCMD_DIR, 'config', STEAM_ACCOUNT_FILE), name, 'utf8');
+    console.log('Signed in as ' +
+        name +
+        '. SteamCMD keeps the login in C:\\SteamCMD\\config (this sandbox only). With accounts.steam.share on, the PC keeps it, encrypted, for the next sandboxes; no password is kept.');
+    return 0;
+}
+async function app(p) {
+    const appId = checkAppId(p.words[1] ?? '');
+    const given = p.values.get('--dir');
+    const dir = given ? path.resolve(given) : steamAppDir(appId);
+    const needGb = Number(p.values.get('--need-gb') ?? DEFAULT_APP_NEED_BYTES / GB);
+    if (!Number.isFinite(needGb) || needGb < 0 || needGb > 10_000)
+        throw new Error('--need-gb takes a number of GB');
+    assertAppRoom(dir, needGb * GB, 'app ' + appId);
+    fs.mkdirSync(dir, { recursive: true });
+    const beta = p.values.get('--beta');
+    const code = await steamCmd(appUpdateArgs({
+        appId,
+        dir,
+        login: account(p, true),
+        ...(beta ? { beta } : {}),
+        validate: p.flags.has('--validate'),
+    }));
+    const size = folderSize(dir);
+    if (!given)
+        recordApp(appId, size);
+    console.log('App ' + appId + ' is in ' + dir + ' (' + gb(size) + ').');
+    return code;
+}
+async function workshop(p) {
+    const verb = p.words[1];
+    if (verb === 'get') {
+        const appId = checkAppId(p.words[2] ?? '');
+        const items = p.words.slice(3);
+        const cache = workshopCache();
+        assertAppRoom(cache, GB, 'workshop items');
+        fs.mkdirSync(cache, { recursive: true });
+        const code = await steamCmd(workshopGetArgs({ appId, items, dir: cache, login: account(p, true), validate: p.flags.has('--validate') }));
+        for (const item of items) {
+            const dir = workshopItemDir(cache, appId, item);
+            console.log(item + ': ' + (fs.existsSync(dir) ? dir : 'not downloaded'));
+        }
+        return code;
+    }
+    if (verb === 'push') {
+        const script = path.resolve(p.words[2] ?? '');
+        if (scriptKind(readScript(script)) !== 'workshopitem')
+            throw new Error(script + ' is not a workshop_item script (its first block is not "workshopitem")');
+        return steamCmd(workshopPushArgs(account(p, false), script));
+    }
+    throw new Error('Usage: sbx-steam workshop get <appid> <item>... | workshop push <workshop_item.vdf>');
+}
+async function build(p) {
+    const script = path.resolve(p.words[1] ?? '');
+    const text = readScript(script);
+    if (scriptKind(text) !== 'appbuild')
+        throw new Error(script + ' is not an app_build script (its first block is not "AppBuild")');
+    const login = account(p, false);
+    const desc = p.values.get('--desc');
+    if (!p.flags.has('--preview') && desc === undefined)
+        return steamCmd(appBuildArgs(login, script));
+    // A copy beside the script (its relative paths stay right) with Preview / Desc set; removed afterwards.
+    const changed = withBuildSettings(text, {
+        preview: p.flags.has('--preview'),
+        ...(desc !== undefined ? { desc } : {}),
+    });
+    const copy = path.join(path.dirname(script), path.basename(script, '.vdf') + '.sbx-' + process.pid + '.vdf');
+    fs.writeFileSync(copy, changed ?? text, 'utf8');
+    try {
+        return await steamCmd(appBuildArgs(login, copy));
+    }
+    finally {
+        fs.rmSync(copy, { force: true });
+    }
+}
+function games() {
+    const apps = installedApps();
+    console.log(apps.length ? 'Downloaded here (tools\\steam-apps):' : 'Nothing downloaded with sbx-steam app yet.');
+    for (const a of apps)
+        console.log('  ' + a.appId + '  ' + a.name + '  ' + gb(a.sizeBytes) + '  ' + a.dir);
+    const pc = (session.pcInstalls?.items ?? []).filter((i) => i.kind === 'steam-game' || i.kind === 'steam-library');
+    if (pc.length) {
+        console.log("This PC's, read-only (pcInstalls.steamGames):");
+        for (const i of pc)
+            console.log('  ' + i.id + '  ' + i.name + '  ' + i.guest);
+        console.log('  Steam cannot update or run a game from a read-only folder: sbx-steam app <appid> makes a copy here.');
+    }
+    return 0;
+}
+function client() {
+    if (!session.toolchains.steam.client) {
+        console.error('The Steam client is off: set toolchains.steam.client to true and restart the sandbox.');
+        return 1;
+    }
+    const exe = path.join(steamClientDir(), 'steam.exe');
+    if (!fs.existsSync(exe)) {
+        console.error('The Steam client is not set up (see the boot log).');
+        return 1;
+    }
+    spawn(exe, [], { cwd: steamClientDir(), detached: true, stdio: 'ignore' }).unref();
+    console.log('Starting the Steam client (it updates itself the first time). Sign in to it here: its sign-in is tied to this sandbox and does not carry over to the next one.');
+    return 0;
+}
+export const steamTool = {
+    name: 'steam',
+    summary: 'log in to SteamCMD, download apps and workshop items, upload builds and workshop items',
+    async run(args) {
+        let p;
+        try {
+            p = parse(args);
+        }
+        catch (e) {
+            console.error('sbx-steam: ' + errMsg(e) + '\n' + USAGE);
+            return 2;
+        }
+        switch (p.words[0]) {
+            case 'login':
+                return login(p);
+            case 'app':
+                return app(p);
+            case 'workshop':
+                return workshop(p);
+            case 'build':
+                return build(p);
+            case 'games':
+                return games();
+            case 'client':
+                return client();
+            case undefined:
+            case 'help':
+                console.log(USAGE);
+                return p.words[0] ? 0 : 2;
+            default:
+                console.error('sbx-steam: unknown command ' + p.words[0] + '\n' + USAGE);
+                return 2;
+        }
+    },
+};

package/dist/guest/devtools/unity.d.ts

@@ -0,0 +1,2 @@
+import { type DevTool } from './devtool.js';
+export declare const unityTool: DevTool;

package/dist/guest/devtools/unity.js

@@ -0,0 +1,7 @@
+// sbx-unity: install editors, list them, build with -executeMethod, the licence status. Not available yet.
+import { notAvailableYet } from './devtool.js';
+export const unityTool = {
+    name: 'unity',
+    summary: 'install editors, list them, build with -executeMethod, the licence status',
+    run: () => notAvailableYet('unity'),
+};

package/dist/guest/entries/daemon.js

@@ -12,6 +12,7 @@ import { Daemon } from '../daemon/daemon.js';
 import { startLiveFolders } from '../daemon/live.js';
 import { sessions } from '../daemon/sessions.js';
 import { governor } from '../governor/index.js';
+import { startAccountWatch } from '../daemon/accounts.js';
 process.on('uncaughtException', (e) => warn('daemon: unexpected error (continuing): ' + (e.stack ?? errMsg(e))));
 process.on('unhandledRejection', (e) => warn('daemon: unexpected error (continuing): ' + errMsg(e)));
 const liveKey = adoptBootSecrets();
@@ -22,4 +23,5 @@ safely('audit', () => startProcessCollector(() => sessions.roots()));
 safely('leftover processes', () => sessions.sweepLeftovers());
 safely('memory governor', () => governor.start());
 log('Memory governor: ' + governor.describe());
+safely('service sign-ins', startAccountWatch);
 new Daemon().start();

package/dist/guest/entries/tool.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/guest/entries/tool.js

@@ -0,0 +1,17 @@
+// The sbx-<name> helpers (sbx-steam, sbx-fivem, sbx-unity, sbx-android): `tool.js <name> <args...>` runs that helper.
+import { errMsg } from '../../core/util/errors.js';
+import { DEVTOOLS, devToolByName } from '../devtools/registry.js';
+const [name, ...args] = process.argv.slice(2);
+const tool = name ? devToolByName(name) : undefined;
+if (!tool) {
+    console.error('Usage: sbx-<' + DEVTOOLS.map((t) => t.name).join('|') + '> <command> ...');
+    process.exitCode = 2;
+}
+else {
+    tool.run(args).then((code) => {
+        process.exitCode = code;
+    }, (e) => {
+        console.error('sbx-' + tool.name + ': ' + errMsg(e));
+        process.exitCode = 1;
+    });
+}

package/dist/guest/toolchains/engines/godot.d.ts

@@ -0,0 +1,4 @@
+import type { Toolchains } from '../../../core/types.js';
+import type { ToolCtx } from '../step.js';
+import type { ToolEnv } from '../tool-env.js';
+export declare function setupGodot(env: ToolEnv, _config: Toolchains['godot'], _ctx: ToolCtx): Promise<void>;

package/dist/guest/toolchains/engines/godot.js

@@ -0,0 +1,4 @@
+import { notAvailableYet } from '../not-yet.js';
+export async function setupGodot(env, _config, _ctx) {
+    notAvailableYet(env, 'Godot');
+}

package/dist/guest/toolchains/engines/unity-release.d.ts

@@ -0,0 +1,15 @@
+export interface UnityDownload {
+    /** "editor", or a module id (android, webgl, windows-il2cpp, ios). */
+    readonly id: string;
+    readonly url: string;
+    /** The SRI hash (sha384-... or sha256-...). */
+    readonly integrity: string | null;
+    readonly sizeBytes: number | null;
+}
+export interface UnityRelease {
+    readonly version: string;
+    readonly changeset: string | null;
+    readonly downloads: readonly UnityDownload[];
+}
+/** The release of one editor version (6000.0.32f1), or null when Unity does not list it. */
+export declare function findUnityRelease(_version: string): Promise<UnityRelease | null>;

package/dist/guest/toolchains/engines/unity-release.js

@@ -0,0 +1,6 @@
+// Unity's release API (services.api.unity.com/unity/editor/release/v1/releases): the editor installer and module
+// downloads of one version, each with its SRI integrity hash. Not available yet.
+/** The release of one editor version (6000.0.32f1), or null when Unity does not list it. */
+export async function findUnityRelease(_version) {
+    return null;
+}

package/dist/guest/toolchains/engines/unity.d.ts

@@ -0,0 +1,4 @@
+import type { Toolchains } from '../../../core/types.js';
+import type { ToolCtx } from '../step.js';
+import type { ToolEnv } from '../tool-env.js';
+export declare function setupUnity(env: ToolEnv, _config: Toolchains['unity'], _ctx: ToolCtx): Promise<void>;

package/dist/guest/toolchains/engines/unity.js

@@ -0,0 +1,4 @@
+import { notAvailableYet } from '../not-yet.js';
+export async function setupUnity(env, _config, _ctx) {
+    notAvailableYet(env, 'Unity');
+}

package/dist/guest/toolchains/engines/unreal-engines.d.ts

@@ -0,0 +1,4 @@
+import type { Toolchains } from '../../../core/types.js';
+import type { ToolCtx } from '../step.js';
+import type { ToolEnv } from '../tool-env.js';
+export declare function setupUnrealEngines(env: ToolEnv, _config: Toolchains['unreal'], _ctx: ToolCtx): Promise<void>;

package/dist/guest/toolchains/engines/unreal-engines.js

@@ -0,0 +1,4 @@
+import { notAvailableYet } from '../not-yet.js';
+export async function setupUnrealEngines(env, _config, _ctx) {
+    notAvailableYet(env, 'Unreal engines');
+}

package/dist/guest/toolchains/fivem/artifacts.d.ts

@@ -0,0 +1,6 @@
+export interface FivemArtifact {
+    readonly build: number;
+    readonly url: string;
+}
+/** The build an artifact setting names, or null when it cannot be told. */
+export declare function pickArtifact(_setting: string): Promise<FivemArtifact | null>;

package/dist/guest/toolchains/fivem/artifacts.js

@@ -0,0 +1,7 @@
+// FXServer builds (the Cfx.re artifacts): which build "recommended", "optional", "latest" or a number means, from
+// changelogs-live.fivem.net/api/changelog/versions/win32/server. No checksums are published: the download is refused
+// under downloads.requireChecksum unless FXServer.exe is signed. Not available yet.
+/** The build an artifact setting names, or null when it cannot be told. */
+export async function pickArtifact(_setting) {
+    return null;
+}

package/dist/guest/toolchains/fivem/fivem.d.ts

@@ -0,0 +1,4 @@
+import type { Toolchains } from '../../../core/types.js';
+import type { ToolCtx } from '../step.js';
+import type { ToolEnv } from '../tool-env.js';
+export declare function setupFivem(env: ToolEnv, _config: Toolchains['fivem'], _ctx: ToolCtx): Promise<void>;

package/dist/guest/toolchains/fivem/fivem.js

@@ -0,0 +1,4 @@
+import { notAvailableYet } from '../not-yet.js';
+export async function setupFivem(env, _config, _ctx) {
+    notAvailableYet(env, 'FiveM server');
+}

package/dist/guest/toolchains/installers.d.ts

@@ -0,0 +1,12 @@
+/** Who signs the installers the toolchains run (the subject of the signature). */
+export declare const SIGNERS: {
+    readonly microsoft: "CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US";
+    readonly valve: RegExp;
+    readonly unity: RegExp;
+};
+/** Whether a file's signature is the expected signer's. */
+export declare function signedBy(file: string, signer: string | RegExp): boolean;
+/** A downloader `verify` hook: refuses a file not signed by `signer` (it counts as integrity for requireChecksum). */
+export declare function signatureCheck(signer: string | RegExp, what: string): (file: string) => void;
+/** The installer at `file` (downloaded once from `url`), checked against its signer and, when given, its SHA-256. */
+export declare function signedInstaller(url: string, file: string, what: string, signer: string | RegExp, sha256?: string | null): Promise<string>;

package/dist/guest/toolchains/installers.js

@@ -0,0 +1,39 @@
+// Real installers and signed downloads: a vendor's installer is kept in tools\ (downloaded once) and run only when its
+// Authenticode signature names the vendor; a file with a bad signature is deleted, and fetched again next boot.
+import fs from 'node:fs';
+import path from 'node:path';
+import { downloader } from '../../shared/download/index.js';
+import { exists, mkdirp } from '../runtime/fs.js';
+import { log } from '../runtime/log.js';
+import { MICROSOFT_SIGNER, signerOf } from './native/vcruntime.js';
+/** Who signs the installers the toolchains run (the subject of the signature). */
+export const SIGNERS = {
+    microsoft: MICROSOFT_SIGNER,
+    valve: /^CN="?Valve(,| Corp)/,
+    unity: /^CN="?Unity Technologies/,
+};
+/** Whether a file's signature is the expected signer's. */
+export function signedBy(file, signer) {
+    const subject = signerOf(file);
+    return typeof signer === 'string' ? subject === signer : signer.test(subject);
+}
+/** A downloader `verify` hook: refuses a file not signed by `signer` (it counts as integrity for requireChecksum). */
+export function signatureCheck(signer, what) {
+    return (file) => {
+        if (!signedBy(file, signer))
+            throw new Error(what + ' is not signed by its vendor');
+    };
+}
+/** The installer at `file` (downloaded once from `url`), checked against its signer and, when given, its SHA-256. */
+export async function signedInstaller(url, file, what, signer, sha256 = null) {
+    if (!exists(file)) {
+        log('Downloading ' + what + ' ...');
+        mkdirp(path.dirname(file));
+        await downloader.file(url, file, { sha256, verify: signatureCheck(signer, path.basename(file)) });
+    }
+    if (!signedBy(file, signer)) {
+        fs.rmSync(file, { force: true });
+        throw new Error(path.basename(file) + ' is not signed by its vendor; deleted it (it is downloaded again next boot)');
+    }
+    return file;
+}

package/dist/guest/toolchains/languages/java.js

@@ -65,7 +65,7 @@ export async function ensureJdk() {
     if (installed.length)
         return path.join(root, installed[0]);
     const scratch = emptyEnv();
-    await setupJdk(scratch, { enabled: true, version: 'lts', maven: false, gradle: false });
+    await setupJdk(scratch, { enabled: true, version: 'lts', maven: false, gradle: false, kotlin: false });
     return scratch.vars.JAVA_HOME;
 }
 const setupMaven = async (env) => {

package/dist/guest/toolchains/languages/kotlin.d.ts

@@ -0,0 +1,3 @@
+import type { ToolCtx } from '../step.js';
+import type { ToolEnv } from '../tool-env.js';
+export declare function setupKotlin(env: ToolEnv, _ctx: ToolCtx): Promise<void>;

package/dist/guest/toolchains/languages/kotlin.js

@@ -0,0 +1,6 @@
+// Kotlin (toolchains.java.kotlin): kotlinc from JetBrains' releases (checked against its digest) in tools\kotlin, on
+// PATH. Gradle builds fetch their own Kotlin. Not available yet.
+import { notAvailableYet } from '../not-yet.js';
+export async function setupKotlin(env, _ctx) {
+    notAvailableYet(env, 'Kotlin');
+}

package/dist/guest/toolchains/mobile/android-repo.d.ts

@@ -0,0 +1,11 @@
+export interface RepoPackage {
+    /** The sdkmanager path: platforms;android-35, build-tools;35.0.0 ... */
+    readonly path: string;
+    readonly url: string;
+    readonly sha1: string;
+    readonly sizeBytes: number;
+}
+/** The packages of a repository XML text (bounded); none when it cannot be read. */
+export declare function parseRepository(_xml: string): RepoPackage[];
+/** Why a package is refused, or null when it may be installed. */
+export declare function refusedPackage(path: string): string | null;

package/dist/guest/toolchains/mobile/android-repo.js

@@ -0,0 +1,10 @@
+// The Android SDK repository (repository2-3.xml): each package's archive for Windows with its SHA-1, and the packages
+// the sandbox refuses (the emulator and system images: Windows Sandbox cannot run them). Not available yet.
+/** The packages of a repository XML text (bounded); none when it cannot be read. */
+export function parseRepository(_xml) {
+    return [];
+}
+/** Why a package is refused, or null when it may be installed. */
+export function refusedPackage(path) {
+    return /^(emulator|system-images;)/.test(path) ? 'Windows Sandbox cannot run the Android emulator' : null;
+}

package/dist/guest/toolchains/mobile/android.d.ts

@@ -0,0 +1,17 @@
+import type { Toolchains } from '../../../core/types.js';
+import type { ToolCtx } from '../step.js';
+import type { ToolEnv } from '../tool-env.js';
+export interface AndroidSdkRequest {
+    readonly packages: readonly string[];
+    readonly ndk?: string | 'auto' | false;
+}
+export interface AndroidSdk {
+    readonly root: string;
+    readonly javaHome: string | null;
+    readonly installed: readonly string[];
+}
+/** The SDK with these packages installed. */
+export declare function ensureAndroidSdk(_env: ToolEnv, _req: AndroidSdkRequest): Promise<AndroidSdk>;
+/** The variables builds need to find the SDK and its JDK. */
+export declare function androidEnv(sdk: AndroidSdk): Record<string, string>;
+export declare function setupAndroid(env: ToolEnv, _config: Toolchains['android'], _ctx: ToolCtx): Promise<void>;

package/dist/guest/toolchains/mobile/android.js

@@ -0,0 +1,16 @@
+import { notAvailableYet } from '../not-yet.js';
+/** The SDK with these packages installed. */
+export async function ensureAndroidSdk(_env, _req) {
+    throw new Error('the Android SDK is not available yet');
+}
+/** The variables builds need to find the SDK and its JDK. */
+export function androidEnv(sdk) {
+    return {
+        ANDROID_HOME: sdk.root,
+        ANDROID_SDK_ROOT: sdk.root,
+        ...(sdk.javaHome ? { JAVA_HOME: sdk.javaHome } : {}),
+    };
+}
+export async function setupAndroid(env, _config, _ctx) {
+    notAvailableYet(env, 'Android SDK');
+}

package/dist/guest/toolchains/mobile/dart.d.ts

@@ -0,0 +1,4 @@
+import type { Toolchains } from '../../../core/types.js';
+import type { ToolCtx } from '../step.js';
+import type { ToolEnv } from '../tool-env.js';
+export declare function setupDart(env: ToolEnv, _config: Toolchains['dart'], _ctx: ToolCtx): Promise<void>;

package/dist/guest/toolchains/mobile/dart.js

@@ -0,0 +1,4 @@
+import { notAvailableYet } from '../not-yet.js';
+export async function setupDart(env, _config, _ctx) {
+    notAvailableYet(env, 'Dart');
+}

package/dist/guest/toolchains/mobile/flutter.d.ts

@@ -0,0 +1,4 @@
+import type { Toolchains } from '../../../core/types.js';
+import type { ToolCtx } from '../step.js';
+import type { ToolEnv } from '../tool-env.js';
+export declare function setupFlutter(env: ToolEnv, _config: Toolchains['flutter'], _ctx: ToolCtx): Promise<void>;

package/dist/guest/toolchains/mobile/flutter.js

@@ -0,0 +1,4 @@
+import { notAvailableYet } from '../not-yet.js';
+export async function setupFlutter(env, _config, _ctx) {
+    notAvailableYet(env, 'Flutter');
+}

package/dist/guest/toolchains/mobile/react-native.d.ts

@@ -0,0 +1,4 @@
+import type { Toolchains } from '../../../core/types.js';
+import type { ToolCtx } from '../step.js';
+import type { ToolEnv } from '../tool-env.js';
+export declare function setupReactNative(env: ToolEnv, _config: Toolchains['reactNative'], _ctx: ToolCtx): Promise<void>;

package/dist/guest/toolchains/mobile/react-native.js

@@ -0,0 +1,4 @@
+import { notAvailableYet } from '../not-yet.js';
+export async function setupReactNative(env, _config, _ctx) {
+    notAvailableYet(env, 'React Native');
+}

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

@@ -1,9 +1,5 @@
 import type { Toolchains } from '../../../core/types.js';
+import type { ToolCtx } from '../step.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>;
+export { UNREAL_COMPONENTS } from './vs-request.js';
+export declare function setupUnreal(env: ToolEnv, config: Toolchains['unreal'], ctx: ToolCtx): Promise<void>;