wyvrnpm 2.10.2 → 2.12.2

package/src/build/cmake.js

@@ -1,342 +1,342 @@
-'use strict';
-
-const fs   = require('fs');
-const path = require('path');
-const { spawn } = require('child_process');
-
-const { loadMsvcEnv } = require('./msvc-env');
-const log = require('../logger');
-
-/**
- * CMake configure + build + install orchestration for the source-build path.
- *
- * Separation of concerns:
- *   - This module does NOT compute CMake flags from a profile. That is the
- *     toolchain generator's job ([src/toolchain/index.js]). We take a
- *     pre-generated toolchain file path and hand it to CMake.
- *   - This module DOES translate a recipe (`{ generator, configure,
- *     buildArgs, installDir, sourceSubdir }`) into `cmake` argv.
- */
-
-const DEFAULT_CONFIG = 'Release';
-
-/**
- * Probe whether a tool is available on PATH by spawning it with `--version`.
- * Uses `shell: true` on Windows so `.cmd`/`.bat` shims resolve correctly.
- *
- * @param {string} cmd
- * @returns {Promise<boolean>}
- */
-function isToolOnPath(cmd) {
-  return new Promise((resolve) => {
-    const proc = spawn(cmd, ['--version'], {
-      stdio: 'ignore',
-      shell: process.platform === 'win32',
-    });
-    proc.on('error', () => resolve(false));
-    proc.on('close', (code) => resolve(code === 0));
-  });
-}
-
-/**
- * Classify a CMake generator's availability on this machine. Tri-state so
- * `pickGenerator` can distinguish "known-available" (take it) from
- * "known-unavailable" (skip) from "unknown name" (use only if nothing else
- * is confirmed — CMake will error itself if it can't handle the name).
- *
- * @param {string} name
- * @returns {Promise<'yes'|'no'|'unknown'>}
- */
-async function classifyGenerator(name) {
-  if (!name) return 'no';
-  if (name === 'Ninja' || name === 'Ninja Multi-Config') {
-    return (await isToolOnPath('ninja')) ? 'yes' : 'no';
-  }
-  if (name.startsWith('Visual Studio')) {
-    // CMake itself validates the exact VS version at configure time.
-    return process.platform === 'win32' ? 'yes' : 'no';
-  }
-  if (name === 'Unix Makefiles') {
-    return (await isToolOnPath('make')) ? 'yes' : 'no';
-  }
-  if (name === 'MinGW Makefiles' || name === 'MSYS Makefiles') {
-    if (process.platform !== 'win32') return 'no';
-    return (await isToolOnPath('mingw32-make') || await isToolOnPath('make')) ? 'yes' : 'no';
-  }
-  if (name === 'NMake Makefiles' || name === 'NMake Makefiles JOM') {
-    if (process.platform !== 'win32') return 'no';
-    return (await isToolOnPath('nmake')) ? 'yes' : 'no';
-  }
-  if (name === 'Xcode') {
-    if (process.platform !== 'darwin') return 'no';
-    return (await isToolOnPath('xcodebuild')) ? 'yes' : 'no';
-  }
-  return 'unknown';
-}
-
-/**
- * Boolean convenience wrapper around `classifyGenerator` — true iff the
- * generator is positively confirmed as available (status === 'yes'). Unknown
- * generators return false here; use `classifyGenerator` directly if you
- * need the distinction.
- *
- * @param {string} name
- * @returns {Promise<boolean>}
- */
-async function isGeneratorAvailable(name) {
-  return (await classifyGenerator(name)) === 'yes';
-}
-
-/**
- * Choose the best generator from an ordered candidate list.
- *
- *   1. First pass: the first candidate whose probe positively confirms
- *      availability (e.g. `ninja --version` succeeds) wins — array order
- *      is preserved within this pass.
- *   2. Second pass: if no candidate is known-available, fall back to the
- *      first candidate with an unknown name (CMake gets a chance to resolve
- *      it, erroring clearly if it can't).
- *   3. Otherwise return `null` so CMake uses its own platform default
- *      (VS on Windows, Make elsewhere).
- *
- * @param {string[]} candidates  from recipe.generators
- * @returns {Promise<string|null>}
- */
-async function pickGenerator(candidates) {
-  if (!candidates || candidates.length === 0) return null;
-
-  const results = [];
-  for (const name of candidates) {
-    results.push({ name, status: await classifyGenerator(name) });
-  }
-
-  const good = results.find((r) => r.status === 'yes');
-  if (good) {
-    if (candidates.length > 1) {
-      log.info(`  generator: ${good.name} (chosen from ${JSON.stringify(candidates)})`);
-    }
-    return good.name;
-  }
-
-  const unknown = results.find((r) => r.status === 'unknown');
-  if (unknown) {
-    log.info(
-      `  generator: ${unknown.name} (unknown to wyvrnpm's probe; trusting CMake to resolve)`,
-    );
-    return unknown.name;
-  }
-
-  log.warn(
-    `  None of the requested generators ${JSON.stringify(candidates)} ` +
-    `are installed. Falling through to CMake's platform default.`,
-  );
-  return null;
-}
-
-/**
- * Run `cmake` with the given args, inheriting stdio so the user sees compiler
- * output in real time.
- * @param {string[]} args
- * @param {{ cwd?: string, env?: object }} [opts]
- * @returns {Promise<void>}
- */
-function runCmake(args, opts = {}) {
-  return new Promise((resolve, reject) => {
-    const proc = spawn('cmake', args, {
-      stdio: 'inherit',
-      cwd:   opts.cwd,
-      env:   opts.env || process.env,
-    });
-    proc.on('error', (err) => reject(new Error(
-      `Failed to spawn cmake: ${err.message} (is CMake installed and on PATH?)`,
-    )));
-    proc.on('close', (code) => {
-      if (code === 0) resolve();
-      else reject(new Error(`cmake ${args.join(' ')} exited ${code}`));
-    });
-  });
-}
-
-/**
- * Multi-config CMake generators pick the build configuration at build time
- * (via `--config`), not configure time. Everything else is single-config
- * and bakes `CMAKE_BUILD_TYPE` into the cache at configure time, so
- * multiple configs need multiple build directories.
- *
- * @param {string|null} generatorName
- * @returns {boolean}
- */
-function isMultiConfigGenerator(generatorName) {
-  if (!generatorName) return false; // null = CMake default — usually Make on Linux, VS on Windows
-  if (generatorName.startsWith('Visual Studio')) return true;
-  return generatorName === 'Xcode' || generatorName === 'Ninja Multi-Config';
-}
-
-/**
- * Build cmake CONFIGURE argv for a source-build.
- *
- * Exactly one of `buildType` (single-config) or `configurations`
- * (multi-config) should be non-null. Setting `configurations` explicitly
- * lets us pin `CMAKE_CONFIGURATION_TYPES` so every expected `build-<Config>.ninja`
- * file is actually generated — CMake's default for that variable varies
- * across versions and user CMakeLists.
- *
- * @param {{
- *   sourceDir:       string,
- *   buildDir:        string,
- *   installDir:      string,
- *   toolchainFile:   string,
- *   generator?:      string|null,
- *   configureExtra:  string[],
- *   buildType?:      string|null,   // single-config only
- *   configurations?: string[]|null, // multi-config only, pins CMAKE_CONFIGURATION_TYPES
- * }} args
- * @returns {string[]}
- */
-function buildConfigureArgs({
-  sourceDir, buildDir, installDir, toolchainFile, generator, configureExtra,
-  buildType, configurations,
-}) {
-  const args = ['-S', sourceDir, '-B', buildDir];
-  if (generator) args.push('-G', generator);
-  args.push(`-DCMAKE_TOOLCHAIN_FILE=${toolchainFile}`);
-  args.push(`-DCMAKE_INSTALL_PREFIX=${installDir}`);
-  // Single-config generators bake CMAKE_BUILD_TYPE into the cache.
-  if (buildType) args.push(`-DCMAKE_BUILD_TYPE=${buildType}`);
-  // Multi-config generators ignore CMAKE_BUILD_TYPE and use
-  // CMAKE_CONFIGURATION_TYPES instead. Passed as a semicolon list.
-  if (configurations && configurations.length > 0) {
-    args.push(`-DCMAKE_CONFIGURATION_TYPES=${configurations.join(';')}`);
-  }
-  if (configureExtra.length > 0) args.push(...configureExtra);
-  return args;
-}
-
-/**
- * Build cmake --build argv for the install target.
- *
- * @param {{
- *   buildDir: string,
- *   config:   string,
- *   buildExtra: string[],
- * }} args
- * @returns {string[]}
- */
-function buildInstallArgs({ buildDir, config, buildExtra }) {
-  const args = ['--build', buildDir, '--target', 'install', '--config', config];
-  if (buildExtra.length > 0) args.push('--', ...buildExtra);
-  return args;
-}
-
-/**
- * Configure + build + install a package from source.
- *
- * @param {{
- *   recipe:        import('./recipe').NormalizedRecipe,
- *   srcRoot:       string,   // absolute path to the cloned source root
- *   buildPaths:    { build: string, install: string },
- *   toolchainFile: string,   // absolute path to wyvrn_toolchain.cmake
- *   config?:       string,   // default 'Release'
- * }} args
- * @returns {Promise<void>}
- */
-async function configureBuildInstall({ recipe, srcRoot, buildPaths, toolchainFile, configs, profile }) {
-  const configList = Array.isArray(configs) && configs.length > 0
-    ? configs
-    : [DEFAULT_CONFIG];
-
-  const sourceDir = path.resolve(srcRoot, recipe.sourceSubdir);
-  if (!fs.existsSync(path.join(sourceDir, 'CMakeLists.txt'))) {
-    throw new Error(
-      `CMakeLists.txt not found at ${sourceDir}. ` +
-      `Check the package's build.sourceSubdir in its wyvrn.json.`,
-    );
-  }
-
-  fs.mkdirSync(buildPaths.install, { recursive: true });
-
-  // Resolve generator from the fallback chain (probes each candidate's
-  // backing tool). `null` → omit `-G`, let CMake pick its default.
-  const generator = await pickGenerator(recipe.generators);
-
-  // On Windows with an MSVC profile + non-VS generator (Ninja, Make, ...),
-  // auto-enter a Developer Command Prompt-equivalent env so `cl.exe` is on
-  // PATH. VS generators don't need this — MSBuild resolves MSVC itself.
-  // Returns null when nothing needs to change, in which case we inherit
-  // the caller's env.
-  const env = await loadMsvcEnv({ profile, skipForGenerator: generator });
-
-  const multiConfig = isMultiConfigGenerator(generator);
-  log.info(
-    `  generator: ${generator ?? '<CMake default>'} ` +
-    `(${multiConfig ? 'multi-config' : 'single-config'}), configs: ${configList.join(', ')}`,
-  );
-
-  if (multiConfig) {
-    // ── Multi-config: one build dir, run install target once per config ─────
-    fs.mkdirSync(buildPaths.build, { recursive: true });
-    const configureArgs = buildConfigureArgs({
-      sourceDir,
-      buildDir:       buildPaths.build,
-      installDir:     buildPaths.install,
-      toolchainFile,
-      generator,
-      configureExtra: recipe.configure,
-      buildType:      null,        // multi-config picks at build time
-      configurations: configList,  // pin CMAKE_CONFIGURATION_TYPES so all 4 build-<Config>.ninja files get generated
-    });
-    log.info(`  cmake ${configureArgs.join(' ')}`);
-    await runCmake(configureArgs, { env });
-
-    for (const cfg of configList) {
-      const installArgs = buildInstallArgs({
-        buildDir:   buildPaths.build,
-        config:     cfg,
-        buildExtra: recipe.buildArgs,
-      });
-      log.info(`  cmake ${installArgs.join(' ')}`);
-      await runCmake(installArgs, { env });
-    }
-    return;
-  }
-
-  // ── Single-config: separate build dir + reconfigure per config ───────────
-  // `CMAKE_BUILD_TYPE` is baked into the cache, so mixing configs in one
-  // build dir would require clobbering the cache between each. Distinct
-  // dirs is simpler and lets CMake's own dependency tracking work per-config.
-  for (const cfg of configList) {
-    const perCfgBuildDir = `${buildPaths.build}-${cfg}`;
-    fs.mkdirSync(perCfgBuildDir, { recursive: true });
-    const configureArgs = buildConfigureArgs({
-      sourceDir,
-      buildDir:       perCfgBuildDir,
-      installDir:     buildPaths.install,
-      toolchainFile,
-      generator,
-      configureExtra: recipe.configure,
-      buildType:      cfg,
-    });
-    log.info(`  cmake ${configureArgs.join(' ')}`);
-    await runCmake(configureArgs, { env });
-
-    const installArgs = buildInstallArgs({
-      buildDir:   perCfgBuildDir,
-      config:     cfg,
-      buildExtra: recipe.buildArgs,
-    });
-    log.info(`  cmake ${installArgs.join(' ')}`);
-    await runCmake(installArgs, { env });
-  }
-}
-
-module.exports = {
-  configureBuildInstall,
-  pickGenerator,
-  classifyGenerator,
-  isGeneratorAvailable,
-  isMultiConfigGenerator,
-  // Exported for unit tests
-  buildConfigureArgs,
-  buildInstallArgs,
-  DEFAULT_CONFIG,
-};
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const { loadMsvcEnv } = require('./msvc-env');
+const log = require('../logger');
+
+/**
+ * CMake configure + build + install orchestration for the source-build path.
+ *
+ * Separation of concerns:
+ *   - This module does NOT compute CMake flags from a profile. That is the
+ *     toolchain generator's job ([src/toolchain/index.js]). We take a
+ *     pre-generated toolchain file path and hand it to CMake.
+ *   - This module DOES translate a recipe (`{ generator, configure,
+ *     buildArgs, installDir, sourceSubdir }`) into `cmake` argv.
+ */
+
+const DEFAULT_CONFIG = 'Release';
+
+/**
+ * Probe whether a tool is available on PATH by spawning it with `--version`.
+ * Uses `shell: true` on Windows so `.cmd`/`.bat` shims resolve correctly.
+ *
+ * @param {string} cmd
+ * @returns {Promise<boolean>}
+ */
+function isToolOnPath(cmd) {
+  return new Promise((resolve) => {
+    const proc = spawn(cmd, ['--version'], {
+      stdio: 'ignore',
+      shell: process.platform === 'win32',
+    });
+    proc.on('error', () => resolve(false));
+    proc.on('close', (code) => resolve(code === 0));
+  });
+}
+
+/**
+ * Classify a CMake generator's availability on this machine. Tri-state so
+ * `pickGenerator` can distinguish "known-available" (take it) from
+ * "known-unavailable" (skip) from "unknown name" (use only if nothing else
+ * is confirmed — CMake will error itself if it can't handle the name).
+ *
+ * @param {string} name
+ * @returns {Promise<'yes'|'no'|'unknown'>}
+ */
+async function classifyGenerator(name) {
+  if (!name) return 'no';
+  if (name === 'Ninja' || name === 'Ninja Multi-Config') {
+    return (await isToolOnPath('ninja')) ? 'yes' : 'no';
+  }
+  if (name.startsWith('Visual Studio')) {
+    // CMake itself validates the exact VS version at configure time.
+    return process.platform === 'win32' ? 'yes' : 'no';
+  }
+  if (name === 'Unix Makefiles') {
+    return (await isToolOnPath('make')) ? 'yes' : 'no';
+  }
+  if (name === 'MinGW Makefiles' || name === 'MSYS Makefiles') {
+    if (process.platform !== 'win32') return 'no';
+    return (await isToolOnPath('mingw32-make') || await isToolOnPath('make')) ? 'yes' : 'no';
+  }
+  if (name === 'NMake Makefiles' || name === 'NMake Makefiles JOM') {
+    if (process.platform !== 'win32') return 'no';
+    return (await isToolOnPath('nmake')) ? 'yes' : 'no';
+  }
+  if (name === 'Xcode') {
+    if (process.platform !== 'darwin') return 'no';
+    return (await isToolOnPath('xcodebuild')) ? 'yes' : 'no';
+  }
+  return 'unknown';
+}
+
+/**
+ * Boolean convenience wrapper around `classifyGenerator` — true iff the
+ * generator is positively confirmed as available (status === 'yes'). Unknown
+ * generators return false here; use `classifyGenerator` directly if you
+ * need the distinction.
+ *
+ * @param {string} name
+ * @returns {Promise<boolean>}
+ */
+async function isGeneratorAvailable(name) {
+  return (await classifyGenerator(name)) === 'yes';
+}
+
+/**
+ * Choose the best generator from an ordered candidate list.
+ *
+ *   1. First pass: the first candidate whose probe positively confirms
+ *      availability (e.g. `ninja --version` succeeds) wins — array order
+ *      is preserved within this pass.
+ *   2. Second pass: if no candidate is known-available, fall back to the
+ *      first candidate with an unknown name (CMake gets a chance to resolve
+ *      it, erroring clearly if it can't).
+ *   3. Otherwise return `null` so CMake uses its own platform default
+ *      (VS on Windows, Make elsewhere).
+ *
+ * @param {string[]} candidates  from recipe.generators
+ * @returns {Promise<string|null>}
+ */
+async function pickGenerator(candidates) {
+  if (!candidates || candidates.length === 0) return null;
+
+  const results = [];
+  for (const name of candidates) {
+    results.push({ name, status: await classifyGenerator(name) });
+  }
+
+  const good = results.find((r) => r.status === 'yes');
+  if (good) {
+    if (candidates.length > 1) {
+      log.info(`  generator: ${good.name} (chosen from ${JSON.stringify(candidates)})`);
+    }
+    return good.name;
+  }
+
+  const unknown = results.find((r) => r.status === 'unknown');
+  if (unknown) {
+    log.info(
+      `  generator: ${unknown.name} (unknown to wyvrnpm's probe; trusting CMake to resolve)`,
+    );
+    return unknown.name;
+  }
+
+  log.warn(
+    `  None of the requested generators ${JSON.stringify(candidates)} ` +
+    `are installed. Falling through to CMake's platform default.`,
+  );
+  return null;
+}
+
+/**
+ * Run `cmake` with the given args, inheriting stdio so the user sees compiler
+ * output in real time.
+ * @param {string[]} args
+ * @param {{ cwd?: string, env?: object }} [opts]
+ * @returns {Promise<void>}
+ */
+function runCmake(args, opts = {}) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn('cmake', args, {
+      stdio: 'inherit',
+      cwd:   opts.cwd,
+      env:   opts.env || process.env,
+    });
+    proc.on('error', (err) => reject(new Error(
+      `Failed to spawn cmake: ${err.message} (is CMake installed and on PATH?)`,
+    )));
+    proc.on('close', (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`cmake ${args.join(' ')} exited ${code}`));
+    });
+  });
+}
+
+/**
+ * Multi-config CMake generators pick the build configuration at build time
+ * (via `--config`), not configure time. Everything else is single-config
+ * and bakes `CMAKE_BUILD_TYPE` into the cache at configure time, so
+ * multiple configs need multiple build directories.
+ *
+ * @param {string|null} generatorName
+ * @returns {boolean}
+ */
+function isMultiConfigGenerator(generatorName) {
+  if (!generatorName) return false; // null = CMake default — usually Make on Linux, VS on Windows
+  if (generatorName.startsWith('Visual Studio')) return true;
+  return generatorName === 'Xcode' || generatorName === 'Ninja Multi-Config';
+}
+
+/**
+ * Build cmake CONFIGURE argv for a source-build.
+ *
+ * Exactly one of `buildType` (single-config) or `configurations`
+ * (multi-config) should be non-null. Setting `configurations` explicitly
+ * lets us pin `CMAKE_CONFIGURATION_TYPES` so every expected `build-<Config>.ninja`
+ * file is actually generated — CMake's default for that variable varies
+ * across versions and user CMakeLists.
+ *
+ * @param {{
+ *   sourceDir:       string,
+ *   buildDir:        string,
+ *   installDir:      string,
+ *   toolchainFile:   string,
+ *   generator?:      string|null,
+ *   configureExtra:  string[],
+ *   buildType?:      string|null,   // single-config only
+ *   configurations?: string[]|null, // multi-config only, pins CMAKE_CONFIGURATION_TYPES
+ * }} args
+ * @returns {string[]}
+ */
+function buildConfigureArgs({
+  sourceDir, buildDir, installDir, toolchainFile, generator, configureExtra,
+  buildType, configurations,
+}) {
+  const args = ['-S', sourceDir, '-B', buildDir];
+  if (generator) args.push('-G', generator);
+  args.push(`-DCMAKE_TOOLCHAIN_FILE=${toolchainFile}`);
+  args.push(`-DCMAKE_INSTALL_PREFIX=${installDir}`);
+  // Single-config generators bake CMAKE_BUILD_TYPE into the cache.
+  if (buildType) args.push(`-DCMAKE_BUILD_TYPE=${buildType}`);
+  // Multi-config generators ignore CMAKE_BUILD_TYPE and use
+  // CMAKE_CONFIGURATION_TYPES instead. Passed as a semicolon list.
+  if (configurations && configurations.length > 0) {
+    args.push(`-DCMAKE_CONFIGURATION_TYPES=${configurations.join(';')}`);
+  }
+  if (configureExtra.length > 0) args.push(...configureExtra);
+  return args;
+}
+
+/**
+ * Build cmake --build argv for the install target.
+ *
+ * @param {{
+ *   buildDir: string,
+ *   config:   string,
+ *   buildExtra: string[],
+ * }} args
+ * @returns {string[]}
+ */
+function buildInstallArgs({ buildDir, config, buildExtra }) {
+  const args = ['--build', buildDir, '--target', 'install', '--config', config];
+  if (buildExtra.length > 0) args.push('--', ...buildExtra);
+  return args;
+}
+
+/**
+ * Configure + build + install a package from source.
+ *
+ * @param {{
+ *   recipe:        import('./recipe').NormalizedRecipe,
+ *   srcRoot:       string,   // absolute path to the cloned source root
+ *   buildPaths:    { build: string, install: string },
+ *   toolchainFile: string,   // absolute path to wyvrn_toolchain.cmake
+ *   config?:       string,   // default 'Release'
+ * }} args
+ * @returns {Promise<void>}
+ */
+async function configureBuildInstall({ recipe, srcRoot, buildPaths, toolchainFile, configs, profile }) {
+  const configList = Array.isArray(configs) && configs.length > 0
+    ? configs
+    : [DEFAULT_CONFIG];
+
+  const sourceDir = path.resolve(srcRoot, recipe.sourceSubdir);
+  if (!fs.existsSync(path.join(sourceDir, 'CMakeLists.txt'))) {
+    throw new Error(
+      `CMakeLists.txt not found at ${sourceDir}. ` +
+      `Check the package's build.sourceSubdir in its wyvrn.json.`,
+    );
+  }
+
+  fs.mkdirSync(buildPaths.install, { recursive: true });
+
+  // Resolve generator from the fallback chain (probes each candidate's
+  // backing tool). `null` → omit `-G`, let CMake pick its default.
+  const generator = await pickGenerator(recipe.generators);
+
+  // On Windows with an MSVC profile + non-VS generator (Ninja, Make, ...),
+  // auto-enter a Developer Command Prompt-equivalent env so `cl.exe` is on
+  // PATH. VS generators don't need this — MSBuild resolves MSVC itself.
+  // Returns null when nothing needs to change, in which case we inherit
+  // the caller's env.
+  const env = await loadMsvcEnv({ profile, skipForGenerator: generator });
+
+  const multiConfig = isMultiConfigGenerator(generator);
+  log.info(
+    `  generator: ${generator ?? '<CMake default>'} ` +
+    `(${multiConfig ? 'multi-config' : 'single-config'}), configs: ${configList.join(', ')}`,
+  );
+
+  if (multiConfig) {
+    // ── Multi-config: one build dir, run install target once per config ─────
+    fs.mkdirSync(buildPaths.build, { recursive: true });
+    const configureArgs = buildConfigureArgs({
+      sourceDir,
+      buildDir:       buildPaths.build,
+      installDir:     buildPaths.install,
+      toolchainFile,
+      generator,
+      configureExtra: recipe.configure,
+      buildType:      null,        // multi-config picks at build time
+      configurations: configList,  // pin CMAKE_CONFIGURATION_TYPES so all 4 build-<Config>.ninja files get generated
+    });
+    log.info(`  cmake ${configureArgs.join(' ')}`);
+    await runCmake(configureArgs, { env });
+
+    for (const cfg of configList) {
+      const installArgs = buildInstallArgs({
+        buildDir:   buildPaths.build,
+        config:     cfg,
+        buildExtra: recipe.buildArgs,
+      });
+      log.info(`  cmake ${installArgs.join(' ')}`);
+      await runCmake(installArgs, { env });
+    }
+    return;
+  }
+
+  // ── Single-config: separate build dir + reconfigure per config ───────────
+  // `CMAKE_BUILD_TYPE` is baked into the cache, so mixing configs in one
+  // build dir would require clobbering the cache between each. Distinct
+  // dirs is simpler and lets CMake's own dependency tracking work per-config.
+  for (const cfg of configList) {
+    const perCfgBuildDir = `${buildPaths.build}-${cfg}`;
+    fs.mkdirSync(perCfgBuildDir, { recursive: true });
+    const configureArgs = buildConfigureArgs({
+      sourceDir,
+      buildDir:       perCfgBuildDir,
+      installDir:     buildPaths.install,
+      toolchainFile,
+      generator,
+      configureExtra: recipe.configure,
+      buildType:      cfg,
+    });
+    log.info(`  cmake ${configureArgs.join(' ')}`);
+    await runCmake(configureArgs, { env });
+
+    const installArgs = buildInstallArgs({
+      buildDir:   perCfgBuildDir,
+      config:     cfg,
+      buildExtra: recipe.buildArgs,
+    });
+    log.info(`  cmake ${installArgs.join(' ')}`);
+    await runCmake(installArgs, { env });
+  }
+}
+
+module.exports = {
+  configureBuildInstall,
+  pickGenerator,
+  classifyGenerator,
+  isGeneratorAvailable,
+  isMultiConfigGenerator,
+  // Exported for unit tests
+  buildConfigureArgs,
+  buildInstallArgs,
+  DEFAULT_CONFIG,
+};