windows-development-sandbox 1.4.0 → 1.4.3

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

@@ -2,12 +2,16 @@
 // published Windows build in seconds; only crates without one are compiled with `cargo install --locked`.
 import fs from 'node:fs';
 import path from 'node:path';
-import { errMsg, execAsync, exists, log, warn } from '../../env.js';
+import { execAsync } from '../../runtime/process.js';
+import { exists } from '../../runtime/fs.js';
+import { log, warn } from '../../runtime/log.js';
+import { errMsg } from '../../../core/util/errors.js';
 import { binstallAsset } from '../catalogue.js';
-import { arch, installFromGithub, tool } from '../common.js';
+import { arch, tool } from '../tool-env.js';
+import { installFromGithub } from '../install.js';
 /**
  * cargo-binstall.exe into CARGO_HOME\bin (so `cargo binstall` works for the agent too). Downloaded into its own
- * tools\cargo-binstall folder first: installArchive replaces its destination, which must never be cargo's bin.
+ * tools\cargo-binstall folder first: downloader.archive replaces its destination, which must never be cargo's bin.
  */
 const ensureBinstall = async (cargoBin) => {
     const target = path.join(cargoBin, 'cargo-binstall.exe');
@@ -16,7 +20,11 @@ const ensureBinstall = async (cargoBin) => {
     try {
         const dir = tool('cargo-binstall');
         if (!exists(path.join(dir, 'cargo-binstall.exe'))) {
-            await installFromGithub('cargo-bins/cargo-binstall', binstallAsset(arch), { dest: dir, what: 'cargo-binstall for prebuilt Rust tools (~10 MB once)', locate: 'cargo-binstall.exe' });
+            await installFromGithub('cargo-bins/cargo-binstall', binstallAsset(arch), {
+                dest: dir,
+                what: 'cargo-binstall for prebuilt Rust tools (~10 MB once)',
+                locate: 'cargo-binstall.exe',
+            });
         }
         fs.copyFileSync(path.join(dir, 'cargo-binstall.exe'), target);
         return true;
@@ -29,13 +37,17 @@ const ensureBinstall = async (cargoBin) => {
 /**
  * Returns the installer for one crate: `cargo binstall` (prebuilt only: its own compile fallback is off, so a crate
  * without a Windows build is compiled by our `cargo install` with the linker settings in `cargoEnv`), then
- * `cargo install --locked`. cargo-binstall is fetched on first use, so boots with every crate installed download nothing.
+ * `cargo install --locked`. cargo-binstall is fetched on first use, so boots with every crate installed download
+ * nothing.
  */
-export const crateInstaller = (cargoHome, cargoEnv) => {
+export function crateInstaller(cargoHome, cargoEnv) {
     const cargo = path.join(cargoHome, 'bin', 'cargo.exe');
     let binstall = null;
     // quick-install's install statistics are opt-out; the sandbox opts out.
-    const binstallEnv = { ...cargoEnv, env: { ...(cargoEnv.env ?? process.env), BINSTALL_DISABLE_TELEMETRY: 'true' } };
+    const binstallEnv = {
+        ...cargoEnv,
+        env: { ...(cargoEnv.env ?? process.env), BINSTALL_DISABLE_TELEMETRY: 'true' },
+    };
     return async (crate) => {
         binstall ??= ensureBinstall(path.join(cargoHome, 'bin'));
         if (await binstall) {
@@ -49,4 +61,4 @@ export const crateInstaller = (cargoHome, cargoEnv) => {
         }
         await execAsync(cargo, ['install', '--locked', crate], cargoEnv);
     };
-};
+}

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

@@ -1,4 +1,4 @@
 import type { Toolchains } from '../../../core/types.js';
-import { type ToolEnv } from '../common.js';
+import { type ToolEnv } from '../tool-env.js';
 /** MinGW-w64 GCC from WinLibs: gcc/g++/mingw32-make for the agent, and the linker for Rust's GNU host. */
-export declare const setupCpp: (env: ToolEnv, config: Toolchains["cpp"]) => Promise<void>;
+export declare function setupCpp(env: ToolEnv, config: Toolchains['cpp']): Promise<void>;

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

@@ -1,10 +1,13 @@
 // C/C++: MinGW-w64 GCC (with CMake, Ninja, make) and the flex/bison parser generators.
 import path from 'node:path';
-import { dryRun, exists, log, warn } from '../../env.js';
-import { arch, installFromGithub, tool, versionOf } from '../common.js';
-import { CMAKE_FLOOR, cmakeTooOld } from '../versions.js';
+import { dryRun } from '../../runtime/paths.js';
+import { exists } from '../../runtime/fs.js';
+import { log, warn } from '../../runtime/log.js';
+import { arch, tool, versionOf } from '../tool-env.js';
+import { installFromGithub } from '../install.js';
+import { CMAKE_FLOOR, cmakeTooOld } from '../../../core/detect/versions.js';
 /** MinGW-w64 GCC from WinLibs: gcc/g++/mingw32-make for the agent, and the linker for Rust's GNU host. */
-export const setupCpp = async (env, config) => {
+export async function setupCpp(env, config) {
     const bin = tool('mingw', 'mingw64', 'bin');
     const gcc = path.join(bin, 'gcc.exe');
     if (dryRun) {
@@ -13,7 +16,11 @@ export const setupCpp = async (env, config) => {
     }
     if (!exists(gcc)) {
         const pattern = arch === 'arm64' ? /^winlibs-aarch64-.*\.zip$/ : /^winlibs-x86_64-posix-seh-gcc-.*\.zip$/;
-        await installFromGithub('brechtsanders/winlibs_mingw', pattern, { dest: tool('mingw'), what: 'the C/C++ compiler, MinGW-w64 GCC with CMake and Ninja (~270 MB once)', searchOlder: true });
+        await installFromGithub('brechtsanders/winlibs_mingw', pattern, {
+            dest: tool('mingw'),
+            what: 'the C/C++ compiler, MinGW-w64 GCC with CMake and Ninja (~270 MB once)',
+            searchOlder: true,
+        });
     }
     if (!exists(gcc))
         throw new Error('gcc.exe missing after installing MinGW');
@@ -22,16 +29,24 @@ export const setupCpp = async (env, config) => {
     env.vars.CARGO_TARGET_X86_64_PC_WINDOWS_GNU_LINKER = gcc;
     const cmake = versionOf(path.join(bin, 'cmake.exe'));
     if (cmakeTooOld(cmake))
-        warn('The bundled CMake ' + cmake + ' is older than ' + CMAKE_FLOOR + ', which many projects need; set toolchains.cpp.enabled to refresh it, or install a newer CMake into C:\\AgentData\\tools\\bin.');
+        warn('The bundled CMake ' +
+            cmake +
+            ' is older than ' +
+            CMAKE_FLOOR +
+            ', which many projects need; set toolchains.cpp.enabled to refresh it, or install a newer CMake into C:\\AgentData\\tools\\bin.');
     env.summary.push('gcc: ' + versionOf(gcc) + ' (MinGW-w64, with cmake ' + cmake + ', ninja, premake5)');
     if (config.flexBison)
         await setupFlexBison(env);
-};
+}
 /** win_flex / win_bison (CMake's FindFLEX/FindBISON look for these names). Kept with the C/C++ tools on PATH. */
 const setupFlexBison = async (env) => {
     const dir = tool('winflexbison');
     if (!exists(path.join(dir, 'win_bison.exe'))) {
-        await installFromGithub('lexxmark/winflexbison', /^win_flex_bison-[\d.]+\.zip$/, { dest: dir, what: 'win_flex / win_bison (~1 MB once)', locate: 'win_bison.exe' });
+        await installFromGithub('lexxmark/winflexbison', /^win_flex_bison-[\d.]+\.zip$/, {
+            dest: dir,
+            what: 'win_flex / win_bison (~1 MB once)',
+            locate: 'win_bison.exe',
+        });
     }
     env.append.push(dir);
     env.summary.push('win_flex/win_bison: ' + versionOf(path.join(dir, 'win_bison.exe')));

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

@@ -1,4 +1,6 @@
 import type { Toolchains } from '../../../core/types.js';
-import { type ToolEnv } from '../common.js';
-/** .NET SDK channels from config plus whatever the workspace's global.json pins. Installs are remembered in a marker. */
-export declare const setupDotnet: (env: ToolEnv, config: Toolchains["dotnet"], refresh: boolean) => Promise<void>;
+import { type ToolEnv } from '../tool-env.js';
+/**
+ * .NET SDK channels from config plus whatever the workspace's global.json pins. Installs are remembered in a marker.
+ */
+export declare function setupDotnet(env: ToolEnv, config: Toolchains['dotnet'], refresh: boolean): Promise<void>;

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

@@ -1,18 +1,27 @@
-// .NET: the SDK (dotnet-install.ps1), .NET Framework reference assemblies for old-style projects, and .NET Framework 3.5.
+// .NET: the SDK (dotnet-install.ps1), .NET Framework reference assemblies for old-style projects, and .NET Framework
+// 3.5.
 import fs from 'node:fs';
 import path from 'node:path';
 import { z } from 'zod';
-import { fetchJson, installArchive } from '../../../shared/download.js';
-import { readJsonFile, writeJsonAtomic } from '../../../shared/rundir.js';
-import { safeRemove } from '../../../shared/safe-remove.js';
+import { downloader, fetchJson } from '../../../shared/download/index.js';
+import { readJsonFile, writeJsonAtomic } from '../../../shared/io/json.js';
+import { safeRemove } from '../../../shared/io/safe-remove.js';
 import { SYSTEM } from '../../../shared/system.js';
-import { dataDir, dryRun, errMsg, execAsync, execOutput, exists, log, mkdirp, warn } from '../../env.js';
-import { projectWorkspace } from '../../project-context.js';
-import { downloadFile, installOnce, tool } from '../common.js';
+import { dataDir, dryRun } from '../../runtime/paths.js';
+import { execAsync, execOutput } from '../../runtime/process.js';
+import { exists, mkdirp } from '../../runtime/fs.js';
+import { log, warn } from '../../runtime/log.js';
+import { errMsg } from '../../../core/util/errors.js';
+import { projectWorkspace } from '../../runtime/project-context.js';
+import { downloadFile } from '../install.js';
+import { installOnce } from '../package-ledger.js';
+import { tool } from '../tool-env.js';
 /** tools\dotnet\.agent-sandbox-installed.json: which install keys (channel:8.0, global.json:...) already ran. */
-const DotnetMarker = z.record(z.string(), z.boolean());
-/** .NET SDK channels from config plus whatever the workspace's global.json pins. Installs are remembered in a marker. */
-export const setupDotnet = async (env, config, refresh) => {
+const DotnetMarkerSchema = z.record(z.string(), z.boolean());
+/**
+ * .NET SDK channels from config plus whatever the workspace's global.json pins. Installs are remembered in a marker.
+ */
+export async function setupDotnet(env, config, refresh) {
     const root = tool('dotnet');
     const marker = path.join(root, '.agent-sandbox-installed.json');
     const script = tool('dotnet-install.ps1');
@@ -21,25 +30,54 @@ export const setupDotnet = async (env, config, refresh) => {
         return;
     }
     // A corrupt or hand-edited marker just means "nothing recorded yet" (the installs are idempotent).
-    const recorded = DotnetMarker.safeParse(exists(marker) && !refresh ? readJsonFile(marker) : {});
+    const recorded = DotnetMarkerSchema.safeParse(exists(marker) && !refresh ? readJsonFile(marker) : {});
     const done = recorded.success ? recorded.data : {};
     const globalJson = path.join(projectWorkspace(), 'global.json');
     const installs = [
         ...config.channels.map((c) => ['channel:' + c, ['-Channel', c]]),
-        ...(exists(globalJson) ? [['global.json:' + fs.readFileSync(globalJson, 'utf8').replace(/\s+/g, ''), ['-JSonFile', globalJson]]] : []),
+        ...(exists(globalJson)
+            ? [
+                ['global.json:' + fs.readFileSync(globalJson, 'utf8').replace(/\s+/g, ''), ['-JSonFile', globalJson]],
+            ]
+            : []),
     ];
     for (const [key, args] of installs.filter(([k]) => !done[k])) {
         // Fetched every time something is installed (it is small): an interrupted earlier download must not be run.
         await downloadFile('https://dot.net/v1/dotnet-install.ps1', script);
-        log('Installing the .NET SDK ' + (key.startsWith('channel:') ? key.slice(8) : 'pinned in global.json') + ' (~250 MB once) ...');
-        await execAsync(SYSTEM.powershell(), ['-NoLogo', '-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', script, ...args, '-InstallDir', root, '-NoPath']);
+        log('Installing the .NET SDK ' +
+            (key.startsWith('channel:') ? key.slice(8) : 'pinned in global.json') +
+            ' (~250 MB once) ...');
+        await execAsync(SYSTEM.powershell(), [
+            '-NoLogo',
+            '-NoProfile',
+            '-ExecutionPolicy',
+            'Bypass',
+            '-File',
+            script,
+            ...args,
+            '-InstallDir',
+            root,
+            '-NoPath',
+        ]);
         done[key] = true;
         writeJsonAtomic(marker, done);
     }
     const home = mkdirp(tool('dotnet-home'));
-    Object.assign(env.vars, { DOTNET_ROOT: root, DOTNET_CLI_HOME: home, DOTNET_CLI_TELEMETRY_OPTOUT: '1', DOTNET_NOLOGO: '1', DOTNET_SKIP_FIRST_TIME_EXPERIENCE: '1', NUGET_PACKAGES: tool('nuget', 'packages') });
+    Object.assign(env.vars, {
+        DOTNET_ROOT: root,
+        DOTNET_CLI_HOME: home,
+        DOTNET_CLI_TELEMETRY_OPTOUT: '1',
+        DOTNET_NOLOGO: '1',
+        DOTNET_SKIP_FIRST_TIME_EXPERIENCE: '1',
+        NUGET_PACKAGES: tool('nuget', 'packages'),
+    });
     env.prepend.push(root, path.join(home, '.dotnet', 'tools'));
-    env.summary.push('dotnet: ' + execOutput(path.join(root, 'dotnet.exe'), ['--list-sdks']).split(/\r?\n/).map((l) => l.split(' ')[0]).filter(Boolean).join(', '));
+    env.summary.push('dotnet: ' +
+        execOutput(path.join(root, 'dotnet.exe'), ['--list-sdks'])
+            .split(/\r?\n/)
+            .map((l) => l.split(' ')[0])
+            .filter(Boolean)
+            .join(', '));
     const dotnet = path.join(root, 'dotnet.exe');
     const dotnetEnv = { env: { ...process.env, ...env.vars, PATH: root + path.delimiter + (process.env.PATH ?? '') } };
     await installOnce(env, 'dotnet workload', config.workloads, (w) => execAsync(dotnet, ['workload', 'install', w, '--skip-manifest-update'], dotnetEnv));
@@ -47,11 +85,11 @@ export const setupDotnet = async (env, config, refresh) => {
     await setupFrameworkReferences(env, config.frameworkTargets);
     if (config.netfx35)
         await setupNetFx35(env);
-};
+}
 /**
- * .NET Framework reference assemblies (the "targeting packs" Visual Studio would install) from NuGet, so net4x projects,
- * old-style .csproj included, build with the SDK's MSBuild. MSBuild reads TargetFrameworkRootPath from the environment.
- * Running .NET Framework 4.8 apps needs nothing: Windows ships it.
+ * .NET Framework reference assemblies (the "targeting packs" Visual Studio would install) from NuGet, so net4x
+ * projects, old-style .csproj included, build with the SDK's MSBuild. MSBuild reads TargetFrameworkRootPath from the
+ * environment. Running .NET Framework 4.8 apps needs nothing: Windows ships it.
  */
 const setupFrameworkReferences = async (env, targets) => {
     if (!targets.length)
@@ -69,12 +107,15 @@ const setupFrameworkReferences = async (env, targets) => {
             if (!version)
                 throw new Error('no stable version of ' + id);
             log('Downloading the .NET Framework ' + target + ' reference assemblies (~30 MB once) ...');
-            await installArchive('https://api.nuget.org/v3-flatcontainer/' + id + '/' + version + '/' + id + '.' + version + '.nupkg', staging, { fileName: id + '.zip' });
+            await downloader.archive('https://api.nuget.org/v3-flatcontainer/' + id + '/' + version + '/' + id + '.' + version + '.nupkg', staging, { fileName: id + '.zip' });
             fs.cpSync(path.join(staging, 'build', '.NETFramework'), path.join(root, '.NETFramework'), { recursive: true });
             fs.writeFileSync(marker, version);
         }
         catch (e) {
-            warn('.NET Framework ' + target + ' reference assemblies could not be installed (projects targeting it will not build): ' + errMsg(e));
+            warn('.NET Framework ' +
+                target +
+                ' reference assemblies could not be installed (projects targeting it will not build): ' +
+                errMsg(e));
         }
         finally {
             safeRemove(staging, dataDir);
@@ -85,9 +126,16 @@ const setupFrameworkReferences = async (env, targets) => {
     env.vars.TargetFrameworkRootPath = root + path.sep;
     env.summary.push('.NET Framework targeting: ' + fs.readdirSync(path.join(root, '.NETFramework')).join(', '));
 };
-/** .NET Framework 3.5 is a Windows feature the sandbox image lacks; DISM fetches it from Windows Update on every boot. */
+/**
+ * .NET Framework 3.5 is a Windows feature the sandbox image lacks; DISM fetches it from Windows Update on every boot.
+ */
 const setupNetFx35 = async (env) => {
-    if (execOutput(SYSTEM.reg(), ['query', 'HKLM\\SOFTWARE\\Microsoft\\NET Framework Setup\\NDP\\v3.5', '/v', 'Install']).includes('0x1')) {
+    if (execOutput(SYSTEM.reg(), [
+        'query',
+        'HKLM\\SOFTWARE\\Microsoft\\NET Framework Setup\\NDP\\v3.5',
+        '/v',
+        'Install',
+    ]).includes('0x1')) {
         env.summary.push('.NET Framework 3.5: on');
         return;
     }

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

@@ -1,7 +1,7 @@
 import type { Toolchains } from '../../../core/types.js';
-import { type ToolEnv } from '../common.js';
+import { type ToolEnv } from '../tool-env.js';
 /**
  * Mesa 3D for Windows (llvmpipe): OpenGL 4.5 on the CPU when the sandbox has no GPU. Windows only offers OpenGL 1.1 in
  * software, and opengl32.dll cannot be replaced system-wide, so programs pick Mesa up from their own folder.
  */
-export declare const setupMesa: (env: ToolEnv, config: Toolchains["mesa"]) => Promise<void>;
+export declare function setupMesa(env: ToolEnv, config: Toolchains['mesa']): Promise<void>;

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

@@ -1,14 +1,18 @@
 // Mesa for running OpenGL and Vulkan programs without a GPU (llvmpipe, lavapipe).
 import path from 'node:path';
-import { installArchive } from '../../../shared/download.js';
+import { downloader } from '../../../shared/download/index.js';
 import { SYSTEM } from '../../../shared/system.js';
-import { dryRun, execAsync, execOutput, exists, log } from '../../env.js';
-import { arch, installFromGithub, tool } from '../common.js';
+import { dryRun } from '../../runtime/paths.js';
+import { execAsync, execOutput } from '../../runtime/process.js';
+import { exists } from '../../runtime/fs.js';
+import { log } from '../../runtime/log.js';
+import { arch, tool } from '../tool-env.js';
+import { installFromGithub } from '../install.js';
 /**
  * Mesa 3D for Windows (llvmpipe): OpenGL 4.5 on the CPU when the sandbox has no GPU. Windows only offers OpenGL 1.1 in
  * software, and opengl32.dll cannot be replaced system-wide, so programs pick Mesa up from their own folder.
  */
-export const setupMesa = async (env, config) => {
+export async function setupMesa(env, config) {
     if (dryRun) {
         log('(dry run) would provision Mesa 3D');
         return;
@@ -16,13 +20,18 @@ export const setupMesa = async (env, config) => {
     const root = tool('mesa');
     const dir = path.join(root, arch === 'arm64' ? 'arm64' : 'x64');
     if (!exists(path.join(dir, 'opengl32.dll'))) {
-        await installFromGithub('pal1000/mesa-dist-win', /^mesa3d-[\d.]+-release-msvc\.7z$/, { dest: root, what: 'Mesa 3D for software OpenGL (~100 MB once)', locate: 'opengl32.dll', up: 1 });
+        await installFromGithub('pal1000/mesa-dist-win', /^mesa3d-[\d.]+-release-msvc\.7z$/, {
+            dest: root,
+            what: 'Mesa 3D for software OpenGL (~100 MB once)',
+            locate: 'opengl32.dll',
+            up: 1,
+        });
     }
     Object.assign(env.vars, { MESA_DIR: dir, GALLIUM_DRIVER: 'llvmpipe' });
-    env.summary.push('mesa (software OpenGL 4.5): copy opengl32.dll + libgallium_wgl.dll from %MESA_DIR% next to a game\'s .exe');
+    env.summary.push("mesa (software OpenGL 4.5): copy opengl32.dll + libgallium_wgl.dll from %MESA_DIR% next to a game's .exe");
     if (config.vulkan)
         await setupLavapipe(env, dir);
-};
+}
 const VULKAN_RUNTIME = 'https://sdk.lunarg.com/sdk/download/latest/windows/vulkan-runtime-components.zip';
 /**
  * Software Vulkan: Mesa's lavapipe plus the Khronos loader (vulkan-1.dll, from LunarG's runtime components; Windows
@@ -38,7 +47,11 @@ const setupLavapipe = async (env, mesaDir) => {
         log('Downloading the Vulkan loader (~10 MB once) ...');
         // LunarG publishes no checksum for this zip; it comes over HTTPS from LunarG, the Khronos SDK's maintainer.
         // The zip has x86 and x64 folders: only the 64-bit loader (and vulkaninfo) is extracted.
-        await installArchive(VULKAN_RUNTIME, dir, { locate: 'vulkan-1.dll', fileName: 'vulkan-runtime.zip', members: ['*/x64/*'] });
+        await downloader.archive(VULKAN_RUNTIME, dir, {
+            locate: 'vulkan-1.dll',
+            fileName: 'vulkan-runtime.zip',
+            members: ['*/x64/*'],
+        });
     }
     const register = (file) => execAsync(SYSTEM.reg(), ['add', 'HKLM\\SOFTWARE\\Khronos\\Vulkan\\Drivers', '/v', file, '/t', 'REG_DWORD', '/d', '0', '/f'], { stdio: 'ignore' });
     await register(icd);
@@ -49,8 +62,12 @@ const setupLavapipe = async (env, mesaDir) => {
     if (gpu && exists(dozen))
         await register(dozen);
     env.prepend.push(dir);
-    env.summary.push('vulkan: ' + (gpu && exists(dozen) ? 'Dozen (Vulkan on the GPU via Direct3D 12) and ' : '') + 'lavapipe (software Vulkan 1.4 on the CPU), vulkaninfo on PATH; WGPU_BACKEND=vulkan for wgpu');
+    env.summary.push('vulkan: ' +
+        (gpu && exists(dozen) ? 'Dozen (Vulkan on the GPU via Direct3D 12) and ' : '') +
+        'lavapipe (software Vulkan 1.4 on the CPU), vulkaninfo on PATH; WGPU_BACKEND=vulkan for wgpu');
 };
 /** A real display adapter (sandbox.vGpu on), not only the remote display or basic render driver. */
 const hasGpu = () => execOutput(SYSTEM.powershell(), ['-NoProfile', '-NonInteractive', '-Command', '(Get-CimInstance Win32_VideoController).Name'], { timeout: 30000 })
-    .split(/\r?\n/).map((n) => n.trim()).some((n) => n && !/^Microsoft (Remote Display|Basic (Render|Display))/i.test(n));
+    .split(/\r?\n/)
+    .map((n) => n.trim())
+    .some((n) => n && !/^Microsoft (Remote Display|Basic (Render|Display))/i.test(n));

package/dist/guest/toolchains/native/msvc/environment.d.ts

@@ -3,14 +3,14 @@ export interface VcEnv {
     path: string[];
 }
 /** Variables vcvars64.bat would set for this tree (host x64, target x64). */
-export declare const vcvars: (root: string, msvc: string, sdk: string) => VcEnv;
+export declare function vcvars(root: string, msvc: string, sdk: string): VcEnv;
 /** vcvars64.bat / vcvarsall.bat in the usual place, for scripts that `call` them. */
-export declare const writeVcvars: (env: VcEnv) => void;
+export declare function writeVcvars(env: VcEnv): void;
 /** vswhere.exe where Visual Studio's installer would put it, answering with this tree. */
-export declare const installVswhere: (msvc: string) => void;
+export declare function installVswhere(msvc: string): void;
 /**
  * cl.exe and link.exe start vctip.exe (Visual Studio's telemetry uploader), which lingers after the build and keeps the
  * folder locked, so `sandbox repair` / `data clean` could not delete tools\msvc. Neither VSCMD_SKIP_SENDTELEMETRY nor
  * the TurnOffSwitch registry value stops it; without the file the compiler simply skips it. Nothing else needs it.
  */
-export declare const removeTelemetry: (msvc: string) => void;
+export declare function removeTelemetry(msvc: string): void;

package/dist/guest/toolchains/native/msvc/environment.js

@@ -1,57 +1,71 @@
 // What makes the unpacked tree behave like a Build Tools install: the vcvars environment, vcvars64.bat, vswhere.
 import fs from 'node:fs';
 import path from 'node:path';
-import { errMsg, mkdirp, warn } from '../../../env.js';
-import { ensureCompiled } from '../../../helpers.js';
+import { mkdirp } from '../../../runtime/fs.js';
+import { warn } from '../../../runtime/log.js';
+import { errMsg } from '../../../../core/util/errors.js';
+import { ensureCompiled } from '../../../runtime/csc.js';
 import { hostBin, ROOT } from './tree.js';
 /** Where build tools look for vswhere (local to the sandbox, so it is written each boot). */
 const VSWHERE_DIR = path.join(process.env['ProgramFiles(x86)'] ?? 'C:\\Program Files (x86)', 'Microsoft Visual Studio', 'Installer');
 /** Variables vcvars64.bat would set for this tree (host x64, target x64). */
-export const vcvars = (root, msvc, sdk) => {
+export function vcvars(root, msvc, sdk) {
     const vc = path.join(root, 'VC', 'Tools', 'MSVC', msvc);
     const kits = path.join(root, 'Windows Kits', '10');
     const inc = (...p) => path.join(kits, 'Include', sdk, ...p);
     const lib = (...p) => path.join(kits, 'Lib', sdk, ...p);
     return {
         vars: {
-            VSINSTALLDIR: root + '\\', VCINSTALLDIR: path.join(root, 'VC') + '\\', VCToolsInstallDir: vc + '\\', VCToolsVersion: msvc, VisualStudioVersion: '17.0',
-            WindowsSdkDir: kits + '\\', WindowsSDKVersion: sdk + '\\', WindowsSDKLibVersion: sdk + '\\', UniversalCRTSdkDir: kits + '\\', UCRTVersion: sdk,
-            VSCMD_ARG_HOST_ARCH: 'x64', VSCMD_ARG_TGT_ARCH: 'x64', Platform: 'x64',
+            VSINSTALLDIR: root + '\\',
+            VCINSTALLDIR: path.join(root, 'VC') + '\\',
+            VCToolsInstallDir: vc + '\\',
+            VCToolsVersion: msvc,
+            VisualStudioVersion: '17.0',
+            WindowsSdkDir: kits + '\\',
+            WindowsSDKVersion: sdk + '\\',
+            WindowsSDKLibVersion: sdk + '\\',
+            UniversalCRTSdkDir: kits + '\\',
+            UCRTVersion: sdk,
+            VSCMD_ARG_HOST_ARCH: 'x64',
+            VSCMD_ARG_TGT_ARCH: 'x64',
+            Platform: 'x64',
             INCLUDE: [path.join(vc, 'include'), inc('ucrt'), inc('shared'), inc('um'), inc('winrt'), inc('cppwinrt')].join(';'),
             LIB: [path.join(vc, 'lib', 'x64'), lib('ucrt', 'x64'), lib('um', 'x64')].join(';'),
             LIBPATH: [path.join(vc, 'lib', 'x64'), path.join(vc, 'lib', 'x86', 'store', 'references')].join(';'),
         },
         path: [path.join(vc, 'bin', 'Hostx64', 'x64'), path.join(kits, 'bin', sdk, 'x64')],
     };
-};
+}
 /** vcvars64.bat / vcvarsall.bat in the usual place, for scripts that `call` them. */
-export const writeVcvars = (env) => {
+export function writeVcvars(env) {
     const dir = mkdirp(path.join(ROOT, 'VC', 'Auxiliary', 'Build'));
     const lines = [
-        '@echo off', 'rem Written by Windows Development Sandbox for its portable MSVC (host x64, target x64).',
+        '@echo off',
+        'rem Written by Windows Development Sandbox for its portable MSVC (host x64, target x64).',
         ...Object.entries(env.vars).map(([k, v]) => 'set "' + k + '=' + v + '"'),
-        'set "PATH=' + env.path.join(';') + ';%PATH%"', 'exit /b 0',
+        'set "PATH=' + env.path.join(';') + ';%PATH%"',
+        'exit /b 0',
     ];
     fs.writeFileSync(path.join(dir, 'vcvars64.bat'), lines.join('\r\n') + '\r\n');
     fs.writeFileSync(path.join(dir, 'vcvarsall.bat'), ['@echo off', 'rem Only x64 (amd64) is installed.', 'call "%~dp0vcvars64.bat"', 'exit /b %errorlevel%'].join('\r\n') + '\r\n');
-};
+}
 /** vswhere.exe where Visual Studio's installer would put it, answering with this tree. */
-export const installVswhere = (msvc) => {
+export function installVswhere(msvc) {
     mkdirp(VSWHERE_DIR);
     fs.copyFileSync(ensureCompiled('vswhere'), path.join(VSWHERE_DIR, 'vswhere.exe'));
     const [major, minor] = msvc.split('.').slice(2);
     fs.writeFileSync(path.join(VSWHERE_DIR, 'vswhere.json'), JSON.stringify({ installationPath: ROOT, installationVersion: '17.' + (minor ?? '0') + '.0.' + (major ?? '0') }));
-};
+}
 /**
  * cl.exe and link.exe start vctip.exe (Visual Studio's telemetry uploader), which lingers after the build and keeps the
  * folder locked, so `sandbox repair` / `data clean` could not delete tools\msvc. Neither VSCMD_SKIP_SENDTELEMETRY nor
  * the TurnOffSwitch registry value stops it; without the file the compiler simply skips it. Nothing else needs it.
  */
-export const removeTelemetry = (msvc) => {
+export function removeTelemetry(msvc) {
     try {
         fs.rmSync(hostBin(msvc, 'vctip.exe'), { force: true });
     }
     catch (e) {
-        warn('Could not remove MSVC\'s telemetry helper (vctip.exe); it may keep tools\\msvc locked: ' + errMsg(e));
+        warn("Could not remove MSVC's telemetry helper (vctip.exe); it may keep tools\\msvc locked: " + errMsg(e));
     }
-};
+}

package/dist/guest/toolchains/native/msvc/index.d.ts

@@ -1,6 +1,6 @@
 import type { Toolchains } from '../../../../core/types.js';
-import type { ToolEnv } from '../../common.js';
+import type { ToolEnv } from '../../tool-env.js';
 import { type VcEnv } from './environment.js';
 /** The vcvars environment of an installed tree (for steps that run before the agent's environment exists). */
-export declare const installedMsvcEnv: () => VcEnv | null;
-export declare const setupMsvc: (env: ToolEnv, config: Toolchains["msvc"]) => Promise<void>;
+export declare function installedMsvcEnv(): VcEnv | null;
+export declare function setupMsvc(env: ToolEnv, config: Toolchains['msvc']): Promise<void>;

package/dist/guest/toolchains/native/msvc/index.js

@@ -1,19 +1,21 @@
 // MSVC (cl, link) and the Windows SDK without an installer (packages.ts), laid out like a Build Tools install with
 // vcvars64.bat and a vswhere that points at it (environment.ts), so CMake, cargo (msvc host), node-gyp and vcvars-based
-// scripts work. Use is governed by the Visual Studio licence terms: it only installs with toolchains.msvc.acceptLicense.
+// scripts work. Use falls under the Visual Studio licence terms: it only installs with toolchains.msvc.acceptLicense.
 import fs from 'node:fs';
 import path from 'node:path';
-import { writeJsonAtomic } from '../../../../shared/rundir.js';
-import { safeRemove } from '../../../../shared/safe-remove.js';
-import { dryRun, exists, log } from '../../../env.js';
+import { writeJsonAtomic } from '../../../../shared/io/json.js';
+import { safeRemove } from '../../../../shared/io/safe-remove.js';
+import { dryRun } from '../../../runtime/paths.js';
+import { exists } from '../../../runtime/fs.js';
+import { log } from '../../../runtime/log.js';
 import { installVswhere, removeTelemetry, vcvars, writeVcvars } from './environment.js';
 import { installPackages } from './packages.js';
 import { hasCompiler, MARKER, readInstalled, ROOT } from './tree.js';
 /** The vcvars environment of an installed tree (for steps that run before the agent's environment exists). */
-export const installedMsvcEnv = () => {
+export function installedMsvcEnv() {
     const done = readInstalled();
     return done && hasCompiler(done.msvc) ? vcvars(ROOT, done.msvc, done.sdk) : null;
-};
+}
 /** Empties tools\msvc for a fresh install, keeping the manifest and the verified downloads of an earlier attempt. */
 const clearTree = () => {
     if (!exists(ROOT))
@@ -21,7 +23,7 @@ const clearTree = () => {
     for (const name of fs.readdirSync(ROOT).filter((n) => n !== '.manifest.json' && n !== '.download'))
         safeRemove(path.join(ROOT, name), ROOT);
 };
-export const setupMsvc = async (env, config) => {
+export async function setupMsvc(env, config) {
     if (!config.acceptLicense) {
         throw new Error('MSVC is installed only with toolchains.msvc.acceptLicense = true: its use is governed by the Visual Studio licence terms (https://visualstudio.microsoft.com/license-terms/), which need a Visual Studio licence');
     }
@@ -45,4 +47,4 @@ export const setupMsvc = async (env, config) => {
     Object.assign(env.vars, vc.vars);
     env.prepend.push(...vc.path);
     env.summary.push('msvc: ' + done.msvc + ', Windows SDK ' + done.sdk + ' (cl, link; vcvars64.bat and vswhere work)');
-};
+}

package/dist/guest/toolchains/native/msvc/packages.d.ts

@@ -1,6 +1,6 @@
 import type { Toolchains } from '../../../../core/types.js';
 /** Downloads and unpacks MSVC and the Windows SDK into tools\msvc; resolves with the toolset and SDK folder names. */
-export declare const installPackages: (config: Toolchains["msvc"]) => Promise<{
+export declare function installPackages(config: Toolchains['msvc']): Promise<{
     msvc: string;
     sdk: string;
 }>;