windows-development-sandbox 1.17.3 → 1.18.0

package/dist/selftest/android.test.js

@@ -0,0 +1,7 @@
+export const androidSuite = {
+    name: 'android',
+    title: 'Android: the SDK, signing keys, Google Play, Kotlin (not available yet)',
+    run: (t) => {
+        t.check(true, 'android: not available yet');
+    },
+};

package/dist/selftest/app.test.js

@@ -551,7 +551,7 @@ export const appSuite = {
         const codexMenu = menuView(agentPage(codex), { category: 'codex', refresh: false });
         t.check(codexMenu.enterLabel('codex', 'codex:main') === 'use' &&
             ['s', 'p', 'd', 'r', 'x'].every((k) => codexMenu.actions.some((a) => a.key === k)) &&
-            accountsPage({ agent: 'codex', agents: [codex] }).sections[0].cards === true, 'accounts: the page offers use on Enter and d/r/x on a login; the codex agent is a card');
+            accountsPage({ agent: 'codex', agents: [codex], services: [] }).sections[0].cards === true, 'accounts: the page offers use on Enter and d/r/x on a login; the codex agent is a card');
         const useDef = definitionFor('account', ['use']);
         t.check(JSON.stringify(cliInput(useDef, parseCli(['account', 'use', 'work', '--no-restart']))) ===
             JSON.stringify({ name: 'work', noRestart: true }) &&

package/dist/selftest/engines.test.d.ts

@@ -0,0 +1,2 @@
+import type { Suite } from './support/suite.js';
+export declare const enginesSuite: Suite;

package/dist/selftest/engines.test.js

@@ -0,0 +1,7 @@
+export const enginesSuite = {
+    name: 'engines',
+    title: 'Unreal engines, Godot and the game-development apps (not available yet)',
+    run: (t) => {
+        t.check(true, 'engines: not available yet');
+    },
+};

package/dist/selftest/fivem.test.d.ts

@@ -0,0 +1,2 @@
+import type { Suite } from './support/suite.js';
+export declare const fivemSuite: Suite;

package/dist/selftest/fivem.test.js

@@ -0,0 +1,7 @@
+export const fivemSuite = {
+    name: 'fivem',
+    title: 'FiveM / RedM: server builds, the Cfx.re key, sbx-fivem (not available yet)',
+    run: (t) => {
+        t.check(true, 'fivem: not available yet');
+    },
+};

package/dist/selftest/generate.test.js

@@ -38,7 +38,7 @@ export const generateSuite = {
             'sandbox/csharp/LinkGate.cs',
         ];
         const missing = expectedFiles.filter((file) => !fs.existsSync(path.join(gen.launchPath, file)));
-        t.check(missing.length === 0 && fs.readdirSync(path.join(gen.launchPath, 'runtime')).length === 7, 'the launch folder has the runtime (7 self-contained files), the C# sources and the boot scripts', missing.join(', '));
+        t.check(missing.length === 0 && fs.readdirSync(path.join(gen.launchPath, 'runtime')).length === 8, 'the launch folder has the runtime (8 self-contained files), the C# sources and the boot scripts', missing.join(', '));
         const logon = fs.readFileSync(path.join(gen.launchPath, 'sandbox', 'boot', 'logon.cmd'), 'utf8');
         t.check(logon.indexOf('trust.cmd') < logon.indexOf('wt.exe') &&
             logon.includes('tools\\terminal\\wt.exe') &&

package/dist/selftest/index.js

@@ -11,6 +11,15 @@ import { createFixtures } from './support/fixtures.js';
 import { createHarness } from './support/harness.js';
 import { liveTestsAvailable } from './support/live.js';
 import { accountsSuite } from './accounts.test.js';
+import { serviceAccountsSuite } from './service-accounts.test.js';
+import { persistedInstallsSuite } from './persisted-installs.test.js';
+import { pcInstallsSuite } from './pc-installs.test.js';
+import { steamSuite } from './steam.test.js';
+import { enginesSuite } from './engines.test.js';
+import { unitySuite } from './unity.test.js';
+import { fivemSuite } from './fivem.test.js';
+import { androidSuite } from './android.test.js';
+import { mobileSuite } from './mobile.test.js';
 import { credentialsSuite } from './credentials.test.js';
 import { vpnSuite } from './vpn.test.js';
 import { githubSuite } from './github.test.js';
@@ -101,6 +110,8 @@ export const SUITES = [
     credentialsSuite,
     vpnSuite,
     githubSuite,
+    serviceAccountsSuite,
+    pcInstallsSuite,
     workspaceViewSuite,
     auditSuite,
     // an untrusted sandbox: what the host refuses to do with what it finds
@@ -117,6 +128,13 @@ export const SUITES = [
     // pure helpers and the command line
     layoutSuite,
     toolchainsSuite,
+    persistedInstallsSuite,
+    steamSuite,
+    enginesSuite,
+    unitySuite,
+    fivemSuite,
+    androidSuite,
+    mobileSuite,
     detectSuite,
     networkSuite,
     personalizationSuite,

package/dist/selftest/menu-screens.js

@@ -34,6 +34,7 @@ const DATA_FOLDER_ROW = [
 ];
 const ACCOUNTS = {
     agent: 'claude',
+    services: [],
     agents: [
         {
             name: 'claude',

package/dist/selftest/menu.test.js

@@ -618,9 +618,10 @@ export const menuSuite = {
             !stoppedItems.some((i) => i.value === 'act:stop'), 'with no sandbox running, Sandbox offers to start one (Status and Databases) instead of dead rows');
         const noLogins = accountsOptions({
             agent: 'claude',
+            services: [],
             agents: [{ name: 'claude', kept: true, canSavePc: true, accounts: [] }],
         });
-        t.equal(noLogins.items.map((i) => i.value), ['@save-sandbox', '@save-pc'], 'with no saved login, Accounts offers to save the sandbox login or this PC login (Enter)');
+        t.equal(noLogins.items.map((i) => i.value), ['@save-sandbox', '@save-pc', '@save-key'], 'with no saved login, Accounts offers to save the sandbox login, this PC login or an API key (Enter)');
         t.section('apps in a few groups');
         const groupIds = appsCategories(user2).map((c) => c.id);
         const appItems = appsItems(user2, t.dir('apps-groups'), new Draft()).filter((i) => i.value !== REQUEST_APP);

package/dist/selftest/mobile.test.d.ts

@@ -0,0 +1,2 @@
+import type { Suite } from './support/suite.js';
+export declare const mobileSuite: Suite;

package/dist/selftest/mobile.test.js

@@ -0,0 +1,7 @@
+export const mobileSuite = {
+    name: 'mobile',
+    title: 'Flutter, Dart, React Native / Expo and App Store Connect (not available yet)',
+    run: (t) => {
+        t.check(true, 'mobile: not available yet');
+    },
+};

package/dist/selftest/pc-installs.test.d.ts

@@ -0,0 +1,2 @@
+import type { Suite } from './support/suite.js';
+export declare const pcInstallsSuite: Suite;

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

@@ -0,0 +1,111 @@
+// pcInstalls (this PC's games, engines and editors, read-only in the sandbox): where each one appears, what is
+// refused, that a project file can never ask for them, and the launch writing them into the .wsb and session.json
+// (paths in the sandbox only). Also the new toolchains' detection: markers, what one brings along, licence gates, and
+// that a project can never accept a licence for you. Temp folders and fake sources only.
+import fs from 'node:fs';
+import path from 'node:path';
+import { DEFAULTS } from '../core/config/index.js';
+import { decideToolchains, LICENSED_TOOLCHAINS } from '../core/detect/index.js';
+import { applyOverrides, normalizeOverrides, OFF_IS_SAFER } from '../core/local-config/index.js';
+import { LocalOverridesSchema } from '../core/schema/index.js';
+import { discoverPcInstalls } from '../host/pc-installs/index.js';
+import { generateSandbox } from '../host/launch/index.js';
+import { isValidGuestPath, PC_INSTALLS_GUEST } from '../shared/paths/index.js';
+const PC = { localAppData: '', appData: '', programData: '' };
+export const pcInstallsSuite = {
+    name: 'pc-installs',
+    title: "this PC's installs mapped read-only; new toolchains' markers, implications and licence gates",
+    run: async (t, f) => {
+        t.section('placing them');
+        const game = t.dir('pc-games', 'Spacewar');
+        const engine = t.dir('pc-engines', 'UE_5.4');
+        const installs = (items) => ({
+            kind: 'steam-game',
+            setting: 'steamGames',
+            find: () => items,
+        });
+        const steam = installs([
+            { kind: 'steam-game', id: '480', name: 'Spacewar', host: game, guest: '' },
+            { kind: 'steam-game', id: '481', name: 'Gone', host: path.join(game, 'missing'), guest: '' },
+            { kind: 'steam-game', id: '..', name: 'Climber', host: game, guest: '' },
+        ]);
+        const unreal = {
+            kind: 'unreal',
+            setting: 'unrealEngines',
+            find: () => [
+                { kind: 'unreal', id: 'UE_5.4', name: 'Unreal Engine 5.4', version: '5.4', host: engine, guest: '' },
+            ],
+        };
+        const settings = { ...DEFAULTS.pcInstalls, steamGames: [480, 481], unrealEngines: true };
+        const found = discoverPcInstalls(settings, { packageRoot: t.packageRoot, storageRoot: f.baseConfig.storage.root, sources: [steam, unreal] }, PC);
+        t.equal(found.mappings.map((m) => [m.guest, m.readOnly]), [
+            [PC_INSTALLS_GUEST + '\\steam\\480', true],
+            [PC_INSTALLS_GUEST + '\\unreal\\UE_5.4', true],
+        ], 'each one appears read-only under C:\\PcInstalls by its kind and id');
+        t.check(found.notes.some((n) => n.includes('Gone')) && found.notes.some((n) => n.includes('Climber')), 'a folder that is not there, or an id that is not a folder name, is left out with a note');
+        t.check(!JSON.stringify(found.manifest).includes(game) &&
+            found.manifest.items.every((i) => i.guest.startsWith(PC_INSTALLS_GUEST)), 'the manifest for the sandbox holds no path of this PC');
+        t.equal(discoverPcInstalls(DEFAULTS.pcInstalls, { packageRoot: t.packageRoot, storageRoot: f.baseConfig.storage.root, sources: [steam] }, PC).mappings, [], 'off by default: nothing is looked for');
+        const unsafe = installs([
+            { kind: 'steam-game', id: '1', name: 'Storage', host: f.baseConfig.storage.root, guest: '' },
+        ]);
+        t.check(discoverPcInstalls({ ...settings, unrealEngines: false }, { packageRoot: t.packageRoot, storageRoot: f.baseConfig.storage.root, sources: [unsafe] }, PC).mappings.length === 0, "this tool's own folders are refused like any other mapping");
+        t.check(!isValidGuestPath('C:\\PcInstalls\\mine'), 'no other mapping may use C:\\PcInstalls');
+        t.section('yours only');
+        t.check(!('pcInstalls' in LocalOverridesSchema.shape), 'a project file has no pcInstalls');
+        await t.throws(() => normalizeOverrides({ pcInstalls: { steamGames: true } }, f.workA, 'project'), 'not valid', 'a project file asking for them is refused');
+        t.section('the launch');
+        const run = await f.run({}, f.makeConfig());
+        const launched = generateSandbox({
+            packageRoot: t.packageRoot,
+            run,
+            harnessArgs: [],
+            probe: f.probe,
+            pcLanguages: [],
+            pcInstalls: { mappings: found.mappings, manifest: found.manifest },
+        });
+        const wsb = fs.readFileSync(launched.wsbPath, 'utf8');
+        const session = f.readJson(launched.sessionPath);
+        t.check(wsb.includes(game) && wsb.includes(PC_INSTALLS_GUEST + '\\steam\\480'), 'the .wsb maps them');
+        t.check(session.pcInstalls?.items.map((i) => i.id).join() === '480,UE_5.4' &&
+            !JSON.stringify(session.pcInstalls).includes(game), 'session.json lists them by their place in the sandbox only');
+        t.section('detection of the new toolchains');
+        const tc = structuredClone(DEFAULTS.toolchains);
+        const decide = (entries, hints = {}, settingsOf = tc) => decideToolchains(settingsOf, entries, [], hints);
+        const godot = decide(['project.godot']);
+        const steamApp = decide(['steam_appid.txt']);
+        const unity = decide(['ProjectSettings/ProjectVersion.txt']);
+        t.check(godot.godot.on && steamApp.steam.on && decide(['src/Main.kt']).java.on, 'project.godot, steam_appid.txt and *.kt turn their toolchains on');
+        t.check(!unity.unity.on && unity.unity.reason.includes('toolchains.unity.acceptLicense'), 'Unity is licensed: "auto" waits for acceptLicense and says so');
+        const flutter = decide([], { flutter: 'pubspec.yaml uses Flutter' });
+        t.check(flutter.flutter.on &&
+            !flutter.android.on &&
+            flutter.android.reason.includes('Flutter') &&
+            flutter.android.reason.includes('acceptLicense') &&
+            !flutter.java.on, 'Flutter would bring the Android SDK, but not before its licence is accepted (and no JDK then)');
+        const accepted = structuredClone(tc);
+        accepted.android.acceptLicense = true;
+        const flutterOk = decide([], { reactNative: 'package.json uses react-native' }, accepted);
+        t.check(flutterOk.android.on && flutterOk.java.on && flutterOk.java.reason.includes('JDK'), 'React Native brings the Android SDK, and the Android SDK a JDK');
+        const godotNet = structuredClone(tc);
+        godotNet.godot.dotnet = true;
+        t.check(decide(['project.godot'], {}, godotNet).dotnet.on, "Godot's .NET build brings .NET");
+        const fivem = decide(['fxmanifest.lua']);
+        t.check(!fivem.fivem.on && fivem.fivem.reason.includes('fivem.acceptLicense'), 'the FiveM server is licensed too');
+        t.section('a project never accepts a licence or shares a sign-in');
+        t.check(LICENSED_TOOLCHAINS.every((n) => OFF_IS_SAFER.includes('toolchains.' + n + '.acceptLicense')) &&
+            OFF_IS_SAFER.includes('accounts.epic.share') &&
+            OFF_IS_SAFER.includes('accounts.appstore.share'), 'every acceptLicense and every share is a protection a project can only turn off');
+        const mine = structuredClone(DEFAULTS);
+        const merged = applyOverrides(mine, normalizeOverrides({
+            toolchains: {
+                unity: { acceptLicense: true },
+                msvc: { acceptLicense: true },
+                android: { acceptLicense: true },
+            },
+        }, f.workA, 'project'));
+        t.check(!merged.toolchains.unity.acceptLicense &&
+            !merged.toolchains.msvc.acceptLicense &&
+            !merged.toolchains.android.acceptLicense, 'a project asking to accept a licence leaves it unaccepted');
+    },
+};

package/dist/selftest/persisted-installs.test.d.ts

@@ -0,0 +1,2 @@
+import type { Suite } from './support/suite.js';
+export declare const persistedInstallsSuite: Suite;

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

@@ -0,0 +1,107 @@
+// Large installs kept between sandboxes (guest/toolchains/persisted.ts): the staging folder and its TEMP, the marker,
+// the refusal when the disk is short (an injected statfs), keeping only keepVersions, the records `sandbox data`
+// reads, and which Visual Studio the toolchains ask for (vs-request.ts). Temp folders only.
+import fs from 'node:fs';
+import path from 'node:path';
+import { DEFAULTS } from '../core/config/index.js';
+import { assertLocalRoom, ensurePersisted, installRecords, InstallRecordsSchema, LOCAL_RESERVE_BYTES, recordUse, } from '../guest/toolchains/persisted.js';
+import { BUILD_TOOLS_COMPONENTS, UNREAL_COMPONENTS, visualStudioWanted, } from '../guest/toolchains/native/vs-request.js';
+import { collectDataEntries } from '../cli/services/data-collect.js';
+const GB = 1024 ** 3;
+export const persistedInstallsSuite = {
+    name: 'persisted-installs',
+    title: 'large persisted installs: staging, marker, room checks, pruning, records; the Visual Studio request',
+    run: async (t) => {
+        t.section('installing a version');
+        const tools = t.dir('persisted-tools');
+        const roomy = { toolsDir: tools, statfs: () => ({ bavail: 100 * GB, bsize: 1 }) };
+        const spec = {
+            name: 'engine',
+            version: '1.0',
+            needBytes: 2 * GB,
+            marker: 'bin/engine.exe',
+            what: 'Engine 1.0',
+            keepVersions: 2,
+        };
+        let seen = null;
+        const first = await ensurePersisted(spec, async (staging, temp) => {
+            seen = { staging, temp };
+            fs.writeFileSync(path.join(temp, 'download.part'), 'x'.repeat(10));
+            fs.mkdirSync(path.join(staging, 'bin'), { recursive: true });
+            fs.writeFileSync(path.join(staging, 'bin', 'engine.exe'), 'engine');
+        }, roomy);
+        const done = path.join(tools, 'engine', '1.0');
+        t.check(first.fresh &&
+            first.dir === done &&
+            fs.existsSync(path.join(done, '.complete.json')) &&
+            !fs.existsSync(path.join(done, '.temp')) &&
+            seen !== null &&
+            path.dirname(seen.staging) === path.join(tools, 'engine') &&
+            seen.temp.startsWith(seen.staging), 'it is built in a staging folder next to the target (TEMP inside it) and moved into place with its marker');
+        t.equal(first.sizeBytes, 'engine'.length, 'its size is counted once (the temporary files are gone)');
+        let ran = false;
+        const again = await ensurePersisted(spec, async () => {
+            ran = true;
+        }, roomy);
+        t.check(!again.fresh && !ran && again.sizeBytes === first.sizeBytes, 'a finished version is not installed again');
+        t.check(InstallRecordsSchema.safeParse(JSON.parse(fs.readFileSync(path.join(tools, 'installs.json'), 'utf8'))).success &&
+            installRecords(roomy).some((r) => r.name === 'engine' && r.version === '1.0' && r.sizeBytes === 6), 'tools\\installs.json records it with its size (what sandbox data shows)');
+        t.section('when something goes wrong');
+        await t.throws(() => ensurePersisted({ ...spec, version: '2.0' }, async () => undefined, roomy), 'without bin/engine.exe', 'an install that does not leave its marker fails');
+        t.check(!fs.existsSync(path.join(tools, 'engine', '2.0')) &&
+            !fs.readdirSync(path.join(tools, 'engine')).some((n) => n.startsWith('.staging')), 'and leaves nothing behind');
+        const short = { toolsDir: tools, statfs: () => ({ bavail: GB, bsize: 1 }) };
+        let installed = false;
+        await t.throws(() => ensurePersisted({ ...spec, version: '3.0' }, async () => {
+            installed = true;
+        }, short), 'it needs 2.0 GB', 'a disk with too little room refuses before anything is downloaded');
+        t.check(!installed, 'and the installer never ran');
+        await t.throws(() => ensurePersisted({ ...spec, version: '..' }, async () => undefined, roomy), 'not a usable', 'a version cannot climb out of tools\\');
+        await t.throws(() => Promise.resolve(assertLocalRoom(GB, 'Visual Studio', {
+            localDir: tools,
+            statfs: () => ({ bavail: LOCAL_RESERVE_BYTES, bsize: 1 }),
+        })), 'Visual Studio', "a real installer leaves 13 GB free on the sandbox's own disk");
+        t.section('keeping versions');
+        const make = (version) => ensurePersisted({ ...spec, version }, async (staging) => {
+            fs.mkdirSync(path.join(staging, 'bin'), { recursive: true });
+            fs.writeFileSync(path.join(staging, 'bin', 'engine.exe'), version);
+        }, roomy);
+        await make('1.1');
+        recordUse('engine', '1.0', roomy);
+        await make('1.2');
+        const left = fs.readdirSync(path.join(tools, 'engine')).sort();
+        t.equal(left, ['1.0', '1.2'], 'beyond keepVersions the least recently used version goes');
+        t.check(!installRecords(roomy).some((r) => r.version === '1.1'), 'and its record with it');
+        t.section('what sandbox data shows');
+        const data = t.dir('persisted-data');
+        const big = t.dir('persisted-data', 'tools', 'editor', '6000.0');
+        fs.writeFileSync(path.join(big, 'Unity.exe'), 'small here');
+        t.writeJson(path.join(data, 'tools', 'installs.json'), {
+            installs: [{ name: 'editor', version: '6000.0', sizeBytes: 7 * GB, installedAt: 'x', usedAt: 'x' }],
+        });
+        t.dir('persisted-data', 'tools', 'walked', '1.0');
+        const rows = collectDataEntries(data, t.dir('persisted-storage'));
+        t.check(rows.find((r) => r.name === 'editor')?.bytes === 7 * GB && rows.some((r) => r.name === 'walked'), 'a tool whose versions are all recorded shows the recorded size (not walked); the others are measured');
+        t.section('which Visual Studio');
+        const tc = structuredClone(DEFAULTS.toolchains);
+        t.equal(visualStudioWanted(tc), null, 'no toolchain that needs it: none');
+        tc.flutter.enabled = true;
+        tc.flutter.windowsDesktop = true;
+        const tools1 = visualStudioWanted(tc);
+        t.check(tools1?.product === 'buildtools' &&
+            BUILD_TOOLS_COMPONENTS.every((c) => tools1.components.includes(c)) &&
+            tools1.licence === 'toolchains.msvc.acceptLicense' &&
+            !tools1.accepted, "Flutter desktop: the Build Tools' C++ parts, under the MSVC licence setting");
+        tc.unity.enabled = true;
+        tc.unity.modules = ['windows-il2cpp'];
+        tc.unreal.enabled = true;
+        tc.unreal.acceptLicense = true;
+        tc.unreal.components = ['Microsoft.VisualStudio.Component.VC.Llvm.Clang'];
+        const all = visualStudioWanted(tc);
+        t.check(all?.product === 'community' &&
+            all.accepted &&
+            all.for.join() === 'unreal,flutter,unity' &&
+            UNREAL_COMPONENTS.every((c) => all.components.includes(c)) &&
+            all.components.includes('Microsoft.VisualStudio.Component.VC.Llvm.Clang'), 'with Unreal: one Community install serves all of them');
+    },
+};

package/dist/selftest/projects.test.js

@@ -22,6 +22,7 @@ import { parseCli, parseSessionWant } from '../cli/args.js';
 import { severalAgentsArgv } from '../cli/menu/index.js';
 import { generateSandbox } from '../host/launch/index.js';
 import { describeSessions } from '../cli/commands/projects/index.js';
+import { onFixedPc } from './support/pc-memory.js';
 /** The error `fn` throws, or null. */
 const caught = async (fn) => {
     try {
@@ -518,7 +519,8 @@ export const projectsSuite = {
             notRegistered &&
             (await joinGames('continue')).missing?.settings.join() === 'sandbox.vGpu', '"Restart with them" hands the restart offer what is missing, "Cancel" stops with a short line (neither registers the project), "Continue anyway" joins and says what is missing', cancelled);
         // The restart that adds it (and any launch with it mapped at boot) boots with the union.
-        const unionGen = generateSandbox({
+        // On a pretend PC with plenty of RAM: the memory asked for is not lowered to what this machine can keep resident.
+        const unionGen = onFixedPc(() => generateSandbox({
             packageRoot: t.packageRoot,
             run: launchedRun,
             harnessArgs: [],
@@ -526,7 +528,7 @@ export const projectsSuite = {
             extraProjects: [games],
             autoSession: false,
             bootWants: { projects: [{ name: 'proj-games', config: gamesRun.config }], keepOff: [] },
-        });
+        }));
         const unionWsb = fs.readFileSync(unionGen.wsbPath, 'utf8');
         t.check(unionWsb.includes('<vGPU>Enable</vGPU>') &&
             unionWsb.includes('<HostFolder>' +
@@ -536,7 +538,7 @@ export const projectsSuite = {
         const unionLearns = unionGen.widened['sandbox.vGpu'] === 'proj-games' &&
             unionGen.projects.notes.some((n) => n.startsWith('vGPU is on in this sandbox')) &&
             nothingMissing(missingAtBoot(protectionsOf(unionGen.bootConfig), { memoryMb: unionGen.memoryMb, mappings: unionGen.mappings }, gamesRun.config, fs.existsSync));
-        const keptOff = generateSandbox({
+        const keptOff = onFixedPc(() => generateSandbox({
             packageRoot: t.packageRoot,
             run: launchedRun,
             harnessArgs: [],
@@ -544,7 +546,7 @@ export const projectsSuite = {
             extraProjects: [games],
             autoSession: false,
             bootWants: { projects: [{ name: 'proj-games', config: gamesRun.config }], keepOff: ['sandbox.vGpu'] },
-        });
+        }));
         t.check(unionLearns && fs.readFileSync(keptOff.wsbPath, 'utf8').includes('<vGPU>Disable</vGPU>'), "the registry learns which setting was turned on for which project, after that restart nothing is missing; a device the launch folder's own file switched off stays off", JSON.stringify(unionGen.projects.notes));
         t.section('projects: wsb (Windows Sandbox command line) adapter');
         const id = '12345678-1234-1234-1234-1234567890ab';

package/dist/selftest/service-accounts.test.d.ts

@@ -0,0 +1,2 @@
+import type { Suite } from './support/suite.js';
+export declare const serviceAccountsSuite: Suite;