wyvrnpm 2.20.1 → 2.21.0

package/README.md

@@ -4,7 +4,21 @@ A simple, private C++ package manager that works with any static file hosting pr
 
 There is no central registry. You control where packages are hosted.
 
-> **README version: 2.15.0**
+> **README version: 2.20.2**
+>
+> **New in 2.16.0 – 2.20.2:**
+>
+> - **Visual Studio architecture pinning (2.20.0).** A recipe-less Windows/MSVC consumer (one that only lists `dependencies`, no `build` recipe) used to get a generator-less `wyvrn-<profile>` preset, so `cmake --preset` fell through to CMake's implicit Visual Studio default — which targets the **host** arch (x64) when no `-A` is supplied. An `x86` / `armv8` profile therefore silently produced 64-bit binaries. `wyvrnpm install` now detects the default VS generator and bakes both `generator` and `architecture` into the emitted preset, and `wyvrnpm build` derives `-A` (`x86→Win32`, `x86_64→x64`, `armv8→ARM64`, `armv7→ARM`) for VS generators. Builds now match the profile's bitness without a recipe. (Already-published non-host-arch artefacts built via the old source-build path may still hold wrong-bitness binaries — those are rebuilt + republished out of band.)
+> - **`wyvrnpm build` resolves the generator from the emitted preset, not the recipe (2.20.2).** The configure step now reads the generator that `cmake --preset` will *actually* use — precedence: CLI `--generator` > the `generator` baked into `CMakePresets.json` > the detected default for a generator-less preset. This drives both the `-A` pin and the vcvarsall-skip decision, so they stay consistent with reality. Fixes a class of failures where a Ninja Multi-Config preset got `-A x64` ("does not support platform specification") and skipped vcvarsall ("CMAKE_CXX_COMPILER not set") because the old code re-derived the generator from the recipe — which can legitimately diverge from the preset (an install-time `--generator`, or a recipe edited after the last install).
+> - **CMake-path fallback (2.20.1).** `install` / `build` / source-build no longer fail outright on a machine where CMake isn't on `PATH` — `resolveCmakeExe()` falls back to the Windows default `C:\Program Files\CMake\bin\cmake.exe` before surfacing the usual "is CMake installed?" error.
+> - **Machine-wide binary package cache (2.19.0).** Every successful v2 exact-match download is also cached under `%LOCALAPPDATA%\wyvrnpm\pkg\` (14-day TTL) so re-installs across projects skip the network. `wyvrnpm cache list` / `cache prune` gain a `--type src|pkg|all` selector covering both this and the source-build cache, and `wyvrnpm clean --pkg-cache` wipes it.
+> - **`wyvrnpm test` (2.18.0).** A `ctest --preset wyvrn-<profile>-<config>` wrapper that auto-builds when stale, supports `-R` / `-L` filters and `--all-configs`, and emits a `--format json` summary for CI.
+> - **Output directory restructure (2.17.0).** Compiled artefacts now land inside the CMake binary dir (`<binaryDir>/lib`, `<binaryDir>/bin`) instead of `${CMAKE_SOURCE_DIR}/output/`, so `wyvrnpm clean --all` actually catches them. Scripts that hard-coded `output/bin64/…` must switch paths — `clean --all` sweeps the legacy `output/` tree as a migration aid.
+> - **`wyvrnpm clean` flags (2.16.0).** `--build-dir` (also wipe the active profile's CMake build tree), `--all` (scorched-earth: build dirs + `wyvrn-*` presets + legacy `output/`), and `--dry-run` (preview, write nothing).
+>
+> **Planned (not yet shipped):**
+>
+> - **Resolver → provider unification.** Today the dependency resolver (`resolve.js` / `download.js`) talks to registries through a bare `fetch` client that hard-codes the v2/v1 URL layouts, separate from the provider classes that handle publish + download. The plan is to route all metadata lookups through provider methods (`v2GetVersionsIndex` / `v2GetMeta` / `v2GetLatest` / `v1*`) so S3 SigV4, auth resolution, and provider-specific quirks live in one place. Design captured in [.claude-wyvrn-local/plans/2026-04-24-resolver-http-unify.md](.claude-wyvrn-local/plans/2026-04-24-resolver-http-unify.md). The 2.8.4 `Accept-Encoding: identity` hotfix covers the immediate CloudFront cache-split symptom in the meantime.
 >
 > **New in 2.15.0:**
 >
@@ -371,7 +385,7 @@ After download, `install` also generates:
 - `wyvrn_internal/wyvrn_toolchain.cmake` — CMake toolchain pointing at the resolved packages.
 - `wyvrn_internal/wyvrn_deps.cmake` — post-`project()` include for `find_package()` wiring and runtime DLL copy.
 - `wyvrn_internal/wyvrn_profile.json` — snapshot of the active build profile.
-- `CMakePresets.json` (or `CMakeUserPresets.json` if the project root file is user-owned) with a `wyvrn-<profile>` configure preset. Presets for other profiles are preserved so multiple profiles coexist.
+- `CMakePresets.json` (or `CMakeUserPresets.json` if the project root file is user-owned) with a `wyvrn-<profile>` configure preset. Presets for other profiles are preserved so multiple profiles coexist. On Windows/MSVC the preset is pinned to a concrete Visual Studio `generator` **and** `architecture` (derived from the profile arch) even when the project carries no `build` recipe — so a recipe-less `x86` / `armv8` consumer builds the correct bitness instead of CMake's implicit host-x64 default (2.20.0). Declare a `build.generator` (or a `CMakeUserPresets.json`) to opt into Ninja/Make instead.
 
 **Toolchain variables exposed to your `CMakeLists.txt` (valid BEFORE `project()`)**:
 
@@ -471,6 +485,8 @@ wyvrnpm build -- -j 8
 
 Everything after `--` is forwarded verbatim to `cmake --build` (e.g. `-j 8`).
 
+**How the effective generator is resolved (2.20.2+).** `wyvrnpm build` decides the `-A` arch pin and the vcvarsall-skip from the generator `cmake --preset` will *actually* use — not the project's `build` recipe. Precedence: CLI `--generator` (wins, passed as `-G`) → the `generator` baked into `CMakePresets.json` at install time → the detected default Visual Studio generator for a generator-less preset. Trusting the preset matters because it can legitimately diverge from the recipe (an install-time `--generator`, or a recipe edited after the last install); pinning `-A` against a non-VS preset is a hard CMake error, so the two decisions must agree with what cmake runs.
+
 ---
 
 ### `wyvrnpm test` (2.18.0+)
@@ -620,16 +636,32 @@ Removes the `wyvrn_internal/` package cache and `wyvrn.lock`.
 # Project-local cleanup
 wyvrnpm clean
 
+# Also wipe the active profile's CMake build tree
+wyvrnpm clean --build-dir
+
+# Scorched earth: build dirs + wyvrn-* presets + legacy output/ tree
+wyvrnpm clean --all
+
 # Also wipe the machine-wide source-build cache used by --build=missing
 wyvrnpm clean --build-cache
+
+# Also wipe the machine-wide binary package cache
+wyvrnpm clean --pkg-cache
+
+# Preview every action without deleting anything
+wyvrnpm clean --all --dry-run
 ```
 
 **Options**
 
 | Option | Default | Description |
 |---|---|---|
+| `--build-dir` | `false` | Also remove the active profile's CMake build tree at `<binaryDirRoot>/wyvrn-<profile>/`. |
+| `--all` | `false` | Default scrub **plus** every `<binaryDirRoot>/wyvrn-*/` build dir, the `wyvrn-*` entries stripped from `CMakePresets.json`, and the legacy `<root>/output/` tree (2.17.0 migration aid). |
 | `--build-cache` | `false` | Also remove the source-build cache under `%LOCALAPPDATA%\wyvrnpm\bc\` (Unix: `~/.cache/wyvrnpm/bc/`). |
-| `--uploaded-built` | `false` | Wipe only the local record of what this machine has uploaded via `--upload-built` (the `.uploaded-to.json` sidecars). Does **not** touch the registry, the artefacts, or `wyvrn_internal/`. |
+| `--pkg-cache` | `false` | Also remove the machine-wide binary package cache under `%LOCALAPPDATA%\wyvrnpm\pkg\` (2.19.0). Opt-in only — never wiped by the default scrub or `--all`. |
+| `--uploaded-built` | `false` | Wipe only the local record of what this machine has uploaded via `--upload-built` (the `.uploaded-to.json` sidecars). Does **not** touch the registry, the artefacts, or `wyvrn_internal/`. When passed alone, the default scrub is skipped. |
+| `--dry-run` | `false` | Log `Would remove …` for every action and write nothing. |
 
 For selective cache pruning (keep last N variants, drop entries older than N days), use `wyvrnpm cache prune` instead — see below.
 
@@ -637,12 +669,22 @@ For selective cache pruning (keep last N variants, drop entries older than N day
 
 ### `wyvrnpm cache` (2.8.0+)
 
-Inspect and selectively prune the machine-wide source-build cache at `%LOCALAPPDATA%\wyvrnpm\bc\` (Unix: `~/.cache/wyvrnpm/bc/`). Useful once `--upload-built` adoption balloons cache size on dev rigs — `clean --build-cache` is the blunt alternative that wipes everything.
+Inspect and selectively prune the two machine-wide caches. Useful once cache size balloons on dev rigs — `clean --build-cache` / `clean --pkg-cache` are the blunt alternatives that wipe everything of one type.
+
+| Type | Location | Populated by | TTL |
+|---|---|---|---|
+| `src` | `%LOCALAPPDATA%\wyvrnpm\bc\` (Unix: `~/.cache/wyvrnpm/bc/`) | source-builds (`--build=missing`) | none |
+| `pkg` | `%LOCALAPPDATA%\wyvrnpm\pkg\` | every successful v2 exact-match download (2.19.0+) | 14 days |
+
+`--type src|pkg|all` (default `all`) restricts both `list` and `prune` to one cache.
 
 ```bash
-# List every cached entry as a table
+# List every cached entry across both caches as a table
 wyvrnpm cache list
 
+# Only the binary package cache
+wyvrnpm cache list --type pkg
+
 # Filter by package name (glob)
 wyvrnpm cache list "boost*"
 
@@ -652,8 +694,8 @@ wyvrnpm cache list --format json
 # Keep the 2 most-recently-touched variants per (name, version)
 wyvrnpm cache prune --keep-last 2
 
-# Drop entries older than 30 days
-wyvrnpm cache prune --older-than 30d
+# Prune only the source-build cache, dropping entries older than 30 days
+wyvrnpm cache prune --type src --older-than 30d
 
 # Combine: keep 1 recent per version AND drop anything stale
 wyvrnpm cache prune --keep-last 1 --older-than 30d
@@ -667,12 +709,14 @@ wyvrnpm cache prune --keep-last 2 --dry-run
 | Option | Default | Description |
 |---|---|---|
 | `[pattern]` / `--pattern` | *(none)* | Glob over package names (`*` for any chars, `?` for one). |
+| `--type` | `all` | Which cache to inspect: `src` (source-build), `pkg` (binary), or `all`. |
 | `--format` | `text` | `text` (table) or `json` (structured payload for CI). |
 
 **`cache prune` options**
 
 | Option | Default | Description |
 |---|---|---|
+| `--type` | `all` | Which cache to prune: `src` (source-build), `pkg` (binary), or `all`. |
 | `--keep-last <N>` | *(none)* | Retain the N most-recently-touched entries **per (name, version) group**. A four-profile rig keeping-last-2 still retains the two newest profile variants of each version. |
 | `--older-than <dur>` | *(none)* | Remove entries whose mtime is older than the threshold. Format: `<number><unit>`, unit ∈ `s` / `m` / `h` / `d` (e.g. `30d`, `72h`). |
 | `--pattern <glob>` | *(none)* | Restrict scope to package names matching the glob. |

package/bin/wyvrnpm.js

@@ -1098,8 +1098,9 @@ yargs
       y
         .positional('name', { type: 'string', description: 'Package name to link' })
         .positional('path', { type: 'string', description: 'Local path to package' })
-        .option('list',   { type: 'boolean', description: 'List all globally registered packages', default: false })
-        .option('subdir', { type: 'string',  description: 'Subdirectory within the package to link' });
+        .option('list',    { type: 'boolean', description: 'List all globally registered packages', default: false })
+        .option('subdir',  { type: 'string',  description: 'Subdirectory within the package to link' })
+        .option('profile', { type: 'string',  description: 'Profile whose install tree to register (default: config default)' });
     },
     (argv) => link(argv),
   )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wyvrnpm",
-  "version": "2.20.1",
+  "version": "2.21.0",
   "description": "A simple, static-hosting-compatible C++ package manager",
   "keywords": [
     "c++",

package/src/commands/build.js

@@ -7,6 +7,7 @@ const { spawn } = require('child_process');
 const { normalizeRecipe, hasBuildRecipe, VALID_CMAKE_CONFIGS, DEFAULT_RECIPE } = require('../build/recipe');
 const { loadMsvcEnv }  = require('../build/msvc-env');
 const { archToVsPlatform, isVisualStudioGenerator } = require('../toolchain');
+const { readConfigurePresetGenerator } = require('../toolchain/presets');
 const { resolveEffectiveGenerator } = require('../build/default-generator');
 const { resolveCmakeExe } = require('../build/cmake-exe');
 const { LOCAL_OVERLAY_FILENAME, readLocalOverlay } = require('../conf');
@@ -226,6 +227,54 @@ function buildInstallArgs({ binaryDir, config, prefix }) {
   return args;
 }
 
+/**
+ * Resolve the generator `cmake --preset <presetName>` will actually use, so
+ * the caller can decide generator-dependent flags (the Visual Studio `-A`
+ * arch pin, and whether to activate vcvarsall) against reality.
+ *
+ * Precedence — each step mirrors what CMake itself does:
+ *   1. CLI `--generator` — `build` passes it as `-G`, which overrides the
+ *      preset, so it wins here too.
+ *   2. The generator baked into the configure preset by `install`. This file,
+ *      not the project's recipe, is the contract `cmake --preset` consumes;
+ *      the recipe and the emitted preset can legitimately diverge (an
+ *      install-time `--generator`, or a recipe edited after the last install).
+ *      Trusting a re-derived recipe value is exactly the bug this guards
+ *      against — it pins `-A` against a non-VS preset (a hard CMake error) and
+ *      wrongly skips vcvarsall.
+ *   3. The detected default (Windows/MSVC → newest VS) for a generator-less
+ *      preset — emitted by a pre-arch-pin client, or any non-Windows
+ *      toolchain. Keeps the recipe-less arch pin firing. See
+ *      claude/PLAN-VS-ARCH-PIN.md.
+ *
+ * `readPresetGenerator` and `detect` are injectable for hermetic tests.
+ *
+ * @param {{
+ *   rootDir:    string,
+ *   presetName: string,
+ *   cliGenerator?: string|null,
+ *   profile?:   { os?: string, compiler?: string, arch?: string }|null,
+ *   readPresetGenerator?: (args: { projectRoot: string, presetName: string }) => string|null,
+ *   detect?:    () => Promise<string|null>,
+ * }} args
+ * @returns {Promise<string|null>}
+ */
+async function resolveConfigureGenerator({
+  rootDir,
+  presetName,
+  cliGenerator = null,
+  profile = null,
+  readPresetGenerator = readConfigurePresetGenerator,
+  detect,
+}) {
+  if (typeof cliGenerator === 'string' && cliGenerator.trim()) return cliGenerator;
+
+  const fromPreset = readPresetGenerator({ projectRoot: rootDir, presetName });
+  if (fromPreset) return fromPreset;
+
+  return resolveEffectiveGenerator({ explicit: null, profile, detect });
+}
+
 // ---------------------------------------------------------------------------
 // Spawn wrapper
 // ---------------------------------------------------------------------------
@@ -370,32 +419,20 @@ async function build(argv) {
   //
   // Same mechanism the source-build path already uses (src/build/msvc-env.js).
   let cmakeEnv = null;
-  let effectiveGenerator = argv.generator ?? null;
-  let effectiveProfile   = null;
+  const effectiveProfile = activeProfile;
+  let effectiveGenerator = null;
   try {
-    effectiveProfile = activeProfile;
-    // Which generator will the preset actually use? Read it from the
-    // project's own recipe if one exists. If not, default to null and let
-    // cmake/CMakePresets decide — in which case MSVC env activation is
-    // skipped (because VS is usually the default on Windows).
-    const manifest = ctx.manifest;
-    let presetGenerator = null;
-    if (hasBuildRecipe(manifest)) {
-      try {
-        const recipe = normalizeRecipe(manifest.build, null);
-        if (recipe.generators.length > 0) [presetGenerator] = recipe.generators;
-      } catch { /* templates need options → skip env activation */ }
-    }
-    // CLI --generator wins, then the recipe's generator, then — on a
-    // Windows/MSVC profile with neither — CMake's detected default VS
-    // generator. Resolving the default here keeps the `-A` pin below and the
-    // vcvarsall-skip decision consistent with the generator `cmake --preset`
-    // will actually use (install pins the same generator into the preset).
-    // Non-Windows / non-MSVC → null, unchanged from before.
-    // See claude/PLAN-VS-ARCH-PIN.md.
-    effectiveGenerator = await resolveEffectiveGenerator({
-      explicit: effectiveGenerator ?? presetGenerator,
-      profile:  activeProfile,
+    // The generator `cmake --preset` will actually use is the one baked into
+    // the configure preset by `install` (a CLI --generator overrides it). That
+    // value — not the project's recipe — drives both the `-A` pin below and the
+    // vcvarsall-skip decision, so they stay consistent with reality even when
+    // the recipe and the emitted preset disagree. See resolveConfigureGenerator
+    // and claude/PLAN-VS-ARCH-PIN.md.
+    effectiveGenerator = await resolveConfigureGenerator({
+      rootDir,
+      presetName,
+      cliGenerator: argv.generator,
+      profile:      activeProfile,
     });
     cmakeEnv = await loadMsvcEnv({
       profile:          activeProfile,
@@ -486,6 +523,7 @@ module.exports._helpers = {
   resolvePresetName,
   resolveBinaryDir,
   resolveConfigList,
+  resolveConfigureGenerator,
   buildConfigureArgs,
   buildBuildArgs,
   buildInstallArgs,

package/src/commands/link.js

@@ -8,6 +8,9 @@ const { createLink, isLink, removeLink, getLinkTarget } = require('../link-utils
 const { downloadDependencies } = require('../download');
 const { resolveDependencies } = require('../resolve');
 const { wyvrnFetch } = require('../http-fetch');
+const { resolveBinaryDirRoot } = require('../binary-dir');
+const { readLocalOverlay } = require('../conf');
+const { hasBuildRecipe, DEFAULT_RECIPE } = require('../build/recipe');
 const log = require('../logger');
 
 /**
@@ -37,14 +40,51 @@ function getEffectivePath(entry) {
   return entry.path;
 }
 
+/**
+ * Compute the install-tree subdirectory for a package that declares a build
+ * recipe, relative to the package root. Mirrors how `publish` locates the
+ * install tree it overlays: `<binaryDirRoot>/wyvrn-<profile>/<installDir>`.
+ *
+ * The returned path is forward-slash separated and relative — `getEffectivePath`
+ * joins it onto the package root to yield the absolute install dir.
+ *
+ * @param {object} manifest - Parsed wyvrn.json (must have a build recipe).
+ * @param {object} config - Resolved config (for defaultProfile fallback).
+ * @param {object} argv - Parsed yargs arguments (reads `profile`).
+ * @param {string} packagePath - Absolute package root (for the local overlay).
+ * @returns {string} Relative, forward-slash install-tree subdir.
+ */
+function installTreeSubdir(manifest, config, argv, packagePath) {
+  const overlay = readLocalOverlay(packagePath);
+  const binaryDirRoot = resolveBinaryDirRoot({
+    localOverlayBinaryDirRoot: overlay.binaryDirRoot,
+  });
+  const profileName =
+    typeof argv.profile === 'string' && argv.profile.length > 0
+      ? argv.profile
+      : config.defaultProfile || 'default';
+  const installDir = manifest.build.installDir ?? DEFAULT_RECIPE.installDir;
+  return [binaryDirRoot, `wyvrn-${profileName}`, installDir].join('/');
+}
+
 /**
  * Register the current directory's package globally for linking.
  * Reads wyvrn.json to get the package name, stores {name: {path, subdir}} in config.
  *
+ * When the package declares a build recipe, the registered target is its
+ * install tree (`<binaryDirRoot>/wyvrn-<profile>/<installDir>`) rather than the
+ * raw source root. That tree carries the installed headers, libraries, and
+ * `<name>Config.cmake` at its root — the exact layout a consumer's
+ * `find_package(<name> CONFIG)` expects after the link lands in
+ * `wyvrn_internal/<name>/`. Linking the source root would bury the CMake
+ * config under `build/` and find_package would miss it, so the link must
+ * simulate the packaged artefact, not the working tree. An explicit
+ * `--subdir` always wins (monorepo: link a sub-package's own tree).
+ *
  * @param {string} manifestPath - Path to wyvrn.json
- * @param {string} [subdir] - Optional subdirectory within the package to link.
+ * @param {object} argv - Parsed yargs arguments (reads `subdir`, `profile`).
  */
-function registerGlobal(manifestPath, subdir) {
+function registerGlobal(manifestPath, argv) {
   const manifest = readManifest(manifestPath);
   const packageName = manifest.name || manifest.Name;
 
@@ -58,14 +98,25 @@ function registerGlobal(manifestPath, subdir) {
   config.linkedPackages = config.linkedPackages || {};
 
   const entry = { path: packagePath };
-  if (subdir) {
-    entry.subdir = subdir;
+  let installTreeLinked = false;
+  if (argv.subdir) {
+    entry.subdir = argv.subdir;
+  } else if (hasBuildRecipe(manifest)) {
+    entry.subdir = installTreeSubdir(manifest, config, argv, packagePath);
+    installTreeLinked = true;
   }
   config.linkedPackages[packageName] = entry;
   writeConfig(config);
 
   const effectivePath = getEffectivePath(entry);
   log.info(`Registered "${packageName}" → ${effectivePath}`);
+  if (installTreeLinked && !fs.existsSync(effectivePath)) {
+    log.warn(
+      `install tree not found at ${effectivePath}\n` +
+      `  Build + install it so consumers' find_package(${packageName}) resolves:\n` +
+      `    wyvrnpm build --all-configs --install`,
+    );
+  }
 }
 
 /**
@@ -261,7 +312,7 @@ async function link(argv) {
       log.error(`no wyvrn.json found at ${manifestPath}`);
       process.exit(1);
     }
-    registerGlobal(manifestPath, argv.subdir);
+    registerGlobal(manifestPath, argv);
     return;
   }
 

package/src/context.js

@@ -7,7 +7,7 @@
  * re-read config, re-resolve auth, and each toggle JSON mode on the logger.
  * The divergence was cheap at 11 commands; it starts costing real bugs
  * once F3 (`tool_requires`) and F4 (build/host profile split) double the
- * flag surface. See [claude/PLAN-COMMAND-CONTEXT.md](../claude/PLAN-COMMAND-CONTEXT.md).
+ * flag surface. See [.claude-wyvrn-local/plans/2026-04-23-command-context.md](../.claude-wyvrn-local/plans/2026-04-23-command-context.md).
  *
  * `buildContext(argv)` runs once at the top of each command. It:
  *   - resolves filesystem anchors (rootDir, manifestPath)

package/src/toolchain/presets.js

@@ -388,6 +388,36 @@ function generateCMakePresets({
   return { path: null, action: 'skipped', isUser: false };
 }
 
+/**
+ * Read the `generator` of a named configure preset from the project's
+ * CMakePresets.json (falling back to CMakeUserPresets.json). This is the
+ * generator `cmake --preset <name>` will actually use, so callers deciding
+ * generator-dependent flags — the Visual Studio `-A` arch pin, or whether to
+ * activate vcvarsall — must trust it over a value re-derived from the recipe.
+ * The recipe and the emitted preset can legitimately diverge (an install-time
+ * `--generator`, or a recipe edited after the last install); trusting the
+ * recipe pins `-A` against a Ninja preset, which CMake rejects with a hard
+ * "does not support platform specification" error.
+ *
+ * Returns the generator string, or null when the file/preset is absent or the
+ * preset declares no generator — the latter means CMake will fall back to its
+ * platform default, which the caller's detection path handles.
+ *
+ * @param {{ projectRoot: string, presetName: string }} args
+ * @returns {string|null}
+ */
+function readConfigurePresetGenerator({ projectRoot, presetName }) {
+  for (const file of ['CMakePresets.json', 'CMakeUserPresets.json']) {
+    const parsed  = safeReadJson(path.join(projectRoot, file));
+    const presets = parsed && Array.isArray(parsed.configurePresets) ? parsed.configurePresets : [];
+    const match   = presets.find((p) => p && p.name === presetName);
+    if (match && typeof match.generator === 'string' && match.generator.trim()) {
+      return match.generator;
+    }
+  }
+  return null;
+}
+
 /**
  * Strip every wyvrnpm-generated entry from a parsed presets object.
  * Mirror of `mergeIntoExisting` — used by `wyvrnpm clean --all` to
@@ -475,6 +505,7 @@ function stripWyvrnPresets(existing) {
 
 module.exports = {
   generateCMakePresets,
+  readConfigurePresetGenerator,
   stripWyvrnPresets,
   safeReadJson,
   // Exported for tests